From 6ac80483f41fab8b078ad706bff0518d7db3c38c Mon Sep 17 00:00:00 2001 From: mvturnho Date: Wed, 31 Jul 2019 22:04:21 +0200 Subject: [PATCH] automation and send_data --- esphome/components/canbus/__init__.py | 25 +++++- esphome/components/canbus/automation.h | 21 ++--- esphome/components/canbus/canbus.cpp | 60 ++++++++----- esphome/components/canbus/canbus.h | 51 +++++------- esphome/components/mcp2515/mcp2515.cpp | 79 +++++++----------- esphome/components/mcp2515/mcp2515.h | 111 +++++++++++-------------- 6 files changed, 170 insertions(+), 177 deletions(-) diff --git a/esphome/components/canbus/__init__.py b/esphome/components/canbus/__init__.py index d018f92077..2039aae00f 100644 --- a/esphome/components/canbus/__init__.py +++ b/esphome/components/canbus/__init__.py @@ -16,9 +16,11 @@ CONF_ON_RECEIVE = 'on_receive' CONF_CANBUS_ID = 'canbus_id' CONF_CAN_ID = 'can_id' CONF_SENDER_ID = 'sender_id' +CONF_BIT_RATE = 'bit_rate' CONF_CANBUS_SEND_ACTION = 'canbus.send' + def validate_raw_data(value): if isinstance(value, text_type): return value.encode('utf-8') @@ -34,10 +36,31 @@ CanbusComponent = canbus_ns.class_('CanbusComponent', cg.Component) CanbusTrigger = canbus_ns.class_('CanbusTrigger', automation.Trigger.template(cg.std_string), cg.Component) +CanSpeed = canbus_ns.enum('CanSpeed') + +CAN_SPEEDS = { + '5KBPS': CanSpeed.CAN_5KBPS, + '10KBPS': CanSpeed.CAN_10KBPS, + '20KBPS': CanSpeed.CAN_20KBPS, + '31K25BPS': CanSpeed.CAN_31K25BPS, + '33KBPS': CanSpeed.CAN_33KBPS, + '40KBPS': CanSpeed.CAN_40KBPS, + '50KBPS': CanSpeed.CAN_50KBPS, + '80KBPS': CanSpeed.CAN_80KBPS, + '83K3BPS': CanSpeed.CAN_83K3BPS, + '95KBPS': CanSpeed.CAN_95KBPS, + '100KBPS': CanSpeed.CAN_100KBPS, + '125KBPS': CanSpeed.CAN_125KBPS, + '200KBPS': CanSpeed.CAN_200KBPS, + '250KBPS': CanSpeed.CAN_250KBPS, + '500KBPS': CanSpeed.CAN_500KBPS, + '1000KBPS': CanSpeed.CAN_1000KBPS, +} CONFIG_SCHEMA = cv.Schema({ cv.GenerateID(): cv.declare_id(CanbusComponent), 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_ON_RECEIVE): automation.validate_automation({ cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(CanbusTrigger), cv.GenerateID(CONF_CAN_ID): cv.int_range(min=1, max=4096), @@ -53,6 +76,7 @@ CANBUS_ACTION_SCHEMA = maybe_simple_id({ cv.Required(CONF_DATA): cv.templatable(validate_raw_data), }) + @coroutine def setup_canbus_core_(var, config): yield cg.register_component(var, config) @@ -90,7 +114,6 @@ def canbus_action_to_code(config, action_id, template_arg, args): yield var - @coroutine_with_priority(100.0) def to_code(config): cg.add_global(canbus_ns.using) diff --git a/esphome/components/canbus/automation.h b/esphome/components/canbus/automation.h index 037f0a005d..5c4c0a88b2 100644 --- a/esphome/components/canbus/automation.h +++ b/esphome/components/canbus/automation.h @@ -3,13 +3,14 @@ #include "esphome/core/component.h" #include "esphome/core/automation.h" #include "esphome/components/canbus/canbus.h" +#include "esphome/core/log.h" namespace esphome { namespace canbus { template class CanbusSendAction : public Action, public Parented { public: - void set_data_template(std::function(Ts...)> func) { + void set_data_template(const std::function(Ts...)> func) { this->data_func_ = func; this->static_ = false; } @@ -18,33 +19,27 @@ template class CanbusSendAction : public Action, public P this->static_ = true; } - void set_can_id(int can_id) {this->can_id_ = can_id;} + void set_can_id(uint32_t can_id) { this->can_id_ = can_id; } TEMPLATABLE_VALUE(float, data) -// void play(Ts... x) override { -// auto call = this->parent_->make_call(this->can_id_); -// //unsigned uint const * p = reinterpret_cast(&f); -// call.set_data(this->data_.optional_value(x...)); -// // call.perform(this->parent_, this->can_id_); -// } void play(Ts... x) override { if (this->static_) { - this->parent_->write_array(this->data_static_); + this->parent_->send_data(this->can_id_, this->data_static_); } else { auto val = this->data_func_(x...); - this->parent_->write_array(val); + this->parent_->send_data(this->can_id_, val); } } + protected: Canbus *parent_; - int can_id_; + uint32_t can_id_; - bool static_{false}; + bool static_{false}; std::function(Ts...)> data_func_{}; std::vector data_static_{}; }; - } // namespace canbus } // namespace esphome diff --git a/esphome/components/canbus/canbus.cpp b/esphome/components/canbus/canbus.cpp index e49dc2dca0..3324906d24 100644 --- a/esphome/components/canbus/canbus.cpp +++ b/esphome/components/canbus/canbus.cpp @@ -16,31 +16,49 @@ void Canbus::setup() { void Canbus::dump_config() { ESP_LOGCONFIG(TAG, "Canbus: sender_id=%d", this->sender_id_); } -void Canbus::send(int can_id, uint8_t *data) { - int size = (sizeof data/ sizeof *data); - ESP_LOGD(TAG, "send: sender_id=%d, can_id=%d, data=%d data_size=%d", this->sender_id_, can_id, data[0],size); - //this->send_internal_(can_id, data); -}; +void Canbus::send_data(uint32_t can_id, const std::vector data) { + struct can_frame can_message; + + //uint8_t size = static_cast(data.size()); + //ESP_LOGD(TAG, "size=%d", size); + // if (size > CAN_MAX_DLC) + // size = CAN_MAX_DLC; + // can_message.can_dlc = size; + // can_message.can_id = this->sender_id_; + + // for (int i = 0; i < size; i++) { + // can_message.data[i] = 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); +} + +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() { // check harware inputbuffer and process to esphome outputs } -CanCall &CanCall::set_data(optional data) { - this->float_data_ = data; - return *this; -} -CanCall &CanCall::set_data(float data) { - this->float_data_ = data; - return *this; -} - -void CanCall::perform() { - ESP_LOGD(TAG,"parent_id=%d can_id= %d data=%f",this->parent_->sender_id_,this->can_id_,this->float_data_); - uint8_t *p = reinterpret_cast(&this->float_data_); - //here we start the canbus->send - this->parent_->send(this->can_id_,p); -} - } // namespace canbus } // namespace esphome \ No newline at end of file diff --git a/esphome/components/canbus/canbus.h b/esphome/components/canbus/canbus.h index 49230ab95b..fb3e9ce6b6 100644 --- a/esphome/components/canbus/canbus.h +++ b/esphome/components/canbus/canbus.h @@ -8,24 +8,19 @@ namespace esphome { namespace canbus { -class Canbus; +/* CAN payload length and DLC definitions according to ISO 11898-1 */ +static const uint8_t CAN_MAX_DLC = 8; +static const uint8_t CAN_MAX_DLEN = 8; -class CanCall { - public: - explicit CanCall(Canbus *parent, int can_id) : parent_(parent), can_id_(can_id) {} - CanCall &set_data(optional data); - CanCall &set_data(float data); - void perform(); - protected: - Canbus *parent_; - int can_id_; - optional float_data_; - optional bool_data_; - optional long_data; +struct can_frame { + uint32_t can_id; /* 32 bit CAN_ID + EFF/RTR/ERR flags */ + uint8_t can_dlc; /* frame payload length in byte (0 .. CAN_MAX_DLEN) */ + uint8_t data[CAN_MAX_DLEN] __attribute__((aligned(8))); }; +class Canbus; + class Canbus : public Component { - friend CanCall; public: /* special address description flags for the CAN_ID */ static const uint32_t CAN_EFF_FLAG = 0x80000000UL; /* EFF/SFF is set in the MSB */ @@ -36,6 +31,7 @@ class Canbus : public Component { 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 * @@ -44,13 +40,8 @@ class Canbus : public Component { * bit 30 : remote transmission request flag (1 = rtr frame) * bit 31 : frame format flag (0 = standard 11 bit, 1 = extended 29 bit) */ - typedef uint32_t canid_t; - /* CAN payload length and DLC definitions according to ISO 11898-1 */ - static const uint8_t CAN_MAX_DLC = 8; - static const uint8_t CAN_MAX_DLEN = 8; - - enum CAN_SPEED { + enum CANSPEED : uint8_t { CAN_5KBPS, CAN_10KBPS, CAN_20KBPS, @@ -84,32 +75,30 @@ class Canbus : public Component { float get_setup_priority() const override { return setup_priority::HARDWARE; } void loop() override; - void send(int can_id, uint8_t *data); + void send_data(uint32_t can_id, const std::vector data); void set_sender_id(int sender_id) { this->sender_id_ = sender_id; } - - CanCall make_call(int can_id){ return CanCall(this, can_id); } + void set_bitrate(uint8_t bit_rate) { this->bit_rate_ = bit_rate; } protected: - int sender_id_{0}; - virtual bool send_internal_(int can_id, uint8_t *data); + uint32_t sender_id_{0}; + uint8_t bit_rate_{CAN_125KBPS}; + + void dump_frame_(const struct can_frame *data_frame); virtual bool setup_internal_(); - virtual ERROR set_bitrate_(const CAN_SPEED canSpeed); + virtual ERROR send_message_(const struct can_frame *frame); }; class CanbusTrigger : public Trigger, public Component { public: - explicit CanbusTrigger(const int &can_id); + explicit CanbusTrigger(const uint32_t &can_id); - void set_payload(const std::string &payload); void setup() override; void dump_config() override; float get_setup_priority() const override; protected: - std::string can_id_; - optional payload_; + uint32_t can_id_; }; - } // namespace canbus } // namespace esphome \ No newline at end of file diff --git a/esphome/components/mcp2515/mcp2515.cpp b/esphome/components/mcp2515/mcp2515.cpp index c949e3a900..2188d6a03f 100644 --- a/esphome/components/mcp2515/mcp2515.cpp +++ b/esphome/components/mcp2515/mcp2515.cpp @@ -6,53 +6,34 @@ namespace mcp2515 { static const char *TAG = "mcp2515"; -const struct MCP2515::TXBn_REGS MCP2515::TXB[MCP2515::N_TXBUFFERS] = {{MCP_TXB0CTRL, MCP_TXB0SIDH, MCP_TXB0DATA}, +const struct MCP2515::TXBn_REGS MCP2515::TXB[N_TXBUFFERS] = {{MCP_TXB0CTRL, MCP_TXB0SIDH, MCP_TXB0DATA}, {MCP_TXB1CTRL, MCP_TXB1SIDH, MCP_TXB1DATA}, {MCP_TXB2CTRL, MCP_TXB2SIDH, MCP_TXB2DATA}}; const struct MCP2515::RXBn_REGS MCP2515::RXB[N_RXBUFFERS] = {{MCP_RXB0CTRL, MCP_RXB0SIDH, MCP_RXB0DATA, CANINTF_RX0IF}, {MCP_RXB1CTRL, MCP_RXB1SIDH, MCP_RXB1DATA, CANINTF_RX1IF}}; -bool MCP2515::send_internal_(int can_id, uint8_t *data) { - struct can_frame canMsg1; - canMsg1.can_id = can_id; - canMsg1.can_dlc = CAN_MAX_DLEN; - canMsg1.data[0] = 0x8E; - canMsg1.data[1] = 0x87; - canMsg1.data[2] = 0x32; - canMsg1.data[3] = 0xFA; - canMsg1.data[4] = 0x26; - canMsg1.data[5] = 0x8E; - canMsg1.data[6] = 0xBE; - canMsg1.data[7] = 0x86; - if (this->send_message_(&canMsg1) == ERROR_FAILTX) { - ESP_LOGE(TAG, "transmit error %d", can_id); - return false; - } - - return true; -}; - bool MCP2515::setup_internal_() { ESP_LOGD(TAG, "setup_internal_()"); this->spi_setup(); if (this->reset_() == ERROR_FAIL) return false; - this->set_bitrate_(CAN_125KBPS); + this->set_bitrate_(this->bit_rate_); this->set_normal_mode_(); -ESP_LOGD(TAG, "setup done send test message"); - struct can_frame canMsg1; - canMsg1.can_dlc = 8; - canMsg1.data[0] = 0x8E; - canMsg1.data[1] = 0x87; - canMsg1.data[2] = 0x32; - canMsg1.data[3] = 0xFA; - canMsg1.data[4] = 0x26; - canMsg1.data[5] = 0x8E; - canMsg1.data[6] = 0xBE; - canMsg1.data[7] = 0x86; - this->send_message_(&canMsg1); + ESP_LOGD(TAG, "setup done send test message"); + struct canbus::can_frame can_message; + 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->send_message_(&can_message); return true; } @@ -292,7 +273,7 @@ MCP2515::ERROR MCP2515::set_filter_(const RXF num, const bool ext, const uint32_ return ERROR_OK; } -MCP2515::ERROR MCP2515::send_message_(const TXBn txbn, const struct can_frame *frame) { +MCP2515::ERROR MCP2515::send_message_(const TXBn txbn, const struct canbus::can_frame *frame) { const struct TXBn_REGS *txbuf = &TXB[txbn]; uint8_t data[13]; @@ -309,19 +290,19 @@ MCP2515::ERROR MCP2515::send_message_(const TXBn txbn, const struct can_frame *f return ERROR_OK; } -MCP2515::ERROR MCP2515::send_message_(const struct can_frame *frame) { - ESP_LOGD(TAG, "send_message_: frame.id = %d", frame->can_id); - if (frame->can_dlc > CAN_MAX_DLEN) { +MCP2515::ERROR MCP2515::send_message_(const struct canbus::can_frame *frame) { + //ESP_LOGD(TAG, "send_message_: frame.id = %d", frame->can_id); + if (frame->can_dlc > canbus::CAN_MAX_DLEN) { return 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}; for (int i = 0; i < N_TXBUFFERS; i++) { const struct TXBn_REGS *txbuf = &TXB[txBuffers[i]]; uint8_t ctrlval = read_register_(txbuf->CTRL); if ((ctrlval & TXB_TXREQ) == 0) { - ESP_LOGD(TAG, "send buffer: %d, ctrl_val = %d", i, ctrlval); + // ESP_LOGD(TAG, "send buffer: %d, ctrl_val = %d", i, ctrlval); return send_message_(txBuffers[i], frame); } } @@ -329,7 +310,7 @@ MCP2515::ERROR MCP2515::send_message_(const struct can_frame *frame) { return ERROR_FAILTX; } -MCP2515::ERROR MCP2515::read_message_(const RXBn rxbn, struct can_frame *frame) { +MCP2515::ERROR MCP2515::read_message_(const RXBn rxbn, struct canbus::can_frame *frame) { const struct RXBn_REGS *rxb = &RXB[rxbn]; uint8_t tbufdata[5]; @@ -346,7 +327,7 @@ MCP2515::ERROR MCP2515::read_message_(const RXBn rxbn, struct can_frame *frame) } uint8_t dlc = (tbufdata[MCP_DLC] & DLC_MASK); - if (dlc > CAN_MAX_DLEN) { + if (dlc > canbus::CAN_MAX_DLEN) { return ERROR_FAIL; } @@ -365,7 +346,7 @@ MCP2515::ERROR MCP2515::read_message_(const RXBn rxbn, struct can_frame *frame) return ERROR_OK; } -MCP2515::ERROR MCP2515::read_message_(struct can_frame *frame) { +MCP2515::ERROR MCP2515::read_message_(struct canbus::can_frame *frame) { ERROR rc; uint8_t stat = get_status_(); @@ -434,9 +415,9 @@ void MCP2515::clearERRIF() { modify_register_(MCP_CANINTF, CANINTF_ERRIF, 0); } -MCP2515::ERROR MCP2515::set_bitrate_(const CAN_SPEED canSpeed) { return set_bitrate_(canSpeed, MCP_16MHZ); } +MCP2515::ERROR MCP2515::set_bitrate_(uint8_t can_speed) { return this->set_bitrate_(can_speed, MCP_16MHZ); } -MCP2515::ERROR MCP2515::set_bitrate_(const CAN_SPEED canSpeed, CAN_CLOCK canClock) { +MCP2515::ERROR MCP2515::set_bitrate_(uint8_t can_speed, CAN_CLOCK can_clock) { ERROR error = set_config_mode_(); if (error != ERROR_OK) { return error; @@ -444,9 +425,9 @@ MCP2515::ERROR MCP2515::set_bitrate_(const CAN_SPEED canSpeed, CAN_CLOCK canCloc uint8_t set, cfg1, cfg2, cfg3; set = 1; - switch (canClock) { + switch (can_clock) { case (MCP_8MHZ): - switch (canSpeed) { + switch (can_speed) { case (CAN_5KBPS): // 5KBPS cfg1 = MCP_8MHz_5kBPS_CFG1; cfg2 = MCP_8MHz_5kBPS_CFG2; @@ -524,7 +505,7 @@ MCP2515::ERROR MCP2515::set_bitrate_(const CAN_SPEED canSpeed, CAN_CLOCK canCloc break; case (MCP_16MHZ): - switch (canSpeed) { + switch (can_speed) { case (CAN_5KBPS): // 5Kbps cfg1 = MCP_16MHz_5kBPS_CFG1; cfg2 = MCP_16MHz_5kBPS_CFG2; @@ -601,7 +582,7 @@ MCP2515::ERROR MCP2515::set_bitrate_(const CAN_SPEED canSpeed, CAN_CLOCK canCloc break; case (MCP_20MHZ): - switch (canSpeed) { + switch (can_speed) { case (CAN_33KBPS): // 33.333Kbps cfg1 = MCP_20MHz_33k3BPS_CFG1; cfg2 = MCP_20MHz_33k3BPS_CFG2; diff --git a/esphome/components/mcp2515/mcp2515.h b/esphome/components/mcp2515/mcp2515.h index 162632971d..89ab3aa91a 100644 --- a/esphome/components/mcp2515/mcp2515.h +++ b/esphome/components/mcp2515/mcp2515.h @@ -7,65 +7,56 @@ namespace esphome { namespace mcp2515 { +static const uint32_t SPI_CLOCK = 10000000; // 10MHz +static const int N_TXBUFFERS = 3; +static const int N_RXBUFFERS = 2; +enum CAN_CLOCK { MCP_20MHZ, MCP_16MHZ, MCP_8MHZ }; +enum MASK { MASK0, MASK1 }; +enum RXF { RXF0 = 0, RXF1 = 1, RXF2 = 2, RXF3 = 3, RXF4 = 4, RXF5 = 5 }; +enum RXBn { RXB0 = 0, RXB1 = 1 }; +enum TXBn { TXB0 = 0, TXB1 = 1, TXB2 = 2 }; + +enum CAN_CLKOUT { + CLKOUT_DISABLE = -1, + CLKOUT_DIV1 = 0x0, + CLKOUT_DIV2 = 0x1, + CLKOUT_DIV4 = 0x2, + CLKOUT_DIV8 = 0x3, +}; + +enum /*class*/ CANINTF : uint8_t { + CANINTF_RX0IF = 0x01, + CANINTF_RX1IF = 0x02, + CANINTF_TX0IF = 0x04, + CANINTF_TX1IF = 0x08, + CANINTF_TX2IF = 0x10, + CANINTF_ERRIF = 0x20, + CANINTF_WAKIF = 0x40, + CANINTF_MERRF = 0x80 +}; + +enum /*class*/ EFLG : uint8_t { + EFLG_RX1OVR = (1 << 7), + EFLG_RX0OVR = (1 << 6), + EFLG_TXBO = (1 << 5), + EFLG_TXEP = (1 << 4), + EFLG_RXEP = (1 << 3), + EFLG_TXWAR = (1 << 2), + EFLG_RXWAR = (1 << 1), + EFLG_EWARN = (1 << 0) +}; + +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 EFLG_ERRORMASK = EFLG_RX1OVR | EFLG_RX0OVR | EFLG_TXBO | EFLG_TXEP | EFLG_RXEP; class MCP2515 : public canbus::Canbus, public spi::SPIDevice { public: MCP2515(){}; - static const uint32_t SPI_CLOCK = 10000000; // 10MHz - - static const int N_TXBUFFERS = 3; - static const int N_RXBUFFERS = 2; - - enum CAN_CLOCK { MCP_20MHZ, MCP_16MHZ, MCP_8MHZ }; - enum MASK { MASK0, MASK1 }; - - enum RXF { RXF0 = 0, RXF1 = 1, RXF2 = 2, RXF3 = 3, RXF4 = 4, RXF5 = 5 }; - - enum RXBn { RXB0 = 0, RXB1 = 1 }; - - enum TXBn { TXB0 = 0, TXB1 = 1, TXB2 = 2 }; - - struct can_frame { - canid_t can_id; /* 32 bit CAN_ID + EFF/RTR/ERR flags */ - uint8_t can_dlc; /* frame payload length in byte (0 .. CAN_MAX_DLEN) */ - uint8_t data[CAN_MAX_DLEN] __attribute__((aligned(8))); - }; - - enum CAN_CLKOUT { - CLKOUT_DISABLE = -1, - CLKOUT_DIV1 = 0x0, - CLKOUT_DIV2 = 0x1, - CLKOUT_DIV4 = 0x2, - CLKOUT_DIV8 = 0x3, - }; - - enum /*class*/ CANINTF : uint8_t { - CANINTF_RX0IF = 0x01, - CANINTF_RX1IF = 0x02, - CANINTF_TX0IF = 0x04, - CANINTF_TX1IF = 0x08, - CANINTF_TX2IF = 0x10, - CANINTF_ERRIF = 0x20, - CANINTF_WAKIF = 0x40, - CANINTF_MERRF = 0x80 - }; - - enum /*class*/ EFLG : uint8_t { - EFLG_RX1OVR = (1 << 7), - EFLG_RX0OVR = (1 << 6), - EFLG_TXBO = (1 << 5), - EFLG_TXEP = (1 << 4), - EFLG_RXEP = (1 << 3), - EFLG_TXWAR = (1 << 2), - EFLG_RXWAR = (1 << 1), - EFLG_EWARN = (1 << 0) - }; - - enum /*class*/ STAT : uint8_t { STAT_RX0IF = (1 << 0), STAT_RX1IF = (1 << 1) }; - static const struct TXBn_REGS { REGISTER CTRL; REGISTER SIDH; @@ -79,11 +70,7 @@ class MCP2515 : public canbus::Canbus, CANINTF CANINTF_RXnIF; } RXB[N_RXBUFFERS]; - 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; - protected: - bool send_internal_(int can_id, uint8_t *data) override; bool setup_internal_() override; ERROR set_mode_(const CANCTRL_REQOP_MODE mode); @@ -101,14 +88,14 @@ class MCP2515 : public canbus::Canbus, ERROR set_loop_back_mode_(); ERROR set_normal_mode_(); ERROR set_clk_out_(const CAN_CLKOUT divisor); - ERROR set_bitrate_(const CAN_SPEED canSpeed) override; - ERROR set_bitrate_(const CAN_SPEED canSpeed, const CAN_CLOCK canClock); + ERROR set_bitrate_(uint8_t can_speed); + ERROR set_bitrate_(uint8_t can_speed, const CAN_CLOCK can_clock); 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); - ERROR send_message_(const TXBn txbn, const struct can_frame *frame); - ERROR send_message_(const struct can_frame *frame); - ERROR read_message_(const RXBn rxbn, struct can_frame *frame); - ERROR read_message_(struct can_frame *frame); + ERROR send_message_(const TXBn txbn, const struct canbus::can_frame *frame); + ERROR send_message_(const struct canbus::can_frame *frame); + ERROR read_message_(const RXBn rxbn, struct canbus::can_frame *frame); + ERROR read_message_(struct canbus::can_frame *frame); bool check_receive_(void); bool check_error_(void); uint8_t get_error_flags_(void);