alexander/gobot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Squashed commit of the following:

Browse Source 
commit c6fd825e39
Author: AlexanderHD27 <alexander@hal>
Date:   Wed Nov 6 23:14:14 2024 +0100

    Moved CAN Interface code to comment libary folder with symlink

commit e7a0035041
Author: AlexanderHD27 <alexander@hal>
Date:   Wed Nov 6 22:01:28 2024 +0100

    Got MCP2521 to work

commit 4bfb1f533e
Author: AlexanderHD27 <alexander@hal>
Date:   Wed Oct 16 21:29:35 2024 +0200

    Did something to YGantryMount. It works. trust me

commit 5683168a47
Author: AlexanderHD27 <alexander@hal>
Date:   Wed Oct 16 21:28:36 2024 +0200

    Implemented Command-Level Interaction with CAN Interface

commit 9c0c676be8
Author: AlexanderHD27 <alexander@hal>
Date:   Mon Oct 14 09:20:37 2024 +0200

    Added Vscode Profile file

commit b150a905a3
Author: AlexanderHD27 <alexander@hal>
Date:   Mon Oct 14 09:19:00 2024 +0200

    Implemented Low Level Compunications

commit 7eebf619ae
Author: AlexanderHD27 <alexander@hal>
Date:   Mon Oct 7 14:46:15 2024 +0200

    Created Head Pipe Mount

commit 93c40e1805
Author: AlexanderHD27 <alexander@hal>
Date:   Mon Oct 7 14:44:11 2024 +0200

    First Revision of YGantryMount

commit 91c2125458
Author: AlexanderHD27 <alexander@hal>
Date:   Thu Oct 3 19:52:37 2024 +0200

    Added Kicad Backups 2 gitignore

commit 096a6c18d6
Author: AlexanderHD27 <alexander@hal>
Date:   Thu Oct 3 19:49:21 2024 +0200

    Created ESP-IDF for can-interface

commit 48fded7981
Author: AlexanderHD27 <alexander@hal>
Date:   Sat Sep 28 19:54:29 2024 +0200

    Added files from Pico sdk to gitignore

commit ec5e5cbf13
Author: AlexanderHD27 <alexander@hal>
Date:   Sat Sep 14 21:09:50 2024 +0200

    Create Marker for position Calibration

commit 58d31964b2
Author: AlexanderHD27 <alexander@hal>
Date:   Wed Sep 11 23:32:55 2024 +0200

    Upgrade to pico SDK 2.0.0
This commit is contained in:
AlexanderHD27
2024-11-06 23:18:12 +01:00
parent f002a01308
commit e091d4df18
49 changed files with 3905 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
common-libaries/mcp2521/CMakeLists.txt Normal file
View File

@@ -0,0 +1,8 @@
idf_component_register(SRCS
"interface_commands.cpp"
"interface_interrupts.cpp"
"toplevel_commands.cpp"
INCLUDE_DIRS "include"
REQUIRES driver
REQUIRES mcp2521_hardware_interface
)

177
common-libaries/mcp2521/include/bitfields.hpp Normal file
View File

@@ -0,0 +1,177 @@
#pragma once
#include <cstdint>
/**
* @brief RXnBF PIN CONTROL AND STATUS REGISTER (ADDRESS: 0Ch)
*
*/
struct BFPCTRL {
uint8_t B0BFM : 1;
uint8_t B1BFM : 1;
uint8_t B0BFE : 1;
uint8_t B1BFE : 1;
uint8_t B0BFS : 1;
uint8_t B1BFS : 1;
uint8_t : 2;
};
/**
* @brief TXnRTS PIN CONTROL AND STATUS REGISTER
*
*/
struct TXRTSCTRL {
uint8_t B0RTSM : 1;
uint8_t B1RTSM : 1;
uint8_t B2RTSM : 1;
uint8_t B0RTS : 1;
uint8_t B1RTS : 1;
uint8_t B2RTS : 1;
uint8_t : 2;
};
struct CANSTAT {
uint8_t ICOD0 : ;
uint8_t : 1;
uint8_t OPMOD0 : 1;
uint8_t OPMOD1 : 1;
uint8_t OPMOD2 : 1;
uint8_t : 1;
};
struct CANCTRL {
uint8_t CLKPRE0 : 1;
uint8_t CLKPRE1 : 1;
uint8_t CLKEN : 1;
uint8_t OSM : 1;
uint8_t ABAT : 1;
uint8_t REQOP0 : 1;
uint8_t REQOP1 : 1;
uint8_t REQOP2 : 1;
};
struct TEC {
uint8_t TEC;
};
struct REC {
uint8_t REC;
};
struct CNF3 {
uint8_t PHSEG20 : 1;
uint8_t PHSEG21 : 1;
uint8_t PHSEG22 : 1;
uint8_t : 3;
uint8_t WAKFIL : 1;
uint8_t SOF : 1;
};
struct CNF2 {
uint8_t PRSEG0 : 1;
uint8_t PRSEG1 : 1;
uint8_t PRSEG2 : 1;
uint8_t PHSEG10 : 1;
uint8_t PHSEG11 : 1;
uint8_t PHSEG12 : 1;
uint8_t SAM : 1;
uint8_t BTLMODE : 1;
};
struct CNF1 {
uint8_t BRP0 : 1;
uint8_t BRP1 : 1;
uint8_t BRP2 : 1;
uint8_t BRP3 : 1;
uint8_t BRP4 : 1;
uint8_t BRP5 : 1;
uint8_t SJW0 : 1;
uint8_t SJW1 : 1;
};
struct CANINTE {
uint8_t RX0IE : 1;
uint8_t RX1IE : 1;
uint8_t TX0IE : 1;
uint8_t TX1IE : 1;
uint8_t TX2IE : 1;
uint8_t ERRIE : 1;
uint8_t WAKIE : 1;
uint8_t MERRE : 1;
};
struct CANINTF {
uint8_t RX0IF : 1;
uint8_t RX1IF : 1;
uint8_t TX0IF : 1;
uint8_t TX1IF : 1;
uint8_t TX2IF : 1;
uint8_t ERRIF : 1;
uint8_t WAKIF : 1;
uint8_t MERRF : 1;
};
struct EFLG {
uint8_t EWARN : 1;
uint8_t RXWAR : 1;
uint8_t TXWAR : 1;
uint8_t RXEP : 1;
uint8_t TXEP : 1;
uint8_t TXBO : 1;
uint8_t RX0OVR : 1;
uint8_t RX1OVR : 1;
};
struct TXB0CTRL {
uint8_t TXP0 : 1;
uint8_t TXP1 : 1;
uint8_t : 1;
uint8_t TXREQ : 1;
uint8_t TXERR : 1;
uint8_t MLOA : 1;
uint8_t ABTF : 1;
uint8_t : 1;
};
struct TXB1CTRL {
uint8_t TXP0 : 1;
uint8_t TXP1 : 1;
uint8_t : 1;
uint8_t TXREQ : 1;
uint8_t TXERR : 1;
uint8_t MLOA : 1;
uint8_t ABTF : 1;
uint8_t : 1;
};
struct TXB2CTRL {
uint8_t TXP0 : 1;
uint8_t TXP1 : 1;
uint8_t : 1;
uint8_t TXREQ : 1;
uint8_t TXERR : 1;
uint8_t MLOA : 1;
uint8_t ABTF : 1;
uint8_t : 1;
};
struct RXB0CTRL {
uint8_t FILHIT0 : 1;
uint8_t BUKT1 : 1;
uint8_t BUKT : 1;
uint8_t RXRTR : 1;
uint8_t : 1;
uint8_t RXM0 : 1;
uint8_t RXM1 : 1;
uint8_t : 1;
};
struct RXB1CTRL {
uint8_t FILHIT0 : 1;
uint8_t FILHIT1 : 1;
uint8_t FILHIT2 : 1;
uint8_t RXRTR : 1;
uint8_t : 1;
uint8_t RXM0 : 1;
uint8_t RXM1 : 1;
uint8_t : 1;
};

