hal.h

ucos在NEC平台下的移植

/*******************************************************************************************************
 *                                                                                                     *
 *        **********                                                                                   *
 *       ************                                                                                  *
 *      ***        ***                                                                                 *
 *      ***   +++   ***                                                                                *
 *      ***   + +   ***                                                                                *
 *      ***   +                        CHIPCON HARDWARE ABSTRACTION LIBRARY FOR THE CC2420             *
 *      ***   + +   ***                               Library Header File                              *
 *      ***   +++   ***                                                                                *
 *      ***        ***                                                                                 *
 *       ************                                                                                  *
 *        **********                                                                                   *
 *                                                                                                     *
 *******************************************************************************************************
 * Copyright Chipcon AS, 2004 / NEC Electronics Europe GmbH , 2004                                     *
 *******************************************************************************************************
 * The Chipcon Hardware Abstraction Library is a collection of functions, macros and constants, which  *
 * can be used to ease access to the hardware on the CC2420 and the target microcontroller.            *
 *                                                                                                     *
 * All HAL library macros and constants are defined here. The file contains the following sections:    *
 *     - 78K0/KF2<->CC2420 SPI interface (collection of simple and advanced SPI macros optimized for speed) *
 *     - Interrupts (macros used to enable, disable and clear various 78K0/KF2 interrupts)             *
 *     - ADC (simple macros used to initialize and get samples from the 78K0/KF2 ADC)                  *
 *     - Pulse width modulator (simple macros used to initalize and use the 8-bit timer 0 for PWM)     *
 *     - Timer 0 (initialization for a single timeout)                                                 *
 *     - Timer 1 (initialization for a series of timeouts at a specified interval + start/stop)        *
 *     - Serial port (UART1) (Initialization + simple operation via macros)                            *
 *     - Useful stuff (macros and function prototypes)                                                 *
 *     - EEPROM access (function prototypes)                                                           *
 *     - Simple CC2420 functions (function prototypes)                                                 *
 *******************************************************************************************************
 * Compiler: NEC Electronics PM plus V5.20                                                             *
 * Target platform: 78K0/KF2                                                                           *
 *******************************************************************************************************
 * The revision history is located at the bottom of this file                                          *
 *******************************************************************************************************/
#ifndef HAL_H
#define HAL_H

extern UINT8 spiCnt ;///
/*******************************************************************************************************
 *******************************************************************************************************
 **************************            78K0/KF2<->CC2420 SPI INTERFACE             **************************
 *******************************************************************************************************
 *******************************************************************************************************/

//extern volatile struct{unsigned char FlagACSI:1;};

//-------------------------------------------------------------------------------------------------------
// Initialization
// port 14.2, 14.4 and 14.5 output, all other input
// port initialization
// pull-up port 14 resistor connected
// SPI enabled, 1 byte comm.mode, master mode, MSB first
// strobe output disabled, busy detection disabled, error detection enabled
// baudrate FX/6
#define SPI_INIT() { CSIM11=0x40; CSIC11=0x01; CSIE11 = 1;}	// fprs/2^2
///#define SPI_INIT() { CSIM11=0x40; CSIC11=0x00; CSIE11 = 1;}	///fprs/2

//-------------------------------------------------------------------------------------------------------


//-------------------------------------------------------------------------------------------------------
// FAST SPI: Low level functions
//      x = value (BYTE or WORD)
//      p = pointer to the byte array to operate on
//      c = the byte count
//
// SPI_ENABLE() and SPI_DISABLE() are located in the devboard header file (CS_N uses GPIO)
// interrupt implementation to wait until the transmission of one byte is finished
//#define FASTSPI_WAIT()        { while (!(FlagACSI)){};FlagACSI = 0; }
// polling implementation to wait until the transmission of one byte is finished

#define FASTSPI_WAIT()        { while ((CSIM11.0==1)){};}

#define FASTSPI_TX(x)         { SOTB11 = x; FASTSPI_WAIT();}

#define FASTSPI_RX(x)         { SOTB11 = 0; FASTSPI_WAIT();  x = SIO11; }

#define FASTSPI_RX_GARBAGE()  { SOTB11 = 0;  FASTSPI_WAIT(); }

#define FASTSPI_TX_WORD_LE(x) { FASTSPI_TX(x); FASTSPI_TX((x) >> 8); }

#define FASTSPI_TX_WORD(x)    { FASTSPI_TX(((WORD)(x)) >> 8); FASTSPI_TX((BYTE)(x)); }

