VOLVER
main.c

Go to the documentation of this file.

/* ###################################################################
**      Reloj en Tiempo Real
**  
**
** _00. Inicial.
**      Al dejar de interrogar se para el reloj y sigue perdiendo la hora
** _01. Funciona correctamente al ralentizar el reloj y cambiar la
**      gestion de las interrupciones
** _02. Refinamiento, a ver si funciona
** _03. Se reinicia en los cambios de alimentación, así que se elimina
**      la inicialización de la hora en ese transitorio
** _04. Cambio en la definicion de dia y mes, junto con la funcion 
**      CalculaDiaSemana, para soluccionar el fallo de cambio de día.
** ###################################################################*/
#include "msp430x12x2.h"
#include <stdlib.h>
/*
** ###################################################################
**      DEFINICION DE TIPOS
** ###################################################################*/
#include "rtc_display_def.h"
/*
** ###################################################################
**      DECLARACIONES
** ###################################################################*/
void InicializaVariables(void);

void GrabaE2Prom(void);
void LeeE2Prom(void);
void ReadInfo(char offset, char * variable_byte, char nro_bytes);
void WriteInfo(char offset, char * variable_byte, char nro_bytes);

void RevisaDesbordMiliseg(void);
void SetRefTime(int *var_ref);
void SetRefTimeValue(int *var_ref, int offset);
BYTE CheckTimeout(int delay_value, int var_ref);
int CheckTimeoutValue(int delay_value, int var_ref);

void Reloj(void);
//char CalculaDiaSemana(int anyo, char mes, char dia);
//BYTE Enero1(int yr);
int CalculaDiaSemana(int anyo, int mes, int dia);
int Enero1(int yr);
void FormatFechaHora(void);
void CambiaReloj(void);

#if __VER__ < 200
interrupt[PORT2_VECTOR] void RegistroDesplazamiento(void);
#else
#pragma vector=PORT2_VECTOR
__interrupt void RegistroDesplazamiento(void);
#endif

#if __VER__ < 200
interrupt[WDT_VECTOR] void BaseTiempos(void);
#else
#pragma vector=WDT_VECTOR
__interrupt void BaseTiempos(void);
#endif

// *****Habilitar/Desabilitar interrupciones*****
/*
unsigned char IntStatus;                // status of GIE flag
unsigned char IntsDisableCount;         // count of performed disables
#define GIEDisable              if(IntsDisableCount==0) \
                                                IntStatus=_BIC_SR(0x0008); \
                                        IntsDisableCount++
                                        
#define GIEEnable               if(--IntsDisableCount==0&&(IntStatus&0x0008)) \
                                                _EINT()
*/
// *****Fin de macros****************************

/*
** ###################################################################
**      VARIABLES GLOBALES
** ###################################################################*/
//***** Grabadas en E2PROM *****
//#pragma location=0x02FA
__no_init char  address_byte @ 0x02FA;                  //Dirección del sensor
//__no_init char f_detect @ 0x02FB;                     //Configuración de indicaciones
//__no_init unsigned int palabra_frec @ 0x02FC; //Frecuencia de trabajo
//__no_init unsigned int num_sensib @ 0x02FE;           

BYTE timeout; //, aux_byte;                     //Generales, índices, etc.

//****************Base de tiempos****************
int tics_1mseg; //Contadores en milisegundos
int tics_1seg;

int t_ref_segundos;

// ***********************************
// *****Variables calendario y reloj**
int anyo;
int mes, dia, dia_semana;
int num_dias_mes[13];
char min, hora; //sec; -> sustituido por tics_1seg;

// *****Variables RTC*****************
BYTE byte_rtc_01, byte_rtc_02, byte_rtc_03;     //Contiene fecha-hora
BYTE byte_rtc_04, byte_rtc_05;
BYTE byte_cmm_rtc_01, byte_cmm_rtc_02, byte_cmm_rtc_03; //Nueva hora/fecha
BYTE byte_cmm_rtc_04, byte_cmm_rtc_05;                           //recibida
BYTE byte_cmm_rtc_00;

// *****Registro de desplazamiento****
char inx_byte_out;      //Para salidas en modo registro de desplazamiento
BYTE byte_in_rtc;
BYTE    inx_bit;
char f_stat;

