rt-thread/bsp/CME_M7/StdPeriph_Driver/inc/cmem7_can.h

/**
	*****************************************************************************
	* @file     cmem7_can.h
	*
	* @brief    CMEM7 CAN header file
	*
	*
	* @version  V1.0
	* @date     3. September 2013
	*
	* @note               
	*           
	*****************************************************************************
	* @attention
	*
	* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
	* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
	* TIME. AS A RESULT, CAPITAL-MICRO SHALL NOT BE HELD LIABLE FOR ANY DIRECT, 
	* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
	* FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
	* CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
	*
	* <h2><center>&copy; COPYRIGHT 2013 Capital-micro </center></h2>
	*****************************************************************************
	*/
	
#ifndef __CMEM7_CAN_H
#define __CMEM7_CAN_H

#ifdef __cplusplus
 extern "C" {
#endif

#include "cmem7.h"
#include "cmem7_conf.h"
	 
#define IS_CAN_ALL_PERIPH(PERIPH) (((PERIPH) == CAN0) || \
                                   ((PERIPH) == CAN1))

/** @defgroup CAN_FLT
  * @{
  */																
#define CAN_FLT_STANDARD_SINGLE    0x00000000
#define CAN_FLT_STANDARD_DUAL      0x00000001
#define CAN_FLT_EXTENDED_SINGLE    0x00000002
#define CAN_FLT_EXTENDED_DUAL      0x00000003

#define IS_CAN_FLT_TYPE(FILTER)    (((FILTER) == CAN_FLT_STANDARD_SINGLE) || \
                                    ((FILTER) == CAN_FLT_STANDARD_DUAL) || \
																		((FILTER) == CAN_FLT_EXTENDED_SINGLE) || \
                                    ((FILTER) == CAN_FLT_EXTENDED_DUAL))	
																		
#define IS_CAN_FLT_SINGLE(FILTER)  (((FILTER) == CAN_FLT_STANDARD_SINGLE) || \
                                    ((FILTER) == CAN_FLT_EXTENDED_SINGLE))

#define IS_CAN_FLT_DUAL(FILTER)    (IS_CAN_FLT_TYPE(FILTER) && \
                                    !IS_CAN_FLT_SINGLE(FILTER))
																		
/**
  * @}
  */

/** @defgroup CAN_CDR_DIV
  * @{
  */
#define CAN_CDR_DIV_1_2            0x0
#define CAN_CDR_DIV_1_4            0x1
#define CAN_CDR_DIV_1_6            0x2
#define CAN_CDR_DIV_1_8            0x3
#define CAN_CDR_DIV_1_10           0x4
#define CAN_CDR_DIV_1_12           0x5
#define CAN_CDR_DIV_1_14           0x6
#define CAN_CDR_DIV_1_1            0x7

#define IS_CAN_CDR_DIV(DIV)        (((DIV) == CAN_CDR_DIV_1_2) || \
                                    ((DIV) == CAN_CDR_DIV_1_4) || \
																		((DIV) == CAN_CDR_DIV_1_6) || \
																		((DIV) == CAN_CDR_DIV_1_8) || \
																		((DIV) == CAN_CDR_DIV_1_10) || \
																		((DIV) == CAN_CDR_DIV_1_12) || \
																		((DIV) == CAN_CDR_DIV_1_14) || \
																		((DIV) == CAN_CDR_DIV_1_1))		
/**
  * @}
  */

/** @defgroup CAN_INT
  * @{
  */
#define CAN_INT_RBNF               0x01
#define CAN_INT_TB_UNLOCK          0x02
#define CAN_INT_ERR                0x04
#define CAN_INT_DATA_OVERRUN       0x08
#define CAN_INT_WAKEUP             0x10
#define CAN_INT_ERR_PASSIVE        0x20
#define CAN_INT_ARBITRATION_LOST   0x40
#define CAN_INT_BUS_ERR            0x80
#define CAN_INT_All                0xFF

#define IS_CAN_INT(INT)            (((INT) != 0) && (((INT) & ~CAN_INT_All) == 0))                                  
/**
  * @}
  */

/**
  * @brief  CAN standard filter structure
	*/ 
typedef struct {
	uint16_t  ID28_18;               /*!< 11 bits                                      */
  BOOL      RTR;                   /*!< if remote frame                              */
	uint8_t   data1;                 /*!< data byte 1, if not 2nd CAN_FLT_STANDARD_DUAL*/
	uint8_t   data2;                 /*!< data byte 2, if CAN_FLT_STANDARD_SINGLE      */
} CAN_STANDARD_FILTER;

/**
  * @brief  CAN extended filter structure
	*/
typedef struct {
	uint16_t  ID28_13;               /*!< 16 bits                                      */
	uint16_t  ID12_0;                /*!< 13 bits, if CAN_FLT_EXTENDED_SINGLE          */
  BOOL      RTR;                   /*!< if remote frame, if CAN_FLT_EXTENDED_SINGLE  */
} CAN_EXTENDED_FILTER;

