/*******************************************************************************************************
 *                                                                                                     *
 *        **********                                                                                   *
 *       ************                                                                                  *
 *      ***        ***                                                                                 *
 *      ***   +++   ***                                                                                *
 *      ***   + +   ***     This file contains macros and function prototypes for the c8051f320        *
 *      ***   +                                                                                        *
 *      ***   + +   ***                                                                                *
 *      ***   +++   ***     halsrf04.h                                                                 *
 *      ***        ***                                                                                 *
 *       ************                                                                                  *
 *        **********                                                                                   *
 *                                                                                                     *
 *******************************************************************************************************
 * Compiler:                Keil C51 V7.50                                                             *
 * Target platform:         Chipcon CCxxx0 (Silabs F320)                                               *
 * Author:                  SNA                                                                        *
 *******************************************************************************************************
 * Revision history:        See end of file                                                            *
 ******************************************************************************************************/
#ifndef HALSRF04_H
#define HALSRF04_H
#include <Chipcon\srf04\regssrf04.h>
#include <Chipcon\srf04\common.h>





/*******************************************************************************************************
 *******************************************************************************************************
 **************************              Interrupt functions/macros          ***************************
 *******************************************************************************************************
 *******************************************************************************************************/
//-------------------------------------------------------------------------------------------------------
//  This section contain useful macros for enable/disable interrupt, set and get flag, set interrupt
//  priority.
//      ENABLE_GLOBAL_INT(on)
//      INT_ENABLE(inum, on)
//      INT_PRIORITY(inum, p)
//      INT_GETFLAG(inum)
//      INT_SETFLAG(inum, f)
//-------------------------------------------------------------------------------------------------------




//-------------------------------------------------------------------------------------------------------
// General
#define ENABLE_GLOBAL_INT(on)   do { EA = on; } while (0)

// where on is one of:
#define INT_ON      1
#define INT_OFF     0
//-------------------------------------------------------------------------------------------------------




//-------------------------------------------------------------------------------------------------------
// Macro used together with the INUM_* constants defined in regssrf04.h to enable or disable certain 
// interrupts. E.g:
// INT_ENABLE(INUM_EXTERNAL0, INT_ON); 
// INT_ENABLE(INUM_UART0, INT_OFF); 
#define INT_ENABLE(inum, on) \
    do { \
        if (inum == INUM_EXTERNAL0) \
            EX0 = (on); \
        else if (inum == INUM_TIMER0) \
            ET0 = (on); \
        else if (inum == INUM_EXTERNAL1) \
            EX1 = (on); \
        else if (inum == INUM_TIMER1) \
            ET1 = (on); \
        else if (inum == INUM_UART0) \
            ES0 = (on); \
        else if (inum == INUM_TIMER2) \
            ET2 = (on); \
        else if (inum == INUM_SPI0) \
            ESPI0 = (on); \
        else if (inum == INUM_SMB0) \
            (on ? (EIE1 |= BM_ESMB0) : (EIP1 &= (~BM_ESMB0))); \
        else if (inum == INUM_USB0) \
            (on ? (EIE1 |= BM_EUSB0) : (EIE1 &= (~BM_EUSB0))); \
        else if (inum == INUM_ADC0WINDOW) \
            (on ? (EIE1 |= BM_EWADC0) : (EIE1 &= (~BM_EWADC0))); \
        else if (inum == INUM_ADC0) \
            (on ? (EIE1 |= BM_EADC0) : (EIE1 &= (~BM_EADC0))); \
        else if (inum == INUM_PCA0) \
            (on ? (EIE1 |= BM_EPCA0) : (EIE1 &= (~BM_EPCA0))); \
        else if (inum == INUM_ACOMP0) \
            (on ? (EIE1 |= BM_ECP0) : (EIE1 &= (~BM_ECP0))); \
        else if (inum == INUM_ACOMP1) \
            (on ? (EIE1 |= BM_ECP1) : (EIE1 &= (~BM_ECP1))); \
        else if (inum == INUM_TIMER3) \
            (on ? (EIE1 |= BM_ET3) : (EIE1 &= (~BM_ET3))); \
        else if (inum == INUM_VBUS) \
            (on ? (EIE2 |= BM_EVBUS) : (EIE2 &= (~BM_EVBUS))); \
    } while (0)
//-------------------------------------------------------------------------------------------------------




