due_can.h

/*
  Copyright (c) 2013 Arduino.  All right reserved.

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  See the GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef _CAN_LIBRARY_
#define _CAN_LIBRARY_

#include <Arduino.h>

//add some extra stuff that is needed for Arduino 1.5.2
#ifndef PINS_CAN0
  static const uint8_t CAN1RX = 88;
  static const uint8_t CAN1TX = 89;

  // CAN0
  #define PINS_CAN0            (90u)
  // CAN1
  #define PINS_CAN1            (91u)
  #define ARDUINO152
#endif

#define CAN   Can0
#define CAN2  Can1

#define CAN0_EN  62
#define CAN1_EN  65

/** Define the Mailbox mask for eight mailboxes. */
#define GLOBAL_MAILBOX_MASK           0x000000ff

/** Disable all interrupt mask */
#define CAN_DISABLE_ALL_INTERRUPT_MASK 0xffffffff

/** Define the typical baudrate for CAN communication. */
#ifdef CAN_BPS_500K
#undef CAN_BPS_1000K 
#undef CAN_BPS_800K                 
#undef CAN_BPS_500K                 
#undef CAN_BPS_250K                 
#undef CAN_BPS_125K    
#undef CAN_BPS_100K                                 
#undef CAN_BPS_50K                   
#undef CAN_BPS_33333          
#undef CAN_BPS_25K                   
#undef CAN_BPS_10K                   
#undef CAN_BPS_5K                   
#endif

/** Define the typical baudrate for CAN communication in KHz. */
#define CAN_BPS_1000K                 1000000
#define CAN_BPS_800K                  800000
#define CAN_BPS_500K                  500000
#define CAN_BPS_250K                  250000
#define CAN_BPS_125K                  125000
#define CAN_BPS_100K                  100000
#define CAN_BPS_50K                   50000
#define CAN_BPS_33333                 33333
#define CAN_BPS_25K                   25000
#define CAN_BPS_10K                   10000
#define CAN_BPS_5K                    5000
#define CAN_DEFAULT_BAUD              CAN_BPS_250K

/** Define the mailbox mode. */
#define CAN_MB_DISABLE_MODE           0
#define CAN_MB_RX_MODE                1
#define CAN_MB_RX_OVER_WR_MODE        2
#define CAN_MB_TX_MODE                3
#define CAN_MB_CONSUMER_MODE          4
#define CAN_MB_PRODUCER_MODE          5

/** Define CAN mailbox transfer status code. */
#define CAN_MAILBOX_TRANSFER_OK       0     //! Read from or write into mailbox successfully.
#define CAN_MAILBOX_NOT_READY         0x01  //! Receiver is empty or transmitter is busy.
#define CAN_MAILBOX_RX_OVER           0x02  //! Message overwriting happens or there're messages lost in different receive modes.
#define CAN_MAILBOX_RX_NEED_RD_AGAIN  0x04  //! Application needs to re-read the data register in Receive with Overwrite mode.

#define SIZE_RX_BUFFER  32 //RX incoming ring buffer is this big
#define SIZE_TX_BUFFER  32 //TX ring buffer is this big

  /** Define the timemark mask. */
#define TIMEMARK_MASK              0x0000ffff

/* CAN timeout for synchronization. */
#define CAN_TIMEOUT                100000

/** The max value for CAN baudrate prescale. */
#define CAN_BAUDRATE_MAX_DIV       128

/** Define the scope for TQ. */
#define CAN_MIN_TQ_NUM             8
#define CAN_MAX_TQ_NUM             25

/** Define the fixed bit time value. */
#define CAN_BIT_SYNC               1
#define CAN_BIT_IPT                2

typedef struct {
  uint8_t uc_tq;      //! CAN_BIT_SYNC + uc_prog + uc_phase1 + uc_phase2 = uc_tq, 8 <= uc_tq <= 25.
  uint8_t uc_prog;    //! Propagation segment, (3-bits + 1), 1~8;
  uint8_t uc_phase1;  //! Phase segment 1, (3-bits + 1), 1~8;
  uint8_t uc_phase2;  //! Phase segment 2, (3-bits + 1), 1~8, CAN_BIT_IPT <= uc_phase2;
  uint8_t uc_sjw;     //! Resynchronization jump width, (2-bits + 1), min(uc_phase1, 4);
  uint8_t uc_sp;      //! Sample point value, 0~100 in percent.
} can_bit_timing_t;


