Michel2/Seeed_Arduino_CAN
1
0
Fork 0
mirror of https://github.com/Seeed-Studio/Seeed_Arduino_CAN.git synced 2026-09-15 11:03:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add mcp2518fd can bus

Browse Source
This commit is contained in:
wangcoolc
2020-11-09 19:52:44 +08:00
parent 91236f0258
commit 0969c611f9
13 changed files with 1035 additions and 2882 deletions
Download Patch File Download Diff File Expand all files Collapse all files
examples/receive/receive.ino
+38
View File
@@ -0,0 +1,38 @@
// demo: CAN-BUS Shield, send data
// loovee@seeed.cc
#include "mcp2518fd_can.h"
/*SAMD core*/
#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif
//Mcp_Factory<mcp2518fd> my_Factory;
// the cs pin of the version after v1.1 is default to D9
// v0.9b and v1.0 is default D10
const int SPI_CS_PIN = 23;
mcp2518fd* controller;
void setup() {
SERIAL.begin(115200);
controller = new mcp2518fd();
controller->mcp_canbus(SPI_CS_PIN);
while (0 != controller->begin()) { // init can bus : baudrate = 500k
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}
void loop() {
controller->mcp2518fd_receiveMsg();
delay(100); // send data per 100ms
}
// END FILE
examples/send/send.ino
+29 -27
View File
@@ -1,8 +1,7 @@
// demo: CAN-BUS Shield, send data
// loovee@seeed.cc
#include <mcp_can.h>
#include <SPI.h>
#include "mcp2518fd_can.h"
/*SAMD core*/
#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
@@ -11,39 +10,42 @@
#define SERIAL Serial
#endif
//Mcp_Factory<mcp2518fd> my_Factory;
// the cs pin of the version after v1.1 is default to D9
// v0.9b and v1.0 is default D10
const int SPI_CS_PIN = 9;
MCP_CAN CAN(SPI_CS_PIN); // Set CS pin
const int SPI_CS_PIN = 23;
mcp2518fd* controller;
void setup() {
SERIAL.begin(115200);
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
SERIAL.begin(115200);
controller = new mcp2518fd();
controller->mcp_canbus(SPI_CS_PIN);
while (0 != controller->begin()) { // init can bus : baudrate = 500k
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}
unsigned char stmp[8] = {0, 0, 0, 0, 0, 0, 0, 0};
void loop() {
// send data: id = 0x00, standrad frame, data len = 8, stmp: data buf
stmp[7] = stmp[7] + 1;
if (stmp[7] == 100) {
stmp[7] = 0;
stmp[6] = stmp[6] + 1;
// send data: id = 0x00, standrad frame, data len = 8, stmp: data buf
stmp[7] = stmp[7] + 1;
if (stmp[7] == 100) {
stmp[7] = 0;
stmp[6] = stmp[6] + 1;
if (stmp[6] == 100) {
stmp[6] = 0;
stmp[5] = stmp[6] + 1;
}
}
if (stmp[6] == 100) {
stmp[6] = 0;
stmp[5] = stmp[6] + 1;
}
}
CAN.sendMsgBuf(0x00, 0, 8, stmp);
delay(100); // send data per 100ms
controller->mcp2518fd_sendMsgBuf(stmp);
delay(100); // send data per 100ms
}
// END FILE
// END FILE
mcp2515_can.cpp
-1505
View File
File diff suppressed because it is too large Load Diff
mcp2515_can.h
-92
View File
@@ -1,92 +0,0 @@
#include "mcp_can.h"
class mcp2515 : public MCP_CAN {
public:
void init_CS(byte _CS);
void enableTxInterrupt(bool enable = true); // enable transmit interrupt
byte begin(byte speedset, const byte clockset = MCP_16MHz); // init can
byte init_Mask(byte num, byte ext, unsigned long ulData);
byte init_Filt(byte num, byte ext, unsigned long ulData); // init filters
void setSleepWakeup(const byte enable);
byte sleep();
byte wake();
byte setMode(byte opMode);
byte getMode();
byte checkReceive(void);
byte checkError(void);
byte readMsgBufID(byte status, volatile unsigned long* id, volatile byte* ext, volatile byte* rtr, volatile byte* len,
volatile byte* buf);
byte trySendMsgBuf(unsigned long id, byte ext, byte rtrBit, byte len, const byte* buf, byte iTxBuf);
byte sendMsgBuf(byte status, unsigned long id, byte ext, byte rtrBit, byte len, volatile const byte* buf);
byte sendMsgBuf(unsigned long id, byte ext, byte rtrBit, byte len, const byte* buf, bool wait_sent = true); // send buf
byte sendMsgBuf(unsigned long id, byte ext, byte len, const byte* buf, bool wait_sent = true); // send buf
void clearBufferTransmitIfFlags(byte flags);
byte readRxTxStatus(void);
byte checkClearRxStatus(byte* status);
byte checkClearTxStatus(byte* status, byte iTxBuf);
bool mcpPinMode(const byte pin, const byte mode);
bool mcpDigitalWrite(const byte pin, const byte mode);
byte mcpDigitalRead(const byte pin);
void mcp2515_reset(void); // reset mcp2515
byte mcp2515_readRegister(const byte address); // read mcp2515's register
void mcp2515_readRegisterS(const byte address,
byte values[],
const byte n);
void mcp2515_setRegister(const byte address, // set mcp2515's register
const byte value);
void mcp2515_setRegisterS(const byte address, // set mcp2515's registers
const byte values[],
const byte n);
void mcp2515_initCANBuffers(void);
void mcp2515_modifyRegister(const byte address, // set bit of one register
const byte mask,
const byte data);
byte mcp2515_readStatus(void); // read mcp2515's Status
byte mcp2515_setCANCTRL_Mode(const byte newmode); // set mode
byte mcp2515_requestNewMode(const byte newmode); // Set mode
byte mcp2515_configRate(const byte canSpeed, const byte clock); // set baudrate
byte mcp2515_init(const byte canSpeed, const byte clock); // mcp2515init
void mcp2515_write_id(const byte mcp_addr, // write can id
const byte ext,
const unsigned long id);
void mcp2515_read_id(const byte mcp_addr, // read can id
byte* ext,
unsigned long* id);
void mcp2515_write_canMsg(const byte buffer_sidh_addr, unsigned long id, byte ext, byte rtr, byte len,
volatile const byte* buf); // read can msg
void mcp2515_read_canMsg(const byte buffer_load_addr, volatile unsigned long* id, volatile byte* ext,
volatile byte* rtr, volatile byte* len, volatile byte* buf); // write can msg
void mcp2515_start_transmit(const byte mcp_addr); // start transmit
byte mcp2515_getNextFreeTXBuf(byte* txbuf_n); // get Next free txbuf
byte mcp2515_isTXBufFree(byte* txbuf_n, byte iBuf); // is buffer by index free
/*
can operator function
*/
byte sendMsg(unsigned long id, byte ext, byte rtrBit, byte len, const byte* buf, bool wait_sent = true); // send message
// private:
// byte ext_flg; // identifier xxxID
// // either extended (the 29 LSB) or standard (the 11 LSB)
// unsigned long can_id; // can id
// byte rtr; // rtr
// byte SPICS;
// SPIClass* pSPI;
// byte nReservedTx = 0; // Count of tx buffers for reserved send
// byte mcpMode;
};
mcp2515_can_dfs.h
-484
View File
@@ -1,484 +0,0 @@
/*
mcp_can_dfs.h
2012 Copyright (c) Seeed Technology Inc. All right reserved.
Author:Loovee (loovee@seeed.cc)
2014-1-16
Contributor:
Cory J. Fowler
Latonita
Woodward1
Mehtajaghvi
BykeBlast
TheRo0T
Tsipizic
ralfEdmund
Nathancheek
BlueAndi
Adlerweb
Btetz
Hurvajs
xboxpro1
ttlappalainen
The MIT License (MIT)
Copyright (c) 2013 Seeed Technology Inc.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#ifndef _MCP2515DFS_H_
#define _MCP2515DFS_H_
#include <Arduino.h>
#include <SPI.h>
#include <inttypes.h>
// if print debug information
#ifndef DEBUG_EN
#define DEBUG_EN 1
#endif
// Begin mt
#define TIMEOUTVALUE 50
#define MCP_SIDH 0
#define MCP_SIDL 1
#define MCP_EID8 2
#define MCP_EID0 3
#define MCP_TXB_EXIDE_M 0x08 // In TXBnSIDL
#define MCP_DLC_MASK 0x0F // 4 LSBits
#define MCP_RTR_MASK 0x40 // (1<<6) Bit 6
#define MCP_RXB_RX_ANY 0x60
#define MCP_RXB_RX_EXT 0x40
#define MCP_RXB_RX_STD 0x20
#define MCP_RXB_RX_STDEXT 0x00
#define MCP_RXB_RX_MASK 0x60
#define MCP_RXB_BUKT_MASK (1<<2)
// Bits in the TXBnCTRL registers.
#define MCP_TXB_TXBUFE_M 0x80
#define MCP_TXB_ABTF_M 0x40
#define MCP_TXB_MLOA_M 0x20
#define MCP_TXB_TXERR_M 0x10
#define MCP_TXB_TXREQ_M 0x08
#define MCP_TXB_TXIE_M 0x04
#define MCP_TXB_TXP10_M 0x03
#define MCP_TXB_RTR_M 0x40 // In TXBnDLC
#define MCP_RXB_IDE_M 0x08 // In RXBnSIDL
#define MCP_RXB_RTR_M 0x40 // In RXBnDLC
#define MCP_STAT_TX_PENDING_MASK (0x54)
#define MCP_STAT_TX0_PENDING (0x04)
#define MCP_STAT_TX1_PENDING (0x10)
#define MCP_STAT_TX2_PENDING (0x40)
#define MCP_STAT_TXIF_MASK (0xA8)
#define MCP_STAT_TX0IF (0x08)
#define MCP_STAT_TX1IF (0x20)
#define MCP_STAT_TX2IF (0x80)
#define MCP_STAT_RXIF_MASK (0x03)
#define MCP_STAT_RX0IF (1<<0)
#define MCP_STAT_RX1IF (1<<1)
#define MCP_EFLG_RX1OVR (1<<7)
#define MCP_EFLG_RX0OVR (1<<6)
#define MCP_EFLG_TXBO (1<<5)
#define MCP_EFLG_TXEP (1<<4)
#define MCP_EFLG_RXEP (1<<3)
#define MCP_EFLG_TXWAR (1<<2)
#define MCP_EFLG_RXWAR (1<<1)
#define MCP_EFLG_EWARN (1<<0)
#define MCP_EFLG_ERRORMASK (0xF8) // 5 MS-Bits
// Define MCP2515 register addresses
#define MCP_RXF0SIDH 0x00
#define MCP_RXF0SIDL 0x01
#define MCP_RXF0EID8 0x02
#define MCP_RXF0EID0 0x03
#define MCP_RXF1SIDH 0x04
#define MCP_RXF1SIDL 0x05
#define MCP_RXF1EID8 0x06
#define MCP_RXF1EID0 0x07
#define MCP_RXF2SIDH 0x08
#define MCP_RXF2SIDL 0x09
#define MCP_RXF2EID8 0x0A
#define MCP_RXF2EID0 0x0B
#define MCP_BFPCTRL 0x0C
#define MCP_TXRTSCTRL 0x0D
#define MCP_CANSTAT 0x0E
#define MCP_CANCTRL 0x0F
#define MCP_RXF3SIDH 0x10
#define MCP_RXF3SIDL 0x11
#define MCP_RXF3EID8 0x12
#define MCP_RXF3EID0 0x13
#define MCP_RXF4SIDH 0x14
#define MCP_RXF4SIDL 0x15
#define MCP_RXF4EID8 0x16
#define MCP_RXF4EID0 0x17
#define MCP_RXF5SIDH 0x18
#define MCP_RXF5SIDL 0x19
#define MCP_RXF5EID8 0x1A
#define MCP_RXF5EID0 0x1B
#define MCP_TEC 0x1C
#define MCP_REC 0x1D
#define MCP_RXM0SIDH 0x20
#define MCP_RXM0SIDL 0x21
#define MCP_RXM0EID8 0x22
#define MCP_RXM0EID0 0x23
#define MCP_RXM1SIDH 0x24
#define MCP_RXM1SIDL 0x25
#define MCP_RXM1EID8 0x26
#define MCP_RXM1EID0 0x27
#define MCP_CNF3 0x28
#define MCP_CNF2 0x29
#define MCP_CNF1 0x2A
#define MCP_CANINTE 0x2B
#define MCP_CANINTF 0x2C
#define MCP_EFLG 0x2D
#define MCP_TXB0CTRL 0x30
#define MCP_TXB0SIDH 0x31
#define MCP_TXB1CTRL 0x40
#define MCP_TXB1SIDH 0x41
#define MCP_TXB2CTRL 0x50
#define MCP_TXB2SIDH 0x51
#define MCP_RXB0CTRL 0x60
#define MCP_RXB0SIDH 0x61
#define MCP_RXB1CTRL 0x70
#define MCP_RXB1SIDH 0x71
#define MCP_TX_INT 0x1C // Enable all transmit interrup ts
#define MCP_TX01_INT 0x0C // Enable TXB0 and TXB1 interru pts
#define MCP_RX_INT 0x03 // Enable receive interrupts
#define MCP_NO_INT 0x00 // Disable all interrupts
#define MCP_TX01_MASK 0x14
#define MCP_TX_MASK 0x54
// Define SPI Instruction Set
#define MCP_WRITE 0x02
#define MCP_READ 0x03
#define MCP_BITMOD 0x05
#define MCP_LOAD_TX0 0x40
#define MCP_LOAD_TX1 0x42
#define MCP_LOAD_TX2 0x44
#define MCP_RTS_TX0 0x81
#define MCP_RTS_TX1 0x82
#define MCP_RTS_TX2 0x84
#define MCP_RTS_ALL 0x87
#define MCP_READ_RX0 0x90
#define MCP_READ_RX1 0x94
#define MCP_READ_STATUS 0xA0
#define MCP_RX_STATUS 0xB0
#define MCP_RESET 0xC0
// CANCTRL Register Values
#define MODE_NORMAL 0x00
#define MODE_SLEEP 0x20
#define MODE_LOOPBACK 0x40
#define MODE_LISTENONLY 0x60
#define MODE_CONFIG 0x80
#define MODE_POWERUP 0xE0
#define MODE_MASK 0xE0
#define ABORT_TX 0x10
#define MODE_ONESHOT 0x08
#define CLKOUT_ENABLE 0x04
#define CLKOUT_DISABLE 0x00
#define CLKOUT_PS1 0x00
#define CLKOUT_PS2 0x01
#define CLKOUT_PS4 0x02
#define CLKOUT_PS8 0x03
// CNF1 Register Values
#define SJW1 0x00
#define SJW2 0x40
#define SJW3 0x80
#define SJW4 0xC0
// CNF2 Register Values
#define BTLMODE 0x80
#define SAMPLE_1X 0x00
#define SAMPLE_3X 0x40
// CNF3 Register Values
#define SOF_ENABLE 0x80
#define SOF_DISABLE 0x00
#define WAKFIL_ENABLE 0x40
#define WAKFIL_DISABLE 0x00
// CANINTF Register Bits
#define MCP_RX0IF 0x01
#define MCP_RX1IF 0x02
#define MCP_TX0IF 0x04
#define MCP_TX1IF 0x08
#define MCP_TX2IF 0x10
#define MCP_ERRIF 0x20
#define MCP_WAKIF 0x40
#define MCP_MERRF 0x80
// BFPCTRL Register Bits
#define B1BFS 0x20
#define B0BFS 0x10
#define B1BFE 0x08
#define B0BFE 0x04
#define B1BFM 0x02
#define B0BFM 0x01
// TXRTCTRL Register Bits
#define B2RTS 0x20
#define B1RTS 0x10
#define B0RTS 0x08
#define B2RTSM 0x04
#define B1RTSM 0x02
#define B0RTSM 0x01
// clock
#define MCP_16MHz 1
#define MCP_8MHz 2
// speed 16M
#define MCP_16MHz_1000kBPS_CFG1 (0x00)
#define MCP_16MHz_1000kBPS_CFG2 (0xD0)
#define MCP_16MHz_1000kBPS_CFG3 (0x82)
#define MCP_16MHz_500kBPS_CFG1 (0x00)
#define MCP_16MHz_500kBPS_CFG2 (0xF0)
#define MCP_16MHz_500kBPS_CFG3 (0x86)
#define MCP_16MHz_250kBPS_CFG1 (0x41)
#define MCP_16MHz_250kBPS_CFG2 (0xF1)
#define MCP_16MHz_250kBPS_CFG3 (0x85)
#define MCP_16MHz_200kBPS_CFG1 (0x01)
#define MCP_16MHz_200kBPS_CFG2 (0xFA)
#define MCP_16MHz_200kBPS_CFG3 (0x87)
#define MCP_16MHz_125kBPS_CFG1 (0x03)
#define MCP_16MHz_125kBPS_CFG2 (0xF0)
#define MCP_16MHz_125kBPS_CFG3 (0x86)
#define MCP_16MHz_100kBPS_CFG1 (0x03)
#define MCP_16MHz_100kBPS_CFG2 (0xFA)
#define MCP_16MHz_100kBPS_CFG3 (0x87)
#define MCP_16MHz_95kBPS_CFG1 (0x03)
#define MCP_16MHz_95kBPS_CFG2 (0xAD)
#define MCP_16MHz_95kBPS_CFG3 (0x07)
#define MCP_16MHz_83k3BPS_CFG1 (0x03)
#define MCP_16MHz_83k3BPS_CFG2 (0xBE)
#define MCP_16MHz_83k3BPS_CFG3 (0x07)
#define MCP_16MHz_80kBPS_CFG1 (0x03)
#define MCP_16MHz_80kBPS_CFG2 (0xFF)
#define MCP_16MHz_80kBPS_CFG3 (0x87)
#define MCP_16MHz_50kBPS_CFG1 (0x07)
#define MCP_16MHz_50kBPS_CFG2 (0xFA)
#define MCP_16MHz_50kBPS_CFG3 (0x87)
#define MCP_16MHz_40kBPS_CFG1 (0x07)
#define MCP_16MHz_40kBPS_CFG2 (0xFF)
#define MCP_16MHz_40kBPS_CFG3 (0x87)
#define MCP_16MHz_33kBPS_CFG1 (0x09)
#define MCP_16MHz_33kBPS_CFG2 (0xBE)
#define MCP_16MHz_33kBPS_CFG3 (0x07)
#define MCP_16MHz_31k25BPS_CFG1 (0x0F)
#define MCP_16MHz_31k25BPS_CFG2 (0xF1)
#define MCP_16MHz_31k25BPS_CFG3 (0x85)
#define MCP_16MHz_25kBPS_CFG1 (0X0F)
#define MCP_16MHz_25kBPS_CFG2 (0XBA)
#define MCP_16MHz_25kBPS_CFG3 (0X07)
#define MCP_16MHz_20kBPS_CFG1 (0x0F)
#define MCP_16MHz_20kBPS_CFG2 (0xFF)
#define MCP_16MHz_20kBPS_CFG3 (0x87)
#define MCP_16MHz_10kBPS_CFG1 (0x1F)
#define MCP_16MHz_10kBPS_CFG2 (0xFF)
#define MCP_16MHz_10kBPS_CFG3 (0x87)
#define MCP_16MHz_5kBPS_CFG1 (0x3F)
#define MCP_16MHz_5kBPS_CFG2 (0xFF)
#define MCP_16MHz_5kBPS_CFG3 (0x87)
#define MCP_16MHz_666kBPS_CFG1 (0x00)
#define MCP_16MHz_666kBPS_CFG2 (0xA0)
#define MCP_16MHz_666kBPS_CFG3 (0x04)
// speed 8M
#define MCP_8MHz_1000kBPS_CFG1 (0x00)
#define MCP_8MHz_1000kBPS_CFG2 (0x80)
#define MCP_8MHz_1000kBPS_CFG3 (0x00)
#define MCP_8MHz_500kBPS_CFG1 (0x00)
#define MCP_8MHz_500kBPS_CFG2 (0x90)
#define MCP_8MHz_500kBPS_CFG3 (0x02)
#define MCP_8MHz_250kBPS_CFG1 (0x00)
#define MCP_8MHz_250kBPS_CFG2 (0xb1)
#define MCP_8MHz_250kBPS_CFG3 (0x05)
#define MCP_8MHz_200kBPS_CFG1 (0x00)
#define MCP_8MHz_200kBPS_CFG2 (0xb4)
#define MCP_8MHz_200kBPS_CFG3 (0x06)
#define MCP_8MHz_125kBPS_CFG1 (0x01)
#define MCP_8MHz_125kBPS_CFG2 (0xb1)
#define MCP_8MHz_125kBPS_CFG3 (0x05)
#define MCP_8MHz_100kBPS_CFG1 (0x01)
#define MCP_8MHz_100kBPS_CFG2 (0xb4)
#define MCP_8MHz_100kBPS_CFG3 (0x06)
#define MCP_8MHz_80kBPS_CFG1 (0x01)
#define MCP_8MHz_80kBPS_CFG2 (0xbf)
#define MCP_8MHz_80kBPS_CFG3 (0x07)
#define MCP_8MHz_50kBPS_CFG1 (0x03)
#define MCP_8MHz_50kBPS_CFG2 (0xb4)
#define MCP_8MHz_50kBPS_CFG3 (0x06)
#define MCP_8MHz_40kBPS_CFG1 (0x03)
#define MCP_8MHz_40kBPS_CFG2 (0xbf)
#define MCP_8MHz_40kBPS_CFG3 (0x07)
#define MCP_8MHz_31k25BPS_CFG1 (0x07)
#define MCP_8MHz_31k25BPS_CFG2 (0xa4)
#define MCP_8MHz_31k25BPS_CFG3 (0x04)
#define MCP_8MHz_20kBPS_CFG1 (0x07)
#define MCP_8MHz_20kBPS_CFG2 (0xbf)
#define MCP_8MHz_20kBPS_CFG3 (0x07)
#define MCP_8MHz_10kBPS_CFG1 (0x0f)
#define MCP_8MHz_10kBPS_CFG2 (0xbf)
#define MCP_8MHz_10kBPS_CFG3 (0x07)
#define MCP_8MHz_5kBPS_CFG1 (0x1f)
#define MCP_8MHz_5kBPS_CFG2 (0xbf)
#define MCP_8MHz_5kBPS_CFG3 (0x07)
#define MCPDEBUG (0)
#define MCPDEBUG_TXBUF (0)
#define MCP_N_TXBUFFERS (3)
#define MCP_RXBUF_0 (MCP_RXB0SIDH)
#define MCP_RXBUF_1 (MCP_RXB1SIDH)
#define MCP2515_SELECT() digitalWrite(SPICS, LOW)
#define MCP2515_UNSELECT() digitalWrite(SPICS, HIGH)
#define MCP2515_OK (0)
#define MCP2515_FAIL (1)
#define MCP_ALLTXBUSY (2)
#define CANDEBUG 1
#define CANUSELOOP 0
#define CANSENDTIMEOUT (200) // milliseconds
#define MCP_PIN_HIZ (0)
#define MCP_PIN_INT (1)
#define MCP_PIN_OUT (2)
#define MCP_PIN_IN (3)
#define MCP_RX0BF (0)
#define MCP_RX1BF (1)
#define MCP_TX0RTS (2)
#define MCP_TX1RTS (3)
#define MCP_TX2RTS (4)
// initial value of gCANAutoProcess
#define CANAUTOPROCESS (1)
#define CANAUTOON (1)
#define CANAUTOOFF (0)
#define CAN_STDID (0)
#define CAN_EXTID (1)
#define CANDEFAULTIDENT (0x55CC)
#define CANDEFAULTIDENTEXT (CAN_EXTID)
#define CAN_5KBPS 1
#define CAN_10KBPS 2
#define CAN_20KBPS 3
#define CAN_25KBPS 4
#define CAN_31K25BPS 5
#define CAN_33KBPS 6
#define CAN_40KBPS 7
#define CAN_50KBPS 8
#define CAN_80KBPS 9
#define CAN_83K3BPS 10
#define CAN_95KBPS 11
#define CAN_100KBPS 12
#define CAN_125KBPS 13
#define CAN_200KBPS 14
#define CAN_250KBPS 15
#define CAN_500KBPS 16
#define CAN_666KBPS 17
#define CAN_1000KBPS 18
#define CAN_OK (0)
#define CAN_FAILINIT (1)
#define CAN_FAILTX (2)
#define CAN_MSGAVAIL (3)
#define CAN_NOMSG (4)
#define CAN_CTRLERROR (5)
#define CAN_GETTXBFTIMEOUT (6)
#define CAN_SENDMSGTIMEOUT (7)
#define CAN_FAIL (0xff)
#define CAN_MAX_CHAR_IN_MESSAGE (8)
#endif
/*********************************************************************************************************
END FILE
*********************************************************************************************************/
mcp2518fd_can.cpp
+128 -368
View File
@@ -1,14 +1,71 @@
#include "mcp2518fd_can.h"
//! SPI Transmit buffer
uint8_t spiTransmitBuffer[96];
uint8_t SPICS;
SPIClass* pSPI;
//! SPI Receive buffer
uint8_t spiReceiveBuffer[96];
CAN_CONFIG config;
// Receive objects
CAN_RX_FIFO_CONFIG rxConfig;
REG_CiFLTOBJ fObj;
REG_CiMASK mObj;
CAN_RX_FIFO_EVENT rxFlags;
CAN_RX_MSGOBJ rxObj;
uint8_t rxd[MAX_DATA_BYTES];
// Transmit objects
CAN_TX_FIFO_CONFIG txConfig;
CAN_TX_FIFO_EVENT txFlags;
CAN_TX_MSGOBJ txObj;
uint8_t txd[MAX_DATA_BYTES];
// Message IDs
#define TX_REQUEST_ID 0x300
#define TX_RESPONSE_ID 0x301
#define BUTTON_STATUS_ID 0x201
#define LED_STATUS_ID 0x200
#define PAYLOAD_ID 0x101
#define MAX_TXQUEUE_ATTEMPTS 50
// Transmit Channels
#define APP_TX_FIFO CAN_FIFO_CH2
// Receive Channels
#define APP_RX_FIFO CAN_FIFO_CH1
// Maximum number of data bytes in message
#define MAX_DATA_BYTES 64
// //! SPI Transmit buffer
// uint8_t spiTransmitBuffer[96];
// //! SPI Receive buffer
// uint8_t spiReceiveBuffer[96];
CAN_BUS_DIAGNOSTIC busDiagnostics;
uint8_t tec;
uint8_t rec;
CAN_ERROR_STATE errorFlags;
#define DRV_CANFDSPI_INDEX_0 0
/*********************************************************************************************************
** Function name: MCP_CAN
** Descriptions: Constructor
*********************************************************************************************************/
void mcp2518fd::mcp_canbus(uint8_t _CS) {
nReservedTx = 0;
pSPI = &SPI;
init_CS(_CS);
}
/*********************************************************************************************************
** Function name: init_CS
** Descriptions: init CS pin and set UNSELECTED
@@ -28,352 +85,13 @@ void mcp2518fd::init_CS(byte _CS) {
** Function name: begin
** Descriptions: init can and set speed
*********************************************************************************************************/
byte mcp2518fd::begin(byte speedset, const byte clockset) {
pSPI->begin();
byte res = mcp2518fd_init(speedset, clockset);
byte mcp2518fd::begin() {
Serial.println("into mcp25184fd begin\n\r");
SPI.begin();
Serial.println("into spi begin\n\r");
byte res = mcp2518fd_init();
return ((res == MCP2515_OK) ? CAN_OK : CAN_FAILINIT);
}
/*********************************************************************************************************
** Function name: mcp2518_reset
** Descriptions: reset the device
*********************************************************************************************************/
void mcp2518fd::mcp2518fd_reset(void) {
spiTransmitBuffer[0] = (uint8_t) (cINSTRUCTION_RESET << 4);
spiTransmitBuffer[1] = 0;
#ifdef SPI_HAS_TRANSACTION
SPI_BEGIN();
#endif
MCP2518fd_SELECT();
spi_readwrite((void)spiTransmitBuffer,(void)spiReceiveBuffer,2,true);
MCP2515_UNSELECT();
#ifdef SPI_HAS_TRANSACTION
SPI_END();
#endif
delay(10);
}
/*********************************************************************************************************
** Function name: mcp2518fd_readRegister
** Descriptions: read register
*********************************************************************************************************/
int8_t mcp2518fd::mcp2518fd_readRegister(const byte address,uint8_t *rxd) {
spiTransmitBuffer[0] = (uint8_t) ((cINSTRUCTION_READ << 4) + ((address >> 8) & 0xF));
spiTransmitBuffer[1] = (uint8_t) (address & 0xFF);
spiTransmitBuffer[2] = 0;
#ifdef SPI_HAS_TRANSACTION
SPI_BEGIN();
#endif
MCP2518fd_SELECT();
spi_readwrite((void)spiTransmitBuffer,(void)spiReceiveBuffer,3,true);
MCP2518fd_UNSELECT();
#ifdef SPI_HAS_TRANSACTION
SPI_END();
#endif
*rxd = spiReceiveBuffer[2];
return 0;
}
int8_t mcp2518fd::mcp2518fd_readRegisterWord(const byte address,uint8_t *rxd) {
// Compose command
spiTransmitBuffer[0] = (uint8_t) ((cINSTRUCTION_READ << 4) + ((address >> 8) & 0xF));
spiTransmitBuffer[1] = (uint8_t) (address & 0xFF);
#ifdef SPI_HAS_TRANSACTION
SPI_BEGIN();
#endif
MCP2518fd_SELECT();
spi_readwrite((void)spiTransmitBuffer,(void)spiReceiveBuffer,6,true);
MCP2518fd_UNSELECT();
#ifdef SPI_HAS_TRANSACTION
SPI_END();
#endif
// Update data
*rxd = 0;
for (i = 2; i < 6; i++) {
x = (uint32_t) spiReceiveBuffer[i];
*rxd += x << ((i - 2)*8);
}
return 0;
}
int8_t mcp2518fd::mcp2518fd_writeRegister(const byte address,uint8_t txd) {
spiTransmitBuffer[0] = (uint8_t) ((cINSTRUCTION_WRITE << 4) + ((address >> 8) & 0xF));
spiTransmitBuffer[1] = (uint8_t) (address & 0xFF);
spiTransmitBuffer[2] = txd;
#ifdef SPI_HAS_TRANSACTION
SPI_BEGIN();
#endif
MCP2515_SELECT();
spi_readwrite((void)spiTransmitBuffer,(void)spiReceiveBuffer,3,true);
MCP2515_UNSELECT();
#ifdef SPI_HAS_TRANSACTION
SPI_END();
#endif
return 0;
}
int8_t mcp2518fd::mcp2518fd_writeRegisterWord(const byte address,uint8_t txd) {
// Compose command
spiTransmitBuffer[0] = (uint8_t) ((cINSTRUCTION_WRITE << 4) + ((address >> 8) & 0xF));
spiTransmitBuffer[1] = (uint8_t) (address & 0xFF);
// Split word into 4 bytes and add them to buffer
for (i = 0; i < 4; i++) {
spiTransmitBuffer[i + 2] = (uint8_t) ((txd >> (i * 8)) & 0xFF);
}
#ifdef SPI_HAS_TRANSACTION
SPI_BEGIN();
#endif
MCP2515_SELECT();
spi_readwrite((void)spiTransmitBuffer,(void)spiReceiveBuffer,6,true);
MCP2515_UNSELECT();
#ifdef SPI_HAS_TRANSACTION
SPI_END();
#endif
return 0;
}
int8_t mcp2518fd::mcp2518fd_ReadRegisterHalfWord(uint16_t address, uint16_t *rxd) {
// Compose command
spiTransmitBuffer[0] = (uint8_t) ((cINSTRUCTION_READ << 4) + ((address >> 8) & 0xF));
spiTransmitBuffer[1] = (uint8_t) (address & 0xFF);
spi_readwrite((void)spiTransmitBuffer,(void)spiReceiveBuffer,4,true);
// Update data
*rxd = 0;
for (i = 2; i < 4; i++) {
x = (uint32_t) spiReceiveBuffer[i];
*rxd += x << ((i - 2)*8);
}
return 0;
}
int8_t mcp2518fd::mcp2518fd_WriteRegisterHalfWord(uint16_t address,uint16_t txd) {
// Compose command
spiTransmitBuffer[0] = (uint8_t) ((cINSTRUCTION_WRITE << 4) + ((address >> 8) & 0xF));
spiTransmitBuffer[1] = (uint8_t) (address & 0xFF);
// Split word into 2 bytes and add them to buffer
for (i = 0; i < 2; i++) {
spiTransmitBuffer[i + 2] = (uint8_t) ((txd >> (i * 8)) & 0xFF);
}
spi_readwrite((void)spiTransmitBuffer,(void)spiReceiveBuffer,4,true);
return 0;
}
int8_t mcp2518fd::mcp2518fd_WriteByteSafe(uint16_t address,uint8_t txd) {
// Compose command
spiTransmitBuffer[0] = (uint8_t) ((cINSTRUCTION_WRITE_SAFE << 4) + ((address >> 8) & 0xF));
spiTransmitBuffer[1] = (uint8_t) (address & 0xFF);
spiTransmitBuffer[2] = txd;
// Add CRC
crcResult = DRV_CANFDSPI_CalculateCRC16(spiTransmitBuffer, 3);
spiTransmitBuffer[3] = (crcResult >> 8) & 0xFF;
spiTransmitBuffer[4] = crcResult & 0xFF;
spi_readwrite((void)spiTransmitBuffer,(void)spiReceiveBuffer,5,true);
return 0;
}
int8_t mcp2518fd::mcp2518fd_WriteWordSafe(uint16_t address,uint32_t txd) {
// Compose command
spiTransmitBuffer[0] = (uint8_t) ((cINSTRUCTION_WRITE_SAFE << 4) + ((address >> 8) & 0xF));
spiTransmitBuffer[1] = (uint8_t) (address & 0xFF);
// Split word into 4 bytes and add them to buffer
for (i = 0; i < 4; i++) {
spiTransmitBuffer[i + 2] = (uint8_t) ((txd >> (i * 8)) & 0xFF);
}
/ Add CRC
crcResult = DRV_CANFDSPI_CalculateCRC16(spiTransmitBuffer, 6);
spiTransmitBuffer[6] = (crcResult >> 8) & 0xFF;
spiTransmitBuffer[7] = crcResult & 0xFF;
spi_readwrite((void)spiTransmitBuffer,(void)spiReceiveBuffer,8,true);
return 0;
}
int8_t mcp2518fd::mcp2518fd_ReadByteArray(uint16_t address,uint8_t *rxd, uint16_t nBytes) {
// Compose command
spiTransmitBuffer[0] = (uint8_t) ((cINSTRUCTION_READ << 4) + ((address >> 8) & 0xF));
spiTransmitBuffer[1] = (uint8_t) (address & 0xFF);
// Clear data
for (i = 2; i < spiTransferSize; i++) {
spiTransmitBuffer[i] = 0;
}
spi_readwrite((void)spiTransmitBuffer,(void)spiReceiveBuffer,(nBytes + 2),true);
// Update data
for (i = 0; i < nBytes; i++) {
rxd[i] = spiReceiveBuffer[i + 2];
}
return 0;
}
int8_t mcp2518fd::mcp2518fd_WriteByteArray(uint16_t address,uint8_t *txd, uint16_t nBytes) {
// Compose command
spiTransmitBuffer[0] = (uint8_t) ((cINSTRUCTION_WRITE << 4) + ((address >> 8) & 0xF));
spiTransmitBuffer[1] = (uint8_t) (address & 0xFF);
// Add data
for (i = 2; i < spiTransferSize; i++) {
spiTransmitBuffer[i] = txd[i - 2];
}
spi_readwrite((void)spiTransmitBuffer,(void)spiReceiveBuffer,(nBytes + 2),true);
return 0;
}
int8_t mcp2518fd::mcp2518fd_ReadByteArrayWithCRC(uint16_t address,uint8_t *rxd, uint16_t nBytes, bool fromRam, bool* crcIsCorrect) {
// Compose command
spiTransmitBuffer[0] = (uint8_t) ((cINSTRUCTION_READ_CRC << 4) + ((address >> 8) & 0xF));
spiTransmitBuffer[1] = (uint8_t) (address & 0xFF);
if (fromRam) {
spiTransmitBuffer[2] = nBytes >> 2;
} else {
spiTransmitBuffer[2] = nBytes;
}
// Clear data
for (i = 3; i < spiTransferSize; i++) {
spiTransmitBuffer[i] = 0;
}
spi_readwrite((void)spiTransmitBuffer,(void)spiReceiveBuffer,(nBytes + 5),true);
// Get CRC from controller
crcFromSpiSlave = (uint16_t) (spiReceiveBuffer[spiTransferSize - 2] << 8) + (uint16_t) (spiReceiveBuffer[spiTransferSize - 1]);
// Use the receive buffer to calculate CRC
// First three bytes need to be command
spiReceiveBuffer[0] = spiTransmitBuffer[0];
spiReceiveBuffer[1] = spiTransmitBuffer[1];
spiReceiveBuffer[2] = spiTransmitBuffer[2];
crcAtController = DRV_CANFDSPI_CalculateCRC16(spiReceiveBuffer, nBytes + 3);
// Compare CRC readings
if (crcFromSpiSlave == crcAtController) {
*crcIsCorrect = true;
} else {
*crcIsCorrect = false;
}
// Update data
for (i = 0; i < nBytes; i++) {
rxd[i] = spiReceiveBuffer[i + 3];
}
return 0;
}
int8_t mcp2518fd::mcp2518fd_WriteByteArrayWithCRC(uint16_t address,uint8_t *txd, uint16_t nBytes, bool fromRam) {
// Compose command
spiTransmitBuffer[0] = (uint8_t) ((cINSTRUCTION_WRITE_CRC << 4) + ((address >> 8) & 0xF));
spiTransmitBuffer[1] = (uint8_t) (address & 0xFF);
if (fromRam) {
spiTransmitBuffer[2] = nBytes >> 2;
} else {
spiTransmitBuffer[2] = nBytes;
}
// Add data
for (i = 0; i < nBytes; i++) {
spiTransmitBuffer[i + 3] = txd[i];
}
// Add CRC
crcResult = DRV_CANFDSPI_CalculateCRC16(spiTransmitBuffer, spiTransferSize - 2);
spiTransmitBuffer[spiTransferSize - 2] = (uint8_t) ((crcResult >> 8) & 0xFF);
spiTransmitBuffer[spiTransferSize - 1] = (uint8_t) (crcResult & 0xFF);
spi_readwrite((void)spiTransmitBuffer,(void)spiReceiveBuffer,(nBytes + 5),true);
return 0;
}
int8_t mcp2518fd::mcp2518fd_ReadWordArray(uint16_t address,uint32_t *rxd, uint16_t nWords) {
// Compose command
spiTransmitBuffer[0] = (cINSTRUCTION_READ << 4) + ((address >> 8) & 0xF);
spiTransmitBuffer[1] = address & 0xFF;
// Clear data
for (i = 2; i < spiTransferSize; i++) {
spiTransmitBuffer[i] = 0;
}
spi_readwrite((void)spiTransmitBuffer,(void)spiReceiveBuffer,(nWords * 4 + 2),true);
// Convert Byte array to Word array
n = 2;
for (i = 0; i < nWords; i++) {
w.word = 0;
for (j = 0; j < 4; j++, n++) {
w.byte[j] = spiReceiveBuffer[n];
}
rxd[i] = w.word;
}
return 0;
}
int8_t mcp2518fd::mcp2518fd_WriteWordArray(uint16_t address,uint32_t *txd, uint16_t nWords) {
// Compose command
spiTransmitBuffer[0] = (cINSTRUCTION_WRITE << 4) + ((address >> 8) & 0xF);
spiTransmitBuffer[1] = address & 0xFF;
// Convert ByteArray to word array
n = 2;
for (i = 0; i < nWords; i++) {
w.word = txd[i];
for (j = 0; j < 4; j++, n++) {
spiTransmitBuffer[n] = w.byte[j];
}
}
spi_readwrite((void)spiTransmitBuffer,(void)spiReceiveBuffer,(nWords * 4 + 2),true);
return 0;
return ((res == MCP2518fd_OK) ? CAN_OK : CAN_FAILINIT);
}
@@ -390,6 +108,7 @@ void mcp2518fd::mcp2518fd_init_txobj() {
txObj.bF.ctrl.FDF = 1;
txObj.bF.ctrl.IDE = 0;
// Configure message data
int i;
for (i = 0; i < MAX_DATA_BYTES; i++) txd[i] = txObj.bF.id.SID + i;
}
@@ -407,6 +126,8 @@ void mcp2518fd::mcp2518fd_sendMsgBuf(const byte* buf) {
** Descriptions: send message
*********************************************************************************************************/
void mcp2518fd::mcp2518fd_sendMsg(const byte* buf) {
Serial.printf("into mcp2518fdsendMsg\n\r");
uint32_t n;
mcp2518fd_init_txobj();
// Prepare data
@@ -419,9 +140,10 @@ void mcp2518fd::mcp2518fd_sendMsg(const byte* buf) {
txObj.bF.ctrl.BRS = true;
txObj.bF.ctrl.FDF = 1;
n = DRV_CANFDSPI_DlcToDataBytes((CAN_DLC) 0);
int i;
for (i = 0; i < n; i++)
{
txd[i] = buf[i]
txd[i] = buf[i];
}
uint8_t attempts = MAX_TXQUEUE_ATTEMPTS;
@@ -429,8 +151,6 @@ void mcp2518fd::mcp2518fd_sendMsg(const byte* buf) {
do {
DRV_CANFDSPI_TransmitChannelEventGet(DRV_CANFDSPI_INDEX_0, APP_TX_FIFO, &txFlags);
if (attempts == 0) {
Nop();
Nop();
DRV_CANFDSPI_ErrorCountStateGet(DRV_CANFDSPI_INDEX_0, &tec, &rec, &errorFlags);
return;
}
@@ -439,51 +159,92 @@ void mcp2518fd::mcp2518fd_sendMsg(const byte* buf) {
while (!(txFlags & CAN_TX_FIFO_NOT_FULL_EVENT));
// Load message and transmit
uint8_t n = DRV_CANFDSPI_DlcToDataBytes(txObj.bF.ctrl.DLC);
n = DRV_CANFDSPI_DlcToDataBytes((CAN_DLC)txObj.bF.ctrl.DLC);
DRV_CANFDSPI_TransmitChannelLoad(DRV_CANFDSPI_INDEX_0, APP_TX_FIFO, &txObj, txd, n, true);
}
int8_t mcp2518fd::mcp2518fd_receiveMsg() {
DRV_CANFDSPI_ReceiveMessageGet(DRV_CANFDSPI_INDEX_0, APP_RX_FIFO, &rxObj, rxd, MAX_DATA_BYTES);
int a;
for (a = 0; a < 64; a++)
{
Serial.printf("mcp2518fd_receiveMsg = %d\n\r",rxd[a]);
}
// switch (rxObj.bF.id.SID) {
// case TX_REQUEST_ID:
// // Check for TX request command
// Nop();
// Nop();
// txObj.bF.id.SID = TX_RESPONSE_ID;
// txObj.bF.ctrl.DLC = rxObj.bF.ctrl.DLC;
// txObj.bF.ctrl.IDE = rxObj.bF.ctrl.IDE;
// txObj.bF.ctrl.BRS = rxObj.bF.ctrl.BRS;
// txObj.bF.ctrl.FDF = rxObj.bF.ctrl.FDF;
// for (i = 0; i < MAX_DATA_BYTES; i++) txd[i] = rxd[i];
// APP_TransmitMessageQueue();
// break;
// case PAYLOAD_ID:
// // Check for Payload command
// Nop();
// Nop();
// payload.On = rxd[0];
// payload.Dlc = rxd[1];
// if (rxd[2] == 0) payload.Mode = true;
// else payload.Mode = false;
// payload.Counter = 0;
// payload.Delay = rxd[3];
// payload.BRS = rxd[4];
// break;
// }
}
/*********************************************************************************************************
** Function name: mcp2515_init
** Descriptions: init the device
*********************************************************************************************************/
byte mcp2518fd::mcp2518fd_init(const byte canSpeed, const byte clock) {
byte res = 0;
byte mcp2518fd::mcp2518fd_init() {
Serial.println("into mcp2518fd init\n\r");
// Reset device
mcp2518fd_reset();
DRV_CANFDSPI_Reset(DRV_CANFDSPI_INDEX_0);
Serial.println("DRV_CANFDSPI_Reset-------end\n\r");
// Enable ECC and initialize RAM
DRV_CANFDSPI_EccEnable(DRV_CANFDSPI_INDEX_0);
Serial.println("DRV_CANFDSPI_EccEnable-------end\n\r");
DRV_CANFDSPI_RamInit(DRV_CANFDSPI_INDEX_0, 0xff);
Serial.println("DRV_CANFDSPI_RamInit-------end\n\r");
// Configure device
DRV_CANFDSPI_ConfigureObjectReset(&config);
config.IsoCrcEnable = 1;
config.IsoCrcEnable = 1;
config.StoreInTEF = 0;
Serial.println("DRV_CANFDSPI_ConfigureObjectReset-------end\n\r");
DRV_CANFDSPI_Configure(DRV_CANFDSPI_INDEX_0, &config);
Serial.println("DRV_CANFDSPI_Configure-------end\n\r");
// Setup TX FIFO
DRV_CANFDSPI_TransmitChannelConfigureObjectReset(&txConfig);
Serial.println("DRV_CANFDSPI_TransmitChannelConfigureObjectReset-------end\n\r");
txConfig.FifoSize = 7;
txConfig.PayLoadSize = CAN_PLSIZE_64;
txConfig.TxPriority = 1;
DRV_CANFDSPI_TransmitChannelConfigure(DRV_CANFDSPI_INDEX_0, APP_TX_FIFO, &txConfig);
Serial.println("DRV_CANFDSPI_TransmitChannelConfigure-------end\n\r");
// Setup RX FIFO
DRV_CANFDSPI_ReceiveChannelConfigureObjectReset(&rxConfig);
Serial.println("DRV_CANFDSPI_ReceiveChannelConfigureObjectReset-------end\n\r");
rxConfig.FifoSize = 15;
rxConfig.PayLoadSize = CAN_PLSIZE_64;
DRV_CANFDSPI_ReceiveChannelConfigure(DRV_CANFDSPI_INDEX_0, APP_RX_FIFO, &rxConfig);
Serial.println("DRV_CANFDSPI_ReceiveChannelConfigure-------end\n\r");
// Setup RX Filter
fObj.word = 0;
fObj.bF.SID = 0xda;
@@ -491,7 +252,7 @@ byte mcp2518fd::mcp2518fd_init(const byte canSpeed, const byte clock) {
fObj.bF.EID = 0x00;
DRV_CANFDSPI_FilterObjectConfigure(DRV_CANFDSPI_INDEX_0, CAN_FILTER0, &fObj.bF);
Serial.println("DRV_CANFDSPI_FilterObjectConfigure-------end\n\r");
// Setup RX Mask
mObj.word = 0;
mObj.bF.MSID = 0x0;
@@ -511,12 +272,11 @@ byte mcp2518fd::mcp2518fd_init(const byte canSpeed, const byte clock) {
DRV_CANFDSPI_TransmitChannelEventEnable(DRV_CANFDSPI_INDEX_0, APP_TX_FIFO, CAN_TX_FIFO_NOT_FULL_EVENT);
#endif
DRV_CANFDSPI_ReceiveChannelEventEnable(DRV_CANFDSPI_INDEX_0, APP_RX_FIFO, CAN_RX_FIFO_NOT_EMPTY_EVENT);
DRV_CANFDSPI_ModuleEventEnable(DRV_CANFDSPI_INDEX_0, CAN_TX_EVENT | CAN_RX_EVENT);
DRV_CANFDSPI_ModuleEventEnable(DRV_CANFDSPI_INDEX_0,(CAN_MODULE_EVENT)(CAN_TX_EVENT | CAN_RX_EVENT));
// Select Normal Mode
DRV_CANFDSPI_OperationModeSelect(DRV_CANFDSPI_INDEX_0, CAN_NORMAL_MODE);
}
return 0;
}
mcp2518fd_can.h
+31 -89
View File
@@ -1,78 +1,28 @@
#include "mcp_can.h"
#include "mcp2518fd_can_dfs.h"
#include "mcp2518fd_can_def.h"
#ifndef _MCP2518FD_H_
#define _MCP2518FD_H_
#include "mcp2518fd_canfdspi_api.h"
#include "mcp2518fd_can_def.h"
#include "mcp2518fd_can_dfs.h"
#include <Arduino.h>
#include <SPI.h>
#define MCP2518fd_OK (0)
#define MCP2518fd_FAIL (1)
#define CAN_OK (0)
#define CAN_FAILINIT (1)
#define CAN_FAILTX (2)
class SPIClass;
#define MAX_TXQUEUE_ATTEMPTS 50
// Code anchor for break points
#define Nop() asm("nop")
extern void _exit(int status)
{
asm("BKPT #0");
for (;;);
}
// Transmit Channels
#define APP_TX_FIFO CAN_FIFO_CH2
// Transmit objects
CAN_TX_FIFO_CONFIG txConfig;
CAN_TX_FIFO_EVENT txFlags;
CAN_TX_MSGOBJ txObj;
uint8_t txd[MAX_DATA_BYTES];
// Receive objects
CAN_RX_FIFO_CONFIG rxConfig;
REG_CiFLTOBJ fObj;
REG_CiMASK mObj;
CAN_RX_FIFO_EVENT rxFlags;
CAN_RX_MSGOBJ rxObj;
uint8_t rxd[MAX_DATA_BYTES];
REG_t reg;
uint8_t ledCount = 0, ledState = 0;
uint8_t i;
CAN_BUS_DIAGNOSTIC busDiagnostics;
uint8_t tec;
uint8_t rec;
CAN_ERROR_STATE errorFlags;
// Message IDs
#define TX_REQUEST_ID 0x300
#define TX_RESPONSE_ID 0x301
#define BUTTON_STATUS_ID 0x201
#define LED_STATUS_ID 0x200
#define PAYLOAD_ID 0x101
// Payload
typedef struct {
bool On;
uint8_t Dlc;
bool Mode;
uint8_t Counter;
uint8_t Delay;
bool BRS;
} APP_Payload;
class mcp2518fd : public MCP_CAN {
class mcp2518fd {
public:
void mcp_canbus(uint8_t _CS);
void init_CS(byte _CS);
byte begin(byte speedset, const byte clockset = MCP_16MHz); // init can
byte begin(); // init can
// byte sendMsgBuf(byte status, unsigned long id, byte ext, byte rtrBit, byte len, volatile const byte* buf);
@@ -81,30 +31,22 @@ public:
void mcp2518fd_sendMsgBuf(const byte* buf); // send buf
void mcp2518fd_sendMsg(const byte* buf);
int8_t mcp2518fd_receiveMsg();
void mcp2518fd_reset(void); // reset mcp2515
byte mcp2518fd_init(const byte canSpeed, const byte clock); // mcp2515init
byte mcp2518fd_init(); // mcp2515init
void mcp2518fd_init_txobj();
int8_t mcp2518fd_readRegister(const byte address,uint8_t *rxd);
int8_t mcp2518fd_writeRegister(const byte address,uint8_t txd);
int8_t mcp2518fd_readRegisterWord(const byte address,uint8_t *rxd);
int8_t mcp2518fd_writeRegisterWord(const byte address,uint8_t txd);
int8_t mcp2518fd_ReadRegisterHalfWord(uint16_t address, uint16_t *rxd);
int8_t mcp2518fd_WriteRegisterHalfWord(uint16_t address,uint16_t txd);
private:
int8_t mcp2518fd_WriteByteSafe(uint16_t address,uint8_t txd);
int8_t mcp2518fd_WriteWordSafe(uint16_t address,uint32_t txd);
byte ext_flg; // identifier xxxID
// either extended (the 29 LSB) or standard (the 11 LSB)
unsigned long can_id; // can id
byte rtr; // rtr
byte nReservedTx; // Count of tx buffers for reserved send
byte mcpMode; // Current controller mode
int8_t mcp2518fd_ReadByteArray(uint16_t address,uint8_t *rxd, uint16_t nBytes);
int8_t mcp2518fd_WriteByteArray(uint16_t address,uint8_t *txd, uint16_t nBytes);
int8_t mcp2518fd_ReadByteArrayWithCRC(uint16_t address,uint8_t *rxd, uint16_t nBytes, bool fromRam, bool* crcIsCorrect);
int8_t mcp2518fd_WriteByteArrayWithCRC(uint16_t address,uint8_t *txd, uint16_t nBytes, bool fromRam);
int8_t mcp2518fd_ReadWordArray(uint16_t address,uint32_t *rxd, uint16_t nWords);
int8_t mcp2518fd_WriteWordArray(uint16_t address,uint32_t *txd, uint16_t nWords);
};
};
#endif
mcp2518fd_can_def.h
+3 -1
View File
@@ -888,5 +888,7 @@ typedef enum {
OSC_CLKO_DIV4,
OSC_CLKO_DIV10
} OSC_CLKO_DIVIDE;
#ifdef __cplusplus // Provide C++ Compatibility
}
#endif
#endif // _DRV_CANFDSPI_DEFINES_H
mcp2518fd_can_dfs.h
+13 -5
View File
@@ -46,6 +46,9 @@ DIRECTLY TO MICROCHIP FOR THIS SOFTWARE.
// Section: Included Files
#include "mcp2518fd_can_def.h"
#include <Arduino.h>
//#include <SPI.h>
#include <inttypes.h>
// DOM-IGNORE-BEGIN
#ifdef __cplusplus // Provide C++ Compatibility
@@ -131,6 +134,13 @@ extern "C" {
#define cRAMADDR_START 0x400
#define cRAMADDR_END (cRAMADDR_START+cRAM_SIZE)
/*spi cs set*/
extern uint8_t SPICS;
#if defined(MCP2517FD) || defined(MCP2518FD)
#define MCP2518fd_SELECT() digitalWrite(SPICS, LOW)
#define MCP2518fd_UNSELECT() digitalWrite(SPICS, HIGH)
#endif
// *****************************************************************************
// *****************************************************************************
/* Register Structures */
@@ -794,9 +804,7 @@ static const uint32_t mcp25xxfdControlResetValues[] = {
0x00000460, 0x00000003, 0x00000000, 0x00000000, 0x00000000
};
#endif
#define MCP2518fd_SELECT() digitalWrite(SPICS, LOW)
#define MCP2518fd_UNSELECT() digitalWrite(SPICS, HIGH)
#ifdef __cplusplus // Provide C++ Compatibility
}
#endif
#endif // _DRV_CANFDSPI_REGISTER_H
mcp2518fd_canfdspi_api.cpp
+784 -147
View File
File diff suppressed because it is too large Load Diff
mcp2518fd_canfdspi_api.h
+9
View File
@@ -51,6 +51,7 @@ DIRECTLY TO MICROCHIP FOR THIS SOFTWARE.
#include <stddef.h>
#include <stdlib.h>
#include "mcp2518fd_can_def.h"
#include "mcp2518fd_can_dfs.h"
// DOM-IGNORE-BEGIN
@@ -65,6 +66,11 @@ typedef uint8_t CANFDSPI_MODULE_ID;
// *****************************************************************************
//! Reset DUT
// Code anchor for break points
#define Nop() asm("nop")
// Index to SPI channel
// Used when multiple MCP25xxFD are connected to the same SPI interface, but with different CS
@@ -1121,5 +1127,8 @@ uint16_t DRV_CANFDSPI_CalculateCRC16(uint8_t* data, uint16_t size);
CAN_DLC DRV_CANFDSPI_DataBytesToDlc(uint8_t n);
#ifdef __cplusplus // Provide C++ Compatibility
}
#endif
#endif // _DRV_CANFDSPI_API_H
mcp_can.cpp
-58
View File
@@ -1,58 +0,0 @@
#include "mcp_can.h"
// #define spi_readwrite pSPI->transfer
// #define spi_read() spi_readwrite(0x00)
// #define spi_write(spi_val) spi_readwrite(spi_val)
// #define SPI_BEGIN() pSPI->beginTransaction(SPISettings(10000000, MSBFIRST, SPI_MODE0))
// #define SPI_END() pSPI->endTransaction()
/*********************************************************************************************************
** Function name: MCP_CAN
** Descriptions: Constructor
*********************************************************************************************************/
void MCP_CAN::mcp_canbus(byte _CS) {
pSPI = &SPI; init_CS(_CS);
}
/*********************************************************************************************************
** Function name: readMsgBuf
** Descriptions: read message buf
*********************************************************************************************************/
byte MCP_CAN::readMsgBuf(byte* len, byte buf[]) {
return readMsgBufID(readRxTxStatus(), &can_id, &ext_flg, &rtr, len, buf);
}
/*********************************************************************************************************
** Function name: readMsgBufID
** Descriptions: read message buf and can bus source ID
*********************************************************************************************************/
byte MCP_CAN::readMsgBufID(unsigned long* ID, byte* len, byte buf[]) {
return readMsgBufID(readRxTxStatus(), ID, &ext_flg, &rtr, len, buf);
}
/*********************************************************************************************************
** Function name: getCanId
** Descriptions: when receive something, you can get the can id!!
*********************************************************************************************************/
unsigned long MCP_CAN::getCanId(void) {
return can_id;
}
/*********************************************************************************************************
** Function name: isRemoteRequest
** Descriptions: when receive something, you can check if it was a request
*********************************************************************************************************/
byte MCP_CAN::isRemoteRequest(void) {
return rtr;
}
/*********************************************************************************************************
** Function name: isExtendedFrame
** Descriptions: did we just receive standard 11bit frame or extended 29bit? 0 = std, 1 = ext
*********************************************************************************************************/
byte MCP_CAN::isExtendedFrame(void) {
return ext_flg;
}
mcp_can.h
-106
View File
@@ -1,106 +0,0 @@
#ifndef _MCP_CAN_H_
#define _MCP_CAN_H_
#include "mcp2515_can_dfs.h"
#define MAX_CHAR_IN_MESSAGE 8
#define spi_readwrite pSPI->transfer
#define spi_read() spi_readwrite(0x00)
#define spi_write(spi_val) spi_readwrite(spi_val)
#define SPI_BEGIN() pSPI->beginTransaction(SPISettings(10000000, MSBFIRST, SPI_MODE0))
#define SPI_END() pSPI->endTransaction()
class MCP_CAN {
public:
void mcp_canbus(byte _CS = 0);
virtual void init_CS(byte _CS) = 0; // define CS after construction before begin()
void setSPI(SPIClass* _pSPI) {
pSPI = _pSPI; // define SPI port to use before begin()
}
virtual void enableTxInterrupt(bool enable = true) = 0; // enable transmit interrupt
void reserveTxBuffers(byte nTxBuf = 0) {
nReservedTx = (nTxBuf < MCP_N_TXBUFFERS ? nTxBuf : MCP_N_TXBUFFERS - 1);
}
byte getLastTxBuffer() {
return MCP_N_TXBUFFERS - 1; // read index of last tx buffer
}
virtual byte begin(byte speedset, const byte clockset = MCP_16MHz) = 0; // init can
virtual byte init_Mask(byte num, byte ext, unsigned long ulData) = 0; // init Masks
virtual byte init_Filt(byte num, byte ext, unsigned long ulData); // init filters
virtual void setSleepWakeup(byte enable) = 0; // Enable or disable the wake up interrupt (If disabled the MCP2515 will not be woken up by CAN bus activity, making it send only)
virtual byte sleep() = 0; // Put the MCP2515 in sleep mode
virtual byte wake() = 0; // Wake MCP2515 manually from sleep
virtual byte setMode(byte opMode) = 0; // Set operational mode
virtual byte getMode() = 0; // Get operational mode
virtual byte sendMsgBuf(unsigned long id, byte ext, byte rtrBit, byte len, const byte* buf, bool wait_sent = true) = 0; // send buf
virtual byte sendMsgBuf(unsigned long id, byte ext, byte len, const byte* buf, bool wait_sent = true) = 0; // send buf
byte readMsgBuf(byte* len, byte* buf); // read buf
byte readMsgBufID(unsigned long* ID, byte* len, byte* buf); // read buf with object ID
virtual byte checkReceive(void) = 0; // if something received
virtual byte checkError(void) = 0; // if something error
unsigned long getCanId(void); // get can id when receive
byte isRemoteRequest(void); // get RR flag when receive
byte isExtendedFrame(void); // did we recieve 29bit frame?
virtual byte readMsgBufID(byte status, volatile unsigned long* id, volatile byte* ext, volatile byte* rtr, volatile byte* len,
volatile byte* buf) = 0; // read buf with object ID
virtual byte trySendMsgBuf(unsigned long id, byte ext, byte rtrBit, byte len, const byte* buf,
byte iTxBuf = 0xff) = 0; // as sendMsgBuf, but does not have any wait for free buffer
virtual byte sendMsgBuf(byte status, unsigned long id, byte ext, byte rtrBit, byte len,
volatile const byte* buf) = 0; // send message buf by using parsed buffer status
inline byte trySendExtMsgBuf(unsigned long id, byte len, const byte* buf,
byte iTxBuf = 0xff) { // as trySendMsgBuf, but set ext=1 and rtr=0
return trySendMsgBuf(id, 1, 0, len, buf, iTxBuf);
}
inline byte sendExtMsgBuf(byte status, unsigned long id, byte len,
volatile const byte* buf) { // as sendMsgBuf, but set ext=1 and rtr=0
return sendMsgBuf(status, id, 1, 0, len, buf);
}
virtual void clearBufferTransmitIfFlags(byte flags = 0) = 0; // Clear transmit flags according to status
virtual byte readRxTxStatus(void) = 0; // read has something send or received
virtual byte checkClearRxStatus(byte* status) = 0; // read and clear and return first found rx status bit
virtual byte checkClearTxStatus(byte* status,
byte iTxBuf = 0xff) = 0; // read and clear and return first found or buffer specified tx status bit
virtual bool mcpPinMode(const byte pin, const byte
mode) = 0; // switch supported pins between HiZ, interrupt, output or input
virtual bool mcpDigitalWrite(const byte pin, const byte mode) = 0; // write HIGH or LOW to RX0BF/RX1BF
virtual byte mcpDigitalRead(const byte pin) = 0; // read HIGH or LOW from supported pins
byte ext_flg; // identifier xxxID
// either extended (the 29 LSB) or standard (the 11 LSB)
unsigned long can_id; // can id
byte rtr; // rtr
byte SPICS;
SPIClass* pSPI;
byte nReservedTx = 0; // Count of tx buffers for reserved send
byte mcpMode;
};
template <class T>
class Mcp_Factory {
public:
// MCP_CAN* getmcpcan(std:string device) {
// if(device == nullptr)
// {
// return nullptr;
// }
// if(device == "mcp2515") {
// return new mcp2515();
// }
// // if(device == "mcp2518") {
// // return new mcp2518fd();
// // }
// }
Mcp_Factory() {
controller = new T();
}
T* controller;
};
#endif