6
common-libaries/mcp2521/include/mcp2521.hpp Normal file
View File

@@ -0,0 +1,6 @@
#pragma once
#include "mcp2521_toplevel.hpp"
#include "mcp2521_command.hpp"
#include "mcp2521_hardware_esp.hpp"
#include "mcp2521_addresses.hpp"

192
common-libaries/mcp2521/include/mcp2521_addresses.hpp Normal file
View File

@@ -0,0 +1,192 @@
#pragma once
#include <stdint.h>
#define MCP2521_BFPCTRL 0x0C
#define MCP2521_BFPCTRL_B1BFS (1 << 5)
#define MCP2521_BFPCTRL_B0BFS (1 << 4)
#define MCP2521_BFPCTRL_B1BFE (1 << 3)
#define MCP2521_BFPCTRL_B0BFE (1 << 2)
#define MCP2521_BFPCTRL_B1BFM (1 << 1)
#define MCP2521_BFPCTRL_B0BFM (1 << 0)
#define MCP2521_TXRTSCTRL 0x0D
#define MCP2521_TXRTSCTRL_B2RTS (1 << 5)
#define MCP2521_TXRTSCTRL_B1RTS (1 << 4)
#define MCP2521_TXRTSCTRL_B0RTS (1 << 3)
#define MCP2521_TXRTSCTRL_B2RTSM (1 << 2)
#define MCP2521_TXRTSCTRL_B1RTSM (1 << 1)
#define MCP2521_TXRTSCTRL_B0RTSM (1 << 0)
#define MCP2521_CANSTAT 0x0E
#define MCP2521_CANSTAT_OPMOD2 (1 << 7)
#define MCP2521_CANSTAT_OPMOD1 (1 << 6)
#define MCP2521_CANSTAT_OPMOD0 (1 << 5)
#define MCP2521_CANSTAT_ICOD2 (1 << 2)
#define MCP2521_CANSTAT_ICOD1 (1 << 1)
#define MCP2521_CANSTAT_ICOD0 (1 << 0)
struct CANSTAT_Register {
uint8_t ICOD : 3;
uint8_t : 1; // Unused bit
uint8_t OPMOD : 3;
uint8_t : 1; // Unused bit
};
#define MCP2521_CANCTRL 0x0F
#define MCP2521_CANCTRL_REQOP2 (1 << 7)
#define MCP2521_CANCTRL_REQOP1 (1 << 6)
#define MCP2521_CANCTRL_REQOP0 (1 << 5)
#define MCP2521_CANCTRL_ABAT (1 << 4)
#define MCP2521_CANCTRL_OSM (1 << 3)
#define MCP2521_CANCTRL_CLKEN (1 << 2)
#define MCP2521_CANCTRL_CLKPRE1 (1 << 1)
#define MCP2521_CANCTRL_CLKPRE0 (1 << 0)
#define MCP2521_TEC 0x1C
#define MCP2521_REC 0x1D
#define MCP2521_CNF3 0x28
#define MCP2521_CNF3_SOF (1 << 7)
#define MCP2521_CNF3_WAKFIL (1 << 6)
#define MCP2521_CNF3_PHSEG22 (1 << 2)
#define MCP2521_CNF3_PHSEG21 (1 << 1)
#define MCP2521_CNF3_PHSEG20 (1 << 0)
#define MCP2521_CNF2 0x29
#define MCP2521_CNF2_BTLMODE (1 << 7)
#define MCP2521_CNF2_SAM (1 << 6)
#define MCP2521_CNF2_PHSEG12 (1 << 5)
#define MCP2521_CNF2_PHSEG11 (1 << 4)
#define MCP2521_CNF2_PHSEG10 (1 << 3)
#define MCP2521_CNF2_PRSEG2 (1 << 2)
#define MCP2521_CNF2_PRSEG1 (1 << 1)
#define MCP2521_CNF2_PRSEG0 (1 << 0)
#define MCP2521_CNF1 0x2A
#define MCP2521_CNF1_SJW1 (1 << 7)
#define MCP2521_CNF1_SJW0 (1 << 6)
#define MCP2521_CNF1_BRP5 (1 << 5)
#define MCP2521_CNF1_BRP4 (1 << 4)
#define MCP2521_CNF1_BRP3 (1 << 3)
#define MCP2521_CNF1_BRP2 (1 << 2)
#define MCP2521_CNF1_BRP1 (1 << 1)
#define MCP2521_CNF1_BRP0 (1 << 0)
#define MCP2521_CANINTE 0x2B
#define MCP2521_CANINTE_MERRE (1 << 7)
#define MCP2521_CANINTE_WAKIE (1 << 6)
#define MCP2521_CANINTE_ERRIE (1 << 5)
#define MCP2521_CANINTE_TX2IE (1 << 4)
#define MCP2521_CANINTE_TX1IE (1 << 3)
#define MCP2521_CANINTE_TX0IE (1 << 2)
#define MCP2521_CANINTE_RX1IE (1 << 1)
#define MCP2521_CANINTE_RX0IE (1 << 0)
#define MCP2521_CANINTF 0x2C
#define MCP2521_CANINTF_MERRF (1 << 7)
#define MCP2521_CANINTF_WAKIF (1 << 6)
#define MCP2521_CANINTF_ERRIF (1 << 5)
#define MCP2521_CANINTF_TX2IF (1 << 4)
#define MCP2521_CANINTF_TX1IF (1 << 3)
#define MCP2521_CANINTF_TX0IF (1 << 2)
#define MCP2521_CANINTF_RX1IF (1 << 1)
#define MCP2521_CANINTF_RX0IF (1 << 0)
#define MCP2521_EFLG 0x2D
#define MCP2521_EFLG_RX1OVR (1 << 7)
#define MCP2521_EFLG_RX0OVR (1 << 6)
#define MCP2521_EFLG_TXBO (1 << 5)
#define MCP2521_EFLG_TXEP (1 << 4)
#define MCP2521_EFLG_RXEP (1 << 3)
#define MCP2521_EFLG_TXWAR (1 << 2)
#define MCP2521_EFLG_RXWAR (1 << 1)
#define MCP2521_EFLG_EWARN (1 << 0)
#define MCP2521_TXB0CTRL 0x30
#define MCP2521_TXB0CTRL_ABTF (1 << 6)
#define MCP2521_TXB0CTRL_MLOA (1 << 5)
#define MCP2521_TXB0CTRL_TXERR (1 << 4)
#define MCP2521_TXB0CTRL_TXREQ (1 << 3)
#define MCP2521_TXB0CTRL_TXP1 (1 << 1)
#define MCP2521_TXB0CTRL_TXP0 (1 << 0)
#define MCP2521_TXB0DLC 0x35
#define MCP2521_TXB1DLC 0x45
#define MCP2521_TXB2DLC 0x55
#define MCP2521_TXB1CTRL 0x40
#define MCP2521_TXB1CTRL_ABTF (1 << 6)
#define MCP2521_TXB1CTRL_MLOA (1 << 5)
#define MCP2521_TXB1CTRL_TXERR (1 << 4)
#define MCP2521_TXB1CTRL_TXREQ (1 << 3)
#define MCP2521_TXB1CTRL_TXP1 (1 << 1)
#define MCP2521_TXB1CTRL_TXP0 (1 << 0)
#define MCP2521_TXB2CTRL 0x50
#define MCP2521_TXB2CTRL_ABTF (1 << 6)
#define MCP2521_TXB2CTRL_MLOA (1 << 5)
#define MCP2521_TXB2CTRL_TXERR (1 << 4)
#define MCP2521_TXB2CTRL_TXREQ (1 << 3)
#define MCP2521_TXB2CTRL_TXP1 (1 << 1)
#define MCP2521_TXB2CTRL_TXP0 (1 << 0)
struct TXBnCTRL_Register {
uint8_t TXP : 2;
uint8_t : 1; // Unused bit
uint8_t TXREQ : 1;
uint8_t TXERR : 1;
uint8_t MLOA : 1;
uint8_t ABTF : 1;
uint8_t : 1; // Unused bit
};
#define MCP2521_RXB0CTRL 0x60
#define MCP2521_RXB0CTRL_RXM1 (1 << 6)
#define MCP2521_RXB0CTRL_RXM0 (1 << 5)
#define MCP2521_RXB0CTRL_RXRTR (1 << 3)
#define MCP2521_RXB0CTRL_BUKT (1 << 2)
#define MCP2521_RXB0CTRL_BUKT1 (1 << 1)
#define MCP2521_RXB0CTRL_FILHIT0 (1 << 0)
#define MCP2521_RXB1CTRL 0x70
#define MCP2521_RXB1CTRL_RXM1 (1 << 6)
#define MCP2521_RXB1CTRL_RXM0 (1 << 5)
#define MCP2521_RXB1CTRL_RXRTR (1 << 3)
#define MCP2521_RXB1CTRL_FILHIT2 (1 << 2)
#define MCP2521_RXB1CTRL_FILHIT1 (1 << 1)
#define MCP2521_RXB1CTRL_FILHIT0 (1 << 0)
#define MCP2521_OP_RESET 0b11000000
#define MCP2521_OP_READ 0b00000011
#define MCP2521_OP_READ_RX_BUFFER 0b10010000
#define MCP2521_OP_WRITE 0b00000010
#define MCP2521_OP_LOAD_TX_BUFFER 0b01000000
#define MCP2521_OP_RTS 0b10000000
#define MCP2521_OP_READ_STATUS 0b10100000
#define MCP2521_OP_RX_STATUS 0b10110000
#define MCP2521_OP_BIT_MODIFY 0b00000101
#define MCP2521_TXB0SIDH 0x31
#define MCP2521_TXB1SIDH 0x41
#define MCP2521_TXB2SIDH 0x51
#define MCP2521_TXB0SIDL 0x32
#define MCP2521_TXB1SIDL 0x42
#define MCP2521_TXB2SIDL 0x52
#define MCP2521_RXB0SIDH 0x61
#define MCP2521_RXB1SIDH 0x71
#define MCP2521_RXB0SIDL 0x62
#define MCP2521_RXB1SIDL 0x72
#define MCP2521_RXB0EID8 0x63
#define MCP2521_RXB1EID8 0x73
#define MCP2521_RXB0EID0 0x64
#define MCP2521_RXB1EID0 0x74
#define MCP2521_RXB0DLC 0x65
#define MCP2521_RXB1DLC 0x75