#define FASTSPI_TX_MANY(p,c)                            \
    {                                                   \
        for (spiCnt = 0; spiCnt < (c); spiCnt++)  \
        {                                               \
            FASTSPI_TX(((BYTE*)(p))[spiCnt]);           \
            FASTSPI_WAIT();                             \
        }                                               \
    }

#define FASTSPI_RX_WORD_LE(x) { SOTB11 = 0; FASTSPI_WAIT(); x = SIO11; SOTB11 = 0; FASTSPI_WAIT(); x |= SIO11 << 8; }

#define FASTSPI_RX_WORD(x)    { SOTB11 = 0; FASTSPI_WAIT(); x = SIO11 << 8; SOTB11 = 0;  FASTSPI_WAIT();  x |= SIO11; }

#define FASTSPI_RX_MANY(p,c)                            \
    {                                                   \
        for (spiCnt = 0; spiCnt < (c); spiCnt++)  \
        {                                               \
            FASTSPI_RX((p)[spiCnt]);                    \
            FASTSPI_WAIT();                             \
        }                                               \
    }

// Register address:
#define FASTSPI_TX_ADDR(a)  { SOTB11 = a; FASTSPI_WAIT(); }

// Register address:
#define FASTSPI_RX_ADDR(a)  { SOTB11 = (a) | 0x40;  FASTSPI_WAIT(); }

//-------------------------------------------------------------------------------------------------------


//-------------------------------------------------------------------------------------------------------
//  FAST SPI: Register access
//      s = command strobe
//      a = register address
//      v = register value

#define FASTSPI_STROBE(s) { SPI_ENABLE(); FASTSPI_TX_ADDR(s);  SPI_DISABLE(); }

#define FASTSPI_SETREG(a,v) \
    do { \
        SPI_ENABLE(); \
        FASTSPI_TX_ADDR(a); \
        FASTSPI_TX((BYTE) ((v) >> 8)); \
        FASTSPI_TX((BYTE) (v)); \
        SPI_DISABLE_BIS(); \
    } while (0)

#define FASTSPI_GETREG(a,v) \
    do { \
        SPI_ENABLE(); \
        FASTSPI_RX_ADDR(a); \
        FASTSPI_RX_WORD(v); \
        SPI_DISABLE(); \
    } while (0)

// Updates the SPI status byte
#define FASTSPI_UPD_STATUS(s) \
    do { \
        SPI_ENABLE(); \
        FASTSPI_TX_ADDR(CC2420_SNOP); \
        s = SIO11; \
        SPI_DISABLE(); \
    } while (0)

//-------------------------------------------------------------------------------------------------------


//-------------------------------------------------------------------------------------------------------
//  FAST SPI: FIFO access
//      p = pointer to the byte array to be read/written
//      c = the number of bytes to read/write
//      b = single data byte

#define FASTSPI_WRITE_FIFO(p,c) \
    do { \
        SPI_ENABLE(); \
        FASTSPI_TX_ADDR(CC2420_TXFIFO); \
        for (UINT8 spiCnt = 0; spiCnt < (c); spiCnt++) { \
            FASTSPI_TX(((BYTE*)(p))[spiCnt]); \
        } \
        SPI_DISABLE(); \
    } while (0)

#define FASTSPI_READ_FIFO(p,c) \
    do { \
        SPI_ENABLE(); \
        FASTSPI_RX_ADDR(CC2420_RXFIFO); \
        for (UINT8 spiCnt = 0; spiCnt < (c); spiCnt++) { \
            while (!FIFO_IS_ACTIVE); \
            FASTSPI_RX(((BYTE*)(p))[spiCnt]); \
        } \
        SPI_DISABLE(); \
    } while (0)

#define FASTSPI_READ_FIFO_BYTE(b) \
    do { \
        SPI_ENABLE(); \
        FASTSPI_RX_ADDR(CC2420_RXFIFO); \
        FASTSPI_RX(b); \
        SPI_DISABLE(); \
    } while (0)

#define FASTSPI_READ_FIFO_NO_WAIT(p,c) \
    do { \
        SPI_ENABLE(); \
        FASTSPI_RX_ADDR(CC2420_RXFIFO); \
        for (spiCnt = 0; spiCnt < (c); spiCnt++) { \
            FASTSPI_RX(((BYTE*)(p))[spiCnt]); \
        } \
        SPI_DISABLE(); \
    } while (0)

