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