102
common-libaries/mcp2521/include/mcp2521_command.hpp Normal file
View File

@@ -0,0 +1,102 @@
#pragma once
#include "mcp2521_addresses.hpp"
#include "mcp2521_hardware_handle.hpp"
#include <stdint.h>
enum MCP2521_RX_BUFFER {
RXB0 = 0,
RXB1 = 1
};
enum MCP2521_TX_BUFFER {
TXB0 = 0,
TXB1 = 1,
TXB2 = 2
};
enum MCP2521_BUFFER_TYPE {
ID = 0,
DATA = 1
};
enum MCP2521_OPERATION_MODE {
NORMAL = 0b000,
SLEEP = 0b001,
LOOPBACK = 0b010,
LISTEN_ONLY = 0b011,
CONFIG = 0b100
};
struct rx_info {
bool extended;
uint16_t id;
uint32_t extended_id;
bool rtr;
bool extended_rtr;
uint8_t length;
};
class MCP2521_Command_Interface {
private:
MCP2521_Hardware_Handle * hardware_handle;
intHandlerFunction_t rx0_handler;
intHandlerFunction_t rx1_handler;
intHandlerFunction_t tx0_handler;
intHandlerFunction_t tx1_handler;
intHandlerFunction_t tx2_handler;
intHandlerFunction_t error_handler;
intHandlerFunction_t wakeup_handler;
intHandlerFunction_t message_error_handler;
void * rx0_handler_arg;
void * rx1_handler_arg;
void * tx0_handler_arg;
void * tx1_handler_arg;
void * tx2_handler_arg;
void * error_handler_arg;
void * wakeup_handler_arg;
void * message_error_handler_arg;
public:
MCP2521_Command_Interface(
MCP2521_Hardware_Handle * hardware_handle
);
void handleInterrupt();
void reset();
void read_reg(uint8_t address, uint8_t *data, size_t length);
uint8_t read_reg(uint8_t address);
void read_rx_buf(MCP2521_RX_BUFFER buffer, MCP2521_BUFFER_TYPE type, uint8_t *data, size_t length);
void write_reg(uint8_t address, uint8_t *data, size_t length);
void write_reg(uint8_t address, uint8_t data);
void write_tx_buf(MCP2521_TX_BUFFER buffer, MCP2521_BUFFER_TYPE type, uint8_t *data, size_t length);
void request_to_send(bool txb2, bool txb1, bool txb0);
void request_to_send(MCP2521_TX_BUFFER buffer);
uint8_t read_status();
uint8_t read_rx_status();
void bit_modify(uint8_t address, uint8_t mask, uint8_t data);
// Registering Handlers for Interrupts
void register_rx0_handler(intHandlerFunction_t handler, void * arg);
void register_rx1_handler(intHandlerFunction_t handler, void * arg);
void register_tx0_handler(intHandlerFunction_t handler, void * arg);
void register_tx1_handler(intHandlerFunction_t handler, void * arg);
void register_tx2_handler(intHandlerFunction_t handler, void * arg);
void register_error_handler(intHandlerFunction_t handler, void * arg);
void register_wakeup_handler(intHandlerFunction_t handler, void * arg);
void register_message_error_handler(intHandlerFunction_t handler, void * arg);
};