#define FASTSPI_READ_FIFO_GARBAGE(c) \
    do { \
        SPI_ENABLE(); \
        FASTSPI_RX_ADDR(CC2420_RXFIFO); \
        for (spiCnt = 0; spiCnt < (c); spiCnt++) { \
            FASTSPI_RX_GARBAGE(); \
        } \
        SPI_DISABLE(); \
    } while (0)

//-------------------------------------------------------------------------------------------------------


//-------------------------------------------------------------------------------------------------------
//  FAST SPI: CC2420 RAM access (big or little-endian order)
//      p = pointer to the variable to be written
//      a = the CC2420 RAM address
//      c = the number of bytes to write
//      n = counter variable which is used in for/while loops (UINT8)
//
//  Example of usage:
//      UINT8 n;
//      UINT16 shortAddress = 0xBEEF;
//      FASTSPI_WRITE_RAM_LE(&shortAddress, CC2420RAM_SHORTADDR, 2);

#define FASTSPI_WRITE_RAM_LE(p,a,c,n) \
    do { \
        SPI_ENABLE(); \
        FASTSPI_TX(0x80 | (a & 0x7F)); \
        FASTSPI_TX((a >> 1) & 0xC0); \
        for (n = 0; n < (c); n++) { \
            FASTSPI_TX(((BYTE*)(p))[n]); \
        } \
        SPI_DISABLE(); \
    } while (0)

#define FASTSPI_READ_RAM_LE(p,a,c,n) \
    do { \
        SPI_ENABLE(); \
        FASTSPI_TX(0x80 | (a & 0x7F)); \
        FASTSPI_TX(((a >> 1) & 0xC0) | 0x20); \
        for (n = 0; n < (c); n++) { \
            FASTSPI_RX(((BYTE*)(p))[n]); \
        } \
        SPI_DISABLE(); \
    } while (0)

#define FASTSPI_WRITE_RAM(p,a,c,n) \
    do { \
        SPI_ENABLE(); \
        FASTSPI_TX(0x80 | (a & 0x7F)); \
        FASTSPI_TX((a >> 1) & 0xC0); \
        n = c; \
        do { \
            FASTSPI_TX(((BYTE*)(p))[--n]); \
        } while (n); \
        SPI_DISABLE(); \
    } while (0)

#define FASTSPI_READ_RAM(p,a,c,n) \
    do { \
        SPI_ENABLE(); \
        FASTSPI_TX(0x80 | (a & 0x7F)); \
        FASTSPI_TX(((a >> 1) & 0xC0) | 0x20); \
        n = c; \
        do { \
            FASTSPI_RX(((BYTE*)(p))[--n]); \
        } while (n); \
        SPI_DISABLE(); \
    } while (0)
//-------------------------------------------------------------------------------------------------------


//-------------------------------------------------------------------------------------------------------
// Other useful SPI macros
#define FASTSPI_RESET_CC2420() \
    do { \
        FASTSPI_SETREG(CC2420_MAIN, 0x0000); \
        FASTSPI_SETREG(CC2420_MAIN, 0xF800); \
    } while (0)
//-------------------------------------------------------------------------------------------------------




/*******************************************************************************************************
 *******************************************************************************************************
 **************************                    INTERRUPTS                     **************************
 *******************************************************************************************************
 *******************************************************************************************************/


//-------------------------------------------------------------------------------------------------------
// General
#define ENABLE_GLOBAL_INT()         {EI(); }
#define DISABLE_GLOBAL_INT()        {DI(); }

//-------------------------------------------------------------------------------------------------------


//-------------------------------------------------------------------------------------------------------
// UART0 interrupts
#define ENABLE_UART1_INT()          { DUALMK0 = 0; SRMK0 = 0; }
#define DISABLE_UART1_INT()         { DUALMK0 = 0; SRMK0 = 0; }

#define ENABLE_UART1_TX_INT()       { DUALMK0 = 0; }
#define DISABLE_UART1_TX_INT()      { DUALMK0 = 1; }
#define IS_UART1_TX_INT_ENABLED()   ( DUALMK0 )
#define CLEAR_UART1_TX_INT()        { DUALIF0 = 0; }

#define ENABLE_UART1_RX_INT()       { SRMK0 = 0 }
#define DISABLE_UART1_RX_INT()      { SRMK0 = 1 }
#define IS_UART1_RX_INT_ENABLED()   ( SRMK0 )
//-------------------------------------------------------------------------------------------------------


//-------------------------------------------------------------------------------------------------------
// Timer/Counter 50 interrupts