/** Values of bit time register for different baudrates, Sample point = ((1 + uc_prog + uc_phase1) / uc_tq) * 100%. */
const can_bit_timing_t can_bit_time[] = {
  {8,   (2 + 1), (1 + 1), (1 + 1), (2 + 1), 75},
  {9,   (1 + 1), (2 + 1), (2 + 1), (1 + 1), 67},
  {10,  (2 + 1), (2 + 1), (2 + 1), (2 + 1), 70},
  {11,  (3 + 1), (2 + 1), (2 + 1), (3 + 1), 72},
  {12,  (2 + 1), (3 + 1), (3 + 1), (3 + 1), 67},
  {13,  (3 + 1), (3 + 1), (3 + 1), (3 + 1), 77},
  {14,  (3 + 1), (3 + 1), (4 + 1), (3 + 1), 64},
  {15,  (3 + 1), (4 + 1), (4 + 1), (3 + 1), 67},
  {16,  (4 + 1), (4 + 1), (4 + 1), (3 + 1), 69},
  {17,  (5 + 1), (4 + 1), (4 + 1), (3 + 1), 71},
  {18,  (4 + 1), (5 + 1), (5 + 1), (3 + 1), 67},
  {19,  (5 + 1), (5 + 1), (5 + 1), (3 + 1), 68},
  {20,  (6 + 1), (5 + 1), (5 + 1), (3 + 1), 70},
  {21,  (7 + 1), (5 + 1), (5 + 1), (3 + 1), 71},
  {22,  (6 + 1), (6 + 1), (6 + 1), (3 + 1), 68},
  {23,  (7 + 1), (7 + 1), (6 + 1), (3 + 1), 70},
  {24,  (6 + 1), (7 + 1), (7 + 1), (3 + 1), 67},
  {25,  (7 + 1), (7 + 1), (7 + 1), (3 + 1), 68}
};

//This is architecture specific. DO NOT USE THIS UNION ON ANYTHING OTHER THAN THE CORTEX M3 / Arduino Due
//UNLESS YOU DOUBLE CHECK THINGS!
typedef union {
    uint64_t value;
  struct {
    uint32_t low;
    uint32_t high;
  };
  struct {
        uint16_t s0;
    uint16_t s1;
    uint16_t s2;
    uint16_t s3;
    };
  uint8_t bytes[8];
  uint8_t byte[8]; //alternate name so you can omit the s if you feel it makes more sense
} BytesUnion;

typedef struct
{
  uint32_t id;    // EID if ide set, SID otherwise
  uint32_t fid;   // family ID
  uint8_t rtr;    // Remote Transmission Request
  uint8_t priority; // Priority but only important for TX frames and then only for special uses.
  uint8_t extended; // Extended ID flag
  uint8_t length;   // Number of data bytes
  BytesUnion data;  // 64 bits - lots of ways to access it.
} CAN_FRAME;

class CANRaw
{
  protected:
  int numTXBoxes; //There are 8 mailboxes, anything not TX will be set RX

  private:
  /* CAN peripheral, set by constructor */
  Can* m_pCan ;

  volatile CAN_FRAME rx_frame_buff[SIZE_RX_BUFFER];
  volatile CAN_FRAME tx_frame_buff[SIZE_TX_BUFFER];

  volatile uint16_t rx_buffer_head, rx_buffer_tail;
  volatile uint16_t tx_buffer_head, tx_buffer_tail;
  void mailbox_int_handler(uint8_t mb, uint32_t ul_status);

  uint8_t enablePin;
  uint32_t write_id; //public storage for an id. Will be used by the write function to set which ID to send to.
  bool bigEndian;

  void (*cbCANFrame[9])(CAN_FRAME *); //8 mailboxes plus an optional catch all

  public:

    // Constructor
    CANRaw( Can* pCan, uint32_t En);