38
common-libaries/mcp2521/include/mcp2521_toplevel.hpp Normal file
View File

@@ -0,0 +1,38 @@
#pragma once
#include <stdint.h>
#include "mcp2521.hpp"
#include "mcp2521_command.hpp"
#include "mcp2521_addresses.hpp"
class MCP2521 : public MCP2521_Command_Interface {
private:
public:
void set_tx_id(MCP2521_TX_BUFFER buffer, uint16_t id, bool extended);
/**
* @brief Loads the Data Length Code register for the specified buffer
*
* @param buffer What Buffer to load the DLC register for
* @param length How many bytes are in the message (0-8)
* @param rtr: Remote Transmission Request
*/
void set_DLC_reg(MCP2521_TX_BUFFER buffer, uint8_t length, bool rtr);
/**
* @brief Loads the data and id into the specified buffer
*
* @param buffer
* @param id
* @param data
* @param length
*/
void prepare_tx(MCP2521_TX_BUFFER buffer, uint32_t id, uint8_t *data, size_t length, bool rtr, bool extended);
void set_mode_of_operation(MCP2521_OPERATION_MODE mode, bool singleshot);
void set_singleshot_mode(bool enable);
void enable_interrupts(bool MessageError, bool ErrorInterrupt, bool WakeUp, bool TXB0, bool TXB1, bool TXB2, bool RXB0, bool RXB1);
rx_info get_rx_id(MCP2521_RX_BUFFER buffer);
};

100
common-libaries/mcp2521/interface_commands.cpp Normal file
View File

@@ -0,0 +1,100 @@
#include <cstring>
#include "mcp2521.hpp"
#include "mcp2521_addresses.hpp"
void runIntHandler(void *arg) {
MCP2521_Command_Interface *command_interface = (MCP2521_Command_Interface *)arg;
command_interface->handleInterrupt();
}
MCP2521_Command_Interface::MCP2521_Command_Interface(
MCP2521_Hardware_Handle * hardware_handle
) {
this->hardware_handle = hardware_handle;
this->hardware_handle->registerIntHandler(runIntHandler, (void *)this);
rx0_handler = NULL;
rx1_handler = NULL;
tx0_handler = NULL;
tx1_handler = NULL;
tx2_handler = NULL;
error_handler = NULL;
wakeup_handler = NULL;
message_error_handler = NULL;
rx0_handler_arg = NULL;
rx1_handler_arg = NULL;
tx0_handler_arg = NULL;
tx1_handler_arg = NULL;
tx2_handler_arg = NULL;
error_handler_arg = NULL;
wakeup_handler_arg = NULL;
message_error_handler_arg = NULL;
}
void MCP2521_Command_Interface::reset() {
hardware_handle->execute(MCP2521_OP_RESET);
}
void MCP2521_Command_Interface::read_reg(uint8_t address, uint8_t *data, size_t length) {
hardware_handle->read(MCP2521_OP_READ, data, length, address);
}
uint8_t MCP2521_Command_Interface::read_reg(uint8_t address) {
return hardware_handle->read(MCP2521_OP_READ, address);
}
void MCP2521_Command_Interface::read_rx_buf(MCP2521_RX_BUFFER buffer, MCP2521_BUFFER_TYPE type, uint8_t *data, size_t length) {
uint8_t address = (buffer << 1) | (type << 2);
hardware_handle->read(MCP2521_OP_READ_RX_BUFFER | address, data, length);
}
void MCP2521_Command_Interface::write_reg(uint8_t address, uint8_t *data, size_t length) {
hardware_handle->write(MCP2521_OP_WRITE, data, length, address);
}
void MCP2521_Command_Interface::write_reg(uint8_t address, uint8_t data) {
hardware_handle->write(MCP2521_OP_WRITE, data, address);
}
void MCP2521_Command_Interface::write_tx_buf(MCP2521_TX_BUFFER buffer, MCP2521_BUFFER_TYPE type, uint8_t *data, size_t length) {
uint8_t address = (buffer << 1) | (type);
hardware_handle->write(MCP2521_OP_LOAD_TX_BUFFER | address, data, length);
}
void MCP2521_Command_Interface::request_to_send(bool txb2, bool txb1, bool txb0) {
uint8_t data = (txb2 << 2) | (txb1 << 1) | txb0;
hardware_handle->execute(MCP2521_OP_RTS | data);
}
void MCP2521_Command_Interface::request_to_send(MCP2521_TX_BUFFER buffer) {
uint8_t mask = 0;
switch (buffer) {
case MCP2521_TX_BUFFER::TXB0:
mask = 0b001;
break;
case MCP2521_TX_BUFFER::TXB1:
mask = 0b010;
break;
case MCP2521_TX_BUFFER::TXB2:
mask = 0b100;
break;
}
hardware_handle->execute(MCP2521_OP_RTS | mask);
}
uint8_t MCP2521_Command_Interface::read_status() {
return hardware_handle->read(MCP2521_OP_READ_STATUS);
}
uint8_t MCP2521_Command_Interface::read_rx_status() {
return hardware_handle->read(MCP2521_OP_RX_STATUS);
}
void MCP2521_Command_Interface::bit_modify(uint8_t address, uint8_t mask, uint8_t data) {
uint8_t data_array[3] = {address, mask, data};
hardware_handle->write(MCP2521_OP_BIT_MODIFY, data_array, 3);
}

