can.h

Go to the documentation of this file.

#ifndef __CAN_H__
#define __CAN_H__

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

/*----- Header-Files -------------------------------------------------------*/
#include <stm32f4xx.h>              /* Processor STM32F407IG                */
#include <carme.h>                  /* CARME Module                         */
#include <can_sja1000.h>            /* CAN Controller SJA1000 defines       */

/*----- Macros -------------------------------------------------------------*/
#define CARME_CAN_nCAN_INT_PORT GPIOI           
#define CARME_CAN_nCAN_INT_PIN  GPIO_Pin_8      
#define CARME_CAN_nCAN_IRQn_CH  EXTI9_5_IRQn    
/* baudrates */
#define CARME_CAN_BAUD_125K         125000      
#define CARME_CAN_BAUD_250K         250000      
#define CARME_CAN_BAUD_500K         500000      
#define CARME_CAN_BAUD_1M           1000000     
/* error codes */
#define CARME_ERROR_CAN                         CARME_ERROR_CAN_BASE + 0    
#define CARME_ERROR_CAN_INVALID_BAUDRATE        CARME_ERROR_CAN_BASE + 1    
#define CARME_ERROR_CAN_RXFIFO_EMPTY            CARME_ERROR_CAN_BASE + 2    
#define CARME_ERROR_CAN_INVALID_MODE            CARME_ERROR_CAN_BASE + 3    
#define CARME_ERROR_CAN_INVALID_OPMODE          CARME_ERROR_CAN_BASE + 4    
#define CARME_ERROR_CAN_INVALID_ACCEPTANCE_MODE CARME_ERROR_CAN_BASE + 5    
#define CARME_ERROR_CAN_ERROR_STATUS            CARME_ERROR_CAN_BASE + 6    
/* interrupt enable flags */
#define CARME_CAN_INT_BUSERR        (SJA1000_IER_BEIE)  
#define CARME_CAN_INT_ARBIT_LOST    (SJA1000_IER_ALIE)  
#define CARME_CAN_INT_PASSIVE       (SJA1000_IER_EPIE)  
#define CARME_CAN_INT_WAKEUP        (SJA1000_IER_WUIE)  
#define CARME_CAN_INT_OVERRUN       (SJA1000_IER_DOIE)  
#define CARME_CAN_INT_ERROR         (SJA1000_IER_EIE)   
#define CARME_CAN_INT_TX            (SJA1000_IER_TIE)   
#define CARME_CAN_INT_RX            (SJA1000_IER_RIE)   
/* driver flags */
#define CARME_CAN_DF_RESET          0x00    
#define CARME_CAN_DF_NORMAL         0x01    
#define CARME_CAN_DF_LISTEN_ONLY    0x02    
//#define CARME_CAN_DF_SLEEP        0x04

/*----- Data types ---------------------------------------------------------*/
enum CARME_CAN_IRQ_CALLBACKS {
    CARME_CAN_IRQID_RX_INTERRUPT = 0,           
    CARME_CAN_IRQID_TX_INTERRUPT,               
    CARME_CAN_IRQID_ERROR_INTERRUPT,            
    CARME_CAN_IRQID_DATAOVERFLOW_INTERRUPT,     
    CARME_CAN_IRQID_WAKEUP_INTERRUPT,           
    CARME_CAN_IRQID_PASSIVE_INTERRUPT,          
    CARME_CAN_IRQID_ARITRATION_LOST_INTERRUPT,  
    CARME_CAN_IRQID_BUS_ERROR_INTERRUPT,        
    CARME_CAN_IRQID_COUNT                       
};

typedef struct _CARME_CAN_MESSAGE {
    uint32_t id;        
    uint8_t ext;        
    uint8_t rtr;        
    uint8_t dlc;        
    uint8_t data[8];    
} CARME_CAN_MESSAGE;

enum CARME_CAN_ACCEPTANCE_FILTER_MODE {
    MODE_SINGLE = 1,    
    MODE_DUAL = 2       
};

typedef struct _CARME_CAN_ACCEPTANCE_FILTER {
    uint8_t acr[4];     
    uint8_t amr[4];     
    enum CARME_CAN_ACCEPTANCE_FILTER_MODE afm; 
} CARME_CAN_ACCEPTANCE_FILTER;

typedef void (*IRQ_CALLBACK)();