  int setRXFilter(uint32_t id, uint32_t mask, bool extended);
  int setRXFilter(uint8_t mailbox, uint32_t id, uint32_t mask, bool extended);
  int watchFor(); //allow anything through
  int watchFor(uint32_t id); //allow just this ID through (automatic determination of extended status)
  int watchFor(uint32_t id, uint32_t mask); //allow a range of ids through
  int watchForRange(uint32_t id1, uint32_t id2); //try to allow the range from id1 to id2 - automatically determine base ID and mask

  void setNumTXBoxes(int txboxes);
  int findFreeRXMailbox();
  uint8_t mailbox_get_mode(uint8_t uc_index);
  uint32_t mailbox_get_id(uint8_t uc_index);
  uint32_t getMailboxIer(int8_t mailbox);
  uint32_t set_baudrate(uint32_t ul_baudrate);

  uint32_t init(uint32_t ul_baudrate);
  uint32_t begin();
  uint32_t begin(uint32_t baudrate);
  uint32_t begin(uint32_t baudrate, uint8_t enablePin);

  void enable();
  void disable();
  void disable_low_power_mode();
  void enable_low_power_mode();
  void disable_autobaud_listen_mode();
  void enable_autobaud_listen_mode();
  void disable_overload_frame();
  void enable_overload_frame();
  void set_timestamp_capture_point(uint32_t ul_flag);
  void disable_time_triggered_mode();
  void enable_time_triggered_mode();
  void disable_timer_freeze();
  void enable_timer_freeze();
  void disable_tx_repeat();
  void enable_tx_repeat();
  void set_rx_sync_stage(uint32_t ul_stage);
  void enable_interrupt(uint32_t dw_mask);
  void disable_interrupt(uint32_t dw_mask);
  uint32_t get_interrupt_mask();
  uint32_t get_status();
  uint8_t check_error();
  uint32_t get_internal_timer_value();
  uint32_t get_timestamp_value();
  uint8_t get_tx_error_cnt();
  uint8_t get_rx_error_cnt();
  void reset_internal_timer();
  void global_send_transfer_cmd(uint8_t uc_mask);
  void global_send_abort_cmd(uint8_t uc_mask);
  void mailbox_set_timemark(uint8_t uc_index, uint16_t us_cnt);
  uint32_t mailbox_get_status(uint8_t uc_index);
  void mailbox_send_transfer_cmd(uint8_t uc_index);
  void mailbox_send_abort_cmd(uint8_t uc_index);
  void mailbox_init(uint8_t uc_index);
  uint32_t mailbox_read(uint8_t uc_index, volatile CAN_FRAME *rxframe);
  uint32_t mailbox_tx_frame(uint8_t uc_index);
  void mailbox_set_id(uint8_t uc_index, uint32_t id, bool extended);
  void mailbox_set_priority(uint8_t uc_index, uint8_t pri);
  void mailbox_set_accept_mask(uint8_t uc_index, uint32_t mask, bool ext);
  void mailbox_set_mode(uint8_t uc_index, uint8_t mode);
  void mailbox_set_databyte(uint8_t uc_index, uint8_t bytepos, uint8_t val);
  void mailbox_set_datalen(uint8_t uc_index, uint8_t dlen);
  void mailbox_set_datal(uint8_t uc_index, uint32_t val);
  void mailbox_set_datah(uint8_t uc_index, uint32_t val);

  bool sendFrame(CAN_FRAME& txFrame);
  void setWriteID(uint32_t id);
  template <typename t> void write(t inputValue); //write a variable # of bytes out in a frame. Uses id as the ID.
  void setBigEndian(bool);

  void setCallback(int mailbox, void (*cb)(CAN_FRAME *));
  void setGeneralCallback(void (*cb)(CAN_FRAME *));
  //note that these below versions still use mailbox number. There isn't a good way around this. 
  void attachCANInterrupt(void (*cb)(CAN_FRAME *)); //alternative callname for setGeneralCallback
  void attachCANInterrupt(uint8_t mailBox, void (*cb)(CAN_FRAME *));
  void detachCANInterrupt(uint8_t mailBox);

  void reset_all_mailbox();
  void interruptHandler();
  bool rx_avail();
  int available(); //like rx_avail but returns the number of waiting frames

  uint32_t get_rx_buff(CAN_FRAME &);
  uint32_t read(CAN_FRAME &);
};

extern CANRaw Can0;
extern CANRaw Can1;

#endif // _CAN_LIBRARY_