113
common-libaries/mcp2521/interface_interrupts.cpp Normal file
View File

@@ -0,0 +1,113 @@
#include "mcp2521.hpp"
#include "mcp2521_addresses.hpp"
void MCP2521_Command_Interface::register_rx0_handler(intHandlerFunction_t handler, void* args) {
rx0_handler = handler;
rx0_handler_arg = args;
}
void MCP2521_Command_Interface::register_rx1_handler(intHandlerFunction_t handler, void* args) {
rx1_handler = handler;
rx1_handler_arg = args;
}
void MCP2521_Command_Interface::register_tx0_handler(intHandlerFunction_t handler, void* args) {
tx0_handler = handler;
tx0_handler_arg = args;
}
void MCP2521_Command_Interface::register_tx1_handler(intHandlerFunction_t handler, void* args) {
tx1_handler = handler;
tx1_handler_arg = args;
}
void MCP2521_Command_Interface::register_tx2_handler(intHandlerFunction_t handler, void* args) {
tx2_handler = handler;
tx2_handler_arg = args;
}
void MCP2521_Command_Interface::register_error_handler(intHandlerFunction_t handler, void* args) {
error_handler = handler;
error_handler_arg = args;
}
void MCP2521_Command_Interface::register_wakeup_handler(intHandlerFunction_t handler, void* args) {
wakeup_handler = handler;
wakeup_handler_arg = args;
}
void MCP2521_Command_Interface::register_message_error_handler(intHandlerFunction_t handler, void* args) {
message_error_handler = handler;
message_error_handler_arg = args;
}
void MCP2521_Command_Interface::handleInterrupt() {
uint8_t flags = read_reg(MCP2521_CANINTF);
uint8_t clearBits = 0;
if (flags & MCP2521_CANINTF_RX0IF) {
if (rx0_handler) {
rx0_handler(rx0_handler_arg);
}
flags &= ~MCP2521_CANINTF_RX0IF;
clearBits |= MCP2521_CANINTF_RX0IF;
}
if (flags & MCP2521_CANINTF_RX1IF) {
if (rx1_handler) {
rx1_handler(rx1_handler_arg);
}
flags &= ~MCP2521_CANINTF_RX1IF;
clearBits |= MCP2521_CANINTF_RX1IF;
}
if (flags & MCP2521_CANINTF_TX0IF) {
if (tx0_handler) {
tx0_handler(tx0_handler_arg);
}
flags &= ~MCP2521_CANINTF_TX0IF;
clearBits |= MCP2521_CANINTF_TX0IF;
}
if (flags & MCP2521_CANINTF_TX1IF) {
if (tx1_handler) {
tx1_handler(tx1_handler_arg);
}
flags &= ~MCP2521_CANINTF_TX1IF;
clearBits |= MCP2521_CANINTF_TX1IF;
}
if (flags & MCP2521_CANINTF_TX2IF) {
if (tx2_handler) {
tx2_handler(tx2_handler_arg);
}
flags &= ~MCP2521_CANINTF_TX2IF;
clearBits |= MCP2521_CANINTF_TX2IF;
}
if (flags & MCP2521_CANINTF_ERRIF) {
if (error_handler) {
error_handler(error_handler_arg);
}
flags &= ~MCP2521_CANINTF_ERRIF;
clearBits |= MCP2521_CANINTF_ERRIF;
}
if (flags & MCP2521_CANINTF_WAKIF) {
if (wakeup_handler) {
wakeup_handler(wakeup_handler_arg);
}
flags &= ~MCP2521_CANINTF_WAKIF;
clearBits |= MCP2521_CANINTF_WAKIF;
}
if (flags & MCP2521_CANINTF_MERRF) {
if (message_error_handler) {
message_error_handler(message_error_handler_arg);
}
flags &= ~MCP2521_CANINTF_MERRF;
clearBits |= MCP2521_CANINTF_MERRF;
}
bit_modify(MCP2521_CANINTF, clearBits, 0);
}

119
common-libaries/mcp2521/toplevel_commands.cpp Normal file
View File