char f_test;
/*
** ###################################################################
**      MAIN
** ###################################################################*/
void main(void) {
        _DINT(); 
        //InicializaRecursos(); //Incluido en el fichero lowinit.c      
        InicializaVariables();
        //LeeE2Prom();
        _EINT();                 

        // ******************************
        // *****BUCLE PRINCIPAL *********
        // ******************************
        for (;;) {
                _DINT();
                
/*              if (f_test == 1) {              //Depuracion
                        f_test = 0;     
                        CalculaDiaSemana (anyo, mes, dia);
                }
                else if (f_test == 2) {
                        f_test = 0;
                        Reloj();
                }
*/              
                RevisaDesbordMiliseg();

                if (f_stat & F_FIX_SEG) {       //Se cumplió temporización 1 SEG
                        f_stat &= ~F_FIX_SEG;

                        SetRefTimeValue(&t_ref_segundos, CheckTimeoutValue(_1_SEG, t_ref_segundos));
                        tics_1seg += 1;
                        //P3OUT ^= 0x10;                //Testigo
                        Reloj();                                //Mantiene hora del sistema
                        FormatFechaHora();              //Para envío hacia micro ppal
                }

                if ((!(f_stat & F_OUT_ACTIVA)) &&
                    (!(f_stat & F_IRQ_CHGED))) {
                        //Terminó la recepción por el bus serie
                        f_stat |= F_IRQ_CHGED;
                        P2IE = BIT_RTC_LD;
                        P2IFG = 0x00;
                        P2DIR &= ~BIT_RTC_DATA_OUT;

                        if (byte_cmm_rtc_00 == COMMD_HORA) {//Si llegó algún comando 
                                                                                //cambia la hora
                                CambiaReloj();          //Puesta en hora desde micro ppal
                        }
                }
                _EINT();

                P3OUT |= 0x10;                  //Testigo
                __low_power_mode_3();   //Paso a modo de bajo consumo
                _NOP();
                _NOP();
                P3OUT &= ~0x10;         //Testigo
        }
}
/*
** ###################################################################
**      Separación de código de la función principal.
** - Se trata de arrancar haciendo medidas, después de hacer la 
**      calibración inicial, y en modo de bajo consumo
** ###################################################################*/
void InicializaVariables(void){
//BYTE i;
//char m;
        
        P2IFG = 0x00;           //Iniciamos esperando el pulso de carga
        P2IE  = 0x01;
        P2IES = 0x01;
                
        f_stat = 0;             //Flag de envío de datos

        // *****Inicialización defecto***
        //anyo = 2005;
        //mes = ENERO;
        //dia = 1;
        //dia_semana = CalculaDiaSemana (anyo, mes, dia);
        //min = 0;
        //hora = 0;
        
        //tics_1mseg = 0;       //Base de tiempos       
        //tics_1seg  = 0;
        //SetRefTime(&t_ref_segundos);
        
        byte_cmm_rtc_01 = byte_cmm_rtc_02 = 0;  //Comandos de cambio 
        byte_cmm_rtc_03 = byte_cmm_rtc_04 = 0;  //de hora
        byte_cmm_rtc_05 = byte_cmm_rtc_00 = 0;

        num_dias_mes[0] = 0;
        num_dias_mes[1] = 31;
        num_dias_mes[2] = 29;
        num_dias_mes[3] = 31;
        num_dias_mes[4] = 30;
        num_dias_mes[5] = 31;
        num_dias_mes[6] = 30;
        num_dias_mes[7] = 31;
        num_dias_mes[8] = 31;
        num_dias_mes[9] = 30;
        num_dias_mes[10] = 31;
        num_dias_mes[11] = 30;
        num_dias_mes[12] = 31;
        
        P3OUT &= ~0x10; //Testigo
        f_test = 0;
}
/*
** ###################################################################
**      Salvaguarda y recuperación de las variables en memoria no volatil
** ###################################################################*/
void GrabaE2Prom(void) {
        _DINT();
        WriteInfo(0, &address_byte, 6);
        _EINT();
}
void LeeE2Prom(void) {
        ReadInfo(0, &address_byte, 6);
}
void WriteInfo(char offset, char * variable_byte, char nro_bytes) {
char *Flash_ptr;
char n;

        Flash_ptr = (char *) ADDRESS_SEG_B;     // Initialize Flash pointer  
        FCTL1 = FWKEY + ERASE;                          // Set Erase bit
        for(n=0; n<8; n++);
        FCTL3 = FWKEY;                                  // Clear Lock bit
        for(n=0; n<8; n++);
        *Flash_ptr = 0;                                 // Dummy write to erase Flash segment
        for(n=0; n<8; n++);
  
        FCTL1 = FWKEY + WRT;                            // Set WRT bit for write operation
        for(n=0; n<8; n++);

        for (; offset>0; offset--) Flash_ptr++;
        for (; nro_bytes>0; nro_bytes--) {
                *Flash_ptr++ = *variable_byte++;        // Write value to flash
                for(n=0; n<8; n++);
        }

        FCTL1 = FWKEY;                                  // Clear WRT bit
        for(n=0; n<8; n++);
        FCTL3 = FWKEY + LOCK;                           // Reset LOCK bit
        for(n=0; n<8; n++);
}
void ReadInfo(char offset, char *variable_byte, char nro_bytes) {
char *Flash_ptr;

        Flash_ptr = (char *)ADDRESS_SEG_B;

        for (; offset>0; offset--) Flash_ptr++;
        for (; nro_bytes>0; nro_bytes--) {
                *variable_byte++ = *Flash_ptr++;
        }
}
/*
** ###################################################################
** RevisaDesbordMiliseg
**      - Mantenimiento de temporizaciones
** ###################################################################*/
void RevisaDesbordMiliseg(void) {
BYTE reinicia_mili_tics, num_positivo;
int aux_int;

        aux_int = INT_MAX - tics_1mseg;
        reinicia_mili_tics = (aux_int < (int)1500);
        if (reinicia_mili_tics) {
                num_positivo = t_ref_segundos > 0;
                if (num_positivo) t_ref_segundos = -(tics_1mseg - t_ref_segundos);
                
                tics_1mseg =0;
        }
}
/*
** ###################################################################
**      Establece una referencia temporal para medir retardos
** - Se toma el valor global de la base de tiempos del sistema y se
**      almacena en la variable de entrada
** ###################################################################*/
void SetRefTime(int *var_ref) {
        *var_ref = tics_1mseg;
        return;
}
void SetRefTimeValue(int *var_ref, int offset) {
        *var_ref = tics_1mseg - offset;
        return;
}
/*
** ###################################################################
**      Comprueba el vencimiento de un retardo
** - Devuelve SI cuando se vence el tiempo
**                  NO, si todavía no se ha cumplido
** - Se genera otra variante de esta funcion para tener en cuenta
**      el tiempo sobrepasado
** ###################################################################*/
BYTE CheckTimeout(int delay_value, int var_ref) {
BYTE t_out;
unsigned int aux;

        aux = tics_1mseg - var_ref;
        t_out = (aux >= delay_value);
        return t_out;
}
int CheckTimeoutValue(int delay_value, int var_ref) {
int aux;

        aux = tics_1mseg - var_ref;
        return (aux - delay_value);
}
/*
** ###################################################################
**      Mantenimiento del Reloj del sistema
**      0=Domingo, 1=Lunes, 2, 3, 4, 5, 6=Sábado
** ###################################################################*/
void Reloj(void) {
//      if (f_reloj & F_1_SEC) {                //Sólo se ejecuta 1 vez / segundo
//              f_reloj &= ~F_1_SEC;

                if (tics_1seg >= 60) {
                        tics_1seg = 0;
                        min++;
                        if (min >=60) {
                                min = 0;
                                hora++;
                                if (hora >=24) {
                                        hora = 0;
                                        CalculaDiaSemana (anyo, mes, dia);
                                        dia+=1;
                                        if (dia > num_dias_mes[mes]) {
                                                dia = 1;
                                                mes+=1;
                                                if (mes > DICIEMBRE) {
                                                        anyo +=1;
                                                        mes = ENERO;                                    
                                                }
                                        }
                                        dia_semana = CalculaDiaSemana (anyo, mes, dia);
                                }
                        }
                }

//      }
}
/*
** ###################################################################
**      Calculo del día de la semana de: día, mes, anyo (Entrada).
** - El resultado está codificado de la siguiente forma:
**      0=Domingo, 1=Lunes, 2, 3, 4, 5, 6=Sábado
** - Tambien se utiliza para actualizar el array num_dias_mes, en los
**      meses de Febrero(años bisiestos)
**
**Ejemplo:

int dia_semana;
int anyo;
BYTE mes, dia;
static BYTE num_dias_mes[] = { 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
        for(;;) {
                anyo = 2051;
                mes = 8;
                dia = 22;
                dia_semana = CalculaDiaSemana (anyo, mes, dia);
                asm("nop");
        }
**
** _04. Cambio en la definicion de dia y mes, junto con la funcion 
**      CalculaDiaSemana, para soluccionar el fallo de cambio de día.
** ###################################################################*/
int CalculaDiaSemana(int anyo, int mes, int dia) {
int aux_dia;
int i;

        aux_dia = Enero1(anyo);
        num_dias_mes[SEPTIEMBRE] = 30;

        switch ((Enero1(anyo+1) + 7 - aux_dia) % 7) {
                case 1:                         /* rem non-leap year */
                        num_dias_mes[FEBRERO] = 28;
                        break;
                default:                                /* 1752 */
                        num_dias_mes[SEPTIEMBRE] = 19;
                        /* fall thru */
                case 2:                         /* leap year */
                        num_dias_mes[FEBRERO] = 29;
                        break;
        }
        for (i = 1; i < mes; ++i) 
                aux_dia += (int)num_dias_mes[i];
                
        aux_dia += (int)dia -1;
        aux_dia %= 7;   
        
        return aux_dia;
}
/*
** ###################################################################
**      Calculo del día de la semana del día 1 de Enero del año de entrada
**      El resultado está codificado de la siguiente forma:
**      0=Domingo, 1=Lunes, 2, 3, 4, 5, 6=Sábado
** ###################################################################*/
int Enero1(int yr) {
//register int y, d;
int y, d;

        y = yr;                                 //normal gregorian calendar
        d = 4 + y + ((y + 3) / 4);      //one extra day per four years

        if (y > 1800) {                 //julian calendar
                d -= (y - 1701) / 100;  //regular gregorian
                d += (y - 1601) / 400;  //less three days per 400
        }

        if (y > 1752)                           //great calendar changeover instant
                d += 3;

        return (d % 7);
}
/*
** ###################################################################
**      FormatFechaHora
** - Codificacion de la fecha del sistema en los bytes de intercambio
** con el micro de control. La codificacion es la siguiente:
**          byte_rtc_01    02       03        04        05
**          YYYYYYYD DDDDMMMM WWWHHHHH xxmmmmmmm xxsssssss
** Y Año
** D Dia del mes
** M Mes
** W Dia de la semana 
** H Hora
** m Minutos
** s Segundos
** ###################################################################*/
void FormatFechaHora(void) {
BYTE aux_byte, aux_byte2;
int aux_int;    
        
        aux_int = anyo - 2000;
        aux_byte = (BYTE)(aux_int & 0x007F);    //Año tope 2127
        aux_byte2 = (aux_byte << 1) & 0xFE;
        aux_byte = (BYTE)(dia & 0x1F); 
        aux_byte = (aux_byte >> 4) & 0x01;
        byte_rtc_01 = aux_byte | aux_byte2;
        
        aux_byte = (BYTE)(dia & 0x1F);
        aux_byte = (aux_byte << 4) & 0xF0;
        aux_byte2 = (BYTE)(mes & 0x0F);
        byte_rtc_02 = aux_byte | aux_byte2;
        
        aux_byte2 = (BYTE)(dia_semana & 0x07);
        aux_byte2 = (aux_byte2 << 5) & 0xE0;
        aux_byte = (BYTE)(hora & 0x1F);
        byte_rtc_03 = aux_byte | aux_byte2;
        
        byte_rtc_04 = (BYTE)(min & 0x3F);
        byte_rtc_05 = (BYTE)(tics_1seg & 0x003F);
}
/*
** ###################################################################
**      FormatFechaHora
** - puesta en hora como consecuencia de un comando desde el micro
**      principal
** ###################################################################*/
void CambiaReloj(void) {
BYTE aux_byte, aux_byte2;
        
        if (byte_cmm_rtc_01 ||  //Si no se reciben todo ceros
            byte_cmm_rtc_02 ||
            byte_cmm_rtc_03 ||
            byte_cmm_rtc_04 ||
            byte_cmm_rtc_05) {
        
                aux_byte = byte_cmm_rtc_01;
                aux_byte = (aux_byte >> 1)& 0x7F;
                anyo = (int)aux_byte + 2000;                    //Año
        
                aux_byte = byte_cmm_rtc_01;
                aux_byte = (aux_byte << 4) & 0x10;
                aux_byte2 = byte_cmm_rtc_02;
                aux_byte2 = (aux_byte2 >> 4) & 0x0F;
                dia = aux_byte | aux_byte2;                     //Dia
        
                mes = byte_cmm_rtc_02 & 0x0F;                   //Mes
                hora = byte_cmm_rtc_03 & 0x1F;                  //Hora
        
                min = byte_cmm_rtc_04 & 0x3F;
                tics_1seg = byte_cmm_rtc_05 & 0x3F;     
                dia_semana = CalculaDiaSemana (anyo, mes, dia);
        }
        byte_cmm_rtc_01 = 0;    //Anulamos el comando pendiente
        byte_cmm_rtc_02 = 0;
        byte_cmm_rtc_03 = 0;
        byte_cmm_rtc_04 = 0;
        byte_cmm_rtc_05 = 0;
        byte_cmm_rtc_00 = 0;
}
/*
** ---------------------------------------------------------------------
**              VECTORES DE INTERRUPCION
** -------------------------------------------------------------------*/
/*
** ###################################################################
** RegistroDesplazamiento
**      Salida de variables hacia micro principal.
**      Emulamos un registro de desplazamiento y por eso nos fijamos
**      en las transiciones de los hilos de control desde el micro ppal
** ###################################################################*/
#if __VER__ < 200
interrupt[PORT2_VECTOR] void RegistroDesplazamiento(void)
#else
#pragma vector=PORT2_VECTOR
__interrupt void RegistroDesplazamiento(void)
#endif
{
BYTE aux_byte;

        P3OUT ^= 0x40;                  //Testigo

        if ((P2IFG & BIT_RTC_LD) &&
            (!(f_stat & F_OUT_ACTIVA))) {
                f_stat |= F_OUT_ACTIVA;
                P2DIR |= BIT_RTC_DATA_OUT;

                inx_byte_out = 0;
                inx_bit = 0x80;

                P2IE = BIT_RTC_SCLK;
                P2IFG = 0x00;
                //P3OUT |= 0x10;                //Testigo

                aux_byte = byte_rtc_01;
                if (aux_byte & inx_bit) P2OUT |= BIT_RTC_DATA_OUT;
                else P2OUT &= ~BIT_RTC_DATA_OUT;
                inx_bit = inx_bit >> 1;
        }
        else if ((P2IFG & BIT_RTC_SCLK)) {
                f_stat |= F_OUT_ACTIVA;
                P2DIR |= BIT_RTC_DATA_OUT;
                switch (inx_byte_out) {
                        case 0:
                                aux_byte = byte_rtc_01;
                                if (aux_byte & inx_bit) P2OUT |= BIT_RTC_DATA_OUT;
                                else P2OUT &= ~BIT_RTC_DATA_OUT;
                                
                                inx_bit = inx_bit >> 1;
                                if (!(inx_bit)) {
                                        inx_byte_out = 1;
                                        inx_bit = 0x80;
                                }
                                break;
                        case 1:
                                aux_byte = byte_rtc_02;
                                if (aux_byte & inx_bit) P2OUT |= BIT_RTC_DATA_OUT;
                                else P2OUT &= ~BIT_RTC_DATA_OUT;
                                
                                inx_bit = inx_bit >> 1;
                                if (!(inx_bit)) {
                                        inx_byte_out = 2;
                                        inx_bit = 0x80;
                                }
                                break;          
                        case 2:
                                aux_byte = byte_rtc_03;
                                if (aux_byte & inx_bit) P2OUT |= BIT_RTC_DATA_OUT;
                                else P2OUT &= ~BIT_RTC_DATA_OUT;
                                
                                inx_bit = inx_bit >> 1;
                                if (!(inx_bit)) {
                                        inx_byte_out = 3;
                                        inx_bit = 0x80;
                                        byte_in_rtc = 0;
                                }
                                break;
                        case 3:
                                aux_byte = byte_rtc_04;
                                if (aux_byte & inx_bit) P2OUT |= BIT_RTC_DATA_OUT;
                                else P2OUT &= ~BIT_RTC_DATA_OUT;
                                
                                inx_bit = inx_bit >> 1;
                                if (!(inx_bit)) {
                                        inx_byte_out = 4;
                                        inx_bit = 0x80;
                                        byte_in_rtc = 0;
                                }
                                break;
                        case 4:
                                aux_byte = byte_rtc_05;
                                if (aux_byte & inx_bit) P2OUT |= BIT_RTC_DATA_OUT;
                                else P2OUT &= ~BIT_RTC_DATA_OUT;
                                
                                inx_bit = inx_bit >> 1;
                                if (!(inx_bit)) {
                                        inx_byte_out = 5;
                                        inx_bit = 0x80;
                                        byte_in_rtc = 0;
                                }
                                break;                                                          
                        case 5:
                                P2OUT &= ~BIT_RTC_DATA_OUT;
                                inx_byte_out = 6;       //Una interrupcion de mas
                                byte_in_rtc = 0;
                                break;
                        case 6:
                                aux_byte = P2IN & BIT_LSB;
                                byte_in_rtc = byte_in_rtc << 1;
                                byte_in_rtc |= aux_byte;
                        
                                inx_bit = inx_bit >> 1;
                                if (!(inx_bit)) {
                                        inx_byte_out = 7;
                                        inx_bit = 0x80;
                                        byte_cmm_rtc_01 = byte_in_rtc;
                                        byte_in_rtc = 0;
                                }
                                break;  
                        case 7:
                                aux_byte = P2IN & BIT_LSB;
                                byte_in_rtc = byte_in_rtc << 1;
                                byte_in_rtc |= aux_byte;
                                
                                inx_bit = inx_bit >> 1;
                                if (!(inx_bit)) {
                                        inx_byte_out = 8;
                                        inx_bit = 0x80;
                                        byte_cmm_rtc_02 = byte_in_rtc;
                                        byte_in_rtc = 0;
                                }
                                break;
                        case 8:
                                aux_byte = P2IN & BIT_LSB;
                                byte_in_rtc = byte_in_rtc << 1;
                                byte_in_rtc |= aux_byte;
                                
                                inx_bit = inx_bit >> 1;
                                if (!(inx_bit)) {
                                        inx_byte_out = 9;
                                        inx_bit = 0x80;
                                        byte_cmm_rtc_03 = byte_in_rtc;
                                        byte_in_rtc = 0;
                                }
                                break;
                        case 9:
                                aux_byte = P2IN & BIT_LSB;
                                byte_in_rtc = byte_in_rtc << 1;
                                byte_in_rtc |= aux_byte;
                                
                                inx_bit = inx_bit >> 1;
                                if (!(inx_bit)) {
                                        inx_byte_out = 10;
                                        inx_bit = 0x80;
                                        byte_cmm_rtc_04 = byte_in_rtc;
                                        byte_in_rtc = 0;
                                }
                                break;
                        case 10:                
                                aux_byte = P2IN & BIT_LSB;      
                                byte_in_rtc = byte_in_rtc << 1;
                                byte_in_rtc |= aux_byte;
                                
                                inx_bit = inx_bit >> 1;
                                if (!(inx_bit)) {
                                        inx_byte_out = 11;
                                        inx_bit = 0x80;
                                        byte_cmm_rtc_05 = byte_in_rtc;
                                        byte_in_rtc = 0;
                                }
                                break;                                                                  
                        case 11:                //Añadido para evitar reprogramaciones 
                                aux_byte = P2IN & BIT_LSB;              //erróneas
                                byte_in_rtc = byte_in_rtc << 1;
                                byte_in_rtc |= aux_byte;
                                
                                inx_bit = inx_bit >> 1;
                                if (!(inx_bit)) {
                                        inx_byte_out = 12;
                                        inx_bit = 0x80;
                                        byte_cmm_rtc_00 = byte_in_rtc;
                                        byte_in_rtc = 0;

                                        f_stat &= ~F_OUT_ACTIVA;        //Finalizó el poll              
                                        f_stat &= ~F_IRQ_CHGED;                 
                                        __low_power_mode_off_on_exit(); //standby
                                        _NOP();
                                        _NOP();
                                }
                                break;
                        default:
                                f_stat &= ~F_OUT_ACTIVA;        //Finalizó el poll              
                                f_stat &= ~F_IRQ_CHGED;                 
                                __low_power_mode_off_on_exit(); //standby
                                _NOP();
                                _NOP();
                                break;
                }
        }
        
        P2IFG = 0x00;
}
/*
** ###################################################################
**      Base de tiempos del sistema basada en el Watchdog Timer,
**      programado para generar interrupciones cada 1.965 mseg
** ###################################################################*/
#if __VER__ < 200
interrupt[WDT_VECTOR] void BaseTiempos(void)
#else
#pragma vector=WDT_VECTOR
__interrupt void BaseTiempos(void)
#endif
{
        tics_1mseg +=1;
        timeout = CheckTimeout(_1_SEG, t_ref_segundos);
        if (timeout) {
                f_stat |= F_FIX_SEG;
                __low_power_mode_off_on_exit();
                _NOP();
                _NOP();
                P3OUT ^= 0x20;  
        }
        //IFG1 &= ~WDTIFG;      //No hace falta
}

---