sascha/esphome
1
0
Fork 0
mirror of https://github.com/esphome/esphome.git synced 2025-03-15 07:08:20 +00:00
Code Issues Releases Wiki Activity

code cleanup

Browse Source
This commit is contained in:
Michiel van Turnhout 2019-08-01 16:44:53 +02:00
parent cf2cf87a66
commit 12121d0d3f
6 changed files with 153 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
esphome/components/canbus/__init__.py
View File

@ -8,11 +8,10 @@ from esphome.automation import maybe_simple_id
from esphome.core import CORE, EsphomeError, Lambda, coroutine, coroutine_with_priority from esphome.core import CORE, EsphomeError, Lambda, coroutine, coroutine_with_priority
from esphome.components import sensor from esphome.components import sensor
from esphome.py_compat import text_type, binary_type, char_to_byte from esphome.py_compat import text_type, binary_type, char_to_byte
from esphome.const import CONF_ID, CONF_TRIGGER_ID, CONF_DATA from esphome.const import CONF_ID, CONF_TRIGGER_ID, CONF_DATA, CONF_ON_MESSAGE
IS_PLATFORM_COMPONENT = True IS_PLATFORM_COMPONENT = True
CONF_ON_RECEIVE = 'on_receive'
CONF_CANBUS_ID = 'canbus_id' CONF_CANBUS_ID = 'canbus_id'
CONF_CAN_ID = 'can_id' CONF_CAN_ID = 'can_id'
CONF_SENDER_ID = 'sender_id' CONF_SENDER_ID = 'sender_id'
@ -36,7 +35,7 @@ CanbusComponent = canbus_ns.class_('CanbusComponent', cg.Component)
CanbusTrigger = canbus_ns.class_('CanbusTrigger', CanbusTrigger = canbus_ns.class_('CanbusTrigger',
automation.Trigger.template(cg.std_string), automation.Trigger.template(cg.std_string),
cg.Component) cg.Component)
CanSpeed = canbus_ns.enum('CanSpeed') CanSpeed = canbus_ns.enum('CAN_SPEED')
CAN_SPEEDS = { CAN_SPEEDS = {
'5KBPS': CanSpeed.CAN_5KBPS, '5KBPS': CanSpeed.CAN_5KBPS,
@ -61,10 +60,10 @@ CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_id(CanbusComponent), cv.GenerateID(): cv.declare_id(CanbusComponent),
cv.Required(CONF_SENDER_ID): cv.int_range(min=0, max=255), cv.Required(CONF_SENDER_ID): cv.int_range(min=0, max=255),
cv.Optional(CONF_BIT_RATE, default='125KBPS'): cv.enum(CAN_SPEEDS, upper=True), cv.Optional(CONF_BIT_RATE, default='125KBPS'): cv.enum(CAN_SPEEDS, upper=True),
cv.Optional(CONF_ON_RECEIVE): automation.validate_automation({ # cv.Optional(CONF_ON_MESSAGE): automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(CanbusTrigger), # cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(CanbusTrigger),
cv.GenerateID(CONF_CAN_ID): cv.int_range(min=1, max=4096), # cv.GenerateID(CONF_CAN_ID): cv.int_range(min=1, max=4096),
}), # }),
}).extend(cv.COMPONENT_SCHEMA) }).extend(cv.COMPONENT_SCHEMA)
# Actions # Actions
@ -84,9 +83,13 @@ def setup_canbus_core_(var, config):
cg.add(var.set_canbus_id(config[CONF_CANBUS_ID])) cg.add(var.set_canbus_id(config[CONF_CANBUS_ID]))
if CONF_SENDER_ID in config: if CONF_SENDER_ID in config:
cg.add(var.set_sender_id([config[CONF_SENDER_ID]])) cg.add(var.set_sender_id([config[CONF_SENDER_ID]]))
if CONF_DATA in config: if CONF_BIT_RATE in config:
cg.add(var.set_can_data([config[CONF_DATA]])) bitrate = CAN_SPEEDS[config[CONF_BIT_RATE]]
cg.add(var.set_bitrate(bitrate))
# for conf in config.get(CONF_ON_MESSAGE, []):
# trig = cg.new_Pvariable(conf[CONF_TRIGGER_ID], conf[CONF_CAN_ID])
# yield cg.register_component(trig, conf)
# yield automation.build_automation(trig, [(cg.uint32, 'x')], conf)
@coroutine @coroutine
def register_canbus(var, config): def register_canbus(var, config):
@ -105,7 +108,6 @@ def canbus_action_to_code(config, action_id, template_arg, args):
data = config[CONF_DATA] data = config[CONF_DATA]
if isinstance(data, binary_type): if isinstance(data, binary_type):
data = [char_to_byte(x) for x in data] data = [char_to_byte(x) for x in data]
if cg.is_template(data): if cg.is_template(data):
templ = yield cg.templatable(data, args, cg.std_vector.template(cg.uint8)) templ = yield cg.templatable(data, args, cg.std_vector.template(cg.uint8))
cg.add(var.set_data_template(templ)) cg.add(var.set_data_template(templ))

22
esphome/components/canbus/canbus.cpp
View File

@ -31,31 +31,9 @@ void Canbus::send_data(uint32_t can_id, const std::vector<uint8_t> data) {
ESP_LOGD(TAG, "data[%d] = %02x", i, can_message.data[i]); ESP_LOGD(TAG, "data[%d] = %02x", i, can_message.data[i]);
} }
// can_message.can_id = this->sender_id_;
// can_message.can_dlc = 8;
// can_message.data[0] = 0x00;
// can_message.data[1] = 0x01;
// can_message.data[2] = 0x02;
// can_message.data[3] = 0x03;
// can_message.data[4] = 0x04;
// can_message.data[5] = 0x05;
// can_message.data[6] = 0x06;
// can_message.data[7] = 0x07;
//this->dump_frame_(&can_message);
this->send_message_(&can_message); this->send_message_(&can_message);
} }
void Canbus::dump_frame_(const struct can_frame *data_frame) {
//ESP_LOGD(TAG, "dump_frame");
//ESP_LOGD(TAG, "canid %d", frame.can_id);
//ESP_LOGD(TAG, "can_id %02x", data_frame->can_id);
// for (int i = 0; i < 8; i++) {
// data_frame->data[i];
// }
return;
}
void Canbus::loop() { void Canbus::loop() {
// check harware inputbuffer and process to esphome outputs // check harware inputbuffer and process to esphome outputs
} }

49
esphome/components/canbus/canbus.h
View File