@@ -0,0 +1,119 @@
#include <cstring>
#include "mcp2521.hpp"
#include "mcp2521_addresses.hpp"
void MCP2521::set_tx_id(MCP2521_TX_BUFFER buffer, uint16_t id, bool extended) {
uint8_t addr_offset = 0;
switch (buffer)
{
case MCP2521_TX_BUFFER::TXB0:
addr_offset = 0x00;
break;
case MCP2521_TX_BUFFER::TXB1:
addr_offset = 0x10;
break;
case MCP2521_TX_BUFFER::TXB2:
addr_offset = 0x20;
break;
}
uint8_t upper_id = (id >> 3) & 0xFF;
uint8_t lower_id = ((id & 0b111) << 5);
if(extended) {
lower_id |= 0b1000;
lower_id |= (id >> 8) & 0b11;
}
write_reg(MCP2521_TXB0SIDH | addr_offset, upper_id);
write_reg(MCP2521_TXB0SIDL | addr_offset, lower_id);
}
void MCP2521::set_DLC_reg(MCP2521_TX_BUFFER buffer, uint8_t length, bool rtr) {
uint8_t data = length;
if (rtr)
data |= 0b01000000;
uint8_t reg_address = 0;
switch (buffer) {
case MCP2521_TX_BUFFER::TXB0:
reg_address = MCP2521_TXB0DLC;
break;
case MCP2521_TX_BUFFER::TXB1:
reg_address = MCP2521_TXB1DLC;
break;
case MCP2521_TX_BUFFER::TXB2:
reg_address = MCP2521_TXB2DLC;
break;
}
write_reg(reg_address, data);
}
void MCP2521::set_mode_of_operation(MCP2521_OPERATION_MODE mode, bool singleshot) {
uint8_t single = singleshot ? 0b00001000 : 0x0;
bit_modify(MCP2521_CANCTRL, 0b11101000 , (mode << 5) | single);
}
void MCP2521::set_singleshot_mode(bool enable) {
uint8_t data = enable ? 0x08 : 0x00;
bit_modify(MCP2521_CANCTRL, 0x08, data);
}
void MCP2521::enable_interrupts(bool MessageError, bool ErrorInterrupt, bool WakeUp, bool TXB0, bool TXB1, bool TXB2, bool RXB0, bool RXB1) {
uint8_t interrupt_flags = 0;
if (MessageError) interrupt_flags |= 0b10000000;
if (WakeUp) interrupt_flags |= 0b01000000;
if (ErrorInterrupt) interrupt_flags |= 0b00100000;
if (TXB2) interrupt_flags |= 0b00010000;
if (TXB1) interrupt_flags |= 0b00001000;
if (TXB0) interrupt_flags |= 0b00000100;
if (RXB1) interrupt_flags |= 0b00000010;
if (RXB0) interrupt_flags |= 0b00000001;
write_reg(MCP2521_CANINTE, interrupt_flags);
}
rx_info MCP2521::get_rx_id(MCP2521_RX_BUFFER buffer) {
uint8_t data[5];
uint8_t addr_offset = MCP2521_RXB0SIDH;
switch (buffer) {
case MCP2521_RX_BUFFER::RXB0:
addr_offset |= 0x00;
break;
case MCP2521_RX_BUFFER::RXB1:
addr_offset |= 0x10;
break;
}
read_reg(addr_offset, data, 5);
rx_info res;
res.extended = data[1] & 0b1000;
res.id = (data[0] << 3) | (data[1] >> 5);
res.extended_id = ((data[1] & 0b11) << 16) | (data[2] << 8) | data[3];
res.rtr = data[1] & 0b10000;
res.extended_rtr = (data[4] & 0b1000000);
res.length = (data[4] & 0b1111);
return res;
}
void MCP2521::prepare_tx(
MCP2521_TX_BUFFER buffer,
uint32_t id,
uint8_t *data,
size_t length,
bool rtr, bool extended) {
set_tx_id(buffer, id, extended);
set_DLC_reg(buffer, length, rtr);
write_tx_buf(buffer, MCP2521_BUFFER_TYPE::DATA, data, length);
}

5
common-libaries/mcp2521_hardware_interface/CMakeLists.txt Normal file
View File

@@ -0,0 +1,5 @@
idf_component_register(SRCS "esp_implementation_init.cpp"
"esp_implementation_cmd.cpp"
"esp_implementation_int.cpp"
INCLUDE_DIRS "include"
REQUIRES driver)

209
common-libaries/mcp2521_hardware_interface/esp_implementation_cmd.cpp Normal file
View File