/**
  * @brief  CAN filter structure
	*/
typedef struct {
	uint8_t   type;                  /*!< Filter type, which is a value of @ref CAN_FLT */
	
	/**
  * @brief  accepted filter
	*/
	union {
		CAN_STANDARD_FILTER sf;				 
		CAN_EXTENDED_FILTER ef;				 
	} ACCEPT;												 
	
	/**
  * @brief  filter mask 
	*/
	union {
		CAN_STANDARD_FILTER sf;        
		CAN_EXTENDED_FILTER ef;				 
	} MASK;													 
} CAN_FILTER;

/**
  * @brief  CAN initialization structure
	*/
typedef struct {	
	BOOL CAN_TxEn;            			 /*!< if transmission is enable 										*/
	BOOL CAN_Loopback;        			 /*!< loop back mode without phy						 				*/
  uint8_t CAN_ClockDiv;     			 /*!< input clock divider, ref as @ref CAN_CDR_DIV  */                               
	uint16_t CAN_Prescaler;   			 /*!< Specifies the length of a time quantum. 
																				Time quantum = (CAN_Prescaler + 1) * 2 * input clock */ 
  uint8_t CAN_SJW;          			 /*!< Specifies the maximum number of time quanta 
																				the CAN hardware is allowed to lengthen or 
																				shorten a bit to perform resynchronization.		*/
	uint8_t CAN_TSEG1;        			 /*!< the maximum number of time quanta of 
																				propagation and 1st phase segment 						*/
  uint8_t CAN_TSEG2;        			 /*!< the maximum number of time quanta of 2nd 
																				phase segment																	*/	
  BOOL CAN_HighSpeed;       			 /*!< if CAN is running on high speed bus (class C) */
} CAN_InitTypeDef;

/**
  * @brief  CAN frame structure
	*/
typedef struct
{
  BOOL SFF;        								 /*!< If standard or extended frame format 					*/ 
	uint32_t Id;     								 /*!< Specifies the identifier.This parameter can 
																				be a value between 0 to 0x1FFFFFFF. 					*/
  BOOL RTR;        								 /*!< Specifies if the frame is a remote frame      */
  uint8_t DLC;     								 /*!< Specifies the length of the frame, which is 
																				a value between  0 to 8 											*/
  uint8_t Data[8]; 								 /*!< Frame data																		*/
} CAN_Frame;

/**
  * @brief  CAN initialization
  * @note   This function should be called at first before any other interfaces.
	* @param[in] CANx CAN peripheral, which is CAN0 or CAN1
	* @param[in] Init A pointer to structure CAN_InitTypeDef
	* @param[in] f1 A pointer to structure CAN_FILTER
	* @param[in] f2 NULL if single filter, or a pointer to second filter while dual filters
  * @retval BOOL The bit indicates if specific CAN is initialized or not
	*/ 
BOOL CAN_Init(CAN0_Type* CANx, CAN_InitTypeDef* Init, 
  CAN_FILTER *f1, CAN_FILTER *f2);

/**
  * @brief  CAN is set to sleep or wake up
  * @param[in] CANx CAN peripheral, which is CAN0 or CAN1
	* @param[in] Enable The bit indicates if sleep mode is enable or not
	* @retval None
	*/
void CAN_SetSleepMode(CAN0_Type* CANx, BOOL enable);

/**
  * @brief  Enable or disable UART interrupt. 
	* @param[in] CANx CAN peripheral, which is CAN0 or CAN1
	* @param[in] Int interrupt mask bits, which can be the combination of @ref CAN_INT
	* @param[in] Enable The bit indicates if specific interrupts are enable or not
  * @retval None
	*/ 
void CAN_EnableInt(CAN0_Type* CANx, uint32_t Int, BOOL enable);

/**
  * @brief  Check specific interrupts are set or not 
	* @note   All interrupts except for receive int are cleared after call this func.
	* @param[in] CANx CAN peripheral, which is CAN0 or CAN1
	* @retval uint8_t CAN interrupt bits, which can be the combination of @ref CAN_INT
	*/
uint8_t CAN_GetIntStatus(CAN0_Type* CANx);

/**
  * @brief  CAN perform to transmit data
	* @param[in] CANx CAN peripheral, which is CAN0 or CAN1
	* @param[in] frame A pointer to the CAN_Frame to be transmitted
	* @retval BOOL The bit indicates if data is transmitted or not
	*/ 
BOOL CAN_Transmit(CAN0_Type* CANx, CAN_Frame* frame);

/**
  * @brief  CAN perform to receive data
	* @param[in] CANx CAN peripheral, which is CAN0 or CAN1
	* @param[out] frame A user-allocated buffer to fetch received frame
	* @retval BOOL The bit indicates if data is recieved or not
	*/
BOOL CAN_Receive(CAN0_Type* CANx, CAN_Frame* frame);

#ifdef __cplusplus
}
#endif

#endif /* __CMEM7_CAN_H */