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

code cleanup and lint

Browse Source
This commit is contained in:
mvturnho 2019-08-12 10:24:36 +02:00
parent f74babeeba
commit 4e80a901ae
6 changed files with 345 additions and 315 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,23 +1,21 @@
#pragma once #pragma once
#include "esphome/core/component.h"
#include "esphome/core/automation.h" #include "esphome/core/automation.h"
#include "esphome/core/component.h"
#include "esphome/core/optional.h" #include "esphome/core/optional.h"
namespace esphome { namespace esphome {
namespace canbus { namespace canbus {
class CanbusTrigger; enum ERROR : uint8_t {
ERROR_OK = 0,
/* CAN payload length and DLC definitions according to ISO 11898-1 */ ERROR_FAIL = 1,
static const uint8_t CAN_MAX_DLC = 8; ERROR_ALLTXBUSY = 2,
static const uint8_t CAN_MAX_DLEN = 8; ERROR_FAILINIT = 3,
ERROR_FAILTX = 4,
struct can_frame { ERROR_NOMSG = 5
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)));
}; };
enum CAN_SPEED : uint8_t { enum CAN_SPEED : uint8_t {
CAN_5KBPS, CAN_5KBPS,
CAN_10KBPS, CAN_10KBPS,
@ -37,26 +35,35 @@ enum CAN_SPEED : uint8_t {
CAN_1000KBPS CAN_1000KBPS
}; };
enum ERROR : uint8_t {
ERROR_OK = 0,
ERROR_FAIL = 1,
ERROR_ALLTXBUSY = 2,
ERROR_FAILINIT = 3,
ERROR_FAILTX = 4,
ERROR_NOMSG = 5
};
/* special address description flags for the CAN_ID */ /* 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_EFF_FLAG =
static const uint32_t CAN_RTR_FLAG = 0x40000000UL; /* remote transmission request */ 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 */ static const uint32_t CAN_ERR_FLAG = 0x20000000UL; /* error message frame */
/* valid bits in CAN ID for frame formats */ /* 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_SFF_MASK =
static const uint32_t CAN_EFF_MASK = 0x1FFFFFFFUL; /* extended frame format (EFF) */ 0x000007FFUL; /* standard frame format (SFF) */
static const uint32_t CAN_ERR_MASK = 0x1FFFFFFFUL; /* omit EFF, RTR, ERR flags */ 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 CanbusTrigger;
/* 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;
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 : public Component { class Canbus : public Component {
public: public:
Canbus(){}; Canbus(){};
Canbus(const std::string &name){}; Canbus(const std::string &name){};
void setup() override; void setup() override;
@ -70,7 +77,7 @@ class Canbus : public Component {
void add_trigger(CanbusTrigger *trigger); void add_trigger(CanbusTrigger *trigger);
protected: protected:
std::vector<CanbusTrigger *> triggers_{}; std::vector<CanbusTrigger *> triggers_{};
uint32_t sender_id_{0}; uint32_t sender_id_{0};
CAN_SPEED bit_rate_{CAN_125KBPS}; CAN_SPEED bit_rate_{CAN_125KBPS};
@ -111,18 +118,18 @@ protected:
std::vector<uint8_t> data_static_{}; std::vector<uint8_t> data_static_{};
}; };
class CanbusTrigger : public Trigger< std::vector<uint8_t> > , public Component { class CanbusTrigger : public Trigger<std::vector<uint8_t>>, public Component {
friend class Canbus; friend class Canbus;
public: public:
explicit CanbusTrigger(Canbus *parent, const std::uint32_t can_id):parent_(parent), can_id_(can_id){}; explicit CanbusTrigger(Canbus *parent, const std::uint32_t can_id)
void setup() override { : parent_(parent), can_id_(can_id){};
this->parent_->add_trigger(this); void setup() override { this->parent_->add_trigger(this); }
}
protected: protected:
Canbus *parent_; Canbus *parent_;
uint32_t can_id_; uint32_t can_id_;
}; };
} // namespace canbus } // namespace canbus
} // namespace esphome } // namespace esphome

1
esphome/components/esp32_can/__init__.py
View File

@ -1 +0,0 @@
print("esp32_can_module")

1
esphome/components/mcp2515/__init__.py
View File

@ -1 +0,0 @@
print("mcp2515.__init__.py")

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

@ -6,12 +6,14 @@ namespace mcp2515 {
static const char *TAG = "mcp2515"; static const char *TAG = "mcp2515";
const struct MCP2515::TXBn_REGS MCP2515::TXB[N_TXBUFFERS] = {{MCP_TXB0CTRL, MCP_TXB0SIDH, MCP_TXB0DATA}, const struct MCP2515::TXBn_REGS MCP2515::TXB[N_TXBUFFERS] = {
{MCP_TXB1CTRL, MCP_TXB1SIDH, MCP_TXB1DATA}, {MCP_TXB0CTRL, MCP_TXB0SIDH, MCP_TXB0DATA},
{MCP_TXB2CTRL, MCP_TXB2SIDH, MCP_TXB2DATA}}; {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}, const struct MCP2515::RXBn_REGS MCP2515::RXB[N_RXBUFFERS] = {
{MCP_RXB1CTRL, MCP_RXB1SIDH, MCP_RXB1DATA, CANINTF_RX1IF}}; {MCP_RXB0CTRL, MCP_RXB0SIDH, MCP_RXB0DATA, CANINTF_RX0IF},
{MCP_RXB1CTRL, MCP_RXB1SIDH, MCP_RXB1DATA, CANINTF_RX1IF}};
bool MCP2515::setup_internal_() { bool MCP2515::setup_internal_() {
ESP_LOGD(TAG, "setup_internal_()"); ESP_LOGD(TAG, "setup_internal_()");
@ -44,9 +46,11 @@ canbus::ERROR MCP2515::reset_(void) {
set_register_(MCP_RXB0CTRL, 0); set_register_(MCP_RXB0CTRL, 0);
set_register_(MCP_RXB1CTRL, 0); set_register_(MCP_RXB1CTRL, 0);
set_register_(MCP_CANINTE, CANINTF_RX0IF | CANINTF_RX1IF | CANINTF_ERRIF | CANINTF_MERRF); set_register_(MCP_CANINTE,
CANINTF_RX0IF | CANINTF_RX1IF | CANINTF_ERRIF | CANINTF_MERRF);
modify_register_(MCP_RXB0CTRL, RXBnCTRL_RXM_MASK | RXB0CTRL_BUKT, RXBnCTRL_RXM_STDEXT | RXB0CTRL_BUKT); modify_register_(MCP_RXB0CTRL, RXBnCTRL_RXM_MASK | RXB0CTRL_BUKT,
RXBnCTRL_RXM_STDEXT | RXB0CTRL_BUKT);
modify_register_(MCP_RXB1CTRL, RXBnCTRL_RXM_MASK, RXBnCTRL_RXM_STDEXT); modify_register_(MCP_RXB1CTRL, RXBnCTRL_RXM_MASK, RXBnCTRL_RXM_STDEXT);
// clear filters and masks // clear filters and masks
@ -79,7 +83,8 @@ uint8_t MCP2515::read_register_(const REGISTER reg) {
return ret; return ret;
} }
void MCP2515::read_registers_(const REGISTER reg, uint8_t values[], const uint8_t n) { void MCP2515::read_registers_(const REGISTER reg, uint8_t values[],
const uint8_t n) {
this->enable(); this->enable();
this->transfer_byte(INSTRUCTION_READ); this->transfer_byte(INSTRUCTION_READ);
this->transfer_byte(reg); this->transfer_byte(reg);
@ -99,7 +104,8 @@ void MCP2515::set_register_(const REGISTER reg, const uint8_t value) {
this->disable(); this->disable();
} }
void MCP2515::set_registers_(const REGISTER reg, uint8_t values[], const uint8_t n) { void MCP2515::set_registers_(const REGISTER reg, uint8_t values[],
const uint8_t n) {
this->enable(); this->enable();
this->transfer_byte(INSTRUCTION_WRITE); this->transfer_byte(INSTRUCTION_WRITE);
this->transfer_byte(reg); this->transfer_byte(reg);
@ -110,7 +116,8 @@ void MCP2515::set_registers_(const REGISTER reg, uint8_t values[], const uint8_t
this->disable(); this->disable();
} }
void MCP2515::modify_register_(const REGISTER reg, const uint8_t mask, const uint8_t data) { void MCP2515::modify_register_(const REGISTER reg, const uint8_t mask,
const uint8_t data) {
this->enable(); this->enable();
this->transfer_byte(INSTRUCTION_BITMOD); this->transfer_byte(INSTRUCTION_BITMOD);
this->transfer_byte(reg); this->transfer_byte(reg);
@ -187,7 +194,8 @@ void MCP2515::prepare_id_(uint8_t *buffer, const bool ext, const uint32_t id) {
} }
} }
canbus::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) {
canbus::ERROR res = set_mode_(CANCTRL_REQOP_CONFIG); canbus::ERROR res = set_mode_(CANCTRL_REQOP_CONFIG);
if (res != canbus::ERROR_OK) { if (res != canbus::ERROR_OK) {
return res; return res;
@ -198,14 +206,14 @@ canbus::ERROR MCP2515::set_filter_mask_(const MASK mask, const bool ext, const u
REGISTER reg; REGISTER reg;
switch (mask) { switch (mask) {
case MASK0: case MASK0:
reg = MCP_RXM0SIDH; reg = MCP_RXM0SIDH;
break; break;
case MASK1: case MASK1:
reg = MCP_RXM1SIDH; reg = MCP_RXM1SIDH;
break; break;
default: default:
return canbus::ERROR_FAIL; return canbus::ERROR_FAIL;
} }
set_registers_(reg, tbufdata, 4); set_registers_(reg, tbufdata, 4);
@ -213,7 +221,8 @@ canbus::ERROR MCP2515::set_filter_mask_(const MASK mask, const bool ext, const u
return canbus::ERROR_OK; return canbus::ERROR_OK;
} }
canbus::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) {
canbus::ERROR res = set_mode_(CANCTRL_REQOP_CONFIG); canbus::ERROR res = set_mode_(CANCTRL_REQOP_CONFIG);
if (res != canbus::ERROR_OK) { if (res != canbus::ERROR_OK) {
return res; return res;
@ -222,26 +231,26 @@ canbus::ERROR MCP2515::set_filter_(const RXF num, const bool ext, const uint32_t
REGISTER reg; REGISTER reg;
switch (num) { switch (num) {
case RXF0: case RXF0:
reg = MCP_RXF0SIDH; reg = MCP_RXF0SIDH;
break; break;
case RXF1: case RXF1:
reg = MCP_RXF1SIDH; reg = MCP_RXF1SIDH;
break; break;
case RXF2: case RXF2:
reg = MCP_RXF2SIDH; reg = MCP_RXF2SIDH;
break; break;
case RXF3: case RXF3:
reg = MCP_RXF3SIDH; reg = MCP_RXF3SIDH;
break; break;
case RXF4: case RXF4:
reg = MCP_RXF4SIDH; reg = MCP_RXF4SIDH;
break; break;
case RXF5: case RXF5:
reg = MCP_RXF5SIDH; reg = MCP_RXF5SIDH;
break; break;
default: default:
return canbus::ERROR_FAIL; return canbus::ERROR_FAIL;
} }
uint8_t tbufdata[4]; uint8_t tbufdata[4];
@ -251,14 +260,16 @@ canbus::ERROR MCP2515::set_filter_(const RXF num, const bool ext, const uint32_t
return canbus::ERROR_OK; return canbus::ERROR_OK;
} }
canbus::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 & canbus::CAN_EFF_FLAG); bool ext = (frame->can_id & canbus::CAN_EFF_FLAG);
bool rtr = (frame->can_id & canbus::CAN_RTR_FLAG); bool rtr = (frame->can_id & canbus::CAN_RTR_FLAG);
uint32_t id = (frame->can_id & (ext ? canbus::CAN_EFF_MASK : canbus::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);
@ -288,7 +299,8 @@ canbus::ERROR MCP2515::send_message_(const struct canbus::can_frame *frame) {
return canbus::ERROR_FAILTX; return canbus::ERROR_FAILTX;
} }
canbus::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];
@ -360,7 +372,9 @@ bool MCP2515::check_error_(void) {
uint8_t MCP2515::get_error_flags_(void) { return read_register_(MCP_EFLG); } uint8_t MCP2515::get_error_flags_(void) { return read_register_(MCP_EFLG); }
void MCP2515::clearRXnOVRFlags(void) { modify_register_(MCP_EFLG, EFLG_RX0OVR | EFLG_RX1OVR, 0); } void MCP2515::clearRXnOVRFlags(void) {
modify_register_(MCP_EFLG, EFLG_RX0OVR | EFLG_RX1OVR, 0);
}
uint8_t MCP2515::getInterrupts(void) { return read_register_(MCP_CANINTF); } uint8_t MCP2515::getInterrupts(void) { return read_register_(MCP_CANINTF); }
@ -369,7 +383,8 @@ void MCP2515::clearInterrupts(void) { set_register_(MCP_CANINTF, 0); }
uint8_t MCP2515::getInterruptMask(void) { return read_register_(MCP_CANINTE); } uint8_t MCP2515::getInterruptMask(void) { return read_register_(MCP_CANINTE); }
void MCP2515::clearTXInterrupts(void) { void MCP2515::clearTXInterrupts(void) {
modify_register_(MCP_CANINTF, (CANINTF_TX0IF | CANINTF_TX1IF | CANINTF_TX2IF), 0); modify_register_(MCP_CANINTF, (CANINTF_TX0IF | CANINTF_TX1IF | CANINTF_TX2IF),
0);
} }
void MCP2515::clearRXnOVR(void) { void MCP2515::clearRXnOVR(void) {
@ -393,9 +408,12 @@ void MCP2515::clearERRIF() {
modify_register_(MCP_CANINTF, CANINTF_ERRIF, 0); modify_register_(MCP_CANINTF, CANINTF_ERRIF, 0);
} }
canbus::ERROR MCP2515::set_bitrate_(canbus::CAN_SPEED 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);
}
canbus::ERROR MCP2515::set_bitrate_(canbus::CAN_SPEED can_speed, CAN_CLOCK can_clock) { canbus::ERROR MCP2515::set_bitrate_(canbus::CAN_SPEED can_speed,
CAN_CLOCK can_clock) {
canbus::ERROR error = set_mode_(CANCTRL_REQOP_CONFIG); canbus::ERROR error = set_mode_(CANCTRL_REQOP_CONFIG);
if (error != canbus::ERROR_OK) { if (error != canbus::ERROR_OK) {
return error; return error;
@ -404,227 +422,227 @@ canbus::ERROR MCP2515::set_bitrate_(canbus::CAN_SPEED can_speed, CAN_CLOCK can_c
uint8_t set, cfg1, cfg2, cfg3; uint8_t set, cfg1, cfg2, cfg3;
set = 1; set = 1;
switch (can_clock) { switch (can_clock) {
case (MCP_8MHZ): case (MCP_8MHZ):
switch (can_speed) { switch (can_speed) {
case (canbus::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;
case (canbus::CAN_10KBPS): // 10KBPS
cfg1 = MCP_8MHz_10kBPS_CFG1;
cfg2 = MCP_8MHz_10kBPS_CFG2;
cfg3 = MCP_8MHz_10kBPS_CFG3;
break;
case (canbus::CAN_20KBPS): // 20KBPS
cfg1 = MCP_8MHz_20kBPS_CFG1;
cfg2 = MCP_8MHz_20kBPS_CFG2;
cfg3 = MCP_8MHz_20kBPS_CFG3;
break;
case (canbus::CAN_31K25BPS): // 31.25KBPS
cfg1 = MCP_8MHz_31k25BPS_CFG1;
cfg2 = MCP_8MHz_31k25BPS_CFG2;
cfg3 = MCP_8MHz_31k25BPS_CFG3;
break;
case (canbus::CAN_33KBPS): // 33.333KBPS
cfg1 = MCP_8MHz_33k3BPS_CFG1;
cfg2 = MCP_8MHz_33k3BPS_CFG2;
cfg3 = MCP_8MHz_33k3BPS_CFG3;
break;
case (canbus::CAN_40KBPS): // 40Kbps
cfg1 = MCP_8MHz_40kBPS_CFG1;
cfg2 = MCP_8MHz_40kBPS_CFG2;
cfg3 = MCP_8MHz_40kBPS_CFG3;
break;
case (canbus::CAN_50KBPS): // 50Kbps
cfg1 = MCP_8MHz_50kBPS_CFG1;
cfg2 = MCP_8MHz_50kBPS_CFG2;
cfg3 = MCP_8MHz_50kBPS_CFG3;
break;
case (canbus::CAN_80KBPS): // 80Kbps
cfg1 = MCP_8MHz_80kBPS_CFG1;
cfg2 = MCP_8MHz_80kBPS_CFG2;
cfg3 = MCP_8MHz_80kBPS_CFG3;
break;
case (canbus::CAN_100KBPS): // 100Kbps
cfg1 = MCP_8MHz_100kBPS_CFG1;
cfg2 = MCP_8MHz_100kBPS_CFG2;
cfg3 = MCP_8MHz_100kBPS_CFG3;
break;
case (canbus::CAN_125KBPS): // 125Kbps
cfg1 = MCP_8MHz_125kBPS_CFG1;
cfg2 = MCP_8MHz_125kBPS_CFG2;
cfg3 = MCP_8MHz_125kBPS_CFG3;
break;
case (canbus::CAN_200KBPS): // 200Kbps
cfg1 = MCP_8MHz_200kBPS_CFG1;
cfg2 = MCP_8MHz_200kBPS_CFG2;
cfg3 = MCP_8MHz_200kBPS_CFG3;
break;
case (canbus::CAN_250KBPS): // 250Kbps
cfg1 = MCP_8MHz_250kBPS_CFG1;
cfg2 = MCP_8MHz_250kBPS_CFG2;
cfg3 = MCP_8MHz_250kBPS_CFG3;
break;
case (canbus::CAN_500KBPS): // 500Kbps
cfg1 = MCP_8MHz_500kBPS_CFG1;
cfg2 = MCP_8MHz_500kBPS_CFG2;
cfg3 = MCP_8MHz_500kBPS_CFG3;
break;
case (canbus::CAN_1000KBPS): // 1Mbps
cfg1 = MCP_8MHz_1000kBPS_CFG1;
cfg2 = MCP_8MHz_1000kBPS_CFG2;
cfg3 = MCP_8MHz_1000kBPS_CFG3;
break;
default:
set = 0;
break;
}
break; break;
case (canbus::CAN_10KBPS): // 10KBPS
case (MCP_16MHZ): cfg1 = MCP_8MHz_10kBPS_CFG1;
switch (can_speed) { cfg2 = MCP_8MHz_10kBPS_CFG2;
case (canbus::CAN_5KBPS): // 5Kbps cfg3 = MCP_8MHz_10kBPS_CFG3;
cfg1 = MCP_16MHz_5kBPS_CFG1;
cfg2 = MCP_16MHz_5kBPS_CFG2;
cfg3 = MCP_16MHz_5kBPS_CFG3;
break;
case (canbus::CAN_10KBPS): // 10Kbps
cfg1 = MCP_16MHz_10kBPS_CFG1;
cfg2 = MCP_16MHz_10kBPS_CFG2;
cfg3 = MCP_16MHz_10kBPS_CFG3;
break;
case (canbus::CAN_20KBPS): // 20Kbps
cfg1 = MCP_16MHz_20kBPS_CFG1;
cfg2 = MCP_16MHz_20kBPS_CFG2;
cfg3 = MCP_16MHz_20kBPS_CFG3;
break;
case (canbus::CAN_33KBPS): // 33.333Kbps
cfg1 = MCP_16MHz_33k3BPS_CFG1;
cfg2 = MCP_16MHz_33k3BPS_CFG2;
cfg3 = MCP_16MHz_33k3BPS_CFG3;
break;
case (canbus::CAN_40KBPS): // 40Kbps
cfg1 = MCP_16MHz_40kBPS_CFG1;
cfg2 = MCP_16MHz_40kBPS_CFG2;
cfg3 = MCP_16MHz_40kBPS_CFG3;
break;
case (canbus::CAN_50KBPS): // 50Kbps
cfg2 = MCP_16MHz_50kBPS_CFG2;
cfg3 = MCP_16MHz_50kBPS_CFG3;
break;
case (canbus::CAN_80KBPS): // 80Kbps
cfg1 = MCP_16MHz_80kBPS_CFG1;
cfg2 = MCP_16MHz_80kBPS_CFG2;
cfg3 = MCP_16MHz_80kBPS_CFG3;
break;
case (canbus::CAN_83K3BPS): // 83.333Kbps
cfg1 = MCP_16MHz_83k3BPS_CFG1;
cfg2 = MCP_16MHz_83k3BPS_CFG2;
cfg3 = MCP_16MHz_83k3BPS_CFG3;
break;
case (canbus::CAN_100KBPS): // 100Kbps
cfg1 = MCP_16MHz_100kBPS_CFG1;
cfg2 = MCP_16MHz_100kBPS_CFG2;
cfg3 = MCP_16MHz_100kBPS_CFG3;
break;
case (canbus::CAN_125KBPS): // 125Kbps
cfg1 = MCP_16MHz_125kBPS_CFG1;
cfg2 = MCP_16MHz_125kBPS_CFG2;
cfg3 = MCP_16MHz_125kBPS_CFG3;
break;
case (canbus::CAN_200KBPS): // 200Kbps
cfg1 = MCP_16MHz_200kBPS_CFG1;
cfg2 = MCP_16MHz_200kBPS_CFG2;
cfg3 = MCP_16MHz_200kBPS_CFG3;
break;
case (canbus::CAN_250KBPS): // 250Kbps
cfg1 = MCP_16MHz_250kBPS_CFG1;
cfg2 = MCP_16MHz_250kBPS_CFG2;
cfg3 = MCP_16MHz_250kBPS_CFG3;
break;
case (canbus::CAN_500KBPS): // 500Kbps
cfg1 = MCP_16MHz_500kBPS_CFG1;
cfg2 = MCP_16MHz_500kBPS_CFG2;
cfg3 = MCP_16MHz_500kBPS_CFG3;
break;
case (canbus::CAN_1000KBPS): // 1Mbps
cfg1 = MCP_16MHz_1000kBPS_CFG1;
cfg2 = MCP_16MHz_1000kBPS_CFG2;
cfg3 = MCP_16MHz_1000kBPS_CFG3;
break;
default:
set = 0;
break;
}
break; break;
case (canbus::CAN_20KBPS): // 20KBPS
case (MCP_20MHZ): cfg1 = MCP_8MHz_20kBPS_CFG1;
switch (can_speed) { cfg2 = MCP_8MHz_20kBPS_CFG2;
case (canbus::CAN_33KBPS): // 33.333Kbps cfg3 = MCP_8MHz_20kBPS_CFG3;
cfg1 = MCP_20MHz_33k3BPS_CFG1; break;
cfg2 = MCP_20MHz_33k3BPS_CFG2; case (canbus::CAN_31K25BPS): // 31.25KBPS
cfg3 = MCP_20MHz_33k3BPS_CFG3; cfg1 = MCP_8MHz_31k25BPS_CFG1;
break; cfg2 = MCP_8MHz_31k25BPS_CFG2;
case (canbus::CAN_40KBPS): // 40Kbps cfg3 = MCP_8MHz_31k25BPS_CFG3;
cfg1 = MCP_20MHz_40kBPS_CFG1; break;
cfg2 = MCP_20MHz_40kBPS_CFG2; case (canbus::CAN_33KBPS): // 33.333KBPS
cfg3 = MCP_20MHz_40kBPS_CFG3; cfg1 = MCP_8MHz_33k3BPS_CFG1;
break; cfg2 = MCP_8MHz_33k3BPS_CFG2;
case (canbus::CAN_50KBPS): // 50Kbps cfg3 = MCP_8MHz_33k3BPS_CFG3;
cfg1 = MCP_20MHz_50kBPS_CFG1; break;
cfg2 = MCP_20MHz_50kBPS_CFG2; case (canbus::CAN_40KBPS): // 40Kbps
cfg3 = MCP_20MHz_50kBPS_CFG3; cfg1 = MCP_8MHz_40kBPS_CFG1;
break; cfg2 = MCP_8MHz_40kBPS_CFG2;
case (canbus::CAN_80KBPS): // 80Kbps cfg3 = MCP_8MHz_40kBPS_CFG3;
cfg1 = MCP_20MHz_80kBPS_CFG1; break;
cfg2 = MCP_20MHz_80kBPS_CFG2; case (canbus::CAN_50KBPS): // 50Kbps
cfg3 = MCP_20MHz_80kBPS_CFG3; cfg1 = MCP_8MHz_50kBPS_CFG1;
break; cfg2 = MCP_8MHz_50kBPS_CFG2;
case (canbus::CAN_83K3BPS): // 83.333Kbps cfg3 = MCP_8MHz_50kBPS_CFG3;
cfg1 = MCP_20MHz_83k3BPS_CFG1; break;
cfg2 = MCP_20MHz_83k3BPS_CFG2; case (canbus::CAN_80KBPS): // 80Kbps
cfg3 = MCP_20MHz_83k3BPS_CFG3; cfg1 = MCP_8MHz_80kBPS_CFG1;
break; cfg2 = MCP_8MHz_80kBPS_CFG2;
case (canbus::CAN_100KBPS): // 100Kbps cfg3 = MCP_8MHz_80kBPS_CFG3;
cfg1 = MCP_20MHz_100kBPS_CFG1; break;
cfg2 = MCP_20MHz_100kBPS_CFG2; case (canbus::CAN_100KBPS): // 100Kbps
cfg3 = MCP_20MHz_100kBPS_CFG3; cfg1 = MCP_8MHz_100kBPS_CFG1;
break; cfg2 = MCP_8MHz_100kBPS_CFG2;
case (canbus::CAN_125KBPS): // 125Kbps cfg3 = MCP_8MHz_100kBPS_CFG3;
cfg1 = MCP_20MHz_125kBPS_CFG1; break;
cfg2 = MCP_20MHz_125kBPS_CFG2; case (canbus::CAN_125KBPS): // 125Kbps
cfg3 = MCP_20MHz_125kBPS_CFG3; cfg1 = MCP_8MHz_125kBPS_CFG1;
break; cfg2 = MCP_8MHz_125kBPS_CFG2;
case (canbus::CAN_200KBPS): // 200Kbps cfg3 = MCP_8MHz_125kBPS_CFG3;
cfg1 = MCP_20MHz_200kBPS_CFG1; break;
cfg2 = MCP_20MHz_200kBPS_CFG2; case (canbus::CAN_200KBPS): // 200Kbps
cfg3 = MCP_20MHz_200kBPS_CFG3; cfg1 = MCP_8MHz_200kBPS_CFG1;
break; cfg2 = MCP_8MHz_200kBPS_CFG2;
case (canbus::CAN_250KBPS): // 250Kbps cfg3 = MCP_8MHz_200kBPS_CFG3;
cfg1 = MCP_20MHz_250kBPS_CFG1; break;
cfg2 = MCP_20MHz_250kBPS_CFG2; case (canbus::CAN_250KBPS): // 250Kbps
cfg3 = MCP_20MHz_250kBPS_CFG3; cfg1 = MCP_8MHz_250kBPS_CFG1;
break; cfg2 = MCP_8MHz_250kBPS_CFG2;
case (canbus::CAN_500KBPS): // 500Kbps cfg3 = MCP_8MHz_250kBPS_CFG3;
cfg1 = MCP_20MHz_500kBPS_CFG1; break;
cfg2 = MCP_20MHz_500kBPS_CFG2; case (canbus::CAN_500KBPS): // 500Kbps
cfg3 = MCP_20MHz_500kBPS_CFG3; cfg1 = MCP_8MHz_500kBPS_CFG1;
break; cfg2 = MCP_8MHz_500kBPS_CFG2;
case (canbus::CAN_1000KBPS): // 1Mbps cfg3 = MCP_8MHz_500kBPS_CFG3;
cfg1 = MCP_20MHz_1000kBPS_CFG1; break;
cfg2 = MCP_20MHz_1000kBPS_CFG2; case (canbus::CAN_1000KBPS): // 1Mbps
cfg3 = MCP_20MHz_1000kBPS_CFG3; cfg1 = MCP_8MHz_1000kBPS_CFG1;
break; cfg2 = MCP_8MHz_1000kBPS_CFG2;
default: cfg3 = MCP_8MHz_1000kBPS_CFG3;
set = 0;
break;
}
break; break;
default: default:
set = 0; set = 0;
break; break;
}
break;
case (MCP_16MHZ):
switch (can_speed) {
case (canbus::CAN_5KBPS): // 5Kbps
cfg1 = MCP_16MHz_5kBPS_CFG1;
cfg2 = MCP_16MHz_5kBPS_CFG2;
cfg3 = MCP_16MHz_5kBPS_CFG3;
break;
case (canbus::CAN_10KBPS): // 10Kbps
cfg1 = MCP_16MHz_10kBPS_CFG1;
cfg2 = MCP_16MHz_10kBPS_CFG2;
cfg3 = MCP_16MHz_10kBPS_CFG3;
break;
case (canbus::CAN_20KBPS): // 20Kbps
cfg1 = MCP_16MHz_20kBPS_CFG1;
cfg2 = MCP_16MHz_20kBPS_CFG2;
cfg3 = MCP_16MHz_20kBPS_CFG3;
break;
case (canbus::CAN_33KBPS): // 33.333Kbps
cfg1 = MCP_16MHz_33k3BPS_CFG1;
cfg2 = MCP_16MHz_33k3BPS_CFG2;
cfg3 = MCP_16MHz_33k3BPS_CFG3;
break;
case (canbus::CAN_40KBPS): // 40Kbps
cfg1 = MCP_16MHz_40kBPS_CFG1;
cfg2 = MCP_16MHz_40kBPS_CFG2;
cfg3 = MCP_16MHz_40kBPS_CFG3;
break;
case (canbus::CAN_50KBPS): // 50Kbps
cfg2 = MCP_16MHz_50kBPS_CFG2;
cfg3 = MCP_16MHz_50kBPS_CFG3;
break;
case (canbus::CAN_80KBPS): // 80Kbps
cfg1 = MCP_16MHz_80kBPS_CFG1;
cfg2 = MCP_16MHz_80kBPS_CFG2;
cfg3 = MCP_16MHz_80kBPS_CFG3;
break;
case (canbus::CAN_83K3BPS): // 83.333Kbps
cfg1 = MCP_16MHz_83k3BPS_CFG1;
cfg2 = MCP_16MHz_83k3BPS_CFG2;
cfg3 = MCP_16MHz_83k3BPS_CFG3;
break;
case (canbus::CAN_100KBPS): // 100Kbps
cfg1 = MCP_16MHz_100kBPS_CFG1;
cfg2 = MCP_16MHz_100kBPS_CFG2;
cfg3 = MCP_16MHz_100kBPS_CFG3;
break;
case (canbus::CAN_125KBPS): // 125Kbps
cfg1 = MCP_16MHz_125kBPS_CFG1;
cfg2 = MCP_16MHz_125kBPS_CFG2;
cfg3 = MCP_16MHz_125kBPS_CFG3;
break;
case (canbus::CAN_200KBPS): // 200Kbps
cfg1 = MCP_16MHz_200kBPS_CFG1;
cfg2 = MCP_16MHz_200kBPS_CFG2;
cfg3 = MCP_16MHz_200kBPS_CFG3;
break;
case (canbus::CAN_250KBPS): // 250Kbps
cfg1 = MCP_16MHz_250kBPS_CFG1;
cfg2 = MCP_16MHz_250kBPS_CFG2;
cfg3 = MCP_16MHz_250kBPS_CFG3;
break;
case (canbus::CAN_500KBPS): // 500Kbps
cfg1 = MCP_16MHz_500kBPS_CFG1;
cfg2 = MCP_16MHz_500kBPS_CFG2;
cfg3 = MCP_16MHz_500kBPS_CFG3;
break;
case (canbus::CAN_1000KBPS): // 1Mbps
cfg1 = MCP_16MHz_1000kBPS_CFG1;
cfg2 = MCP_16MHz_1000kBPS_CFG2;
cfg3 = MCP_16MHz_1000kBPS_CFG3;
break;
default:
set = 0;
break;
}
break;
case (MCP_20MHZ):
switch (can_speed) {
case (canbus::CAN_33KBPS): // 33.333Kbps
cfg1 = MCP_20MHz_33k3BPS_CFG1;
cfg2 = MCP_20MHz_33k3BPS_CFG2;
cfg3 = MCP_20MHz_33k3BPS_CFG3;
break;
case (canbus::CAN_40KBPS): // 40Kbps
cfg1 = MCP_20MHz_40kBPS_CFG1;
cfg2 = MCP_20MHz_40kBPS_CFG2;
cfg3 = MCP_20MHz_40kBPS_CFG3;
break;
case (canbus::CAN_50KBPS): // 50Kbps
cfg1 = MCP_20MHz_50kBPS_CFG1;
cfg2 = MCP_20MHz_50kBPS_CFG2;
cfg3 = MCP_20MHz_50kBPS_CFG3;
break;
case (canbus::CAN_80KBPS): // 80Kbps
cfg1 = MCP_20MHz_80kBPS_CFG1;
cfg2 = MCP_20MHz_80kBPS_CFG2;
cfg3 = MCP_20MHz_80kBPS_CFG3;
break;
case (canbus::CAN_83K3BPS): // 83.333Kbps
cfg1 = MCP_20MHz_83k3BPS_CFG1;
cfg2 = MCP_20MHz_83k3BPS_CFG2;
cfg3 = MCP_20MHz_83k3BPS_CFG3;
break;
case (canbus::CAN_100KBPS): // 100Kbps
cfg1 = MCP_20MHz_100kBPS_CFG1;
cfg2 = MCP_20MHz_100kBPS_CFG2;
cfg3 = MCP_20MHz_100kBPS_CFG3;
break;
case (canbus::CAN_125KBPS): // 125Kbps
cfg1 = MCP_20MHz_125kBPS_CFG1;
cfg2 = MCP_20MHz_125kBPS_CFG2;
cfg3 = MCP_20MHz_125kBPS_CFG3;
break;
case (canbus::CAN_200KBPS): // 200Kbps
cfg1 = MCP_20MHz_200kBPS_CFG1;
cfg2 = MCP_20MHz_200kBPS_CFG2;
cfg3 = MCP_20MHz_200kBPS_CFG3;
break;
case (canbus::CAN_250KBPS): // 250Kbps
cfg1 = MCP_20MHz_250kBPS_CFG1;
cfg2 = MCP_20MHz_250kBPS_CFG2;
cfg3 = MCP_20MHz_250kBPS_CFG3;
break;
case (canbus::CAN_500KBPS): // 500Kbps
cfg1 = MCP_20MHz_500kBPS_CFG1;
cfg2 = MCP_20MHz_500kBPS_CFG2;
cfg3 = MCP_20MHz_500kBPS_CFG3;
break;
case (canbus::CAN_1000KBPS): // 1Mbps
cfg1 = MCP_20MHz_1000kBPS_CFG1;
cfg2 = MCP_20MHz_1000kBPS_CFG2;
cfg3 = MCP_20MHz_1000kBPS_CFG3;
break;
default:
set = 0;
break;
}
break;
default:
set = 0;
break;
} }
if (set) { if (set) {
@ -636,5 +654,5 @@ canbus::ERROR MCP2515::set_bitrate_(canbus::CAN_SPEED can_speed, CAN_CLOCK can_c
return canbus::ERROR_FAIL; return canbus::ERROR_FAIL;
} }
} }
} // namespace mcp2515 } // namespace mcp2515
} // namespace esphome } // namespace esphome

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

@ -7,7 +7,7 @@
namespace esphome { namespace esphome {
namespace mcp2515 { namespace mcp2515 {
static const uint32_t SPI_CLOCK = 10000000; // 10MHz static const uint32_t SPI_CLOCK = 10000000; // 10MHz
static const int N_TXBUFFERS = 3; static const int N_TXBUFFERS = 3;
static const int N_RXBUFFERS = 2; static const int N_RXBUFFERS = 2;
@ -50,12 +50,14 @@ enum /*class*/ EFLG : uint8_t {
enum /*class*/ STAT : uint8_t { STAT_RX0IF = (1 << 0), STAT_RX1IF = (1 << 1) }; 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 spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW, spi::CLOCK_PHASE_LEADING, : public canbus::Canbus,
spi::DATA_RATE_8MHZ> { public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW,
public: spi::CLOCK_PHASE_LEADING, spi::DATA_RATE_8MHZ> {
public:
MCP2515(){}; MCP2515(){};
void set_mcp_clock(CAN_CLOCK clock) { this->mcp_clock_ = clock; }; void set_mcp_clock(CAN_CLOCK clock) { this->mcp_clock_ = clock; };
void set_mcp_mode(const CANCTRL_REQOP_MODE mode) { this->mcp_mode_ = mode; } void set_mcp_mode(const CANCTRL_REQOP_MODE mode) { this->mcp_mode_ = mode; }
@ -72,7 +74,7 @@ class MCP2515 : public canbus::Canbus,
CANINTF CANINTF_RXnIF; CANINTF CANINTF_RXnIF;
} RXB[N_RXBUFFERS]; } RXB[N_RXBUFFERS];
protected: protected:
CAN_CLOCK mcp_clock_{MCP_8MHZ}; CAN_CLOCK mcp_clock_{MCP_8MHZ};
CANCTRL_REQOP_MODE mcp_mode_ = CANCTRL_REQOP_NORMAL; CANCTRL_REQOP_MODE mcp_mode_ = CANCTRL_REQOP_NORMAL;
bool setup_internal_() override; bool setup_internal_() override;
@ -82,16 +84,21 @@ class MCP2515 : public canbus::Canbus,
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);
void set_register_(const REGISTER reg, const uint8_t value); void set_register_(const REGISTER reg, const uint8_t value);
void set_registers_(const REGISTER reg, uint8_t values[], const uint8_t n); void set_registers_(const REGISTER reg, uint8_t values[], const uint8_t n);
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);
canbus::ERROR reset_(void); canbus::ERROR reset_(void);
canbus::ERROR set_clk_out_(const CAN_CLKOUT divisor); canbus::ERROR set_clk_out_(const CAN_CLKOUT divisor);
canbus::ERROR set_bitrate_(canbus::CAN_SPEED can_speed); canbus::ERROR set_bitrate_(canbus::CAN_SPEED can_speed);
canbus::ERROR set_bitrate_(canbus::CAN_SPEED can_speed, const CAN_CLOCK can_clock); canbus::ERROR set_bitrate_(canbus::CAN_SPEED can_speed,
canbus::ERROR set_filter_mask_(const MASK num, const bool ext, const uint32_t ulData); const CAN_CLOCK can_clock);
canbus::ERROR set_filter_(const RXF num, const bool ext, const uint32_t ulData); canbus::ERROR set_filter_mask_(const MASK num, const bool ext,
canbus::ERROR send_message_(const TXBn txbn, const struct canbus::can_frame *frame); const uint32_t ulData);
canbus::ERROR set_filter_(const RXF num, const bool ext,
const uint32_t ulData);
canbus::ERROR send_message_(const TXBn txbn,
const struct canbus::can_frame *frame);
canbus::ERROR send_message_(const struct canbus::can_frame *frame); canbus::ERROR send_message_(const struct canbus::can_frame *frame);
canbus::ERROR read_message_(const RXBn rxbn, struct canbus::can_frame *frame); canbus::ERROR read_message_(const RXBn rxbn, struct canbus::can_frame *frame);
canbus::ERROR read_message_(struct canbus::can_frame *frame); canbus::ERROR read_message_(struct canbus::can_frame *frame);
@ -108,5 +115,5 @@ class MCP2515 : public canbus::Canbus,
void clearMERR(); void clearMERR();
void clearERRIF(); void clearERRIF();
}; };
} // namespace mcp2515 } // namespace mcp2515
} // namespace esphome } // namespace esphome

4
esphome/components/mcp2515/mcp2515_defs.h
View File

@ -313,5 +313,5 @@ static const uint8_t MCP_20MHz_33k3BPS_CFG1 = 0x0B;
static const uint8_t MCP_20MHz_33k3BPS_CFG2 = 0xFF; static const uint8_t MCP_20MHz_33k3BPS_CFG2 = 0xFF;
static const uint8_t MCP_20MHz_33k3BPS_CFG3 = 0x87; static const uint8_t MCP_20MHz_33k3BPS_CFG3 = 0x87;
} // namespace mcp2515 } // namespace mcp2515
} // namespace esphome } // namespace esphome