@@ -0,0 +1,209 @@
#include "mcp2521_hardware_handle.hpp"
#ifdef ESP_PLATFORM
#include "mcp2521_hardware_esp.hpp"
const uint8_t null_buffer[32] = {0};
void MCP2521_Hardware_Handle_ESP::spi_transmit(spi_transaction_t *t) {
xSemaphoreTake(spiMutex, portMAX_DELAY);
spi_device_transmit(this->spi_device_handle, t);
xSemaphoreGive(spiMutex);
}
void MCP2521_Hardware_Handle_ESP::execute(uint8_t cmd) {
spi_transaction_ext_t t = {
.base = {
.flags = SPI_TRANS_VARIABLE_CMD | SPI_TRANS_VARIABLE_ADDR,
.cmd = cmd,
.addr = 0,
.length = 0,
.rxlength = 0,
.tx_buffer = NULL,
.rx_buffer = NULL
},
.command_bits = 8,
.address_bits = 0,
.dummy_bits = 0,
};
spi_transmit((spi_transaction_t*)(&t));
}
void MCP2521_Hardware_Handle_ESP::execute(uint8_t cmd, uint8_t address) {
spi_transaction_ext_t t = {
.base = {
.flags = SPI_TRANS_VARIABLE_CMD | SPI_TRANS_VARIABLE_ADDR,
.cmd = cmd,
.addr = address,
.length = 0,
.rxlength = 0,
.tx_buffer = NULL,
.rx_buffer = NULL
},
.command_bits = 8,
.address_bits = 8,
.dummy_bits = 0,
};
spi_transmit((spi_transaction_t*)(&t));
}
void MCP2521_Hardware_Handle_ESP::read(uint8_t cmd, uint8_t *data, size_t length, uint8_t address) {
spi_transaction_ext_t t = {
.base = {
.flags = SPI_TRANS_VARIABLE_CMD | SPI_TRANS_VARIABLE_ADDR,
.cmd = cmd,
.addr = address,
.length = 8*length,
.rxlength = 8*length,
.tx_buffer = null_buffer,
.rx_buffer = data
},
.command_bits = 8,
.address_bits = 8,
.dummy_bits = 0,
};
spi_transmit((spi_transaction_t*)(&t));
}
void MCP2521_Hardware_Handle_ESP::read(uint8_t cmd, uint8_t *data, size_t length) {
spi_transaction_ext_t t = {
.base = {
.flags = SPI_TRANS_VARIABLE_CMD | SPI_TRANS_VARIABLE_ADDR,
.cmd = cmd,
.addr = 0,
.length = 8*length,
.rxlength = 8*length,
.tx_buffer = NULL,
.rx_buffer = data
},
.command_bits = 8,
.address_bits = 0,
.dummy_bits = 0,
};
spi_transmit((spi_transaction_t*)(&t));
}
uint8_t MCP2521_Hardware_Handle_ESP::read(uint8_t cmd, uint8_t address) {
uint8_t result = 0;
spi_transaction_ext_t t = {
.base = {
.flags = SPI_TRANS_VARIABLE_CMD | SPI_TRANS_VARIABLE_ADDR,
.cmd = cmd,
.addr = address,
.length = 8,
.rxlength = 8,
.tx_buffer = null_buffer,
.rx_buffer = &result
},
.command_bits = 8,
.address_bits = 8,
.dummy_bits = 0,
};
spi_transmit((spi_transaction_t*)(&t));
return result;
}
uint8_t MCP2521_Hardware_Handle_ESP::read(uint8_t cmd) {
uint8_t result;
spi_transaction_ext_t t = {
.base = {
.flags = SPI_TRANS_VARIABLE_CMD | SPI_TRANS_VARIABLE_ADDR,
.cmd = cmd,
.addr = 0,
.length = 8,
.rxlength = 8,
.tx_buffer = null_buffer,
.rx_buffer = &result
},
.command_bits = 8,
.address_bits = 0,
.dummy_bits = 0,
};
spi_transmit((spi_transaction_t*)(&t));
return result;
}
void MCP2521_Hardware_Handle_ESP::write(uint8_t cmd, uint8_t *data, size_t length, uint8_t address) {
uint8_t result;
spi_transaction_ext_t t = {
.base = {
.flags = SPI_TRANS_VARIABLE_CMD | SPI_TRANS_VARIABLE_ADDR,
.cmd = cmd,
.addr = address,
.length = 8*length,
.rxlength = 0,
.tx_buffer = data,
.rx_buffer = NULL
},
.command_bits = 8,
.address_bits = 8,
.dummy_bits = 0,
};
spi_transmit((spi_transaction_t*)(&t));
}
void MCP2521_Hardware_Handle_ESP::write(uint8_t cmd, uint8_t *data, size_t length) {
spi_transaction_ext_t t = {
.base = {
.flags = SPI_TRANS_VARIABLE_CMD | SPI_TRANS_VARIABLE_ADDR,
.cmd = cmd,
.addr = 0,
.length = 8*length,
.rxlength = 0,
.tx_buffer = data,
.rx_buffer = NULL
},
.command_bits = 8,
.address_bits = 0,
.dummy_bits = 0,
};
spi_transmit((spi_transaction_t*)(&t));
}
void MCP2521_Hardware_Handle_ESP::write(uint8_t cmd, uint8_t data, uint8_t address) {
spi_transaction_ext_t t = {
.base = {
.flags = SPI_TRANS_VARIABLE_CMD | SPI_TRANS_VARIABLE_ADDR,
.cmd = cmd,
.addr = address,
.length = 8,
.rxlength = 0,
.tx_buffer = &data,
.rx_buffer = NULL
},
.command_bits = 8,
.address_bits = 8,
.dummy_bits = 0,
};
spi_transmit((spi_transaction_t*)(&t));
}
void MCP2521_Hardware_Handle_ESP::write(uint8_t cmd, uint8_t data) {
spi_transaction_ext_t t = {
.base = {
.flags = SPI_TRANS_VARIABLE_CMD | SPI_TRANS_VARIABLE_ADDR,
.cmd = cmd,
.addr = 0,
.length = 8,
.rxlength = 0,
.tx_buffer = &data,
.rx_buffer = NULL
},
.command_bits = 8,
.address_bits = 0,
.dummy_bits = 0,
};
spi_transmit((spi_transaction_t*)(&t));
}
#endif

92
common-libaries/mcp2521_hardware_interface/esp_implementation_init.cpp Normal file
View File

@@ -0,0 +1,92 @@
#include "mcp2521_hardware_handle.hpp"
#ifdef ESP_PLATFORM
#include "mcp2521_hardware_esp.hpp"
#include "driver/gpio.h"
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
MCP2521_Hardware_Handle_ESP::MCP2521_Hardware_Handle_ESP(
spi_host_device_t spi_host,
spi_bus_config_t *bus_config,
gpio_num_t mosi,
gpio_num_t miso,
gpio_num_t sclk,
gpio_num_t cs,
gpio_num_t int_pin
) {
initPins(int_pin);
initSPIBus(spi_host, mosi, miso, sclk, bus_config);
this->spi_bus_config = bus_config;
initSPIDevice(spi_host, cs);
}
MCP2521_Hardware_Handle_ESP::MCP2521_Hardware_Handle_ESP(
spi_host_device_t spi_host,
spi_bus_config_t *bus_config,
gpio_num_t cs,
gpio_num_t int_pin
) {
initPins(int_pin);
this->spi_bus_config = bus_config;
initSPIDevice(spi_host, cs);
}
MCP2521_Hardware_Handle_ESP::~MCP2521_Hardware_Handle_ESP() {
}
void MCP2521_Hardware_Handle_ESP::initSPIBus(
spi_host_device_t spi_host,
gpio_num_t mosi,
gpio_num_t miso,
gpio_num_t sclk,
spi_bus_config_t *bus_config
) {
memset(bus_config, 0, sizeof(spi_bus_config_t));
bus_config->mosi_io_num = mosi;
bus_config->miso_io_num = miso;
bus_config->sclk_io_num = sclk;
bus_config->quadwp_io_num = -1;
bus_config->quadhd_io_num = -1;
bus_config->flags = SPICOMMON_BUSFLAG_MASTER;
spi_bus_initialize(spi_host, bus_config, SPI_DMA_CH_AUTO);
}
void MCP2521_Hardware_Handle_ESP::initSPIDevice(
spi_host_device_t spi_host,
gpio_num_t cs
) {
memset(&this->spi_device_config, 0, sizeof(spi_device_interface_config_t));
this->spi_device_config = {
.command_bits = 8,
.address_bits = 0,
.dummy_bits = 0,
.mode = 0,
.duty_cycle_pos = 128,
// cs_ena_pretrans = 0 and cs_ena_posttrans = 0 need to be set to zero, if not its not compatible with full-duplex mode
// Learned this the hard way
.cs_ena_pretrans = 0,
.cs_ena_posttrans = 0,
.clock_speed_hz = 10000,
.spics_io_num = cs,
.flags = SPI_DEVICE_NO_DUMMY,
.queue_size = 5,
};
spi_bus_add_device(spi_host, &this->spi_device_config, &this->spi_device_handle);
spiMutex = xSemaphoreCreateMutex();
}
spi_bus_config_t * MCP2521_Hardware_Handle_ESP::getSPI_bus_config() {
return this->spi_bus_config;
}
#endif