//-------------------------------------------------------------------------------------------------------
// Macro used together with the INUM_* constants defined in regssrf04.h to set the priority of certain 
// interrupts. E.g:
// INT_PRIORITY(INUM_RF, INT_HIGH);
// INT_PRIORITY(INUM_UART0, INT_LOW);
#define INT_PRIORITY(inum, p) \
    do {\
        if (inum == INUM_EXTERNAL0) \
                PX0 = (p); \
        else if (inum == INUM_TIMER0) \
                PT0 = (p); \
        else if (inum == INUM_EXTERNAL1) \
                PX1 = (p); \
        else if (inum == INUM_TIMER1) \
                PT1 = (p); \
        else if (inum == INUM_UART0) \
                PS0 = (p); \
        else if (inum == INUM_TIMER2) \
                PT2 = (p); \
        else if (inum == INUM_SPI0) \
                PSPI0 = (p); \
        else if (inum == INUM_SMB0) \
            (p ? (EIP1 |= BM_PSMB0) : (EIP1 &= (~BM_PSMB0))); \
        else if (inum == INUM_USB0) \
            (p ? (EIP1 |= BM_PUSB0) : (EIP1 &= (~BM_PUSB0))); \
        else if (inum == INUM_ADC0WINDOW) \
            (p ? (EIP1 |= BM_PWADC0) : (EIP1 &= (~BM_PWADC0))); \
        else if (inum == INUM_ADC0) \
            (p ? (EIP1 |= BM_PADC0) : (EIP1 &= (~BM_PADC0))); \
        else if (inum == INUM_PCA0) \
            (p ? (EIP1 |= BM_PPCA0) : (EIP1 &= (~BM_PPCA0))); \
        else if (inum == INUM_ACOMP0) \
            (p ? (EIP1 |= BM_PCP0) : (EIP1 &= (~BM_PCP0))); \
        else if (inum == INUM_ACOMP1) \
            (p ? (EIP1 |= BM_PCP1) : (EIP1 &= (~BM_PCP1))); \
        else if (inum == INUM_TIMER3) \
            (p ? (EIP1 |= BM_PT3) : (EIP1 &= (~BM_PT3))); \
        else if (inum == INUM_VBUS) \
            (p ? (EIP2 |= BM_PVBUS) : (EIP2 &= (~BM_PVBUS))); \
    } while (0)

// where p is one of:
#define INT_HIGH    1
#define INT_LOW     0
//-------------------------------------------------------------------------------------------------------


        

//-------------------------------------------------------------------------------------------------------
// Macro used together with the INUM_* constants defined in regssrf04.h to read the interrupt flags:
// if (INT_GETFLAG(INUM_RF))
//     ...
// while (!INT_GETFLAG(INUM_UART0_TX));
#define INT_GETFLAG(inum) ( \
    (inum == INUM_EXTERNAL0)    ? \
        IE0: \
    (inum == INUM_TIMER0)       ? \
        TF0: \
    (inum == INUM_EXTERNAL1)    ? \
        IE1: \
    (inum == INUM_TIMER1)       ? \
        TF1: \
    (inum == INUM_UART0_RX)     ? \
        RI0: \
    (inum == INUM_UART0_TX)     ? \
        TI0: \
    (inum == INUM_TIMER2_H)     ? \
        TF2H: \
    (inum == INUM_TIMER2_L)     ? \
        TF2L: \
    (inum == INUM_SPI0_IF)      ? \
        SPIF: \
    (inum == INUM_SPI0_WCOL)    ? \
        WCOL: \
    (inum == INUM_SPI0_MODF)    ? \
        MODF: \
    (inum == INUM_SPI0_RXOVRN)  ? \
        RXOVRN: \
    (inum == INUM_SMB0)         ? \
        SI: \
    (inum == INUM_ADC0WINDOW)   ? \
        AD0WINT: \
    (inum == INUM_ADC0)         ? \
        AD0INT: \
    (inum == INUM_PCA0_IF)      ? \
        CF: \
    (inum == INUM_PCA0_CCF0)    ? \
        CCF0: \
    (inum == INUM_PCA0_CCF1)    ? \
        CCF1: \
    (inum == INUM_PCA0_CCF2)    ? \
        CCF2: \
    (inum == INUM_PCA0_CCF3)    ? \
        CCF3: \
    (inum == INUM_PCA0_CCF4)    ? \
        CCF4: \
    (inum == INUM_ACOMP0_F)     ? \
        (CPT0CN & BM_CP0FIF): \
    (inum == INUM_ACOMP0_R)     ? \
        (CPT0CN & BM_CP0RIF): \
    (inum == INUM_ACOMP1_F)     ? \
        (CPT1CN & BM_CP1FIF): \
    (inum == INUM_ACOMP1_R)     ? \
        (CPT1CN & BM_CP1RIF): \
    (inum == INUM_TIMER3_H)     ? \
        (TMR3CN & BM_TF3H): \
    (inum == INUM_TIMER3_L)     ? \
        (TMR3CN & BM_TF3L): \
    0 \
)
//-------------------------------------------------------------------------------------------------------




