ESPHome  2022.12.8
mcp2515.cpp
Go to the documentation of this file.
1 #include "mcp2515.h"
2 #include "esphome/core/log.h"
3 
4 namespace esphome {
5 namespace mcp2515 {
6 
7 static const char *const TAG = "mcp2515";
8 
9 const struct MCP2515::TxBnRegs MCP2515::TXB[N_TXBUFFERS] = {{MCP_TXB0CTRL, MCP_TXB0SIDH, MCP_TXB0DATA},
12 
13 const struct MCP2515::RxBnRegs MCP2515::RXB[N_RXBUFFERS] = {{MCP_RXB0CTRL, MCP_RXB0SIDH, MCP_RXB0DATA, CANINTF_RX0IF},
15 
16 bool MCP2515::setup_internal() {
17  this->spi_setup();
18 
19  if (this->reset_() == canbus::ERROR_FAIL)
20  return false;
21  this->set_bitrate_(this->bit_rate_, this->mcp_clock_);
22  this->set_mode_(this->mcp_mode_);
23  ESP_LOGV(TAG, "setup done");
24  return true;
25 }
26 
27 canbus::Error MCP2515::reset_() {
28  this->enable();
29  this->transfer_byte(INSTRUCTION_RESET);
30  this->disable();
31  ESP_LOGV(TAG, "reset_()");
32  delay(10);
33 
34  ESP_LOGV(TAG, "reset() CLEAR ALL TXB registers");
35 
36  uint8_t zeros[14];
37  memset(zeros, 0, sizeof(zeros));
38  set_registers_(MCP_TXB0CTRL, zeros, 14);
39  set_registers_(MCP_TXB1CTRL, zeros, 14);
40  set_registers_(MCP_TXB2CTRL, zeros, 14);
41  ESP_LOGD(TAG, "reset() CLEARED TXB registers");
42 
43  set_register_(MCP_RXB0CTRL, 0);
44  set_register_(MCP_RXB1CTRL, 0);
45 
46  set_register_(MCP_CANINTE, CANINTF_RX0IF | CANINTF_RX1IF | CANINTF_ERRIF | CANINTF_MERRF);
47 
48  modify_register_(MCP_RXB0CTRL, RXB_CTRL_RXM_MASK | RXB_0_CTRL_BUKT, RXB_CTRL_RXM_STDEXT | RXB_0_CTRL_BUKT);
49  modify_register_(MCP_RXB1CTRL, RXB_CTRL_RXM_MASK, RXB_CTRL_RXM_STDEXT);
50 
51  return canbus::ERROR_OK;
52 }
53 
54 uint8_t MCP2515::read_register_(const REGISTER reg) {
55  this->enable();
56  this->transfer_byte(INSTRUCTION_READ);
57  this->transfer_byte(reg);
58  uint8_t ret = this->transfer_byte(0x00);
59  this->disable();
60 
61  return ret;
62 }
63 
64 void MCP2515::read_registers_(const REGISTER reg, uint8_t values[], const uint8_t n) {
65  this->enable();
66  this->transfer_byte(INSTRUCTION_READ);
67  this->transfer_byte(reg);
68  // this->transfer_array(values, n);
69  // mcp2515 has auto - increment of address - pointer
70  for (uint8_t i = 0; i < n; i++) {
71  values[i] = this->transfer_byte(0x00);
72  }
73  this->disable();
74 }
75 
76 void MCP2515::set_register_(const REGISTER reg, const uint8_t value) {
77  this->enable();
78  this->transfer_byte(INSTRUCTION_WRITE);
79  this->transfer_byte(reg);
80  this->transfer_byte(value);
81  this->disable();
82 }
83 
84 void MCP2515::set_registers_(const REGISTER reg, uint8_t values[], const uint8_t n) {
85  this->enable();
86  this->transfer_byte(INSTRUCTION_WRITE);
87  this->transfer_byte(reg);
88  // this->transfer_array(values, n);
89  for (uint8_t i = 0; i < n; i++) {
90  this->transfer_byte(values[i]);
91  }
92  this->disable();
93 }
94 
95 void MCP2515::modify_register_(const REGISTER reg, const uint8_t mask, const uint8_t data) {
96  this->enable();
97  this->transfer_byte(INSTRUCTION_BITMOD);
98  this->transfer_byte(reg);
99  this->transfer_byte(mask);
100  this->transfer_byte(data);
101  this->disable();
102 }
103 
104 uint8_t MCP2515::get_status_() {
105  this->enable();
106  this->transfer_byte(INSTRUCTION_READ_STATUS);
107  uint8_t i = this->transfer_byte(0x00);
108  this->disable();
109 
110  return i;
111 }
112 
113 canbus::Error MCP2515::set_mode_(const CanctrlReqopMode mode) {
114  modify_register_(MCP_CANCTRL, CANCTRL_REQOP, mode);
115 
116  uint32_t end_time = millis() + 10;
117  bool mode_match = false;
118  while (millis() < end_time) {
119  uint8_t new_mode = read_register_(MCP_CANSTAT);
120  new_mode &= CANSTAT_OPMOD;
121  mode_match = new_mode == mode;
122  if (mode_match) {
123  break;
124  }
125  }
126  return mode_match ? canbus::ERROR_OK : canbus::ERROR_FAIL;
127 }
128 
129 canbus::Error MCP2515::set_clk_out_(const CanClkOut divisor) {
130  if (divisor == CLKOUT_DISABLE) {
131  /* Turn off CLKEN */
132  modify_register_(MCP_CANCTRL, CANCTRL_CLKEN, 0x00);
133 
134  /* Turn on CLKOUT for SOF */
135  modify_register_(MCP_CNF3, CNF3_SOF, CNF3_SOF);
136  return canbus::ERROR_OK;
137  }
138 
139  /* Set the prescaler (CLKPRE) */
140  modify_register_(MCP_CANCTRL, CANCTRL_CLKPRE, divisor);
141 
142  /* Turn on CLKEN */
143  modify_register_(MCP_CANCTRL, CANCTRL_CLKEN, CANCTRL_CLKEN);
144 
145  /* Turn off CLKOUT for SOF */
146  modify_register_(MCP_CNF3, CNF3_SOF, 0x00);
147  return canbus::ERROR_OK;
148 }
149 
150 void MCP2515::prepare_id_(uint8_t *buffer, const bool extended, const uint32_t id) {
151  uint16_t canid = (uint16_t)(id & 0x0FFFF);
152 
153  if (extended) {
154  buffer[MCP_EID0] = (uint8_t)(canid & 0xFF);
155  buffer[MCP_EID8] = (uint8_t)(canid >> 8);
156  canid = (uint16_t)(id >> 16);
157  buffer[MCP_SIDL] = (uint8_t)(canid & 0x03);
158  buffer[MCP_SIDL] += (uint8_t)((canid & 0x1C) << 3);
159  buffer[MCP_SIDL] |= TXB_EXIDE_MASK;
160  buffer[MCP_SIDH] = (uint8_t)(canid >> 5);
161  } else {
162  buffer[MCP_SIDH] = (uint8_t)(canid >> 3);
163  buffer[MCP_SIDL] = (uint8_t)((canid & 0x07) << 5);
164  buffer[MCP_EID0] = 0;
165  buffer[MCP_EID8] = 0;
166  }
167 }
168 
169 canbus::Error MCP2515::set_filter_mask_(const MASK mask, const bool extended, const uint32_t ul_data) {
170  canbus::Error res = set_mode_(CANCTRL_REQOP_CONFIG);
171  if (res != canbus::ERROR_OK) {
172  return res;
173  }
174 
175  uint8_t tbufdata[4];
176  prepare_id_(tbufdata, extended, ul_data);
177 
178  REGISTER reg;
179  switch (mask) {
180  case MASK0:
181  reg = MCP_RXM0SIDH;
182  break;
183  case MASK1:
184  reg = MCP_RXM1SIDH;
185  break;
186  default:
187  return canbus::ERROR_FAIL;
188  }
189 
190  set_registers_(reg, tbufdata, 4);
191 
192  return canbus::ERROR_OK;
193 }
194 
195 canbus::Error MCP2515::set_filter_(const RXF num, const bool extended, const uint32_t ul_data) {
196  canbus::Error res = set_mode_(CANCTRL_REQOP_CONFIG);
197  if (res != canbus::ERROR_OK) {
198  return res;
199  }
200 
201  REGISTER reg;
202 
203  switch (num) {
204  case RXF0:
205  reg = MCP_RXF0SIDH;
206  break;
207  case RXF1:
208  reg = MCP_RXF1SIDH;
209  break;
210  case RXF2:
211  reg = MCP_RXF2SIDH;
212  break;
213  case RXF3:
214  reg = MCP_RXF3SIDH;
215  break;
216  case RXF4:
217  reg = MCP_RXF4SIDH;
218  break;
219  case RXF5:
220  reg = MCP_RXF5SIDH;
221  break;
222  default:
223  return canbus::ERROR_FAIL;
224  }
225 
226  uint8_t tbufdata[4];
227  prepare_id_(tbufdata, extended, ul_data);
228  set_registers_(reg, tbufdata, 4);
229 
230  return canbus::ERROR_OK;
231 }
232 
233 canbus::Error MCP2515::send_message_(TXBn txbn, struct canbus::CanFrame *frame) {
234  const struct TxBnRegs *txbuf = &TXB[txbn];
235 
236  uint8_t data[13];
237 
238  prepare_id_(data, frame->use_extended_id, frame->can_id);
239  data[MCP_DLC] =
240  frame->remote_transmission_request ? (frame->can_data_length_code | RTR_MASK) : frame->can_data_length_code;
241  memcpy(&data[MCP_DATA], frame->data, frame->can_data_length_code);
242  set_registers_(txbuf->SIDH, data, 5 + frame->can_data_length_code);
243  modify_register_(txbuf->CTRL, TXB_TXREQ, TXB_TXREQ);
244 
245  return canbus::ERROR_OK;
246 }
247 
248 canbus::Error MCP2515::send_message(struct canbus::CanFrame *frame) {
249  if (frame->can_data_length_code > canbus::CAN_MAX_DATA_LENGTH) {
250  return canbus::ERROR_FAILTX;
251  }
252  TXBn tx_buffers[N_TXBUFFERS] = {TXB0, TXB1, TXB2};
253 
254  for (auto &tx_buffer : tx_buffers) {
255  const struct TxBnRegs *txbuf = &TXB[tx_buffer];
256  uint8_t ctrlval = read_register_(txbuf->CTRL);
257  if ((ctrlval & TXB_TXREQ) == 0) {
258  return send_message_(tx_buffer, frame);
259  }
260  }
261 
262  return canbus::ERROR_FAILTX;
263 }
264 
265 canbus::Error MCP2515::read_message_(RXBn rxbn, struct canbus::CanFrame *frame) {
266  const struct RxBnRegs *rxb = &RXB[rxbn];
267 
268  uint8_t tbufdata[5];
269 
270  read_registers_(rxb->SIDH, tbufdata, 5);
271 
272  uint32_t id = (tbufdata[MCP_SIDH] << 3) + (tbufdata[MCP_SIDL] >> 5);
273  bool use_extended_id = false;
274  bool remote_transmission_request = false;
275 
276  if ((tbufdata[MCP_SIDL] & TXB_EXIDE_MASK) == TXB_EXIDE_MASK) {
277  id = (id << 2) + (tbufdata[MCP_SIDL] & 0x03);
278  id = (id << 8) + tbufdata[MCP_EID8];
279  id = (id << 8) + tbufdata[MCP_EID0];
280  // id |= canbus::CAN_EFF_FLAG;
281  use_extended_id = true;
282  }
283 
284  uint8_t dlc = (tbufdata[MCP_DLC] & DLC_MASK);
285  if (dlc > canbus::CAN_MAX_DATA_LENGTH) {
286  return canbus::ERROR_FAIL;
287  }
288 
289  uint8_t ctrl = read_register_(rxb->CTRL);
290  if (ctrl & RXB_CTRL_RTR) {
291  // id |= canbus::CAN_RTR_FLAG;
292  remote_transmission_request = true;
293  }
294 
295  frame->can_id = id;
296  frame->can_data_length_code = dlc;
297  frame->use_extended_id = use_extended_id;
298  frame->remote_transmission_request = remote_transmission_request;
299 
300  read_registers_(rxb->DATA, frame->data, dlc);
301 
302  modify_register_(MCP_CANINTF, rxb->CANINTF_RXnIF, 0);
303 
304  return canbus::ERROR_OK;
305 }
306 
307 canbus::Error MCP2515::read_message(struct canbus::CanFrame *frame) {
308  canbus::Error rc;
309  uint8_t stat = get_status_();
310 
311  if (stat & STAT_RX0IF) {
312  rc = read_message_(RXB0, frame);
313  } else if (stat & STAT_RX1IF) {
314  rc = read_message_(RXB1, frame);
315  } else {
316  rc = canbus::ERROR_NOMSG;
317  }
318 
319  return rc;
320 }
321 
322 bool MCP2515::check_receive_() {
323  uint8_t res = get_status_();
324  return (res & STAT_RXIF_MASK) != 0;
325 }
326 
327 bool MCP2515::check_error_() {
328  uint8_t eflg = get_error_flags_();
329  return (eflg & EFLG_ERRORMASK) != 0;
330 }
331 
332 uint8_t MCP2515::get_error_flags_() { return read_register_(MCP_EFLG); }
333 
334 void MCP2515::clear_rx_n_ovr_flags_() { modify_register_(MCP_EFLG, EFLG_RX0OVR | EFLG_RX1OVR, 0); }
335 
336 uint8_t MCP2515::get_int_() { return read_register_(MCP_CANINTF); }
337 
338 void MCP2515::clear_int_() { set_register_(MCP_CANINTF, 0); }
339 
340 uint8_t MCP2515::get_int_mask_() { return read_register_(MCP_CANINTE); }
341 
342 void MCP2515::clear_tx_int_() { modify_register_(MCP_CANINTF, (CANINTF_TX0IF | CANINTF_TX1IF | CANINTF_TX2IF), 0); }
343 
344 void MCP2515::clear_rx_n_ovr_() {
345  uint8_t eflg = get_error_flags_();
346  if (eflg != 0) {
347  clear_rx_n_ovr_flags_();
348  clear_int_();
349  // modify_register_(MCP_CANINTF, CANINTF_ERRIF, 0);
350  }
351 }
352 
353 void MCP2515::clear_merr_() {
354  // modify_register_(MCP_EFLG, EFLG_RX0OVR | EFLG_RX1OVR, 0);
355  // clear_int_();
356  modify_register_(MCP_CANINTF, CANINTF_MERRF, 0);
357 }
358 
359 void MCP2515::clear_errif_() {
360  // modify_register_(MCP_EFLG, EFLG_RX0OVR | EFLG_RX1OVR, 0);
361  // clear_int_();
362  modify_register_(MCP_CANINTF, CANINTF_ERRIF, 0);
363 }
364 
365 canbus::Error MCP2515::set_bitrate_(canbus::CanSpeed can_speed) { return this->set_bitrate_(can_speed, MCP_16MHZ); }
366 
367 canbus::Error MCP2515::set_bitrate_(canbus::CanSpeed can_speed, CanClock can_clock) {
368  canbus::Error error = set_mode_(CANCTRL_REQOP_CONFIG);
369  if (error != canbus::ERROR_OK) {
370  return error;
371  }
372 
373  uint8_t set, cfg1, cfg2, cfg3;
374  set = 1;
375  switch (can_clock) {
376  case (MCP_8MHZ):
377  switch (can_speed) {
378  case (canbus::CAN_5KBPS): // 5KBPS
379  cfg1 = MCP_8MHZ_5KBPS_CFG1;
380  cfg2 = MCP_8MHZ_5KBPS_CFG2;
381  cfg3 = MCP_8MHZ_5KBPS_CFG3;
382  break;
383  case (canbus::CAN_10KBPS): // 10KBPS
384  cfg1 = MCP_8MHZ_10KBPS_CFG1;
385  cfg2 = MCP_8MHZ_10KBPS_CFG2;
386  cfg3 = MCP_8MHZ_10KBPS_CFG3;
387  break;
388  case (canbus::CAN_20KBPS): // 20KBPS
389  cfg1 = MCP_8MHZ_20KBPS_CFG1;
390  cfg2 = MCP_8MHZ_20KBPS_CFG2;
391  cfg3 = MCP_8MHZ_20KBPS_CFG3;
392  break;
393  case (canbus::CAN_31K25BPS): // 31.25KBPS
394  cfg1 = MCP_8MHZ_31K25BPS_CFG1;
395  cfg2 = MCP_8MHZ_31K25BPS_CFG2;
396  cfg3 = MCP_8MHZ_31K25BPS_CFG3;
397  break;
398  case (canbus::CAN_33KBPS): // 33.333KBPS
399  cfg1 = MCP_8MHZ_33K3BPS_CFG1;
400  cfg2 = MCP_8MHZ_33K3BPS_CFG2;
401  cfg3 = MCP_8MHZ_33K3BPS_CFG3;
402  break;
403  case (canbus::CAN_40KBPS): // 40Kbps
404  cfg1 = MCP_8MHZ_40KBPS_CFG1;
405  cfg2 = MCP_8MHZ_40KBPS_CFG2;
406  cfg3 = MCP_8MHZ_40KBPS_CFG3;
407  break;
408  case (canbus::CAN_50KBPS): // 50Kbps
409  cfg1 = MCP_8MHZ_50KBPS_CFG1;
410  cfg2 = MCP_8MHZ_50KBPS_CFG2;
411  cfg3 = MCP_8MHZ_50KBPS_CFG3;
412  break;
413  case (canbus::CAN_80KBPS): // 80Kbps
414  cfg1 = MCP_8MHZ_80KBPS_CFG1;
415  cfg2 = MCP_8MHZ_80KBPS_CFG2;
416  cfg3 = MCP_8MHZ_80KBPS_CFG3;
417  break;
418  case (canbus::CAN_100KBPS): // 100Kbps
419  cfg1 = MCP_8MHZ_100KBPS_CFG1;
420  cfg2 = MCP_8MHZ_100KBPS_CFG2;
421  cfg3 = MCP_8MHZ_100KBPS_CFG3;
422  break;
423  case (canbus::CAN_125KBPS): // 125Kbps
424  cfg1 = MCP_8MHZ_125KBPS_CFG1;
425  cfg2 = MCP_8MHZ_125KBPS_CFG2;
426  cfg3 = MCP_8MHZ_125KBPS_CFG3;
427  break;
428  case (canbus::CAN_200KBPS): // 200Kbps
429  cfg1 = MCP_8MHZ_200KBPS_CFG1;
430  cfg2 = MCP_8MHZ_200KBPS_CFG2;
431  cfg3 = MCP_8MHZ_200KBPS_CFG3;
432  break;
433  case (canbus::CAN_250KBPS): // 250Kbps
434  cfg1 = MCP_8MHZ_250KBPS_CFG1;
435  cfg2 = MCP_8MHZ_250KBPS_CFG2;
436  cfg3 = MCP_8MHZ_250KBPS_CFG3;
437  break;
438  case (canbus::CAN_500KBPS): // 500Kbps
439  cfg1 = MCP_8MHZ_500KBPS_CFG1;
440  cfg2 = MCP_8MHZ_500KBPS_CFG2;
441  cfg3 = MCP_8MHZ_500KBPS_CFG3;
442  break;
443  case (canbus::CAN_1000KBPS): // 1Mbps
444  cfg1 = MCP_8MHZ_1000KBPS_CFG1;
445  cfg2 = MCP_8MHZ_1000KBPS_CFG2;
446  cfg3 = MCP_8MHZ_1000KBPS_CFG3;
447  break;
448  default:
449  set = 0;
450  break;
451  }
452  break;
453 
454  case (MCP_16MHZ):
455  switch (can_speed) {
456  case (canbus::CAN_5KBPS): // 5Kbps
457  cfg1 = MCP_16MHZ_5KBPS_CFG1;
458  cfg2 = MCP_16MHZ_5KBPS_CFG2;
459  cfg3 = MCP_16MHZ_5KBPS_CFG3;
460  break;
461  case (canbus::CAN_10KBPS): // 10Kbps
462  cfg1 = MCP_16MHZ_10KBPS_CFG1;
463  cfg2 = MCP_16MHZ_10KBPS_CFG2;
464  cfg3 = MCP_16MHZ_10KBPS_CFG3;
465  break;
466  case (canbus::CAN_20KBPS): // 20Kbps
467  cfg1 = MCP_16MHZ_20KBPS_CFG1;
468  cfg2 = MCP_16MHZ_20KBPS_CFG2;
469  cfg3 = MCP_16MHZ_20KBPS_CFG3;
470  break;
471  case (canbus::CAN_33KBPS): // 33.333Kbps
472  cfg1 = MCP_16MHZ_33K3BPS_CFG1;
473  cfg2 = MCP_16MHZ_33K3BPS_CFG2;
474  cfg3 = MCP_16MHZ_33K3BPS_CFG3;
475  break;
476  case (canbus::CAN_40KBPS): // 40Kbps
477  cfg1 = MCP_16MHZ_40KBPS_CFG1;
478  cfg2 = MCP_16MHZ_40KBPS_CFG2;
479  cfg3 = MCP_16MHZ_40KBPS_CFG3;
480  break;
481  case (canbus::CAN_50KBPS): // 50Kbps
482  cfg2 = MCP_16MHZ_50KBPS_CFG2;
483  cfg3 = MCP_16MHZ_50KBPS_CFG3;
484  break;
485  case (canbus::CAN_80KBPS): // 80Kbps
486  cfg1 = MCP_16MHZ_80KBPS_CFG1;
487  cfg2 = MCP_16MHZ_80KBPS_CFG2;
488  cfg3 = MCP_16MHZ_80KBPS_CFG3;
489  break;
490  case (canbus::CAN_83K3BPS): // 83.333Kbps
491  cfg1 = MCP_16MHZ_83K3BPS_CFG1;
492  cfg2 = MCP_16MHZ_83K3BPS_CFG2;
493  cfg3 = MCP_16MHZ_83K3BPS_CFG3;
494  break;
495  case (canbus::CAN_100KBPS): // 100Kbps
496  cfg1 = MCP_16MHZ_100KBPS_CFG1;
497  cfg2 = MCP_16MHZ_100KBPS_CFG2;
498  cfg3 = MCP_16MHZ_100KBPS_CFG3;
499  break;
500  case (canbus::CAN_125KBPS): // 125Kbps
501  cfg1 = MCP_16MHZ_125KBPS_CFG1;
502  cfg2 = MCP_16MHZ_125KBPS_CFG2;
503  cfg3 = MCP_16MHZ_125KBPS_CFG3;
504  break;
505  case (canbus::CAN_200KBPS): // 200Kbps
506  cfg1 = MCP_16MHZ_200KBPS_CFG1;
507  cfg2 = MCP_16MHZ_200KBPS_CFG2;
508  cfg3 = MCP_16MHZ_200KBPS_CFG3;
509  break;
510  case (canbus::CAN_250KBPS): // 250Kbps
511  cfg1 = MCP_16MHZ_250KBPS_CFG1;
512  cfg2 = MCP_16MHZ_250KBPS_CFG2;
513  cfg3 = MCP_16MHZ_250KBPS_CFG3;
514  break;
515  case (canbus::CAN_500KBPS): // 500Kbps
516  cfg1 = MCP_16MHZ_500KBPS_CFG1;
517  cfg2 = MCP_16MHZ_500KBPS_CFG2;
518  cfg3 = MCP_16MHZ_500KBPS_CFG3;
519  break;
520  case (canbus::CAN_1000KBPS): // 1Mbps
521  cfg1 = MCP_16MHZ_1000KBPS_CFG1;
522  cfg2 = MCP_16MHZ_1000KBPS_CFG2;
523  cfg3 = MCP_16MHZ_1000KBPS_CFG3;
524  break;
525  default:
526  set = 0;
527  break;
528  }
529  break;
530 
531  case (MCP_20MHZ):
532  switch (can_speed) {
533  case (canbus::CAN_33KBPS): // 33.333Kbps
534  cfg1 = MCP_20MHZ_33K3BPS_CFG1;
535  cfg2 = MCP_20MHZ_33K3BPS_CFG2;
536  cfg3 = MCP_20MHZ_33K3BPS_CFG3;
537  break;
538  case (canbus::CAN_40KBPS): // 40Kbps
539  cfg1 = MCP_20MHZ_40KBPS_CFG1;
540  cfg2 = MCP_20MHZ_40KBPS_CFG2;
541  cfg3 = MCP_20MHZ_40KBPS_CFG3;
542  break;
543  case (canbus::CAN_50KBPS): // 50Kbps
544  cfg1 = MCP_20MHZ_50KBPS_CFG1;
545  cfg2 = MCP_20MHZ_50KBPS_CFG2;
546  cfg3 = MCP_20MHZ_50KBPS_CFG3;
547  break;
548  case (canbus::CAN_80KBPS): // 80Kbps
549  cfg1 = MCP_20MHZ_80KBPS_CFG1;
550  cfg2 = MCP_20MHZ_80KBPS_CFG2;
551  cfg3 = MCP_20MHZ_80KBPS_CFG3;
552  break;
553  case (canbus::CAN_83K3BPS): // 83.333Kbps
554  cfg1 = MCP_20MHZ_83K3BPS_CFG1;
555  cfg2 = MCP_20MHZ_83K3BPS_CFG2;
556  cfg3 = MCP_20MHZ_83K3BPS_CFG3;
557  break;
558  case (canbus::CAN_100KBPS): // 100Kbps
559  cfg1 = MCP_20MHZ_100KBPS_CFG1;
560  cfg2 = MCP_20MHZ_100KBPS_CFG2;
561  cfg3 = MCP_20MHZ_100KBPS_CFG3;
562  break;
563  case (canbus::CAN_125KBPS): // 125Kbps
564  cfg1 = MCP_20MHZ_125KBPS_CFG1;
565  cfg2 = MCP_20MHZ_125KBPS_CFG2;
566  cfg3 = MCP_20MHZ_125KBPS_CFG3;
567  break;
568  case (canbus::CAN_200KBPS): // 200Kbps
569  cfg1 = MCP_20MHZ_200KBPS_CFG1;
570  cfg2 = MCP_20MHZ_200KBPS_CFG2;
571  cfg3 = MCP_20MHZ_200KBPS_CFG3;
572  break;
573  case (canbus::CAN_250KBPS): // 250Kbps
574  cfg1 = MCP_20MHZ_250KBPS_CFG1;
575  cfg2 = MCP_20MHZ_250KBPS_CFG2;
576  cfg3 = MCP_20MHZ_250KBPS_CFG3;
577  break;
578  case (canbus::CAN_500KBPS): // 500Kbps
579  cfg1 = MCP_20MHZ_500KBPS_CFG1;
580  cfg2 = MCP_20MHZ_500KBPS_CFG2;
581  cfg3 = MCP_20MHZ_500KBPS_CFG3;
582  break;
583  case (canbus::CAN_1000KBPS): // 1Mbps
584  cfg1 = MCP_20MHZ_1000KBPS_CFG1;
585  cfg2 = MCP_20MHZ_1000KBPS_CFG2;
586  cfg3 = MCP_20MHZ_1000KBPS_CFG3;
587  break;
588  default:
589  set = 0;
590  break;
591  }
592  break;
593 
594  default:
595  set = 0;
596  break;
597  }
598 
599  if (set) {
600  set_register_(MCP_CNF1, cfg1); // NOLINT
601  set_register_(MCP_CNF2, cfg2); // NOLINT
602  set_register_(MCP_CNF3, cfg3); // NOLINT
603  return canbus::ERROR_OK;
604  } else {
605  return canbus::ERROR_FAIL;
606  }
607 }
608 } // namespace mcp2515
609 } // namespace esphome
uint8_t can_data_length_code
Definition: canbus.h:55
T id(T value)
Helper function to make id(var) known from lambdas work in custom components.
Definition: helpers.h:641
uint32_t IRAM_ATTR HOT millis()
Definition: core.cpp:26
bool remote_transmission_request
Definition: canbus.h:53
BedjetMode mode
BedJet operating mode.
Definition: bedjet_codec.h:151
Definition: a4988.cpp:4
void IRAM_ATTR HOT delay(uint32_t ms)
Definition: core.cpp:27