can.h

从Luminary官方网站下载的LM3S6000系列的UCos+Tcp/IP的源码, 经本人稍微修改后可直接在IAR6.2下编译通过,里面包括了LM3S6000系列的所有外设UART, PWn....

//*****************************************************************************
//
// can.h - Defines and Macros for the CAN controller.
//
// Copyright (c) 2006-2007 Luminary Micro, Inc.  All rights reserved.
// 
// Software License Agreement
// 
// Luminary Micro, Inc. (LMI) is supplying this software for use solely and
// exclusively on LMI's microcontroller products.
// 
// The software is owned by LMI and/or its suppliers, and is protected under
// applicable copyright laws.  All rights are reserved.  Any use in violation
// of the foregoing restrictions may subject the user to criminal sanctions
// under applicable laws, as well as to civil liability for the breach of the
// terms and conditions of this license.
// 
// THIS SOFTWARE IS PROVIDED "AS IS".  NO WARRANTIES, WHETHER EXPRESS, IMPLIED
// OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE.
// LMI SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR
// CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
// 
// This is part of revision 1234-conf of the Stellaris Peripheral Driver Library.
//
//*****************************************************************************

#ifndef __CAN_H__
#define __CAN_H__

#ifdef __cplusplus
extern "C"
{
#endif

//*****************************************************************************
//
//! \addtogroup can_api
//! @{
//
//*****************************************************************************

//*****************************************************************************
//
// Miscellaneous defines for Message ID Types
//
//*****************************************************************************

//*****************************************************************************
//
//! Enumerated flags used by the tCANMsgObject in the CANMessageSet() and
//! CANMessageGet() APIs.
//
//*****************************************************************************
typedef enum
{
    //
    //! This indicates that transmit interrupts should be enabled, or are
    //! enabled.
    //
    MSG_OBJ_TX_INT_ENABLE =     0x00000001,

    //
    //! This indicates that receive interrupts should be enabled or are
    //! enabled.
    //
    MSG_OBJ_RX_INT_ENABLE =     0x00000002,

    //
    //! This indicates that a message object will use or is using an extended
    //! identifier.
    //
    MSG_OBJ_EXTENDED_ID =       0x00000004,

    //
    //! This indicates that a message object will use or is using filtering
    //! based on the object's message Identifier.
    //
    MSG_OBJ_USE_ID_FILTER =     0x00000008,

    //
    //! This indicates that new data was available in the message object.
    //
    MSG_OBJ_NEW_DATA =          0x00000080,

    //
    //! This indicates that data was lost since this message object was last
    //! read.
    //
    MSG_OBJ_DATA_LOST =         0x00000100,

    //
    //! This indicates that a message object will use or is using filtering
    //! based on the direction of the transfer. If the direction filtering is
    //! used then ID filtering must also be enabled.
    //
    MSG_OBJ_USE_DIR_FILTER =    (0x00000010 | MSG_OBJ_USE_ID_FILTER),

    //
    //! This indicates that a message object will use or is using message
    //! identifier filtering based of the the extended identifier.
    //! If the extended identifier filtering is used then ID filtering must
    //! also be enabled.
    //
    MSG_OBJ_USE_EXT_FILTER =    (0x00000020 | MSG_OBJ_USE_ID_FILTER),

    //
    //! This indicates that a message object is a remote frame.
    //
    MSG_OBJ_REMOTE_FRAME =      0x00000040,

    //
    //! This indicates that a message object has no flags set.
    //
    MSG_OBJ_NO_FLAGS =          0x00000000
}
tCANObjFlags;

//*****************************************************************************
//
//! This define is used with the tCANObjFlags enumerated values to allow
//! checking only status flags and not configuration flags.
//
//*****************************************************************************
#define MSG_OBJ_STATUS_MASK     (MSG_OBJ_NEW_DATA | MSG_OBJ_DATA_LOST)

//*****************************************************************************
//
//! This structure used for encapsulating all the items associated with a CAN
//! message object in the CAN controller.
//
//*****************************************************************************
typedef struct
{
    //
    //! The CAN message identifier 11 or 29 bits.
    //
    unsigned long ulMsgID;

    //
    //! The message identifier filter mask.
    //
    unsigned long ulMsgIDMask;

    //
    //! Holds various status flags and settings.
    //
    unsigned long ulFlags;

    //
    //! Length in bytes of the data for the message object.
    //
    unsigned long ulMsgLen;

    //
    //! Points and array in memeory holding the message object data bytes.
    //
    unsigned char *pucMsgData;
}
tCANMsgObject;

//*****************************************************************************
//
//! This structure is used for encapsulating the items associated with setting
//! up the bit timing for one of the CAN controllers.
//
//*****************************************************************************
typedef struct
{
    //
    //! Sychronization + Propagation + Phase Buffer 1 segments, measured in
    //! time quanta. Valid values are in the range of 2-16.
    //
    unsigned int uSyncPropPhase1Seg;

    //
    //! Phase Buffer 2 segments, measured in time quanta. Valid values are in
    //! the range of 1-8.
    //
    unsigned int uPhase2Seg;

    //
    //! Resynchronization Jump Width, measured in time quanta. Valid values are
    //! in the range of 1-4.
    //
    unsigned int uSJW;

    //
    //! The CAN_CLK divider to determine time quantum. Valid values are in the
    //! range of 1-1023.
    //
    unsigned int uQuantumPrescaler;

}
tCANBitClkParms;

//*****************************************************************************
//
//! This data type is used to identify the interrupt status register.  This is
//! used when calling the a CANIntStatus() function.
//
//*****************************************************************************
typedef enum
{
    //
    //! Read the CAN interrupt status information.
    //
    CAN_INT_STS_CAUSE,

    //
    //! Read a message object's interrupt status.
    //
    CAN_INT_STS_OBJECT
}
tCANIntStsReg;

//*****************************************************************************
//
//! This data type is used to identify which of the several status registers
//! to read when calling the CANStatusGet() function.
//
//*****************************************************************************
typedef enum
{
    //
    //! Read the full CAN controller status.
    //
    CAN_STS_CONTROL,

    //
    //! Read the full 32 bit mask of message objects with a transmit request
    //! set.
    //
    CAN_STS_TXREQUEST,

    //
    //! Read the full 32 bit mask of message objects with a new data available.
    //
    CAN_STS_NEWDAT,

    //
    //! Read the full 32 bit mask of message objects that are enabled.
    //
    CAN_STS_MSGVAL
}
tCANStsReg;

//*****************************************************************************
//
//! These definitions are used in calls to CANIntEnable() and
//! CANIntDisable().
//
//*****************************************************************************
typedef enum
{
    //
    //! This is used to allow a CAN controller to generate error interrupts.
    //
    CAN_INT_ERROR =             0x00000008,

    //
    //! This is used to allow a CAN controlelr to generate status interrupts.
    //
    CAN_INT_STATUS =            0x00000004,

    //
    //! This is used to allow a CAN controller to gererate any CAN interrupts.
    //! If this is not set then no interrupts will be generated by the CAN
    //! controller.
    //
    CAN_INT_MASTER =            0x00000002
}
tCANIntFlags;

//*****************************************************************************
//
//! This definition is used to determine the type of message object that will
//! be set up via a call to the CANMessageSet() API.
//
//*****************************************************************************
typedef enum
{
    //
    //! Transmit message object.
    //
    MSG_OBJ_TYPE_TX,

    //
    //! Transmit remote request message object
    //
    MSG_OBJ_TYPE_TX_REMOTE,

    //
    //! Recieve message object.
    //
    MSG_OBJ_TYPE_RX,

    //
    //! Recieve remote request message object.
    //
    MSG_OBJ_TYPE_RX_REMOTE,

    //
    //! Remote frame receive remote, with auto-transmit message object.
    //
    MSG_OBJ_TYPE_RXTX_REMOTE
}
tMsgObjType;

//*****************************************************************************
//
//! The following enumeration contains all error or status indicators that 
//! can be returned when calling the CANStatusGet() API.
//
//*****************************************************************************
typedef enum
{
    //
    //! CAN controller has entered a Bus Off state.
    //
    CAN_STATUS_BUS_OFF =        0x00000080, 
    
    //
    //! CAN controller error level has reached warning level.
    // 
    CAN_STATUS_EWARN =          0x00000040, 

    //
    //! CAN controller error level has reached error passive level.
    //
    CAN_STATUS_EPASS =          0x00000020,
    
    //
    //! A message was received successfully since the last read of this status.
    //
    CAN_STATUS_RXOK =           0x00000010,  

    //
    //! A message was transmitted successfully since the last read of this
    //! status.
    //
    CAN_STATUS_TXOK =           0x00000008,
    
    //
    //! This is the mask for the last error code field.
    //
    CAN_STATUS_LEC_MSK =        0x00000007,
    
    //
    //! There was no error.
    //
    CAN_STATUS_LEC_NONE =       0x00000000,
    
    //
    //! A bit stuffing error has occured.
    //
    CAN_STATUS_LEC_STUFF =      0x00000001,

    //
    //! A formatting error has occured.
    //
    CAN_STATUS_LEC_FORM =       0x00000002,
    
    //
    //! An acknowledge error has occurred.
    //
    CAN_STATUS_LEC_ACK =        0x00000003,
    
    //
    //! The bus remained a bit level of 1 for longer than is allowed.
    //
    CAN_STATUS_LEC_BIT1 =       0x00000004,

    //
    //! The bus remained a bit level of 0 for longer than is allowed.
    //
    CAN_STATUS_LEC_BIT0 =       0x00000005,
    
    //
    //! A CRC error has occured.
    //
    CAN_STATUS_LEC_CRC =        0x00000006
}
tCANStatusCtrl;

//*****************************************************************************
//
// API Function prototypes
//
//*****************************************************************************
extern void CANInit(unsigned long ulBase);

extern void CANEnable(unsigned long ulBase);

extern void CANDisable(unsigned long ulBase);

extern void CANSetBitTiming(unsigned long ulBase, tCANBitClkParms *pClkParms);

extern void CANGetBitTiming(unsigned long ulBase, tCANBitClkParms *pClkParms);

extern unsigned long CANReadReg(unsigned long ulRegAddress);

extern void CANWriteReg(unsigned long ulRegAddress, unsigned long ulRegValue);

extern long CANMessageSet(unsigned long ulBase, unsigned long ulObjID,
    tCANMsgObject *pMsgObject, tMsgObjType eMsgType);

extern void CANMessageGet(unsigned long ulBase, unsigned long ulObjID,
    tCANMsgObject *pMsgObject, tBoolean bClrPendingInt);

extern unsigned long CANStatusGet(unsigned long ulBase, tCANStsReg eStatusReg);

extern void CANMessageClear(unsigned long ulBase, unsigned long ulObjID);

extern void CANIntRegister(unsigned long ulBase, void (*pfnHandler)(void));

extern void CANIntEnable(unsigned long ulBase, unsigned long ulIntFlags);

extern void CANIntDisable(unsigned long ulBase, unsigned long ulIntFlags);

extern void CANIntClear(unsigned long ulBase, unsigned long ulIntClr);

extern unsigned long CANIntStatus(unsigned long ulBase,
    tCANIntStsReg eIntStsReg);

extern tBoolean CANRetryGet(unsigned long ulBase);

void CANRetrySet(unsigned long ulBase, tBoolean bAutoRetry);

extern tBoolean CANErrCntrGet(unsigned long ulBase, unsigned long *pulRxCount,
    unsigned long *pulTxCount);

long CANGetIntNumber(unsigned long ulBase);

void CANReadDataReg(unsigned char *pucData, unsigned long *pulRegister,
    int iSize);

void CANWriteDataReg(unsigned char *pucData, unsigned long *pulRegister,
    int iSize);


//*****************************************************************************
//
// Close the Doxygen group.
//! @}
//
//*****************************************************************************

#ifdef __cplusplus
}
#endif

#endif //  __CAN_H__