/*----- Function prototypes ------------------------------------------------*/
extern void CARME_CAN_Init(uint32_t baud, uint8_t flags);
extern void CARME_CAN_InitI(uint32_t baud, uint8_t flags, uint32_t interrupts);
extern ERROR_CODES CARME_CAN_Write(CARME_CAN_MESSAGE* txMsg);
extern ERROR_CODES CARME_CAN_Read(CARME_CAN_MESSAGE* rxMsg);

extern void CARME_CAN_Interrupt_Handler(void);
extern void CARME_CAN_RegisterIRQCallback(enum CARME_CAN_IRQ_CALLBACKS id,
                                          IRQ_CALLBACK pIRQCallback);
extern void CARME_CAN_UnregisterIRQCallback(enum CARME_CAN_IRQ_CALLBACKS id);

extern ERROR_CODES CARME_CAN_SetMode(uint8_t flags);
extern ERROR_CODES CARME_CAN_SetBaudrate(uint32_t baud);
extern ERROR_CODES CARME_CAN_SetAcceptaceFilter(
        CARME_CAN_ACCEPTANCE_FILTER* af);
extern ERROR_CODES CARME_CAN_GetAcceptaceFilter(
        CARME_CAN_ACCEPTANCE_FILTER* af);
#ifdef CARME_CAN_DEBUG
/* debug functions */
extern void CARME_CAN_PrintRegisters();
extern void CARME_CAN_GetRegisterString(char* pStr);
#endif

/*----- Data ---------------------------------------------------------------*/
static __IO uint8_t *SJA1000_CMD = (__IO uint8_t *) (FSMC_CAN_BASE);
static __IO uint8_t *SJA1000_DATA = (__IO uint8_t *) (FSMC_CAN_BASE + 8);

/*----- Implementation -----------------------------------------------------*/
static void CARME_CAN_Write_Register(uint8_t registerAddress, uint8_t val) {
    *SJA1000_CMD = registerAddress;     /* write address                    */
    *SJA1000_DATA = val;                /* write data                       */
}

static uint8_t CARME_CAN_Read_Register(uint8_t registerAddress) {
    *SJA1000_CMD = registerAddress;     /* write address                    */
    return *SJA1000_DATA;               /* read data                        */
}

static inline uint8_t CARME_CAN_IsBusOn(void) {
    return (CARME_CAN_Read_Register(SJA1000_SR) & SJA1000_SR_BS) == 0;
}

static inline uint8_t CARME_CAN_IsDataOverrun(void) {
    return (CARME_CAN_Read_Register(SJA1000_SR) & SJA1000_SR_DOS)
            == SJA1000_SR_DOS;
}

static inline uint8_t CARME_CAN_IsError(void) {
    return (CARME_CAN_Read_Register(SJA1000_SR) & SJA1000_SR_ES)
            == SJA1000_SR_ES;
}

static inline void CARME_CAN_ClearDataOverrun(void) {
    CARME_CAN_Write_Register(SJA1000_CMR, SJA1000_CMR_CDO); // set CDO-bit
}

static inline void CARME_CAN_AbortTransmisssion(void) {

    CARME_CAN_Write_Register(SJA1000_CMR, SJA1000_CMR_AT);  // set At-bit
}

static inline ERROR_CODES CARME_CAN_SetErrorWarningLimit(uint8_t limit) {
    ERROR_CODES err = CARME_NO_ERROR;

    if (!(CARME_CAN_Read_Register(SJA1000_MOD) & SJA1000_MOD_RM)) {
        err = CARME_ERROR_CAN_INVALID_OPMODE;
    }
    CARME_CAN_Write_Register(SJA1000_EWL, limit);

    return err;
}

static inline void CARME_CAN_GetErrorWarningLimit(uint8_t* limit) {
    *limit = CARME_CAN_Read_Register(SJA1000_EWL);
}

static inline void CARME_CAN_GetRxErrCount(uint8_t* count) {
    *count = CARME_CAN_Read_Register(SJA1000_RXERR);
}

static inline void CARME_CAN_GetTxErrCount(uint8_t* count) {

    *count = CARME_CAN_Read_Register(SJA1000_TXERR);
}

static inline void CARME_CAN_GetArbitrationLostCapture(uint8_t* alc) {
    *alc = CARME_CAN_Read_Register(SJA1000_ALC);
}

static inline void CARME_CAN_GetErrorCodeCapture(uint8_t* ecc) {

    *ecc = CARME_CAN_Read_Register(SJA1000_ECC);
}

#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif /* __CAN_H__ */