65
common-libaries/mcp2521_hardware_interface/esp_implementation_int.cpp Normal file
View File

@@ -0,0 +1,65 @@
#include "mcp2521_hardware_handle.hpp"
#ifdef ESP_PLATFORM
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "mcp2521_hardware_esp.hpp"
static void IRAM_ATTR gpio_isr_can_handler(void* arg) {
MCP2521_Hardware_Handle_ESP * handle = (MCP2521_Hardware_Handle_ESP *)arg;
handle->isr_can_interrupt();
}
static void handleInteruptTaskCallerFn(void *arg) {
MCP2521_Hardware_Handle_ESP * handle = (MCP2521_Hardware_Handle_ESP *)arg;
handle->handleIntteruptTaskFn();
}
void MCP2521_Hardware_Handle_ESP::initPins(
gpio_num_t int_pin
) {
canInterruptSemaphore = xSemaphoreCreateBinary();
gpio_config_t io_conf;
io_conf.intr_type = GPIO_INTR_NEGEDGE;
io_conf.mode = GPIO_MODE_INPUT;
io_conf.pin_bit_mask = 1 << int_pin;
io_conf.pull_down_en = GPIO_PULLDOWN_DISABLE;
io_conf.pull_up_en = GPIO_PULLUP_ENABLE;
gpio_config(&io_conf);
gpio_install_isr_service(0);
gpio_isr_handler_add(int_pin, gpio_isr_can_handler, this);
xTaskCreate(
(TaskFunction_t)&handleInteruptTaskCallerFn,
"canInterruptTask",
2048,
this,
5,
&canInterruptTaskHandle
);
}
void MCP2521_Hardware_Handle_ESP::handleIntteruptTaskFn() {
while(true) {
xSemaphoreTake(canInterruptSemaphore, portMAX_DELAY);
intHandler(intHandlerArg);
}
}
void MCP2521_Hardware_Handle_ESP::isr_can_interrupt() {
BaseType_t wokenTask = pdFALSE;
xSemaphoreGiveFromISR(canInterruptSemaphore, &wokenTask);
if(wokenTask) {
portYIELD_FROM_ISR();
}
}
void MCP2521_Hardware_Handle_ESP::registerIntHandler(intHandlerFunction_t handler, void * arg) {
intHandlerArg = arg;
intHandler = handler;
}
#endif

87
common-libaries/mcp2521_hardware_interface/include/mcp2521_hardware_esp.hpp Normal file
View File

@@ -0,0 +1,87 @@
#pragma once
#include "mcp2521_hardware_handle.hpp"
#ifdef ESP_PLATFORM
#include "driver/gpio.h"
#include "driver/spi_master.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
class MCP2521_Hardware_Handle_ESP : public MCP2521_Hardware_Handle {
char spi_tmp_buffer;
spi_bus_config_t * spi_bus_config;
spi_device_interface_config_t spi_device_config;
spi_device_handle_t spi_device_handle;
SemaphoreHandle_t canInterruptSemaphore = NULL;
SemaphoreHandle_t spiMutex = NULL;
TaskHandle_t canInterruptTaskHandle = NULL;
void spi_transmit(spi_transaction_t *t);
void * intHandlerArg = NULL;
intHandlerFunction_t intHandler = NULL;
public:
MCP2521_Hardware_Handle_ESP(
spi_host_device_t spi_host,
spi_bus_config_t *bus_config,
gpio_num_t mosi,
gpio_num_t miso,
gpio_num_t sclk,
gpio_num_t cs,
gpio_num_t int_pin
);
MCP2521_Hardware_Handle_ESP(
spi_host_device_t spi_host,
spi_bus_config_t *bus_config,
gpio_num_t cs,
gpio_num_t int_pin
);
static void initSPIBus(
spi_host_device_t spi_host,
gpio_num_t mosi,
gpio_num_t miso,
gpio_num_t sclk,
spi_bus_config_t *bus_config
);
void initSPIDevice(
spi_host_device_t spi_host,
gpio_num_t cs
);
void initPins(
gpio_num_t int_pin
);
~MCP2521_Hardware_Handle_ESP();
spi_bus_config_t * getSPI_bus_config();
// ISR Stuff
void isr_can_interrupt();
void handleIntteruptTaskFn();
// Inherited from MCP2521_Hardware_Handle
void execute(uint8_t cmd);
void execute(uint8_t cmd, uint8_t address);
void read(uint8_t cmd, uint8_t *data, size_t length, uint8_t address);
void read(uint8_t cmd, uint8_t *data, size_t length);
uint8_t read(uint8_t cmd, uint8_t address);
uint8_t read(uint8_t cmd);
void write(uint8_t cmd, uint8_t *data, size_t length, uint8_t address);
void write(uint8_t cmd, uint8_t *data, size_t length);
void write(uint8_t cmd, uint8_t data, uint8_t address);
void write(uint8_t cmd, uint8_t data);
void registerIntHandler(intHandlerFunction_t handler, void * arg);
};
#endif

24
common-libaries/mcp2521_hardware_interface/include/mcp2521_hardware_handle.hpp Normal file
View File

@@ -0,0 +1,24 @@
#pragma once
#include <cstdint>
#include <strings.h>
typedef void (*intHandlerFunction_t)(void *);
class MCP2521_Hardware_Handle {
public:
virtual void registerIntHandler(intHandlerFunction_t handler, void * arg) = 0;
virtual void execute(uint8_t cmd) = 0;
virtual void execute(uint8_t cmd, uint8_t address) = 0;
virtual void read(uint8_t cmd, uint8_t *data, size_t length, uint8_t address) = 0;
virtual void read(uint8_t cmd, uint8_t *data, size_t length) = 0;
virtual uint8_t read(uint8_t cmd, uint8_t address) = 0;
virtual uint8_t read(uint8_t cmd) = 0;
virtual void write(uint8_t cmd, uint8_t *data, size_t length, uint8_t address) = 0;
virtual void write(uint8_t cmd, uint8_t *data, size_t length) = 0;
virtual void write(uint8_t cmd, uint8_t data, uint8_t address) = 0;
virtual void write(uint8_t cmd, uint8_t data) = 0;
};