//-------------------------------------------------------------------------------------------------------
// Macro used together with the INUM_* constants defined in regsrf04.h to set
// or clear certain interrupt flags. E.g:
// INT_SETFLAG(INUM_UART0_RX, INT_CLR);
#define INT_SETFLAG(inum, f) \
    do { \
        if (inum == INUM_EXTERNAL0) \
            IE0 = (f); \
        else if (inum == INUM_TIMER0) \
            TF0 = (f); \
        else if (inum == INUM_EXTERNAL1) \
            IE1 = (f); \
        else if (inum == INUM_TIMER1) \
            TF1 = (f); \
        else if (inum == INUM_UART0_RX) \
            RI0 = (f); \
        else if (inum == INUM_UART0_TX) \
            TI0 = (f); \
        else if (inum == INUM_TIMER2_H) \
            TF2H = (f); \
        else if (inum == INUM_TIMER2_L) \
            TF2L = (f); \
        else if (inum == INUM_SPI0_IF) \
            SPIF = (f); \
        else if (inum == INUM_SPI0_WCOL) \
            WCOL = (f); \
        else if (inum == INUM_SPI0_MODF) \
            MODF = (f); \
        else if (inum == INUM_SPI0_RXOVRN) \
            RXOVRN = (f); \
        else if (inum == INUM_SMB0) \
            SI = (f); \
        else if (inum == INUM_ADC0WINDOW) \
            AD0WINT = (f); \
        else if (inum == INUM_ADC0) \
            AD0INT = (f); \
        else if (inum == INUM_PCA0_IF) \
            CF = (f); \
        else if (inum == INUM_PCA0_CCF0) \
            CCF0 = (f); \
        else if (inum == INUM_PCA0_CCF1) \
            CCF1 = (f); \
        else if (inum == INUM_PCA0_CCF2) \
            CCF2 = (f); \
        else if (inum == INUM_PCA0_CCF3) \
            CCF3 = (f); \
        else if (inum == INUM_PCA0_CCF4) \
            CCF4 = (f); \
        else if (inum == INUM_ACOMP0_F) \
            (f ? (CPT0CN |= BM_CP0FIF) : (CPT0CN &= (~BM_CP0FIF))); \
        else if (inum == INUM_ACOMP0_R) \
            (f ? (CPT0CN |= BM_CP0RIF) : (CPT0CN &= (~BM_CP0RIF))); \
        else if (inum == INUM_ACOMP1_F) \
            (f ? (CPT1CN |= BM_CP1FIF) : (CPT1CN &= (~BM_CP1FIF))); \
        else if (inum == INUM_ACOMP1_R) \
            (f ? (CPT1CN |= BM_CP1RIF) : (CPT1CN &= (~BM_CP1RIF))); \
        else if (inum == INUM_TIMER3_H) \
            (f ? (TMR3CN |= BM_TF3H) : (TMR3CN &= (~BM_TF3H))); \
        else if (inum == INUM_TIMER3_L) \
            (f ? (TMR3CN |= BM_TF3L) : (TMR3CN &= (~BM_TF3L))); \
    } while (0)

//where f is one of:
#define INT_SET     1
#define INT_CLR     0
//-------------------------------------------------------------------------------------------------------





/*******************************************************************************************************
 *******************************************************************************************************
 **************************               EXTERNAL INTERRUPTS                 **************************
 *******************************************************************************************************
 *******************************************************************************************************/
//-------------------------------------------------------------------------------------------------------
// This section contains macros for setting up GDO0 and GDO2 interrupt from CCxxx0. 
//-------------------------------------------------------------------------------------------------------




//------------------------------------------------------------------------------------------------------
//  SETUP_GDO0_INT(trigger, polarity)
//
//  DESCRIPTION:
//      This macro is setting up the GDO0 interrupt from CCxx00. The interrupt is on P0.6 and is 
//      assign to external interrupt0. The macro enables external interrupt0.
//
//  ARGUMENTS:
//      trigger
//          EDGE    (interrupt is edge sensitive)
//          LEVEL   (interrupt is level sensitive)
//      polarity
//          HIGH    (input is active high)
//          LOW     (input is active low)
//------------------------------------------------------------------------------------------------------
#define SETUP_GDO0_INT(trigger, polarity) \
    do { \
        IT0 = trigger; \
        IT01CF = ((IT01CF & 0xF0) | ((polarity << 3) | 0x06)); \
        INT_ENABLE(INUM_EXTERNAL0, INT_ON); \
    } while (0)
//------------------------------------------------------------------------------------------------------