@ -3,7 +3,6 @@
#include "esphome/core/component.h" #include "esphome/core/component.h"
#include "esphome/core/automation.h" #include "esphome/core/automation.h"
#include "esphome/core/optional.h" #include "esphome/core/optional.h"
#include "esphome/components/binary_sensor/binary_sensor.h"
namespace esphome { namespace esphome {
namespace canbus { namespace canbus {
@ -17,31 +16,7 @@ struct can_frame {
uint8_t can_dlc; /* frame payload length in byte (0 .. CAN_MAX_DLEN) */ uint8_t can_dlc; /* frame payload length in byte (0 .. CAN_MAX_DLEN) */
uint8_t data[CAN_MAX_DLEN] __attribute__((aligned(8))); uint8_t data[CAN_MAX_DLEN] __attribute__((aligned(8)));
}; };
enum CAN_SPEED : uint8_t {
class Canbus;
class Canbus : public Component {
public:
/* special address description flags for the CAN_ID */
static const uint32_t CAN_EFF_FLAG = 0x80000000UL; /* EFF/SFF is set in the MSB */
static const uint32_t CAN_RTR_FLAG = 0x40000000UL; /* remote transmission request */
static const uint32_t CAN_ERR_FLAG = 0x20000000UL; /* error message frame */
/* valid bits in CAN ID for frame formats */
static const uint32_t CAN_SFF_MASK = 0x000007FFUL; /* standard frame format (SFF) */
static const uint32_t CAN_EFF_MASK = 0x1FFFFFFFUL; /* extended frame format (EFF) */
static const uint32_t CAN_ERR_MASK = 0x1FFFFFFFUL; /* omit EFF, RTR, ERR flags */
/*
* Controller Area Network Identifier structure
*
* bit 0-28 : CAN identifier (11/29 bit)
* bit 29 : error message frame flag (0 = data frame, 1 = error message)
* bit 30 : remote transmission request flag (1 = rtr frame)
* bit 31 : frame format flag (0 = standard 11 bit, 1 = extended 29 bit)
*/
enum CANSPEED : uint8_t {
CAN_5KBPS, CAN_5KBPS,
CAN_10KBPS, CAN_10KBPS,
CAN_20KBPS, CAN_20KBPS,
@ -59,6 +34,7 @@ class Canbus : public Component {
CAN_500KBPS, CAN_500KBPS,
CAN_1000KBPS CAN_1000KBPS
}; };
enum ERROR : uint8_t { enum ERROR : uint8_t {
ERROR_OK = 0, ERROR_OK = 0,
ERROR_FAIL = 1, ERROR_FAIL = 1,
@ -67,6 +43,18 @@ class Canbus : public Component {
ERROR_FAILTX = 4, ERROR_FAILTX = 4,
ERROR_NOMSG = 5 ERROR_NOMSG = 5
}; };
/* special address description flags for the CAN_ID */
static const uint32_t CAN_EFF_FLAG = 0x80000000UL; /* EFF/SFF is set in the MSB */
static const uint32_t CAN_RTR_FLAG = 0x40000000UL; /* remote transmission request */
static const uint32_t CAN_ERR_FLAG = 0x20000000UL; /* error message frame */
/* valid bits in CAN ID for frame formats */
static const uint32_t CAN_SFF_MASK = 0x000007FFUL; /* standard frame format (SFF) */
static const uint32_t CAN_EFF_MASK = 0x1FFFFFFFUL; /* extended frame format (EFF) */
static const uint32_t CAN_ERR_MASK = 0x1FFFFFFFUL; /* omit EFF, RTR, ERR flags */
class Canbus : public Component {
public:
Canbus(){}; Canbus(){};
Canbus(const std::string &name){}; Canbus(const std::string &name){};
@ -77,20 +65,19 @@ class Canbus : public Component {
void send_data(uint32_t can_id, const std::vector<uint8_t> data); void send_data(uint32_t can_id, const std::vector<uint8_t> data);
void set_sender_id(int sender_id) { this->sender_id_ = sender_id; } void set_sender_id(int sender_id) { this->sender_id_ = sender_id; }
void set_bitrate(uint8_t bit_rate) { this->bit_rate_ = bit_rate; } void set_bitrate(CAN_SPEED bit_rate) { this->bit_rate_ = bit_rate; }
protected: protected:
uint32_t sender_id_{0}; uint32_t sender_id_{0};
uint8_t bit_rate_{CAN_125KBPS}; CAN_SPEED bit_rate_{CAN_125KBPS};
void dump_frame_(const struct can_frame *data_frame);
virtual bool setup_internal_(); virtual bool setup_internal_();
virtual ERROR send_message_(const struct can_frame *frame); virtual ERROR send_message_(const struct can_frame *frame);
}; };
class CanbusTrigger : public Trigger<int>, public Component { class CanbusTrigger : public Trigger<std::uint32_t>, public Component {
public: public:
explicit CanbusTrigger(const uint32_t &can_id); explicit CanbusTrigger(const std::uint32_t &can_id);
void setup() override; void setup() override;
void dump_config() override; void dump_config() override;

25
esphome/components/mcp2515/canbus.py
View File

@ -1,20 +1,26 @@
import esphome.codegen as cg import esphome.codegen as cg
import esphome.config_validation as cv import esphome.config_validation as cv
from esphome.components import spi, canbus from esphome.components import spi, canbus
from esphome.automation import LambdaAction from esphome.const import CONF_ID
from esphome import automation from esphome.components.canbus import CanbusComponent, CAN_SPEEDS, CONF_BIT_RATE
from esphome.const import CONF_ID, CONF_TRIGGER_ID
from esphome.components.canbus import CanbusComponent,CONF_ON_RECEIVE, CONF_CAN_ID
print("mcp2515.canbus.py")
AUTO_LOAD = ['canbus'] AUTO_LOAD = ['canbus']
DEPENDENCIES = ['spi'] DEPENDENCIES = ['spi']
CONF_MCP_CLOCK = 'clock'
mcp2515_ns = cg.esphome_ns.namespace('mcp2515') mcp2515_ns = cg.esphome_ns.namespace('mcp2515')
mcp2515 = mcp2515_ns.class_('MCP2515', CanbusComponent, spi.SPIDevice) mcp2515 = mcp2515_ns.class_('MCP2515', CanbusComponent, spi.SPIDevice)
CanClock = mcp2515_ns.enum('CAN_CLOCK')
CAN_CLOCK = {
'20MHZ': CanClock.MCP_20MHZ,
'16MHZ': CanClock.MCP_16MHZ,
'8MHZ':CanClock.MCP_8MHZ,
}
CONFIG_SCHEMA = canbus.CONFIG_SCHEMA.extend({ CONFIG_SCHEMA = canbus.CONFIG_SCHEMA.extend({
cv.GenerateID(): cv.declare_id(mcp2515), cv.GenerateID(): cv.declare_id(mcp2515),
cv.Optional(CONF_MCP_CLOCK, default='8MHZ'): cv.enum(CAN_CLOCK, upper=True),
}).extend(spi.SPI_DEVICE_SCHEMA) }).extend(spi.SPI_DEVICE_SCHEMA)
@ -22,8 +28,9 @@ def to_code(config):
rhs = mcp2515.new() rhs = mcp2515.new()
var = cg.Pvariable(config[CONF_ID], rhs) var = cg.Pvariable(config[CONF_ID], rhs)
yield canbus.register_canbus(var, config) yield canbus.register_canbus(var, config)
# canclock = CAN_CLOCK[config[CONF_MCP_CLOCK]]
# bitrate = CAN_SPEEDS[config[CONF_BIT_RATE]]
# cg.add(var.set_bitrate(bitrate,canclock))
yield spi.register_spi_device(var, config) yield spi.register_spi_device(var, config)
for conf in config.get(CONF_ON_RECEIVE, []):
trig = cg.new_Pvariable(conf[CONF_TRIGGER_ID], conf[CONF_CAN_ID])
yield cg.register_component(trig, conf)
yield automation.build_automation(trig, [(cg.std_string, 'x')], conf)

178
esphome/components/mcp2515/mcp2515.cpp
View File

@ -17,7 +17,7 @@ bool MCP2515::setup_internal_() {
ESP_LOGD(TAG, "setup_internal_()"); ESP_LOGD(TAG, "setup_internal_()");
this->spi_setup(); this->spi_setup();
if (this->reset_() == ERROR_FAIL) if (this->reset_() == canbus::ERROR_FAIL)
return false; return false;
this->set_bitrate_(this->bit_rate_); this->set_bitrate_(this->bit_rate_);
this->set_normal_mode_(); this->set_normal_mode_();
@ -37,7 +37,7 @@ bool MCP2515::setup_internal_() {
return true; return true;
} }
MCP2515::ERROR MCP2515::reset_(void) { canbus::ERROR MCP2515::reset_(void) {
this->enable(); this->enable();
this->transfer_byte(INSTRUCTION_RESET); this->transfer_byte(INSTRUCTION_RESET);
this->disable(); this->disable();
@ -64,21 +64,21 @@ MCP2515::ERROR MCP2515::reset_(void) {
// clear filters and masks // clear filters and masks
/*RXF filters[] = {RXF0, RXF1, RXF2, RXF3, RXF4, RXF5}; /*RXF filters[] = {RXF0, RXF1, RXF2, RXF3, RXF4, RXF5};
for (int i=0; i<6; i++) { for (int i=0; i<6; i++) {
ERROR result = set_filter_(filters[i], true, 0); canbus::ERROR result = set_filter_(filters[i], true, 0);
if (result != ERROR_OK) { if (result != canbus::ERROR_OK) {
return result; return result;
} }
} }
MASK masks[] = {MASK0, MASK1}; MASK masks[] = {MASK0, MASK1};
for (int i=0; i<2; i++) { for (int i=0; i<2; i++) {
ERROR result = set_filter_mask_(masks[i], true, 0); canbus::ERROR result = set_filter_mask_(masks[i], true, 0);
if (result != ERROR_OK) { if (result != canbus::ERROR_OK) {
return result; return result;
} }
}*/ }*/
return ERROR_OK; return canbus::ERROR_OK;
} }
uint8_t MCP2515::read_register_(const REGISTER reg) { uint8_t MCP2515::read_register_(const REGISTER reg) {
@ -140,17 +140,17 @@ uint8_t MCP2515::get_status_(void) {
return i; return i;
} }
MCP2515::ERROR MCP2515::set_config_mode_() { return set_mode_(CANCTRL_REQOP_CONFIG); } canbus::ERROR MCP2515::set_config_mode_() { return set_mode_(CANCTRL_REQOP_CONFIG); }
MCP2515::ERROR MCP2515::set_listen_only_() { return set_mode_(CANCTRL_REQOP_LISTENONLY); } canbus::ERROR MCP2515::set_listen_only_() { return set_mode_(CANCTRL_REQOP_LISTENONLY); }
MCP2515::ERROR MCP2515::set_sleep_mode_() { return set_mode_(CANCTRL_REQOP_SLEEP); } canbus::ERROR MCP2515::set_sleep_mode_() { return set_mode_(CANCTRL_REQOP_SLEEP); }
MCP2515::ERROR MCP2515::set_loop_back_mode_() { return set_mode_(CANCTRL_REQOP_LOOPBACK); } canbus::ERROR MCP2515::set_loop_back_mode_() { return set_mode_(CANCTRL_REQOP_LOOPBACK); }
MCP2515::ERROR MCP2515::set_normal_mode_() { return set_mode_(CANCTRL_REQOP_NORMAL); } canbus::ERROR MCP2515::set_normal_mode_() { return set_mode_(CANCTRL_REQOP_NORMAL); }
MCP2515::ERROR MCP2515::set_mode_(const CANCTRL_REQOP_MODE mode) { canbus::ERROR MCP2515::set_mode_(const CANCTRL_REQOP_MODE mode) {
modify_register_(MCP_CANCTRL, CANCTRL_REQOP, mode); modify_register_(MCP_CANCTRL, CANCTRL_REQOP, mode);
unsigned long endTime = millis() + 10; unsigned long endTime = millis() + 10;
@ -163,11 +163,11 @@ MCP2515::ERROR MCP2515::set_mode_(const CANCTRL_REQOP_MODE mode) {
break; break;
} }
} }
return modeMatch ? ERROR_OK : ERROR_FAIL; return modeMatch ? canbus::ERROR_OK : canbus::ERROR_FAIL;
} }
MCP2515::ERROR MCP2515::set_clk_out_(const CAN_CLKOUT divisor) { canbus::ERROR MCP2515::set_clk_out_(const CAN_CLKOUT divisor) {
ERROR res; canbus::ERROR res;
uint8_t cfg3; uint8_t cfg3;
if (divisor == CLKOUT_DISABLE) { if (divisor == CLKOUT_DISABLE) {
@ -176,7 +176,7 @@ MCP2515::ERROR MCP2515::set_clk_out_(const CAN_CLKOUT divisor) {
/* Turn on CLKOUT for SOF */ /* Turn on CLKOUT for SOF */
modify_register_(MCP_CNF3, CNF3_SOF, CNF3_SOF); modify_register_(MCP_CNF3, CNF3_SOF, CNF3_SOF);
return ERROR_OK; return canbus::ERROR_OK;
} }
/* Set the prescaler (CLKPRE) */ /* Set the prescaler (CLKPRE) */
@ -187,7 +187,7 @@ MCP2515::ERROR MCP2515::set_clk_out_(const CAN_CLKOUT divisor) {
/* Turn off CLKOUT for SOF */ /* Turn off CLKOUT for SOF */
modify_register_(MCP_CNF3, CNF3_SOF, 0x00); modify_register_(MCP_CNF3, CNF3_SOF, 0x00);
return ERROR_OK; return canbus::ERROR_OK;
} }
void MCP2515::prepare_id_(uint8_t *buffer, const bool ext, const uint32_t id) { void MCP2515::prepare_id_(uint8_t *buffer, const bool ext, const uint32_t id) {
@ -209,9 +209,9 @@ void MCP2515::prepare_id_(uint8_t *buffer, const bool ext, const uint32_t id) {
} }
} }
MCP2515::ERROR MCP2515::set_filter_mask_(const MASK mask, const bool ext, const uint32_t ulData) { canbus::ERROR MCP2515::set_filter_mask_(const MASK mask, const bool ext, const uint32_t ulData) {
ERROR res = set_config_mode_(); canbus::ERROR res = set_config_mode_();
if (res != ERROR_OK) { if (res != canbus::ERROR_OK) {
return res; return res;
} }
@ -227,17 +227,17 @@ MCP2515::ERROR MCP2515::set_filter_mask_(const MASK mask, const bool ext, const
reg = MCP_RXM1SIDH; reg = MCP_RXM1SIDH;
break; break;
default: default:
return ERROR_FAIL; return canbus::ERROR_FAIL;
} }
set_registers_(reg, tbufdata, 4); set_registers_(reg, tbufdata, 4);
return ERROR_OK; return canbus::ERROR_OK;
} }
MCP2515::ERROR MCP2515::set_filter_(const RXF num, const bool ext, const uint32_t ulData) { canbus::ERROR MCP2515::set_filter_(const RXF num, const bool ext, const uint32_t ulData) {
ERROR res = set_config_mode_(); canbus::ERROR res = set_config_mode_();
if (res != ERROR_OK) { if (res != canbus::ERROR_OK) {
return res; return res;
} }
@ -263,37 +263,37 @@ MCP2515::ERROR MCP2515::set_filter_(const RXF num, const bool ext, const uint32_
reg = MCP_RXF5SIDH; reg = MCP_RXF5SIDH;
break; break;
default: default:
return ERROR_FAIL; return canbus::ERROR_FAIL;
} }
uint8_t tbufdata[4]; uint8_t tbufdata[4];
prepare_id_(tbufdata, ext, ulData); prepare_id_(tbufdata, ext, ulData);
set_registers_(reg, tbufdata, 4); set_registers_(reg, tbufdata, 4);
return ERROR_OK; return canbus::ERROR_OK;
} }
MCP2515::ERROR MCP2515::send_message_(const TXBn txbn, const struct canbus::can_frame *frame) { canbus::ERROR MCP2515::send_message_(const TXBn txbn, const struct canbus::can_frame *frame) {
const struct TXBn_REGS *txbuf = &TXB[txbn]; const struct TXBn_REGS *txbuf = &TXB[txbn];
uint8_t data[13]; uint8_t data[13];
bool ext = (frame->can_id & CAN_EFF_FLAG); bool ext = (frame->can_id & canbus::CAN_EFF_FLAG);
bool rtr = (frame->can_id & CAN_RTR_FLAG); bool rtr = (frame->can_id & canbus::CAN_RTR_FLAG);
uint32_t id = (frame->can_id & (ext ? CAN_EFF_MASK : CAN_SFF_MASK)); uint32_t id = (frame->can_id & (ext ? canbus::CAN_EFF_MASK : canbus::CAN_SFF_MASK));
prepare_id_(data, ext, id); prepare_id_(data, ext, id);
data[MCP_DLC] = rtr ? (frame->can_dlc | RTR_MASK) : frame->can_dlc; data[MCP_DLC] = rtr ? (frame->can_dlc | RTR_MASK) : frame->can_dlc;
memcpy(&data[MCP_DATA], frame->data, frame->can_dlc); memcpy(&data[MCP_DATA], frame->data, frame->can_dlc);
set_registers_(txbuf->SIDH, data, 5 + frame->can_dlc); set_registers_(txbuf->SIDH, data, 5 + frame->can_dlc);
modify_register_(txbuf->CTRL, TXB_TXREQ, TXB_TXREQ); modify_register_(txbuf->CTRL, TXB_TXREQ, TXB_TXREQ);
return ERROR_OK; return canbus::ERROR_OK;
} }
MCP2515::ERROR MCP2515::send_message_(const struct canbus::can_frame *frame) { canbus::ERROR MCP2515::send_message_(const struct canbus::can_frame *frame) {
//ESP_LOGD(TAG, "send_message_: frame.id = %d", frame->can_id); //ESP_LOGD(TAG, "send_message_: frame.id = %d", frame->can_id);
if (frame->can_dlc > canbus::CAN_MAX_DLEN) { if (frame->can_dlc > canbus::CAN_MAX_DLEN) {
return ERROR_FAILTX; return canbus::ERROR_FAILTX;
} }
//ESP_LOGD(TAG, "send_message_: size = %d is OK", frame->can_dlc); //ESP_LOGD(TAG, "send_message_: size = %d is OK", frame->can_dlc);
TXBn txBuffers[N_TXBUFFERS] = {TXB0, TXB1, TXB2}; TXBn txBuffers[N_TXBUFFERS] = {TXB0, TXB1, TXB2};
@ -307,10 +307,10 @@ MCP2515::ERROR MCP2515::send_message_(const struct canbus::can_frame *frame) {
} }
} }
return ERROR_FAILTX; return canbus::ERROR_FAILTX;
} }
MCP2515::ERROR MCP2515::read_message_(const RXBn rxbn, struct canbus::can_frame *frame) { canbus::ERROR MCP2515::read_message_(const RXBn rxbn, struct canbus::can_frame *frame) {
const struct RXBn_REGS *rxb = &RXB[rxbn]; const struct RXBn_REGS *rxb = &RXB[rxbn];
uint8_t tbufdata[5]; uint8_t tbufdata[5];
@ -323,17 +323,17 @@ MCP2515::ERROR MCP2515::read_message_(const RXBn rxbn, struct canbus::can_frame
id = (id << 2) + (tbufdata[MCP_SIDL] & 0x03); id = (id << 2) + (tbufdata[MCP_SIDL] & 0x03);
id = (id << 8) + tbufdata[MCP_EID8]; id = (id << 8) + tbufdata[MCP_EID8];
id = (id << 8) + tbufdata[MCP_EID0]; id = (id << 8) + tbufdata[MCP_EID0];
id |= CAN_EFF_FLAG; id |= canbus::CAN_EFF_FLAG;
} }
uint8_t dlc = (tbufdata[MCP_DLC] & DLC_MASK); uint8_t dlc = (tbufdata[MCP_DLC] & DLC_MASK);
if (dlc > canbus::CAN_MAX_DLEN) { if (dlc > canbus::CAN_MAX_DLEN) {
return ERROR_FAIL; return canbus::ERROR_FAIL;
} }
uint8_t ctrl = read_register_(rxb->CTRL); uint8_t ctrl = read_register_(rxb->CTRL);
if (ctrl & RXBnCTRL_RTR) { if (ctrl & RXBnCTRL_RTR) {
id |= CAN_RTR_FLAG; id |= canbus::CAN_RTR_FLAG;
} }
frame->can_id = id; frame->can_id = id;
@ -343,11 +343,11 @@ MCP2515::ERROR MCP2515::read_message_(const RXBn rxbn, struct canbus::can_frame
modify_register_(MCP_CANINTF, rxb->CANINTF_RXnIF, 0); modify_register_(MCP_CANINTF, rxb->CANINTF_RXnIF, 0);
return ERROR_OK; return canbus::ERROR_OK;
} }
MCP2515::ERROR MCP2515::read_message_(struct canbus::can_frame *frame) { canbus::ERROR MCP2515::read_message_(struct canbus::can_frame *frame) {
ERROR rc; canbus::ERROR rc;
uint8_t stat = get_status_(); uint8_t stat = get_status_();
if (stat & STAT_RX0IF) { if (stat & STAT_RX0IF) {
@ -355,7 +355,7 @@ MCP2515::ERROR MCP2515::read_message_(struct canbus::can_frame *frame) {
} else if (stat & STAT_RX1IF) { } else if (stat & STAT_RX1IF) {
rc = read_message_(RXB1, frame); rc = read_message_(RXB1, frame);
} else { } else {
rc = ERROR_NOMSG; rc = canbus::ERROR_NOMSG;
} }
return rc; return rc;
@ -415,11 +415,11 @@ void MCP2515::clearERRIF() {
modify_register_(MCP_CANINTF, CANINTF_ERRIF, 0); modify_register_(MCP_CANINTF, CANINTF_ERRIF, 0);
} }
MCP2515::ERROR MCP2515::set_bitrate_(uint8_t can_speed) { return this->set_bitrate_(can_speed, MCP_16MHZ); } canbus::ERROR MCP2515::set_bitrate_(canbus::CAN_SPEED can_speed) { return this->set_bitrate_(can_speed, MCP_16MHZ); }
MCP2515::ERROR MCP2515::set_bitrate_(uint8_t can_speed, CAN_CLOCK can_clock) { canbus::ERROR MCP2515::set_bitrate_(canbus::CAN_SPEED can_speed, CAN_CLOCK can_clock) {
ERROR error = set_config_mode_(); canbus::ERROR error = set_config_mode_();
if (error != ERROR_OK) { if (error != canbus::ERROR_OK) {
return error; return error;
} }
@ -428,72 +428,72 @@ MCP2515::ERROR MCP2515::set_bitrate_(uint8_t can_speed, CAN_CLOCK can_clock) {
switch (can_clock) { switch (can_clock) {
case (MCP_8MHZ): case (MCP_8MHZ):
switch (can_speed) { switch (can_speed) {
case (CAN_5KBPS): // 5KBPS case (canbus::CAN_5KBPS): // 5KBPS
cfg1 = MCP_8MHz_5kBPS_CFG1; cfg1 = MCP_8MHz_5kBPS_CFG1;
cfg2 = MCP_8MHz_5kBPS_CFG2; cfg2 = MCP_8MHz_5kBPS_CFG2;
cfg3 = MCP_8MHz_5kBPS_CFG3; cfg3 = MCP_8MHz_5kBPS_CFG3;
break; break;
case (CAN_10KBPS): // 10KBPS case (canbus::CAN_10KBPS): // 10KBPS
cfg1 = MCP_8MHz_10kBPS_CFG1; cfg1 = MCP_8MHz_10kBPS_CFG1;
cfg2 = MCP_8MHz_10kBPS_CFG2; cfg2 = MCP_8MHz_10kBPS_CFG2;
cfg3 = MCP_8MHz_10kBPS_CFG3; cfg3 = MCP_8MHz_10kBPS_CFG3;
break; break;
case (CAN_20KBPS): // 20KBPS case (canbus::CAN_20KBPS): // 20KBPS
cfg1 = MCP_8MHz_20kBPS_CFG1; cfg1 = MCP_8MHz_20kBPS_CFG1;
cfg2 = MCP_8MHz_20kBPS_CFG2; cfg2 = MCP_8MHz_20kBPS_CFG2;
cfg3 = MCP_8MHz_20kBPS_CFG3; cfg3 = MCP_8MHz_20kBPS_CFG3;
break; break;
case (CAN_31K25BPS): // 31.25KBPS case (canbus::CAN_31K25BPS): // 31.25KBPS
cfg1 = MCP_8MHz_31k25BPS_CFG1; cfg1 = MCP_8MHz_31k25BPS_CFG1;
cfg2 = MCP_8MHz_31k25BPS_CFG2; cfg2 = MCP_8MHz_31k25BPS_CFG2;
cfg3 = MCP_8MHz_31k25BPS_CFG3; cfg3 = MCP_8MHz_31k25BPS_CFG3;
break; break;
case (CAN_33KBPS): // 33.333KBPS case (canbus::CAN_33KBPS): // 33.333KBPS
cfg1 = MCP_8MHz_33k3BPS_CFG1; cfg1 = MCP_8MHz_33k3BPS_CFG1;
cfg2 = MCP_8MHz_33k3BPS_CFG2; cfg2 = MCP_8MHz_33k3BPS_CFG2;
cfg3 = MCP_8MHz_33k3BPS_CFG3; cfg3 = MCP_8MHz_33k3BPS_CFG3;
break; break;
case (CAN_40KBPS): // 40Kbps case (canbus::CAN_40KBPS): // 40Kbps
cfg1 = MCP_8MHz_40kBPS_CFG1; cfg1 = MCP_8MHz_40kBPS_CFG1;
cfg2 = MCP_8MHz_40kBPS_CFG2; cfg2 = MCP_8MHz_40kBPS_CFG2;
cfg3 = MCP_8MHz_40kBPS_CFG3; cfg3 = MCP_8MHz_40kBPS_CFG3;
break; break;
case (CAN_50KBPS): // 50Kbps case (canbus::CAN_50KBPS): // 50Kbps
cfg1 = MCP_8MHz_50kBPS_CFG1; cfg1 = MCP_8MHz_50kBPS_CFG1;
cfg2 = MCP_8MHz_50kBPS_CFG2; cfg2 = MCP_8MHz_50kBPS_CFG2;
cfg3 = MCP_8MHz_50kBPS_CFG3; cfg3 = MCP_8MHz_50kBPS_CFG3;
break; break;
case (CAN_80KBPS): // 80Kbps case (canbus::CAN_80KBPS): // 80Kbps
cfg1 = MCP_8MHz_80kBPS_CFG1; cfg1 = MCP_8MHz_80kBPS_CFG1;
cfg2 = MCP_8MHz_80kBPS_CFG2; cfg2 = MCP_8MHz_80kBPS_CFG2;
cfg3 = MCP_8MHz_80kBPS_CFG3; cfg3 = MCP_8MHz_80kBPS_CFG3;
break; break;
case (CAN_100KBPS): // 100Kbps case (canbus::CAN_100KBPS): // 100Kbps
cfg1 = MCP_8MHz_100kBPS_CFG1; cfg1 = MCP_8MHz_100kBPS_CFG1;
cfg2 = MCP_8MHz_100kBPS_CFG2; cfg2 = MCP_8MHz_100kBPS_CFG2;
cfg3 = MCP_8MHz_100kBPS_CFG3; cfg3 = MCP_8MHz_100kBPS_CFG3;
break; break;
case (CAN_125KBPS): // 125Kbps case (canbus::CAN_125KBPS): // 125Kbps
cfg1 = MCP_8MHz_125kBPS_CFG1; cfg1 = MCP_8MHz_125kBPS_CFG1;
cfg2 = MCP_8MHz_125kBPS_CFG2; cfg2 = MCP_8MHz_125kBPS_CFG2;
cfg3 = MCP_8MHz_125kBPS_CFG3; cfg3 = MCP_8MHz_125kBPS_CFG3;
break; break;
case (CAN_200KBPS): // 200Kbps case (canbus::CAN_200KBPS): // 200Kbps
cfg1 = MCP_8MHz_200kBPS_CFG1; cfg1 = MCP_8MHz_200kBPS_CFG1;
cfg2 = MCP_8MHz_200kBPS_CFG2; cfg2 = MCP_8MHz_200kBPS_CFG2;
cfg3 = MCP_8MHz_200kBPS_CFG3; cfg3 = MCP_8MHz_200kBPS_CFG3;
break; break;
case (CAN_250KBPS): // 250Kbps case (canbus::CAN_250KBPS): // 250Kbps
cfg1 = MCP_8MHz_250kBPS_CFG1; cfg1 = MCP_8MHz_250kBPS_CFG1;
cfg2 = MCP_8MHz_250kBPS_CFG2; cfg2 = MCP_8MHz_250kBPS_CFG2;
cfg3 = MCP_8MHz_250kBPS_CFG3; cfg3 = MCP_8MHz_250kBPS_CFG3;
break; break;
case (CAN_500KBPS): // 500Kbps case (canbus::CAN_500KBPS): // 500Kbps
cfg1 = MCP_8MHz_500kBPS_CFG1; cfg1 = MCP_8MHz_500kBPS_CFG1;
cfg2 = MCP_8MHz_500kBPS_CFG2; cfg2 = MCP_8MHz_500kBPS_CFG2;
cfg3 = MCP_8MHz_500kBPS_CFG3; cfg3 = MCP_8MHz_500kBPS_CFG3;
break; break;
case (CAN_1000KBPS): // 1Mbps case (canbus::CAN_1000KBPS): // 1Mbps
cfg1 = MCP_8MHz_1000kBPS_CFG1; cfg1 = MCP_8MHz_1000kBPS_CFG1;
cfg2 = MCP_8MHz_1000kBPS_CFG2; cfg2 = MCP_8MHz_1000kBPS_CFG2;
cfg3 = MCP_8MHz_1000kBPS_CFG3; cfg3 = MCP_8MHz_1000kBPS_CFG3;
@ -506,71 +506,71 @@ MCP2515::ERROR MCP2515::set_bitrate_(uint8_t can_speed, CAN_CLOCK can_clock) {
case (MCP_16MHZ): case (MCP_16MHZ):
switch (can_speed) { switch (can_speed) {
case (CAN_5KBPS): // 5Kbps case (canbus::CAN_5KBPS): // 5Kbps
cfg1 = MCP_16MHz_5kBPS_CFG1; cfg1 = MCP_16MHz_5kBPS_CFG1;
cfg2 = MCP_16MHz_5kBPS_CFG2; cfg2 = MCP_16MHz_5kBPS_CFG2;
cfg3 = MCP_16MHz_5kBPS_CFG3; cfg3 = MCP_16MHz_5kBPS_CFG3;
break; break;
case (CAN_10KBPS): // 10Kbps case (canbus::CAN_10KBPS): // 10Kbps
cfg1 = MCP_16MHz_10kBPS_CFG1; cfg1 = MCP_16MHz_10kBPS_CFG1;
cfg2 = MCP_16MHz_10kBPS_CFG2; cfg2 = MCP_16MHz_10kBPS_CFG2;
cfg3 = MCP_16MHz_10kBPS_CFG3; cfg3 = MCP_16MHz_10kBPS_CFG3;
break; break;
case (CAN_20KBPS): // 20Kbps case (canbus::CAN_20KBPS): // 20Kbps
cfg1 = MCP_16MHz_20kBPS_CFG1; cfg1 = MCP_16MHz_20kBPS_CFG1;
cfg2 = MCP_16MHz_20kBPS_CFG2; cfg2 = MCP_16MHz_20kBPS_CFG2;
cfg3 = MCP_16MHz_20kBPS_CFG3; cfg3 = MCP_16MHz_20kBPS_CFG3;
break; break;
case (CAN_33KBPS): // 33.333Kbps case (canbus::CAN_33KBPS): // 33.333Kbps
cfg1 = MCP_16MHz_33k3BPS_CFG1; cfg1 = MCP_16MHz_33k3BPS_CFG1;
cfg2 = MCP_16MHz_33k3BPS_CFG2; cfg2 = MCP_16MHz_33k3BPS_CFG2;
cfg3 = MCP_16MHz_33k3BPS_CFG3; cfg3 = MCP_16MHz_33k3BPS_CFG3;
break; break;
case (CAN_40KBPS): // 40Kbps case (canbus::CAN_40KBPS): // 40Kbps
cfg1 = MCP_16MHz_40kBPS_CFG1; cfg1 = MCP_16MHz_40kBPS_CFG1;
cfg2 = MCP_16MHz_40kBPS_CFG2; cfg2 = MCP_16MHz_40kBPS_CFG2;
cfg3 = MCP_16MHz_40kBPS_CFG3; cfg3 = MCP_16MHz_40kBPS_CFG3;
break; break;
case (CAN_50KBPS): // 50Kbps case (canbus::CAN_50KBPS): // 50Kbps
cfg2 = MCP_16MHz_50kBPS_CFG2; cfg2 = MCP_16MHz_50kBPS_CFG2;
cfg3 = MCP_16MHz_50kBPS_CFG3; cfg3 = MCP_16MHz_50kBPS_CFG3;
break; break;
case (CAN_80KBPS): // 80Kbps case (canbus::CAN_80KBPS): // 80Kbps
cfg1 = MCP_16MHz_80kBPS_CFG1; cfg1 = MCP_16MHz_80kBPS_CFG1;
cfg2 = MCP_16MHz_80kBPS_CFG2; cfg2 = MCP_16MHz_80kBPS_CFG2;
cfg3 = MCP_16MHz_80kBPS_CFG3; cfg3 = MCP_16MHz_80kBPS_CFG3;
break; break;
case (CAN_83K3BPS): // 83.333Kbps case (canbus::CAN_83K3BPS): // 83.333Kbps
cfg1 = MCP_16MHz_83k3BPS_CFG1; cfg1 = MCP_16MHz_83k3BPS_CFG1;
cfg2 = MCP_16MHz_83k3BPS_CFG2; cfg2 = MCP_16MHz_83k3BPS_CFG2;
cfg3 = MCP_16MHz_83k3BPS_CFG3; cfg3 = MCP_16MHz_83k3BPS_CFG3;
break; break;
case (CAN_100KBPS): // 100Kbps case (canbus::CAN_100KBPS): // 100Kbps
cfg1 = MCP_16MHz_100kBPS_CFG1; cfg1 = MCP_16MHz_100kBPS_CFG1;
cfg2 = MCP_16MHz_100kBPS_CFG2; cfg2 = MCP_16MHz_100kBPS_CFG2;
cfg3 = MCP_16MHz_100kBPS_CFG3; cfg3 = MCP_16MHz_100kBPS_CFG3;
break; break;
case (CAN_125KBPS): // 125Kbps case (canbus::CAN_125KBPS): // 125Kbps
cfg1 = MCP_16MHz_125kBPS_CFG1; cfg1 = MCP_16MHz_125kBPS_CFG1;
cfg2 = MCP_16MHz_125kBPS_CFG2; cfg2 = MCP_16MHz_125kBPS_CFG2;
cfg3 = MCP_16MHz_125kBPS_CFG3; cfg3 = MCP_16MHz_125kBPS_CFG3;
break; break;
case (CAN_200KBPS): // 200Kbps case (canbus::CAN_200KBPS): // 200Kbps
cfg1 = MCP_16MHz_200kBPS_CFG1; cfg1 = MCP_16MHz_200kBPS_CFG1;
cfg2 = MCP_16MHz_200kBPS_CFG2; cfg2 = MCP_16MHz_200kBPS_CFG2;
cfg3 = MCP_16MHz_200kBPS_CFG3; cfg3 = MCP_16MHz_200kBPS_CFG3;
break; break;
case (CAN_250KBPS): // 250Kbps case (canbus::CAN_250KBPS): // 250Kbps
cfg1 = MCP_16MHz_250kBPS_CFG1; cfg1 = MCP_16MHz_250kBPS_CFG1;
cfg2 = MCP_16MHz_250kBPS_CFG2; cfg2 = MCP_16MHz_250kBPS_CFG2;
cfg3 = MCP_16MHz_250kBPS_CFG3; cfg3 = MCP_16MHz_250kBPS_CFG3;
break; break;
case (CAN_500KBPS): // 500Kbps case (canbus::CAN_500KBPS): // 500Kbps
cfg1 = MCP_16MHz_500kBPS_CFG1; cfg1 = MCP_16MHz_500kBPS_CFG1;
cfg2 = MCP_16MHz_500kBPS_CFG2; cfg2 = MCP_16MHz_500kBPS_CFG2;
cfg3 = MCP_16MHz_500kBPS_CFG3; cfg3 = MCP_16MHz_500kBPS_CFG3;
break; break;
case (CAN_1000KBPS): // 1Mbps case (canbus::CAN_1000KBPS): // 1Mbps
cfg1 = MCP_16MHz_1000kBPS_CFG1; cfg1 = MCP_16MHz_1000kBPS_CFG1;
cfg2 = MCP_16MHz_1000kBPS_CFG2; cfg2 = MCP_16MHz_1000kBPS_CFG2;
cfg3 = MCP_16MHz_1000kBPS_CFG3; cfg3 = MCP_16MHz_1000kBPS_CFG3;
@ -583,57 +583,57 @@ MCP2515::ERROR MCP2515::set_bitrate_(uint8_t can_speed, CAN_CLOCK can_clock) {
case (MCP_20MHZ): case (MCP_20MHZ):
switch (can_speed) { switch (can_speed) {
case (CAN_33KBPS): // 33.333Kbps case (canbus::CAN_33KBPS): // 33.333Kbps
cfg1 = MCP_20MHz_33k3BPS_CFG1; cfg1 = MCP_20MHz_33k3BPS_CFG1;
cfg2 = MCP_20MHz_33k3BPS_CFG2; cfg2 = MCP_20MHz_33k3BPS_CFG2;
cfg3 = MCP_20MHz_33k3BPS_CFG3; cfg3 = MCP_20MHz_33k3BPS_CFG3;
break; break;
case (CAN_40KBPS): // 40Kbps case (canbus::CAN_40KBPS): // 40Kbps
cfg1 = MCP_20MHz_40kBPS_CFG1; cfg1 = MCP_20MHz_40kBPS_CFG1;
cfg2 = MCP_20MHz_40kBPS_CFG2; cfg2 = MCP_20MHz_40kBPS_CFG2;
cfg3 = MCP_20MHz_40kBPS_CFG3; cfg3 = MCP_20MHz_40kBPS_CFG3;
break; break;
case (CAN_50KBPS): // 50Kbps case (canbus::CAN_50KBPS): // 50Kbps
cfg1 = MCP_20MHz_50kBPS_CFG1; cfg1 = MCP_20MHz_50kBPS_CFG1;
cfg2 = MCP_20MHz_50kBPS_CFG2; cfg2 = MCP_20MHz_50kBPS_CFG2;
cfg3 = MCP_20MHz_50kBPS_CFG3; cfg3 = MCP_20MHz_50kBPS_CFG3;
break; break;
case (CAN_80KBPS): // 80Kbps case (canbus::CAN_80KBPS): // 80Kbps
cfg1 = MCP_20MHz_80kBPS_CFG1; cfg1 = MCP_20MHz_80kBPS_CFG1;
cfg2 = MCP_20MHz_80kBPS_CFG2; cfg2 = MCP_20MHz_80kBPS_CFG2;
cfg3 = MCP_20MHz_80kBPS_CFG3; cfg3 = MCP_20MHz_80kBPS_CFG3;
break; break;
case (CAN_83K3BPS): // 83.333Kbps case (canbus::CAN_83K3BPS): // 83.333Kbps
cfg1 = MCP_20MHz_83k3BPS_CFG1; cfg1 = MCP_20MHz_83k3BPS_CFG1;
cfg2 = MCP_20MHz_83k3BPS_CFG2; cfg2 = MCP_20MHz_83k3BPS_CFG2;
cfg3 = MCP_20MHz_83k3BPS_CFG3; cfg3 = MCP_20MHz_83k3BPS_CFG3;
break; break;
case (CAN_100KBPS): // 100Kbps case (canbus::CAN_100KBPS): // 100Kbps
cfg1 = MCP_20MHz_100kBPS_CFG1; cfg1 = MCP_20MHz_100kBPS_CFG1;
cfg2 = MCP_20MHz_100kBPS_CFG2; cfg2 = MCP_20MHz_100kBPS_CFG2;
cfg3 = MCP_20MHz_100kBPS_CFG3; cfg3 = MCP_20MHz_100kBPS_CFG3;
break; break;
case (CAN_125KBPS): // 125Kbps case (canbus::CAN_125KBPS): // 125Kbps
cfg1 = MCP_20MHz_125kBPS_CFG1; cfg1 = MCP_20MHz_125kBPS_CFG1;
cfg2 = MCP_20MHz_125kBPS_CFG2; cfg2 = MCP_20MHz_125kBPS_CFG2;
cfg3 = MCP_20MHz_125kBPS_CFG3; cfg3 = MCP_20MHz_125kBPS_CFG3;
break; break;
case (CAN_200KBPS): // 200Kbps case (canbus::CAN_200KBPS): // 200Kbps
cfg1 = MCP_20MHz_200kBPS_CFG1; cfg1 = MCP_20MHz_200kBPS_CFG1;
cfg2 = MCP_20MHz_200kBPS_CFG2; cfg2 = MCP_20MHz_200kBPS_CFG2;
cfg3 = MCP_20MHz_200kBPS_CFG3; cfg3 = MCP_20MHz_200kBPS_CFG3;
break; break;
case (CAN_250KBPS): // 250Kbps case (canbus::CAN_250KBPS): // 250Kbps
cfg1 = MCP_20MHz_250kBPS_CFG1; cfg1 = MCP_20MHz_250kBPS_CFG1;
cfg2 = MCP_20MHz_250kBPS_CFG2; cfg2 = MCP_20MHz_250kBPS_CFG2;
cfg3 = MCP_20MHz_250kBPS_CFG3; cfg3 = MCP_20MHz_250kBPS_CFG3;
break; break;
case (CAN_500KBPS): // 500Kbps case (canbus::CAN_500KBPS): // 500Kbps
cfg1 = MCP_20MHz_500kBPS_CFG1; cfg1 = MCP_20MHz_500kBPS_CFG1;
cfg2 = MCP_20MHz_500kBPS_CFG2; cfg2 = MCP_20MHz_500kBPS_CFG2;
cfg3 = MCP_20MHz_500kBPS_CFG3; cfg3 = MCP_20MHz_500kBPS_CFG3;
break; break;
case (CAN_1000KBPS): // 1Mbps case (canbus::CAN_1000KBPS): // 1Mbps
cfg1 = MCP_20MHz_1000kBPS_CFG1; cfg1 = MCP_20MHz_1000kBPS_CFG1;
cfg2 = MCP_20MHz_1000kBPS_CFG2; cfg2 = MCP_20MHz_1000kBPS_CFG2;
cfg3 = MCP_20MHz_1000kBPS_CFG3; cfg3 = MCP_20MHz_1000kBPS_CFG3;
@ -653,9 +653,9 @@ MCP2515::ERROR MCP2515::set_bitrate_(uint8_t can_speed, CAN_CLOCK can_clock) {
set_register_(MCP_CNF1, cfg1); set_register_(MCP_CNF1, cfg1);
set_register_(MCP_CNF2, cfg2); set_register_(MCP_CNF2, cfg2);
set_register_(MCP_CNF3, cfg3); set_register_(MCP_CNF3, cfg3);
return ERROR_OK; return canbus::ERROR_OK;
} else { } else {
return ERROR_FAIL; return canbus::ERROR_FAIL;
} }
} }
} // namespace mcp2515 } // namespace mcp2515

33
esphome/components/mcp2515/mcp2515.h
View File

@ -51,6 +51,7 @@ enum /*class*/ STAT : uint8_t { STAT_RX0IF = (1 << 0), STAT_RX1IF = (1 << 1) };
static const uint8_t STAT_RXIF_MASK = STAT_RX0IF | STAT_RX1IF; static const uint8_t STAT_RXIF_MASK = STAT_RX0IF | STAT_RX1IF;
static const uint8_t EFLG_ERRORMASK = EFLG_RX1OVR | EFLG_RX0OVR | EFLG_TXBO | EFLG_TXEP | EFLG_RXEP; static const uint8_t EFLG_ERRORMASK = EFLG_RX1OVR | EFLG_RX0OVR | EFLG_TXBO | EFLG_TXEP | EFLG_RXEP;
class MCP2515 : public canbus::Canbus, class MCP2515 : public canbus::Canbus,
public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW, spi::CLOCK_PHASE_LEADING, public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW, spi::CLOCK_PHASE_LEADING,
spi::DATA_RATE_8MHZ> { spi::DATA_RATE_8MHZ> {
@ -72,7 +73,7 @@ class MCP2515 : public canbus::Canbus,
protected: protected:
bool setup_internal_() override; bool setup_internal_() override;
ERROR set_mode_(const CANCTRL_REQOP_MODE mode); canbus::ERROR set_mode_(const CANCTRL_REQOP_MODE mode);
uint8_t read_register_(const REGISTER reg); uint8_t read_register_(const REGISTER reg);
void read_registers_(const REGISTER reg, uint8_t values[], const uint8_t n); void read_registers_(const REGISTER reg, uint8_t values[], const uint8_t n);
@ -81,21 +82,21 @@ class MCP2515 : public canbus::Canbus,
void modify_register_(const REGISTER reg, const uint8_t mask, const uint8_t data); void modify_register_(const REGISTER reg, const uint8_t mask, const uint8_t data);
void prepare_id_(uint8_t *buffer, const bool ext, const uint32_t id); void prepare_id_(uint8_t *buffer, const bool ext, const uint32_t id);
ERROR reset_(void); canbus::ERROR reset_(void);
ERROR set_config_mode_(); canbus::ERROR set_config_mode_();
ERROR set_listen_only_(); canbus::ERROR set_listen_only_();
ERROR set_sleep_mode_(); canbus::ERROR set_sleep_mode_();
ERROR set_loop_back_mode_(); canbus::ERROR set_loop_back_mode_();
ERROR set_normal_mode_(); canbus::ERROR set_normal_mode_();
ERROR set_clk_out_(const CAN_CLKOUT divisor); canbus::ERROR set_clk_out_(const CAN_CLKOUT divisor);
ERROR set_bitrate_(uint8_t can_speed); canbus::ERROR set_bitrate_(canbus::CAN_SPEED can_speed);
ERROR set_bitrate_(uint8_t can_speed, const CAN_CLOCK can_clock); canbus::ERROR set_bitrate_(canbus::CAN_SPEED can_speed, const CAN_CLOCK can_clock);
ERROR set_filter_mask_(const MASK num, const bool ext, const uint32_t ulData); canbus::ERROR set_filter_mask_(const MASK num, const bool ext, const uint32_t ulData);
ERROR set_filter_(const RXF num, const bool ext, const uint32_t ulData); canbus::ERROR set_filter_(const RXF num, const bool ext, const uint32_t ulData);
ERROR send_message_(const TXBn txbn, const struct canbus::can_frame *frame); canbus::ERROR send_message_(const TXBn txbn, const struct canbus::can_frame *frame);
ERROR send_message_(const struct canbus::can_frame *frame); canbus::ERROR send_message_(const struct canbus::can_frame *frame);
ERROR read_message_(const RXBn rxbn, struct canbus::can_frame *frame); canbus::ERROR read_message_(const RXBn rxbn, struct canbus::can_frame *frame);
ERROR read_message_(struct canbus::can_frame *frame); canbus::ERROR read_message_(struct canbus::can_frame *frame);
bool check_receive_(void); bool check_receive_(void);
bool check_error_(void); bool check_error_(void);
uint8_t get_error_flags_(void); uint8_t get_error_flags_(void);