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