bxcan.h

Go to the documentation of this file.

 
#ifndef BXCAN_H
#define BXCAN_H
 
/* -- Includes -- */
#include <stdint.h>
#include "stm32f4xx.h"
#include "defines.h"
 
/* -- Structs -- */
struct __attribute__((packed)) bxCANMailboxRegs {
  REG32 IR; 
  REG32 TR; 
  REG32 LR; 
  REG32 HR; 
};
 
_Static_assert((sizeof(struct bxCANMailboxRegs)) == (sizeof(uint32_t) * 4U),
               "bxCAN Mailbox register struct size mismatch. Is it aligned?");
 
struct __attribute__((packed)) bxCANFilterRegs {
  REG32 FR1;
  REG32 FR2;
};
 
_Static_assert((sizeof(struct bxCANFilterRegs)) == (sizeof(uint32_t) * 2U),
               "bxCAN Filter register struct size mismatch. Is it aligned?");
 
struct __attribute__((packed)) bxCANRegs {
  REG32 MCR;
  REG32 MSR;
  REG32 TSR;
  REG32 RFR[2];
  REG32 IER;
  REG32 ESR;
  REG32 BTR;
  REG32 _reserved1[88];
  struct bxCANMailboxRegs TxMailbox[3];
  struct bxCANMailboxRegs FIFOMailbox[2];
  REG32 _reserved2[12];
  REG32 FMR;
  REG32 FM1R;
  REG32 _reserved3;
  REG32 FS1R;
  REG32 _reserved4;
  REG32 FFA1R;
  REG32 _reserved5;
  REG32 FA1R;
  REG32 _reserved6[8];
  struct bxCANFilterRegs FilterBank[28];
};
 
_Static_assert((sizeof(struct bxCANRegs)) == (sizeof(uint32_t) * 200U),
               "bxCAN register struct size mismatch. Is it aligned?");
 
#define CAN(NUM) (struct bxCANRegs *)(CAN1_BASE + (0x400UL * (uint8_t)NUM))
 
struct __attribute__((packed)) bxCANISR {
  _Bool TME  : 1; 
  _Bool FMP0 : 1; 
  _Bool FF0  : 1; 
  _Bool FOV0 : 1; 
  _Bool FMP1 : 1; 
  _Bool FF1  : 1; 
  _Bool FOV1 : 1; 
  _Bool EWG  : 1; 
  _Bool EPV  : 1; 
  _Bool BOF  : 1; 
  _Bool LEC  : 1; 
  _Bool ERR  : 1; 
  _Bool WKU  : 1; 
  _Bool SLK  : 1; 
};
 
_Static_assert((sizeof(struct bxCANISR)) == (sizeof(uint8_t) * 2U),
               "bxCAN ISR struct size mismatch. Is it aligned?");
 
struct __attribute__((packed)) bxCANBitrateConfig {
  uint8_t TimeSeg1       : 4;  
  uint8_t TimeSeg2       : 3;  
  uint16_t BaudPrescaler : 10; 
};
 
_Static_assert((sizeof(struct bxCANBitrateConfig)) == (sizeof(uint8_t) * 3U),
               "bxCAN Bitrate config struct size mismatch. Is it aligned?");
 
struct __attribute__((packed)) bxCANFilterConfig {
  uint16_t FilterID[2];
  uint16_t FilterIDMask[2];
  _Bool ListMode    : 1;
  _Bool SingleScale : 1;
  _Bool FIFO        : 1;
  _Bool Activate    : 1;
};
 
_Static_assert((sizeof(struct bxCANFilterConfig)) == (sizeof(uint8_t) * 9U),
               "bxCAN Filter config struct size mismatch. Is it aligned?");
 
struct __attribute__((packed)) bxCANAutomationConfig {
  _Bool AutoBusOff : 1;
  _Bool AutoWakeUp : 1;
  _Bool AutoReTx   : 1;
};
 
struct __attribute__((packed)) bxCANFrame {
  /* --- Header --- */
  volatile uint32_t ID;
  volatile _Bool IDE;
  volatile _Bool RTR;
  volatile uint8_t DLC;
  /* --- Time --- */
  volatile uint16_t TIME;
  volatile _Bool TGT;
  /* --- Data --- */
  volatile uint8_t DATA[8];
  // CRC handled by HW
  // ACK handled by HW
};
 
_Static_assert((sizeof(struct bxCANFrame)) == (sizeof(uint8_t) * 18U),
               "bxCAN Frame struct size mismatch. Is it aligned?");
 
struct __attribute__((packed)) bxCANErrorInfo {
  uint8_t RxErrors;
  uint8_t TxErrors;
  uint8_t LastCode;
  _Bool BusOff;
  _Bool Passive;
  _Bool Warning;
};
 
_Static_assert((sizeof(struct bxCANErrorInfo)) == (sizeof(uint8_t) * 6U),
               "bxCAN Error info struct size mismatch. Is it aligned?");
 
/* -- Enums -- */
typedef enum bxcan_peripheral {
#ifdef CAN1_BASE
  BXCAN_PERIPH_1 = 0x0,
#endif
#ifdef CAN2_BASE
  BXCAN_PERIPH_2 = 0x1,
#endif
  BXCAN_PERIPH_LEN
} bxcan_peripheral_t;
 
typedef enum bxcan_mode {
  BXCAN_MODE_INIT = 0x0,
  BXCAN_MODE_NORM,
  BXCAN_MODE_LPOW,
} bxcan_mode_t;
 
typedef enum bxcan_test_mode {
  BXCAN_TEST_MODE_NONE = 0x0,
  BXCAN_TEST_MODE_LOOP,
  BXCAN_TEST_MODE_SLNT,
  BXCAN_TEST_MODE_BOTH
} bxcan_test_mode_t;
 
typedef enum bxcan_fifo_priority {
  BXCAN_FIFO_PRIORITY_ID = 0x0,
  BXCAN_FIFO_PRIORITY_RQ,
} bxcan_fifo_priority_t;
 
void bxcan_set_current_mode(const bxcan_peripheral_t can,
                            const bxcan_mode_t mode);
 
void bxcan_set_test_mode(const bxcan_peripheral_t can,
                         const bxcan_test_mode_t mode);
 
void bxcan_set_time_triggered_mode(const bxcan_peripheral_t can,
                                   const _Bool state);
 
void bxcan_set_interrupts(const bxcan_peripheral_t can,
                          const struct bxCANISR config);
 
void bxcan_configure_bitrate(const bxcan_peripheral_t can,
                             const struct bxCANBitrateConfig config);
 
void bxcan_configure_automation(const bxcan_peripheral_t can,
                                const struct bxCANAutomationConfig config);
 
void bxcan_configure_fifo(const bxcan_peripheral_t can, const _Bool lock,
                          const bxcan_fifo_priority_t priority);
 
void bxcan_set_filter_start(const bxcan_peripheral_t can,
                            const uint8_t filters);
 
void bxcan_configure_filter(const bxcan_peripheral_t can, const uint8_t filter,
                            const struct bxCANFilterConfig config);
 
void bxcan_tx_frame(const bxcan_peripheral_t can, struct bxCANFrame *frame);
 
void bxcan_rx_frame_fetch(const bxcan_peripheral_t can, const _Bool FIFO,
                          struct bxCANMailboxRegs *buffer);
 
void bxcan_rx_frame_process(const struct bxCANMailboxRegs buffer,
                            struct bxCANFrame *frame);
 
const struct bxCANErrorInfo bxcan_get_error_info(const bxcan_peripheral_t can);
 
#endif