ESPHome 2026.11.0-dev
Loading...
Searching...
No Matches
mcp2515.cpp
Go to the documentation of this file.
1#include "mcp2515.h"
2#include "esphome/core/log.h"
3
4namespace esphome::mcp2515 {
5
6ESPHOME_LOG_TAG(TAG, "mcp2515");
7
8const struct MCP2515::TxBnRegs MCP2515::TXB[N_TXBUFFERS] = {{MCP_TXB0CTRL, MCP_TXB0SIDH, MCP_TXB0DATA},
9 {MCP_TXB1CTRL, MCP_TXB1SIDH, MCP_TXB1DATA},
10 {MCP_TXB2CTRL, MCP_TXB2SIDH, MCP_TXB2DATA}};
11
12const struct MCP2515::RxBnRegs MCP2515::RXB[N_RXBUFFERS] = {{MCP_RXB0CTRL, MCP_RXB0SIDH, MCP_RXB0DATA, CANINTF_RX0IF},
13 {MCP_RXB1CTRL, MCP_RXB1SIDH, MCP_RXB1DATA, CANINTF_RX1IF}};
14
15bool MCP2515::setup_internal() {
16 this->spi_setup();
17
18 if (this->reset_() != canbus::ERROR_OK)
19 return false;
20 if (this->set_bitrate_(this->bit_rate_, this->mcp_clock_) != canbus::ERROR_OK)
21 return false;
22
23 // setup hardware filter RXF0 accepting all standard CAN IDs
24 if (this->set_filter_(RXF::RXF0, false, 0) != canbus::ERROR_OK) {
25 return false;
26 }
27 if (this->set_filter_mask_(MASK::MASK0, false, 0) != canbus::ERROR_OK) {
28 return false;
29 }
30
31 // setup hardware filter RXF1 accepting all extended CAN IDs
32 if (this->set_filter_(RXF::RXF1, true, 0) != canbus::ERROR_OK) {
33 return false;
34 }
35 if (this->set_filter_mask_(MASK::MASK1, true, 0) != canbus::ERROR_OK) {
36 return false;
37 }
38
39 if (this->set_mode_(this->mcp_mode_) != canbus::ERROR_OK)
40 return false;
41 uint8_t err_flags = this->get_error_flags_();
42 ESP_LOGD(TAG, "mcp2515 setup done, error_flags = %02X", err_flags);
43 return true;
44}
45
46canbus::CanEventFlags MCP2515::get_events() {
47 uint8_t events = 0;
48 uint8_t error_flags = this->get_error_flags_();
49
50 // Error-passive is one state for RX and TX together, so only a change of the combined flag is an event
51 bool was_passive = this->last_error_flags_ & (EFLG_RXEP | EFLG_TXEP);
52 bool is_passive = error_flags & (EFLG_RXEP | EFLG_TXEP);
53 if (was_passive != is_passive) {
54 events |= is_passive ? canbus::CAN_EVENT_PASSIVE : canbus::CAN_EVENT_ACTIVE;
55 }
56 if ((this->last_error_flags_ ^ error_flags) & EFLG_TXBO) {
57 events |= canbus::CAN_EVENT_BUS_OFF;
58 }
59
60 // The receive flowchart in the datasheet says that if rollover is set (BUKT), RX1OVR flag will be set
61 // once both buffers are full. However, the RX0OVR flag is actually set instead.
62 // We can just check for both though because it doesn't break anything.
63 if (error_flags & (EFLG_RX0OVR | EFLG_RX1OVR)) {
64 events |= canbus::CAN_EVENT_RX_QUEUE_FULL;
65 this->clear_rx_n_ovr_flags_();
66 }
67
68 this->last_error_flags_ = error_flags;
69 return static_cast<canbus::CanEventFlags>(events);
70}
71
72canbus::CanStatus MCP2515::get_status() {
73 canbus::CanStatus status = {};
74
75 uint8_t error_flags = this->get_error_flags_();
76 status.bus_off = error_flags & EFLG_TXBO;
77
78 // Transmit Error Counter is followed by Receive Error Counter so we're reading both at once
79 uint8_t err_counters[2];
80 this->read_registers_(MCP_TEC, err_counters, 2);
81
82 status.rx_error_counter = err_counters[1];
83 status.tx_error_counter = err_counters[0];
84
85 return status;
86}
87
88canbus::Error MCP2515::reset_() {
89 this->enable();
90 this->transfer_byte(INSTRUCTION_RESET);
91 this->disable();
92 ESP_LOGV(TAG, "reset_()");
93 delay(10);
94
95 ESP_LOGV(TAG, "reset() CLEAR ALL TXB registers");
96
97 uint8_t zeros[14];
98 memset(zeros, 0, sizeof(zeros));
99 set_registers_(MCP_TXB0CTRL, zeros, 14);
100 set_registers_(MCP_TXB1CTRL, zeros, 14);
101 set_registers_(MCP_TXB2CTRL, zeros, 14);
102 ESP_LOGV(TAG, "reset() CLEARED TXB registers");
103
104 set_register_(MCP_RXB0CTRL, 0);
105 set_register_(MCP_RXB1CTRL, 0);
106
107 set_register_(MCP_CANINTE, CANINTF_RX0IF | CANINTF_RX1IF | CANINTF_ERRIF | CANINTF_MERRF);
108
109 modify_register_(MCP_RXB0CTRL, RXB_CTRL_RXM_MASK | RXB_0_CTRL_BUKT, RXB_CTRL_RXM_STDEXT | RXB_0_CTRL_BUKT);
110 modify_register_(MCP_RXB1CTRL, RXB_CTRL_RXM_MASK, RXB_CTRL_RXM_STDEXT);
111
112 return canbus::ERROR_OK;
113}
114
115uint8_t MCP2515::read_register_(const REGISTER reg) {
116 this->enable();
117 this->transfer_byte(INSTRUCTION_READ);
118 this->transfer_byte(reg);
119 uint8_t ret = this->transfer_byte(0x00);
120 this->disable();
121
122 return ret;
123}
124
125void MCP2515::read_registers_(const REGISTER reg, uint8_t values[], const uint8_t n) {
126 this->enable();
127 this->transfer_byte(INSTRUCTION_READ);
128 this->transfer_byte(reg);
129 // this->transfer_array(values, n);
130 // mcp2515 has auto - increment of address - pointer
131 for (uint8_t i = 0; i < n; i++) {
132 values[i] = this->transfer_byte(0x00);
133 }
134 this->disable();
135}
136
137void MCP2515::set_register_(const REGISTER reg, const uint8_t value) {
138 this->enable();
139 this->transfer_byte(INSTRUCTION_WRITE);
140 this->transfer_byte(reg);
141 this->transfer_byte(value);
142 this->disable();
143}
144
145void MCP2515::set_registers_(const REGISTER reg, uint8_t values[], const uint8_t n) {
146 this->enable();
147 this->transfer_byte(INSTRUCTION_WRITE);
148 this->transfer_byte(reg);
149 // this->transfer_array(values, n);
150 for (uint8_t i = 0; i < n; i++) {
151 this->transfer_byte(values[i]);
152 }
153 this->disable();
154}
155
156void MCP2515::modify_register_(const REGISTER reg, const uint8_t mask, const uint8_t data) {
157 this->enable();
158 this->transfer_byte(INSTRUCTION_BITMOD);
159 this->transfer_byte(reg);
160 this->transfer_byte(mask);
161 this->transfer_byte(data);
162 this->disable();
163}
164
165uint8_t MCP2515::get_status_() {
166 this->enable();
167 this->transfer_byte(INSTRUCTION_READ_STATUS);
168 uint8_t i = this->transfer_byte(0x00);
169 this->disable();
170
171 return i;
172}
173
174canbus::Error MCP2515::set_mode_(const CanctrlReqopMode mode) {
175 modify_register_(MCP_CANCTRL, CANCTRL_REQOP, mode);
176
177 uint32_t start_time = millis();
178 while (millis() - start_time < 10) {
179 if ((read_register_(MCP_CANSTAT) & CANSTAT_OPMOD) == mode)
180 return canbus::ERROR_OK;
181 }
182 ESP_LOGE(TAG, "Failed to set mode");
183 return canbus::ERROR_FAIL;
184}
185
186canbus::Error MCP2515::set_clk_out_(const CanClkOut divisor) {
187 if (divisor == CLKOUT_DISABLE) {
188 /* Turn off CLKEN */
189 modify_register_(MCP_CANCTRL, CANCTRL_CLKEN, 0x00);
190
191 /* Turn on CLKOUT for SOF */
192 modify_register_(MCP_CNF3, CNF3_SOF, CNF3_SOF);
193 return canbus::ERROR_OK;
194 }
195
196 /* Set the prescaler (CLKPRE) */
197 modify_register_(MCP_CANCTRL, CANCTRL_CLKPRE, divisor);
198
199 /* Turn on CLKEN */
200 modify_register_(MCP_CANCTRL, CANCTRL_CLKEN, CANCTRL_CLKEN);
201
202 /* Turn off CLKOUT for SOF */
203 modify_register_(MCP_CNF3, CNF3_SOF, 0x00);
204 return canbus::ERROR_OK;
205}
206
207void MCP2515::prepare_id_(uint8_t *buffer, const bool extended, const uint32_t id) {
208 uint16_t canid = (uint16_t) (id & 0x0FFFF);
209
210 if (extended) {
211 buffer[MCP_EID0] = (uint8_t) (canid & 0xFF);
212 buffer[MCP_EID8] = (uint8_t) (canid >> 8);
213 canid = (uint16_t) (id >> 16);
214 buffer[MCP_SIDL] = (uint8_t) (canid & 0x03);
215 buffer[MCP_SIDL] += (uint8_t) ((canid & 0x1C) << 3);
216 buffer[MCP_SIDL] |= SIDL_EXIDE_MASK;
217 buffer[MCP_SIDH] = (uint8_t) (canid >> 5);
218 } else {
219 buffer[MCP_SIDH] = (uint8_t) (canid >> 3);
220 buffer[MCP_SIDL] = (uint8_t) ((canid & 0x07) << 5);
221 buffer[MCP_EID0] = 0;
222 buffer[MCP_EID8] = 0;
223 }
224}
225
226canbus::Error MCP2515::set_filter_mask_(const MASK mask, const bool extended, const uint32_t ul_data) {
227 canbus::Error res = set_mode_(CANCTRL_REQOP_CONFIG);
228 if (res != canbus::ERROR_OK) {
229 return res;
230 }
231
232 uint8_t tbufdata[4];
233 prepare_id_(tbufdata, extended, ul_data);
234
235 REGISTER reg;
236 switch (mask) {
237 case MASK0:
238 reg = MCP_RXM0SIDH;
239 break;
240 case MASK1:
241 reg = MCP_RXM1SIDH;
242 break;
243 default:
244 return canbus::ERROR_FAIL;
245 }
246
247 set_registers_(reg, tbufdata, 4);
248
249 return canbus::ERROR_OK;
250}
251
252canbus::Error MCP2515::set_filter_(const RXF num, const bool extended, const uint32_t ul_data) {
253 canbus::Error res = set_mode_(CANCTRL_REQOP_CONFIG);
254 if (res != canbus::ERROR_OK) {
255 return res;
256 }
257
258 REGISTER reg;
259
260 switch (num) {
261 case RXF0:
262 reg = MCP_RXF0SIDH;
263 break;
264 case RXF1:
265 reg = MCP_RXF1SIDH;
266 break;
267 case RXF2:
268 reg = MCP_RXF2SIDH;
269 break;
270 case RXF3:
271 reg = MCP_RXF3SIDH;
272 break;
273 case RXF4:
274 reg = MCP_RXF4SIDH;
275 break;
276 case RXF5:
277 reg = MCP_RXF5SIDH;
278 break;
279 default:
280 return canbus::ERROR_FAIL;
281 }
282
283 uint8_t tbufdata[4];
284 prepare_id_(tbufdata, extended, ul_data);
285 set_registers_(reg, tbufdata, 4);
286
287 return canbus::ERROR_OK;
288}
289
290canbus::Error MCP2515::send_message_(TXBn txbn, struct canbus::CanFrame *frame) {
291 const struct TxBnRegs *txbuf = &TXB[txbn];
292
293 uint8_t data[13];
294
295 prepare_id_(data, frame->use_extended_id, frame->can_id);
296 data[MCP_DLC] =
297 frame->remote_transmission_request ? (frame->can_data_length_code | RTR_MASK) : frame->can_data_length_code;
298 memcpy(&data[MCP_DATA], frame->data, frame->can_data_length_code);
299 set_registers_(txbuf->SIDH, data, 5 + frame->can_data_length_code);
300 modify_register_(txbuf->CTRL, TXB_TXREQ, TXB_TXREQ);
301
302 return canbus::ERROR_OK;
303}
304
305canbus::Error MCP2515::send_message(struct canbus::CanFrame *frame) {
306 if (frame->can_data_length_code > canbus::CAN_MAX_DATA_LENGTH) {
307 return canbus::ERROR_FAILTX;
308 }
309 TXBn tx_buffers[N_TXBUFFERS] = {TXB0, TXB1, TXB2};
310
311 for (auto &tx_buffer : tx_buffers) {
312 const struct TxBnRegs *txbuf = &TXB[tx_buffer];
313 uint8_t ctrlval = read_register_(txbuf->CTRL);
314 if ((ctrlval & TXB_TXREQ) == 0) {
315 return send_message_(tx_buffer, frame);
316 }
317 }
318
319 return canbus::ERROR_ALLTXBUSY;
320}
321
322canbus::Error MCP2515::read_message_(RXBn rxbn, struct canbus::CanFrame *frame) {
323 const struct RxBnRegs *rxb = &RXB[rxbn];
324
325 uint8_t tbufdata[5];
326
327 read_registers_(rxb->SIDH, tbufdata, 5);
328
329 uint32_t id = (tbufdata[MCP_SIDH] << 3) + (tbufdata[MCP_SIDL] >> 5);
330 bool use_extended_id = false;
331 bool remote_transmission_request = false;
332
333 if ((tbufdata[MCP_SIDL] & SIDL_EXIDE_MASK) == SIDL_EXIDE_MASK) {
334 id = (id << 2) + (tbufdata[MCP_SIDL] & 0x03);
335 id = (id << 8) + tbufdata[MCP_EID8];
336 id = (id << 8) + tbufdata[MCP_EID0];
337 // id |= canbus::CAN_EFF_FLAG;
338 use_extended_id = true;
339 }
340
341 uint8_t dlc = (tbufdata[MCP_DLC] & DLC_MASK);
342 if (dlc > canbus::CAN_MAX_DATA_LENGTH) {
343 return canbus::ERROR_FAIL;
344 }
345
346 uint8_t ctrl = read_register_(rxb->CTRL);
347 if (ctrl & RXB_CTRL_RTR) {
348 // id |= canbus::CAN_RTR_FLAG;
349 remote_transmission_request = true;
350 }
351
352 frame->can_id = id;
353 frame->can_data_length_code = dlc;
354 frame->use_extended_id = use_extended_id;
355 frame->remote_transmission_request = remote_transmission_request;
356
357 read_registers_(rxb->DATA, frame->data, dlc);
358
359 modify_register_(MCP_CANINTF, rxb->CANINTF_RXnIF, 0);
360
361 return canbus::ERROR_OK;
362}
363
364canbus::Error MCP2515::read_message(struct canbus::CanFrame *frame) {
365 canbus::Error rc;
366 uint8_t stat = get_status_();
367
368 if (stat & STAT_RX0IF) {
369 rc = read_message_(RXB0, frame);
370 } else if (stat & STAT_RX1IF) {
371 rc = read_message_(RXB1, frame);
372 } else {
373 rc = canbus::ERROR_NOMSG;
374 }
375
376 return rc;
377}
378
379bool MCP2515::check_receive_() {
380 uint8_t res = get_status_();
381 return (res & STAT_RXIF_MASK) != 0;
382}
383
384bool MCP2515::check_error_() {
385 uint8_t eflg = get_error_flags_();
386 return (eflg & EFLG_ERRORMASK) != 0;
387}
388
389uint8_t MCP2515::get_error_flags_() { return read_register_(MCP_EFLG); }
390
391void MCP2515::clear_rx_n_ovr_flags_() { modify_register_(MCP_EFLG, EFLG_RX0OVR | EFLG_RX1OVR, 0); }
392
393uint8_t MCP2515::get_int_() { return read_register_(MCP_CANINTF); }
394
395void MCP2515::clear_int_() { set_register_(MCP_CANINTF, 0); }
396
397uint8_t MCP2515::get_int_mask_() { return read_register_(MCP_CANINTE); }
398
399void MCP2515::clear_tx_int_() { modify_register_(MCP_CANINTF, (CANINTF_TX0IF | CANINTF_TX1IF | CANINTF_TX2IF), 0); }
400
401void MCP2515::clear_rx_n_ovr_() {
402 uint8_t eflg = get_error_flags_();
403 if (eflg != 0) {
404 clear_rx_n_ovr_flags_();
405 clear_int_();
406 // modify_register_(MCP_CANINTF, CANINTF_ERRIF, 0);
407 }
408}
409
410void MCP2515::clear_merr_() {
411 // modify_register_(MCP_EFLG, EFLG_RX0OVR | EFLG_RX1OVR, 0);
412 // clear_int_();
413 modify_register_(MCP_CANINTF, CANINTF_MERRF, 0);
414}
415
416void MCP2515::clear_errif_() {
417 // modify_register_(MCP_EFLG, EFLG_RX0OVR | EFLG_RX1OVR, 0);
418 // clear_int_();
419 modify_register_(MCP_CANINTF, CANINTF_ERRIF, 0);
420}
421
422canbus::Error MCP2515::set_bitrate_(canbus::CanSpeed can_speed) { return this->set_bitrate_(can_speed, MCP_16MHZ); }
423
424canbus::Error MCP2515::set_bitrate_(canbus::CanSpeed can_speed, CanClock can_clock) {
425 canbus::Error error = set_mode_(CANCTRL_REQOP_CONFIG);
426 if (error != canbus::ERROR_OK) {
427 return error;
428 }
429
430 uint8_t set, cfg1, cfg2, cfg3;
431 set = 1;
432 switch (can_clock) {
433 case (MCP_8MHZ):
434 switch (can_speed) {
435 case (canbus::CAN_5KBPS): // 5KBPS
436 cfg1 = MCP_8MHZ_5KBPS_CFG1;
437 cfg2 = MCP_8MHZ_5KBPS_CFG2;
438 cfg3 = MCP_8MHZ_5KBPS_CFG3;
439 break;
440 case (canbus::CAN_10KBPS): // 10KBPS
441 cfg1 = MCP_8MHZ_10KBPS_CFG1;
442 cfg2 = MCP_8MHZ_10KBPS_CFG2;
443 cfg3 = MCP_8MHZ_10KBPS_CFG3;
444 break;
445 case (canbus::CAN_20KBPS): // 20KBPS
446 cfg1 = MCP_8MHZ_20KBPS_CFG1;
447 cfg2 = MCP_8MHZ_20KBPS_CFG2;
448 cfg3 = MCP_8MHZ_20KBPS_CFG3;
449 break;
450 case (canbus::CAN_31K25BPS): // 31.25KBPS
451 cfg1 = MCP_8MHZ_31K25BPS_CFG1;
452 cfg2 = MCP_8MHZ_31K25BPS_CFG2;
453 cfg3 = MCP_8MHZ_31K25BPS_CFG3;
454 break;
455 case (canbus::CAN_33KBPS): // 33.333KBPS
456 cfg1 = MCP_8MHZ_33K3BPS_CFG1;
457 cfg2 = MCP_8MHZ_33K3BPS_CFG2;
458 cfg3 = MCP_8MHZ_33K3BPS_CFG3;
459 break;
460 case (canbus::CAN_40KBPS): // 40Kbps
461 cfg1 = MCP_8MHZ_40KBPS_CFG1;
462 cfg2 = MCP_8MHZ_40KBPS_CFG2;
463 cfg3 = MCP_8MHZ_40KBPS_CFG3;
464 break;
465 case (canbus::CAN_50KBPS): // 50Kbps
466 cfg1 = MCP_8MHZ_50KBPS_CFG1;
467 cfg2 = MCP_8MHZ_50KBPS_CFG2;
468 cfg3 = MCP_8MHZ_50KBPS_CFG3;
469 break;
470 case (canbus::CAN_80KBPS): // 80Kbps
471 cfg1 = MCP_8MHZ_80KBPS_CFG1;
472 cfg2 = MCP_8MHZ_80KBPS_CFG2;
473 cfg3 = MCP_8MHZ_80KBPS_CFG3;
474 break;
475 case (canbus::CAN_100KBPS): // 100Kbps
476 cfg1 = MCP_8MHZ_100KBPS_CFG1;
477 cfg2 = MCP_8MHZ_100KBPS_CFG2;
478 cfg3 = MCP_8MHZ_100KBPS_CFG3;
479 break;
480 case (canbus::CAN_125KBPS): // 125Kbps
481 cfg1 = MCP_8MHZ_125KBPS_CFG1;
482 cfg2 = MCP_8MHZ_125KBPS_CFG2;
483 cfg3 = MCP_8MHZ_125KBPS_CFG3;
484 break;
485 case (canbus::CAN_200KBPS): // 200Kbps
486 cfg1 = MCP_8MHZ_200KBPS_CFG1;
487 cfg2 = MCP_8MHZ_200KBPS_CFG2;
488 cfg3 = MCP_8MHZ_200KBPS_CFG3;
489 break;
490 case (canbus::CAN_250KBPS): // 250Kbps
491 cfg1 = MCP_8MHZ_250KBPS_CFG1;
492 cfg2 = MCP_8MHZ_250KBPS_CFG2;
493 cfg3 = MCP_8MHZ_250KBPS_CFG3;
494 break;
495 case (canbus::CAN_500KBPS): // 500Kbps
496 cfg1 = MCP_8MHZ_500KBPS_CFG1;
497 cfg2 = MCP_8MHZ_500KBPS_CFG2;
498 cfg3 = MCP_8MHZ_500KBPS_CFG3;
499 break;
500 case (canbus::CAN_1000KBPS): // 1Mbps
501 cfg1 = MCP_8MHZ_1000KBPS_CFG1;
502 cfg2 = MCP_8MHZ_1000KBPS_CFG2;
503 cfg3 = MCP_8MHZ_1000KBPS_CFG3;
504 break;
505 default:
506 set = 0;
507 break;
508 }
509 break;
510
511 case (MCP_12MHZ):
512 switch (can_speed) {
513 case (canbus::CAN_5KBPS): // 5Kbps
514 cfg1 = MCP_12MHZ_5KBPS_CFG1;
515 cfg2 = MCP_12MHZ_5KBPS_CFG2;
516 cfg3 = MCP_12MHZ_5KBPS_CFG3;
517 break;
518 case (canbus::CAN_10KBPS): // 10Kbps
519 cfg1 = MCP_12MHZ_10KBPS_CFG1;
520 cfg2 = MCP_12MHZ_10KBPS_CFG2;
521 cfg3 = MCP_12MHZ_10KBPS_CFG3;
522 break;
523 case (canbus::CAN_20KBPS): // 20Kbps
524 cfg1 = MCP_12MHZ_20KBPS_CFG1;
525 cfg2 = MCP_12MHZ_20KBPS_CFG2;
526 cfg3 = MCP_12MHZ_20KBPS_CFG3;
527 break;
528 case (canbus::CAN_33KBPS): // 33.333Kbps
529 cfg1 = MCP_12MHZ_33K3BPS_CFG1;
530 cfg2 = MCP_12MHZ_33K3BPS_CFG2;
531 cfg3 = MCP_12MHZ_33K3BPS_CFG3;
532 break;
533 case (canbus::CAN_40KBPS): // 40Kbps
534 cfg1 = MCP_12MHZ_40KBPS_CFG1;
535 cfg2 = MCP_12MHZ_40KBPS_CFG2;
536 cfg3 = MCP_12MHZ_40KBPS_CFG3;
537 break;
538 case (canbus::CAN_50KBPS): // 50Kbps
539 cfg1 = MCP_12MHZ_50KBPS_CFG1;
540 cfg2 = MCP_12MHZ_50KBPS_CFG2;
541 cfg3 = MCP_12MHZ_50KBPS_CFG3;
542 break;
543 case (canbus::CAN_80KBPS): // 80Kbps
544 cfg1 = MCP_12MHZ_80KBPS_CFG1;
545 cfg2 = MCP_12MHZ_80KBPS_CFG2;
546 cfg3 = MCP_12MHZ_80KBPS_CFG3;
547 break;
548 case (canbus::CAN_100KBPS): // 100Kbps
549 cfg1 = MCP_12MHZ_100KBPS_CFG1;
550 cfg2 = MCP_12MHZ_100KBPS_CFG2;
551 cfg3 = MCP_12MHZ_100KBPS_CFG3;
552 break;
553 case (canbus::CAN_125KBPS): // 125Kbps
554 cfg1 = MCP_12MHZ_125KBPS_CFG1;
555 cfg2 = MCP_12MHZ_125KBPS_CFG2;
556 cfg3 = MCP_12MHZ_125KBPS_CFG3;
557 break;
558 case (canbus::CAN_200KBPS): // 200Kbps
559 cfg1 = MCP_12MHZ_200KBPS_CFG1;
560 cfg2 = MCP_12MHZ_200KBPS_CFG2;
561 cfg3 = MCP_12MHZ_200KBPS_CFG3;
562 break;
563 case (canbus::CAN_250KBPS): // 250Kbps
564 cfg1 = MCP_12MHZ_250KBPS_CFG1;
565 cfg2 = MCP_12MHZ_250KBPS_CFG2;
566 cfg3 = MCP_12MHZ_250KBPS_CFG3;
567 break;
568 case (canbus::CAN_500KBPS): // 500Kbps
569 cfg1 = MCP_12MHZ_500KBPS_CFG1;
570 cfg2 = MCP_12MHZ_500KBPS_CFG2;
571 cfg3 = MCP_12MHZ_500KBPS_CFG3;
572 break;
573 case (canbus::CAN_1000KBPS): // 1Mbps
574 cfg1 = MCP_12MHZ_1000KBPS_CFG1;
575 cfg2 = MCP_12MHZ_1000KBPS_CFG2;
576 cfg3 = MCP_12MHZ_1000KBPS_CFG3;
577 break;
578 default:
579 set = 0;
580 break;
581 }
582 break;
583
584 case (MCP_16MHZ):
585 switch (can_speed) {
586 case (canbus::CAN_5KBPS): // 5Kbps
587 cfg1 = MCP_16MHZ_5KBPS_CFG1;
588 cfg2 = MCP_16MHZ_5KBPS_CFG2;
589 cfg3 = MCP_16MHZ_5KBPS_CFG3;
590 break;
591 case (canbus::CAN_10KBPS): // 10Kbps
592 cfg1 = MCP_16MHZ_10KBPS_CFG1;
593 cfg2 = MCP_16MHZ_10KBPS_CFG2;
594 cfg3 = MCP_16MHZ_10KBPS_CFG3;
595 break;
596 case (canbus::CAN_20KBPS): // 20Kbps
597 cfg1 = MCP_16MHZ_20KBPS_CFG1;
598 cfg2 = MCP_16MHZ_20KBPS_CFG2;
599 cfg3 = MCP_16MHZ_20KBPS_CFG3;
600 break;
601 case (canbus::CAN_33KBPS): // 33.333Kbps
602 cfg1 = MCP_16MHZ_33K3BPS_CFG1;
603 cfg2 = MCP_16MHZ_33K3BPS_CFG2;
604 cfg3 = MCP_16MHZ_33K3BPS_CFG3;
605 break;
606 case (canbus::CAN_40KBPS): // 40Kbps
607 cfg1 = MCP_16MHZ_40KBPS_CFG1;
608 cfg2 = MCP_16MHZ_40KBPS_CFG2;
609 cfg3 = MCP_16MHZ_40KBPS_CFG3;
610 break;
611 case (canbus::CAN_50KBPS): // 50Kbps
612 cfg1 = MCP_16MHZ_50KBPS_CFG1;
613 cfg2 = MCP_16MHZ_50KBPS_CFG2;
614 cfg3 = MCP_16MHZ_50KBPS_CFG3;
615 break;
616 case (canbus::CAN_80KBPS): // 80Kbps
617 cfg1 = MCP_16MHZ_80KBPS_CFG1;
618 cfg2 = MCP_16MHZ_80KBPS_CFG2;
619 cfg3 = MCP_16MHZ_80KBPS_CFG3;
620 break;
621 case (canbus::CAN_83K3BPS): // 83.333Kbps
622 cfg1 = MCP_16MHZ_83K3BPS_CFG1;
623 cfg2 = MCP_16MHZ_83K3BPS_CFG2;
624 cfg3 = MCP_16MHZ_83K3BPS_CFG3;
625 break;
626 case (canbus::CAN_100KBPS): // 100Kbps
627 cfg1 = MCP_16MHZ_100KBPS_CFG1;
628 cfg2 = MCP_16MHZ_100KBPS_CFG2;
629 cfg3 = MCP_16MHZ_100KBPS_CFG3;
630 break;
631 case (canbus::CAN_125KBPS): // 125Kbps
632 cfg1 = MCP_16MHZ_125KBPS_CFG1;
633 cfg2 = MCP_16MHZ_125KBPS_CFG2;
634 cfg3 = MCP_16MHZ_125KBPS_CFG3;
635 break;
636 case (canbus::CAN_200KBPS): // 200Kbps
637 cfg1 = MCP_16MHZ_200KBPS_CFG1;
638 cfg2 = MCP_16MHZ_200KBPS_CFG2;
639 cfg3 = MCP_16MHZ_200KBPS_CFG3;
640 break;
641 case (canbus::CAN_250KBPS): // 250Kbps
642 cfg1 = MCP_16MHZ_250KBPS_CFG1;
643 cfg2 = MCP_16MHZ_250KBPS_CFG2;
644 cfg3 = MCP_16MHZ_250KBPS_CFG3;
645 break;
646 case (canbus::CAN_500KBPS): // 500Kbps
647 cfg1 = MCP_16MHZ_500KBPS_CFG1;
648 cfg2 = MCP_16MHZ_500KBPS_CFG2;
649 cfg3 = MCP_16MHZ_500KBPS_CFG3;
650 break;
651 case (canbus::CAN_1000KBPS): // 1Mbps
652 cfg1 = MCP_16MHZ_1000KBPS_CFG1;
653 cfg2 = MCP_16MHZ_1000KBPS_CFG2;
654 cfg3 = MCP_16MHZ_1000KBPS_CFG3;
655 break;
656 default:
657 set = 0;
658 break;
659 }
660 break;
661
662 case (MCP_20MHZ):
663 switch (can_speed) {
664 case (canbus::CAN_33KBPS): // 33.333Kbps
665 cfg1 = MCP_20MHZ_33K3BPS_CFG1;
666 cfg2 = MCP_20MHZ_33K3BPS_CFG2;
667 cfg3 = MCP_20MHZ_33K3BPS_CFG3;
668 break;
669 case (canbus::CAN_40KBPS): // 40Kbps
670 cfg1 = MCP_20MHZ_40KBPS_CFG1;
671 cfg2 = MCP_20MHZ_40KBPS_CFG2;
672 cfg3 = MCP_20MHZ_40KBPS_CFG3;
673 break;
674 case (canbus::CAN_50KBPS): // 50Kbps
675 cfg1 = MCP_20MHZ_50KBPS_CFG1;
676 cfg2 = MCP_20MHZ_50KBPS_CFG2;
677 cfg3 = MCP_20MHZ_50KBPS_CFG3;
678 break;
679 case (canbus::CAN_80KBPS): // 80Kbps
680 cfg1 = MCP_20MHZ_80KBPS_CFG1;
681 cfg2 = MCP_20MHZ_80KBPS_CFG2;
682 cfg3 = MCP_20MHZ_80KBPS_CFG3;
683 break;
684 case (canbus::CAN_83K3BPS): // 83.333Kbps
685 cfg1 = MCP_20MHZ_83K3BPS_CFG1;
686 cfg2 = MCP_20MHZ_83K3BPS_CFG2;
687 cfg3 = MCP_20MHZ_83K3BPS_CFG3;
688 break;
689 case (canbus::CAN_100KBPS): // 100Kbps
690 cfg1 = MCP_20MHZ_100KBPS_CFG1;
691 cfg2 = MCP_20MHZ_100KBPS_CFG2;
692 cfg3 = MCP_20MHZ_100KBPS_CFG3;
693 break;
694 case (canbus::CAN_125KBPS): // 125Kbps
695 cfg1 = MCP_20MHZ_125KBPS_CFG1;
696 cfg2 = MCP_20MHZ_125KBPS_CFG2;
697 cfg3 = MCP_20MHZ_125KBPS_CFG3;
698 break;
699 case (canbus::CAN_200KBPS): // 200Kbps
700 cfg1 = MCP_20MHZ_200KBPS_CFG1;
701 cfg2 = MCP_20MHZ_200KBPS_CFG2;
702 cfg3 = MCP_20MHZ_200KBPS_CFG3;
703 break;
704 case (canbus::CAN_250KBPS): // 250Kbps
705 cfg1 = MCP_20MHZ_250KBPS_CFG1;
706 cfg2 = MCP_20MHZ_250KBPS_CFG2;
707 cfg3 = MCP_20MHZ_250KBPS_CFG3;
708 break;
709 case (canbus::CAN_500KBPS): // 500Kbps
710 cfg1 = MCP_20MHZ_500KBPS_CFG1;
711 cfg2 = MCP_20MHZ_500KBPS_CFG2;
712 cfg3 = MCP_20MHZ_500KBPS_CFG3;
713 break;
714 case (canbus::CAN_1000KBPS): // 1Mbps
715 cfg1 = MCP_20MHZ_1000KBPS_CFG1;
716 cfg2 = MCP_20MHZ_1000KBPS_CFG2;
717 cfg3 = MCP_20MHZ_1000KBPS_CFG3;
718 break;
719 default:
720 set = 0;
721 break;
722 }
723 break;
724
725 default:
726 set = 0;
727 break;
728 }
729
730 if (set) {
731 set_register_(MCP_CNF1, cfg1); // NOLINT
732 set_register_(MCP_CNF2, cfg2); // NOLINT
733 set_register_(MCP_CNF3, cfg3); // NOLINT
734 return canbus::ERROR_OK;
735 } else {
736 ESP_LOGE(TAG, "Invalid frequency/bitrate combination: %d/%d", can_clock, can_speed);
737 return canbus::ERROR_FAIL;
738 }
739}
740} // namespace esphome::mcp2515
mode
BedjetMode mode
BedJet operating mode.
Definition bedjet_codec.h:19
status
uint8_t status
Definition bl0942.h:8
esphome::mcp2515::MCP2515::reset_
canbus::Error reset_()
Definition mcp2515.cpp:88
esphome::mcp2515::MCP2515::RXB
static const struct esphome::mcp2515::MCP2515::RxBnRegs RXB[N_RXBUFFERS]
Definition mcp2515.cpp:12
esphome::mcp2515::MCP2515::modify_register_
void modify_register_(REGISTER reg, uint8_t mask, uint8_t data)
Definition mcp2515.cpp:156
esphome::mcp2515::MCP2515::get_status
canbus::CanStatus get_status() override
Definition mcp2515.cpp:72
esphome::mcp2515::MCP2515::set_filter_mask_
canbus::Error set_filter_mask_(MASK mask, bool extended, uint32_t ul_data)
Definition mcp2515.cpp:226
esphome::mcp2515::MCP2515::prepare_id_
void prepare_id_(uint8_t *buffer, bool extended, uint32_t id)
Definition mcp2515.cpp:207
esphome::mcp2515::MCP2515::read_registers_
void read_registers_(REGISTER reg, uint8_t values[], uint8_t n)
Definition mcp2515.cpp:125
esphome::mcp2515::MCP2515::read_register_
uint8_t read_register_(REGISTER reg)
Definition mcp2515.cpp:115
esphome::mcp2515::MCP2515::set_registers_
void set_registers_(REGISTER reg, uint8_t values[], uint8_t n)
Definition mcp2515.cpp:145
esphome::mcp2515::MCP2515::mcp_mode_
CanctrlReqopMode mcp_mode_
Definition mcp2515.h:77
esphome::mcp2515::MCP2515::TXB
static const struct esphome::mcp2515::MCP2515::TxBnRegs TXB[N_TXBUFFERS]
Definition mcp2515.cpp:8
esphome::mcp2515::MCP2515::send_message
canbus::Error send_message(struct canbus::CanFrame *frame) override
Definition mcp2515.cpp:305
esphome::mcp2515::MCP2515::setup_internal
bool setup_internal() override
Definition mcp2515.cpp:15
esphome::mcp2515::MCP2515::get_events
canbus::CanEventFlags get_events() override
Definition mcp2515.cpp:46
esphome::mcp2515::MCP2515::set_register_
void set_register_(REGISTER reg, uint8_t value)
Definition mcp2515.cpp:137
esphome::mcp2515::MCP2515::set_filter_
canbus::Error set_filter_(RXF num, bool extended, uint32_t ul_data)
Definition mcp2515.cpp:252
esphome::mcp2515::MCP2515::set_mode_
canbus::Error set_mode_(CanctrlReqopMode mode)
Definition mcp2515.cpp:174
esphome::mcp2515::MCP2515::send_message_
canbus::Error send_message_(TXBn txbn, struct canbus::CanFrame *frame)
Definition mcp2515.cpp:290
esphome::mcp2515::MCP2515::read_message
canbus::Error read_message(struct canbus::CanFrame *frame) override
Definition mcp2515.cpp:364
esphome::mcp2515::MCP2515::set_clk_out_
canbus::Error set_clk_out_(CanClkOut divisor)
Definition mcp2515.cpp:186
esphome::mcp2515::MCP2515::read_message_
canbus::Error read_message_(RXBn rxbn, struct canbus::CanFrame *frame)
Definition mcp2515.cpp:322
esphome::mcp2515::MCP2515::set_bitrate_
canbus::Error set_bitrate_(canbus::CanSpeed can_speed)
Definition mcp2515.cpp:422
id
uint16_t id
Definition dns_server_esp32_idf.cpp:0
buffer
uint32_t buffer
Definition gif.cpp:50
ret
int ret
Definition ln882h_ble.cpp:174
esphome::canbus::CAN_EVENT_PASSIVE
@ CAN_EVENT_PASSIVE
Definition canbus.h:67
esphome::canbus::CAN_EVENT_BUS_OFF
@ CAN_EVENT_BUS_OFF
Definition canbus.h:69
esphome::canbus::CAN_EVENT_RX_QUEUE_FULL
@ CAN_EVENT_RX_QUEUE_FULL
Definition canbus.h:70
esphome::mcp2515::ESPHOME_LOG_TAG
ESPHOME_LOG_TAG(TAG, "mcp2515")
esphome::delay
void HOT delay(uint32_t ms)
Definition hal.cpp:85
esphome::millis
uint32_t IRAM_ATTR HOT millis()
Definition hal.cpp:25
uint32_t
static void uint32_t
Definition crash_handler.cpp:153
esphome::canbus::CanFrame::can_data_length_code
uint8_t can_data_length_code
Definition canbus.h:62
Generated by doxygen 1.12.0