[136] | 1 | /*
|
---|
| 2 | mcp_can.cpp
|
---|
| 3 | 2012 Copyright (c) Seeed Technology Inc. All right reserved.
|
---|
| 4 |
|
---|
| 5 | Author:Loovee
|
---|
| 6 | Contributor: Cory J. Fowler
|
---|
| 7 | 2014-1-16
|
---|
| 8 | This library is free software; you can redistribute it and/or
|
---|
| 9 | modify it under the terms of the GNU Lesser General Public
|
---|
| 10 | License as published by the Free Software Foundation; either
|
---|
| 11 | version 2.1 of the License, or (at your option) any later version.
|
---|
| 12 |
|
---|
| 13 | This library is distributed in the hope that it will be useful,
|
---|
| 14 | but WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
| 15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
---|
| 16 | Lesser General Public License for more details.
|
---|
| 17 |
|
---|
| 18 | You should have received a copy of the GNU Lesser General Public
|
---|
| 19 | License along with this library; if not, write to the Free Software
|
---|
| 20 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-
|
---|
| 21 | 1301 USA
|
---|
| 22 | */
|
---|
| 23 | #include "mcp_can.h"
|
---|
| 24 |
|
---|
[195] | 25 | #ifdef TOPPERS_WITH_ARDUINO
|
---|
[260] | 26 | #include "r2ca.h"
|
---|
[195] | 27 | #define ENTER_CRITICAL wai_sem(SPI_SEM);
|
---|
| 28 | #define LEAVE_CRITICAL sig_sem(SPI_SEM);
|
---|
| 29 | #else /* !TOPPERS_WITH_ARDUINO */
|
---|
| 30 | #define WAIT_TIMEOUT
|
---|
| 31 | #define ENTER_CRITICAL
|
---|
| 32 | #define LEAVE_CRITICAL
|
---|
| 33 | #endif /* TOPPERS_WITH_ARDUINO */
|
---|
| 34 |
|
---|
[136] | 35 | #define spi_readwrite SPI.transfer
|
---|
| 36 | #define spi_read() spi_readwrite(0x00)
|
---|
| 37 |
|
---|
| 38 | #define CHECK_RXBID(rxbid) do { \
|
---|
| 39 | if (!((rxbid == 0) || (rxbid == 1))) { \
|
---|
| 40 | return CAN_FAIL; \
|
---|
| 41 | } \
|
---|
| 42 | } while(false)
|
---|
| 43 |
|
---|
| 44 | #define CHECK_LEN(len) do { \
|
---|
| 45 | if (len > 8) { \
|
---|
| 46 | return CAN_FAIL; \
|
---|
| 47 | } \
|
---|
| 48 | } while(false)
|
---|
| 49 |
|
---|
| 50 | #define CHECK_TXBID(txbid) do { \
|
---|
| 51 | if (!((txbid == 0) || (txbid == 1) || (txbid == 2))) { \
|
---|
| 52 | return CAN_FAIL; \
|
---|
| 53 | } \
|
---|
| 54 | } while(false)
|
---|
| 55 |
|
---|
| 56 | /*********************************************************************************************************
|
---|
| 57 | ** Function name: mcp2515_reset
|
---|
| 58 | ** Descriptions: reset the device
|
---|
| 59 | *********************************************************************************************************/
|
---|
| 60 | void MCP_CAN::mcp2515_reset(void)
|
---|
| 61 | {
|
---|
| 62 | MCP2515_SELECT();
|
---|
| 63 | spi_readwrite(MCP_RESET);
|
---|
| 64 | MCP2515_UNSELECT();
|
---|
| 65 | delay(10);
|
---|
| 66 | }
|
---|
| 67 |
|
---|
| 68 | /*********************************************************************************************************
|
---|
| 69 | ** Function name: mcp2515_readRegister
|
---|
| 70 | ** Descriptions: read register
|
---|
| 71 | *********************************************************************************************************/
|
---|
| 72 | INT8U MCP_CAN::mcp2515_readRegister(const INT8U address)
|
---|
| 73 | {
|
---|
| 74 | INT8U ret;
|
---|
| 75 |
|
---|
| 76 | MCP2515_SELECT();
|
---|
| 77 | spi_readwrite(MCP_READ);
|
---|
| 78 | spi_readwrite(address);
|
---|
| 79 | ret = spi_read();
|
---|
| 80 | MCP2515_UNSELECT();
|
---|
| 81 |
|
---|
| 82 | return ret;
|
---|
| 83 | }
|
---|
| 84 |
|
---|
| 85 | /*********************************************************************************************************
|
---|
| 86 | ** Function name: mcp2515_readRegisterS
|
---|
| 87 | ** Descriptions: read registerS
|
---|
| 88 | *********************************************************************************************************/
|
---|
| 89 | void MCP_CAN::mcp2515_readRegisterS(const INT8U address, INT8U values[], const INT8U n)
|
---|
| 90 | {
|
---|
| 91 | INT8U i;
|
---|
| 92 | MCP2515_SELECT();
|
---|
| 93 | spi_readwrite(MCP_READ);
|
---|
| 94 | spi_readwrite(address);
|
---|
| 95 | // mcp2515 has auto-increment of address-pointer
|
---|
| 96 | for (i=0; i<n && i<CAN_MAX_CHAR_IN_MESSAGE; i++) {
|
---|
| 97 | values[i] = spi_read();
|
---|
| 98 | }
|
---|
| 99 | MCP2515_UNSELECT();
|
---|
| 100 | }
|
---|
| 101 |
|
---|
| 102 | /*********************************************************************************************************
|
---|
| 103 | ** Function name: mcp2515_setRegister
|
---|
| 104 | ** Descriptions: set register
|
---|
| 105 | *********************************************************************************************************/
|
---|
| 106 | void MCP_CAN::mcp2515_setRegister(const INT8U address, const INT8U value)
|
---|
| 107 | {
|
---|
| 108 | MCP2515_SELECT();
|
---|
| 109 | spi_readwrite(MCP_WRITE);
|
---|
| 110 | spi_readwrite(address);
|
---|
| 111 | spi_readwrite(value);
|
---|
| 112 | MCP2515_UNSELECT();
|
---|
| 113 | }
|
---|
| 114 |
|
---|
| 115 | /*********************************************************************************************************
|
---|
| 116 | ** Function name: mcp2515_setRegisterS
|
---|
| 117 | ** Descriptions: set registerS
|
---|
| 118 | *********************************************************************************************************/
|
---|
| 119 | void MCP_CAN::mcp2515_setRegisterS(const INT8U address, const INT8U values[], const INT8U n)
|
---|
| 120 | {
|
---|
| 121 | INT8U i;
|
---|
| 122 | MCP2515_SELECT();
|
---|
| 123 | spi_readwrite(MCP_WRITE);
|
---|
| 124 | spi_readwrite(address);
|
---|
| 125 |
|
---|
| 126 | for (i=0; i<n; i++)
|
---|
| 127 | {
|
---|
| 128 | spi_readwrite(values[i]);
|
---|
| 129 | }
|
---|
| 130 | MCP2515_UNSELECT();
|
---|
| 131 | }
|
---|
| 132 |
|
---|
| 133 | /*********************************************************************************************************
|
---|
| 134 | ** Function name: mcp2515_modifyRegister
|
---|
| 135 | ** Descriptions: set bit of one register
|
---|
| 136 | *********************************************************************************************************/
|
---|
| 137 | void MCP_CAN::mcp2515_modifyRegister(const INT8U address, const INT8U mask, const INT8U data)
|
---|
| 138 | {
|
---|
| 139 | MCP2515_SELECT();
|
---|
| 140 | spi_readwrite(MCP_BITMOD);
|
---|
| 141 | spi_readwrite(address);
|
---|
| 142 | spi_readwrite(mask);
|
---|
| 143 | spi_readwrite(data);
|
---|
| 144 | MCP2515_UNSELECT();
|
---|
| 145 | }
|
---|
| 146 |
|
---|
| 147 | /*********************************************************************************************************
|
---|
| 148 | ** Function name: mcp2515_readStatus
|
---|
| 149 | ** Descriptions: read mcp2515's Status
|
---|
| 150 | *********************************************************************************************************/
|
---|
| 151 | INT8U MCP_CAN::mcp2515_readStatus(void)
|
---|
| 152 | {
|
---|
| 153 | INT8U i;
|
---|
| 154 | MCP2515_SELECT();
|
---|
| 155 | spi_readwrite(MCP_READ_STATUS);
|
---|
| 156 | i = spi_read();
|
---|
| 157 | MCP2515_UNSELECT();
|
---|
| 158 |
|
---|
| 159 | return i;
|
---|
| 160 | }
|
---|
| 161 |
|
---|
| 162 | /*********************************************************************************************************
|
---|
| 163 | ** Function name: mcp2515_setCANCTRL_Mode
|
---|
| 164 | ** Descriptions: set control mode
|
---|
| 165 | *********************************************************************************************************/
|
---|
| 166 | INT8U MCP_CAN::mcp2515_setCANCTRL_Mode(const INT8U newmode)
|
---|
| 167 | {
|
---|
| 168 | INT8U i;
|
---|
| 169 |
|
---|
| 170 | mcp2515_modifyRegister(MCP_CANCTRL, MODE_MASK, newmode);
|
---|
| 171 |
|
---|
| 172 | i = mcp2515_readRegister(MCP_CANCTRL);
|
---|
| 173 | i &= MODE_MASK;
|
---|
| 174 |
|
---|
| 175 | if ( i == newmode )
|
---|
| 176 | {
|
---|
| 177 | return MCP2515_OK;
|
---|
| 178 | }
|
---|
| 179 |
|
---|
| 180 | return MCP2515_FAIL;
|
---|
| 181 |
|
---|
| 182 | }
|
---|
| 183 |
|
---|
| 184 | /*********************************************************************************************************
|
---|
| 185 | ** Function name: mcp2515_configRate
|
---|
| 186 | ** Descriptions: set boadrate
|
---|
| 187 | *********************************************************************************************************/
|
---|
| 188 | INT8U MCP_CAN::mcp2515_configRate(const INT8U canSpeed)
|
---|
| 189 | {
|
---|
| 190 | INT8U set, cfg1, cfg2, cfg3;
|
---|
| 191 | set = 1;
|
---|
| 192 | switch (canSpeed)
|
---|
| 193 | {
|
---|
| 194 | case (CAN_5KBPS):
|
---|
| 195 | cfg1 = MCP_16MHz_5kBPS_CFG1;
|
---|
| 196 | cfg2 = MCP_16MHz_5kBPS_CFG2;
|
---|
| 197 | cfg3 = MCP_16MHz_5kBPS_CFG3;
|
---|
| 198 | break;
|
---|
| 199 |
|
---|
| 200 | case (CAN_10KBPS):
|
---|
| 201 | cfg1 = MCP_16MHz_10kBPS_CFG1;
|
---|
| 202 | cfg2 = MCP_16MHz_10kBPS_CFG2;
|
---|
| 203 | cfg3 = MCP_16MHz_10kBPS_CFG3;
|
---|
| 204 | break;
|
---|
| 205 |
|
---|
| 206 | case (CAN_20KBPS):
|
---|
| 207 | cfg1 = MCP_16MHz_20kBPS_CFG1;
|
---|
| 208 | cfg2 = MCP_16MHz_20kBPS_CFG2;
|
---|
| 209 | cfg3 = MCP_16MHz_20kBPS_CFG3;
|
---|
| 210 | break;
|
---|
| 211 |
|
---|
| 212 | case (CAN_31K25BPS):
|
---|
| 213 | cfg1 = MCP_16MHz_31k25BPS_CFG1;
|
---|
| 214 | cfg2 = MCP_16MHz_31k25BPS_CFG2;
|
---|
| 215 | cfg3 = MCP_16MHz_31k25BPS_CFG3;
|
---|
| 216 | break;
|
---|
| 217 |
|
---|
| 218 | case (CAN_33KBPS):
|
---|
| 219 | cfg1 = MCP_16MHz_33kBPS_CFG1;
|
---|
| 220 | cfg2 = MCP_16MHz_33kBPS_CFG2;
|
---|
| 221 | cfg3 = MCP_16MHz_33kBPS_CFG3;
|
---|
| 222 | break;
|
---|
| 223 |
|
---|
| 224 | case (CAN_40KBPS):
|
---|
| 225 | cfg1 = MCP_16MHz_40kBPS_CFG1;
|
---|
| 226 | cfg2 = MCP_16MHz_40kBPS_CFG2;
|
---|
| 227 | cfg3 = MCP_16MHz_40kBPS_CFG3;
|
---|
| 228 | break;
|
---|
| 229 |
|
---|
| 230 | case (CAN_50KBPS):
|
---|
| 231 | cfg1 = MCP_16MHz_50kBPS_CFG1;
|
---|
| 232 | cfg2 = MCP_16MHz_50kBPS_CFG2;
|
---|
| 233 | cfg3 = MCP_16MHz_50kBPS_CFG3;
|
---|
| 234 | break;
|
---|
| 235 |
|
---|
| 236 | case (CAN_80KBPS):
|
---|
| 237 | cfg1 = MCP_16MHz_80kBPS_CFG1;
|
---|
| 238 | cfg2 = MCP_16MHz_80kBPS_CFG2;
|
---|
| 239 | cfg3 = MCP_16MHz_80kBPS_CFG3;
|
---|
| 240 | break;
|
---|
| 241 |
|
---|
| 242 | case (CAN_83K3BPS):
|
---|
| 243 | cfg1 = MCP_16MHz_83k3BPS_CFG1;
|
---|
| 244 | cfg2 = MCP_16MHz_83k3BPS_CFG2;
|
---|
| 245 | cfg3 = MCP_16MHz_83k3BPS_CFG3;
|
---|
| 246 | break;
|
---|
| 247 |
|
---|
| 248 | case (CAN_95KBPS):
|
---|
| 249 | cfg1 = MCP_16MHz_95kBPS_CFG1;
|
---|
| 250 | cfg2 = MCP_16MHz_95kBPS_CFG2;
|
---|
| 251 | cfg3 = MCP_16MHz_95kBPS_CFG3;
|
---|
| 252 | break;
|
---|
| 253 |
|
---|
| 254 | case (CAN_100KBPS): /* 100KBPS */
|
---|
| 255 | cfg1 = MCP_16MHz_100kBPS_CFG1;
|
---|
| 256 | cfg2 = MCP_16MHz_100kBPS_CFG2;
|
---|
| 257 | cfg3 = MCP_16MHz_100kBPS_CFG3;
|
---|
| 258 | break;
|
---|
| 259 |
|
---|
| 260 | case (CAN_125KBPS):
|
---|
| 261 | cfg1 = MCP_16MHz_125kBPS_CFG1;
|
---|
| 262 | cfg2 = MCP_16MHz_125kBPS_CFG2;
|
---|
| 263 | cfg3 = MCP_16MHz_125kBPS_CFG3;
|
---|
| 264 | break;
|
---|
| 265 |
|
---|
| 266 | case (CAN_200KBPS):
|
---|
| 267 | cfg1 = MCP_16MHz_200kBPS_CFG1;
|
---|
| 268 | cfg2 = MCP_16MHz_200kBPS_CFG2;
|
---|
| 269 | cfg3 = MCP_16MHz_200kBPS_CFG3;
|
---|
| 270 | break;
|
---|
| 271 |
|
---|
| 272 | case (CAN_250KBPS):
|
---|
| 273 | cfg1 = MCP_16MHz_250kBPS_CFG1;
|
---|
| 274 | cfg2 = MCP_16MHz_250kBPS_CFG2;
|
---|
| 275 | cfg3 = MCP_16MHz_250kBPS_CFG3;
|
---|
| 276 | break;
|
---|
| 277 |
|
---|
| 278 | case (CAN_500KBPS):
|
---|
| 279 | cfg1 = MCP_16MHz_500kBPS_CFG1;
|
---|
| 280 | cfg2 = MCP_16MHz_500kBPS_CFG2;
|
---|
| 281 | cfg3 = MCP_16MHz_500kBPS_CFG3;
|
---|
| 282 | break;
|
---|
| 283 |
|
---|
| 284 | case (CAN_1000KBPS):
|
---|
| 285 | cfg1 = MCP_16MHz_1000kBPS_CFG1;
|
---|
| 286 | cfg2 = MCP_16MHz_1000kBPS_CFG2;
|
---|
| 287 | cfg3 = MCP_16MHz_1000kBPS_CFG3;
|
---|
| 288 | break;
|
---|
| 289 |
|
---|
| 290 | default:
|
---|
| 291 | set = 0;
|
---|
| 292 | break;
|
---|
| 293 | }
|
---|
| 294 |
|
---|
| 295 | if (set) {
|
---|
| 296 | mcp2515_setRegister(MCP_CNF1, cfg1);
|
---|
| 297 | mcp2515_setRegister(MCP_CNF2, cfg2);
|
---|
| 298 | mcp2515_setRegister(MCP_CNF3, cfg3);
|
---|
| 299 | return MCP2515_OK;
|
---|
| 300 | }
|
---|
| 301 | else {
|
---|
| 302 | return MCP2515_FAIL;
|
---|
| 303 | }
|
---|
| 304 | }
|
---|
| 305 |
|
---|
| 306 | /*********************************************************************************************************
|
---|
| 307 | ** Function name: mcp2515_initCANBuffers
|
---|
| 308 | ** Descriptions: init canbuffers
|
---|
| 309 | *********************************************************************************************************/
|
---|
| 310 | void MCP_CAN::mcp2515_initCANBuffers(void)
|
---|
| 311 | {
|
---|
| 312 | INT8U i, a1, a2, a3;
|
---|
| 313 |
|
---|
| 314 | INT8U std = 0;
|
---|
| 315 | INT8U ext = 1;
|
---|
| 316 | INT32U ulMask = 0xffffffff, ulFilt = 0x00;
|
---|
| 317 |
|
---|
| 318 |
|
---|
| 319 | mcp2515_write_id(MCP_RXM0SIDH, ext, ulMask); /*Set both masks to 0xff */
|
---|
| 320 | mcp2515_write_id(MCP_RXM1SIDH, ext, ulMask); /*Mask register ignores ext bit */
|
---|
| 321 |
|
---|
| 322 | /* Set all filters to 0 */
|
---|
| 323 | mcp2515_write_id(MCP_RXF0SIDH, std, ulFilt); /* RXB0: standard */
|
---|
| 324 | mcp2515_write_id(MCP_RXF1SIDH, std, ulFilt); /* RXB1: standard */
|
---|
| 325 | mcp2515_write_id(MCP_RXF2SIDH, std, ulFilt); /* RXB2: standard */
|
---|
| 326 | mcp2515_write_id(MCP_RXF3SIDH, std, ulFilt); /* RXB3: standard */
|
---|
| 327 | mcp2515_write_id(MCP_RXF4SIDH, std, ulFilt);
|
---|
| 328 | mcp2515_write_id(MCP_RXF5SIDH, std, ulFilt);
|
---|
| 329 |
|
---|
| 330 | /* Clear, deactivate the three */
|
---|
| 331 | /* transmit buffers */
|
---|
| 332 | /* TXBnCTRL -> TXBnD7 */
|
---|
| 333 | a1 = MCP_TXB0CTRL;
|
---|
| 334 | a2 = MCP_TXB1CTRL;
|
---|
| 335 | a3 = MCP_TXB2CTRL;
|
---|
| 336 | for (i = 0; i < 14; i++) { /* in-buffer loop */
|
---|
| 337 | mcp2515_setRegister(a1, 0);
|
---|
| 338 | mcp2515_setRegister(a2, 0);
|
---|
| 339 | mcp2515_setRegister(a3, 0);
|
---|
| 340 | a1++;
|
---|
| 341 | a2++;
|
---|
| 342 | a3++;
|
---|
| 343 | }
|
---|
| 344 | mcp2515_setRegister(MCP_RXB0CTRL, 0x00);
|
---|
| 345 | mcp2515_setRegister(MCP_RXB1CTRL, 0xff);
|
---|
| 346 | }
|
---|
| 347 |
|
---|
| 348 | /*********************************************************************************************************
|
---|
| 349 | ** Function name: mcp2515_init
|
---|
| 350 | ** Descriptions: init the device
|
---|
| 351 | *********************************************************************************************************/
|
---|
| 352 | INT8U MCP_CAN::mcp2515_init(const INT8U canSpeed) /* mcp2515init */
|
---|
| 353 | {
|
---|
| 354 |
|
---|
| 355 | INT8U res;
|
---|
| 356 |
|
---|
| 357 | mcp2515_reset();
|
---|
| 358 |
|
---|
| 359 | res = mcp2515_setCANCTRL_Mode(MODE_CONFIG);
|
---|
| 360 | if(res > 0)
|
---|
| 361 | {
|
---|
| 362 | #if DEBUG_MODE
|
---|
| 363 | Serial.print("Enter setting mode fall\r\n");
|
---|
| 364 | #endif
|
---|
| 365 | return res;
|
---|
| 366 | }
|
---|
| 367 | #if DEBUG_MODE
|
---|
| 368 | Serial.print("Enter setting mode success \r\n");
|
---|
| 369 | #endif
|
---|
| 370 |
|
---|
| 371 | if(mcp2515_configRate(canSpeed))
|
---|
| 372 | {
|
---|
| 373 | #if DEBUG_MODE
|
---|
| 374 | Serial.print("set rate fall!!\r\n");
|
---|
| 375 | #endif
|
---|
| 376 | return res;
|
---|
| 377 | }
|
---|
| 378 | #if DEBUG_MODE
|
---|
| 379 | Serial.print("set rate success!!\r\n");
|
---|
| 380 | #endif
|
---|
| 381 |
|
---|
| 382 | if ( res == MCP2515_OK ) {
|
---|
| 383 |
|
---|
| 384 | /* init canbuffers */
|
---|
| 385 | mcp2515_initCANBuffers();
|
---|
| 386 |
|
---|
| 387 | /* interrupt mode */
|
---|
| 388 | mcp2515_setRegister(MCP_CANINTE, 0x00);
|
---|
| 389 |
|
---|
| 390 | /* enter normal mode */
|
---|
| 391 | res = mcp2515_setCANCTRL_Mode(MODE_NORMAL);
|
---|
| 392 | if(res)
|
---|
| 393 | {
|
---|
| 394 | #if DEBUG_MODE
|
---|
| 395 | Serial.print("Enter Normal Mode Fall!!\r\n");
|
---|
| 396 | #endif
|
---|
| 397 | return res;
|
---|
| 398 | }
|
---|
| 399 |
|
---|
| 400 |
|
---|
| 401 | #if DEBUG_MODE
|
---|
| 402 | Serial.print("Enter Normal Mode Success!!\r\n");
|
---|
| 403 | #endif
|
---|
| 404 |
|
---|
| 405 | }
|
---|
| 406 | return res;
|
---|
| 407 |
|
---|
| 408 | }
|
---|
| 409 |
|
---|
| 410 | /*********************************************************************************************************
|
---|
| 411 | ** Function name: mcp2515_write_id
|
---|
| 412 | ** Descriptions: write can id
|
---|
| 413 | *********************************************************************************************************/
|
---|
| 414 | void MCP_CAN::mcp2515_write_id( const INT8U mcp_addr, const INT8U ext, const INT32U id )
|
---|
| 415 | {
|
---|
| 416 | uint16_t canid;
|
---|
| 417 | INT8U tbufdata[4];
|
---|
| 418 |
|
---|
| 419 | canid = (uint16_t)(id & 0x0FFFF);
|
---|
| 420 |
|
---|
| 421 | if ( ext == 1)
|
---|
| 422 | {
|
---|
| 423 | tbufdata[MCP_EID0] = (INT8U) (canid & 0xFF);
|
---|
| 424 | tbufdata[MCP_EID8] = (INT8U) (canid >> 8);
|
---|
| 425 | canid = (uint16_t)(id >> 16);
|
---|
| 426 | tbufdata[MCP_SIDL] = (INT8U) (canid & 0x03);
|
---|
| 427 | tbufdata[MCP_SIDL] += (INT8U) ((canid & 0x1C) << 3);
|
---|
| 428 | tbufdata[MCP_SIDL] |= MCP_TXB_EXIDE_M;
|
---|
| 429 | tbufdata[MCP_SIDH] = (INT8U) (canid >> 5 );
|
---|
| 430 | }
|
---|
| 431 | else
|
---|
| 432 | {
|
---|
| 433 | tbufdata[MCP_SIDH] = (INT8U) (canid >> 3 );
|
---|
| 434 | tbufdata[MCP_SIDL] = (INT8U) ((canid & 0x07 ) << 5);
|
---|
| 435 | tbufdata[MCP_EID0] = 0;
|
---|
| 436 | tbufdata[MCP_EID8] = 0;
|
---|
| 437 | }
|
---|
| 438 | mcp2515_setRegisterS( mcp_addr, tbufdata, 4 );
|
---|
| 439 | }
|
---|
| 440 |
|
---|
| 441 | /*********************************************************************************************************
|
---|
| 442 | ** Function name: mcp2515_read_id
|
---|
| 443 | ** Descriptions: read can id
|
---|
| 444 | *********************************************************************************************************/
|
---|
| 445 | void MCP_CAN::mcp2515_read_id( const INT8U mcp_addr, INT8U* ext, INT32U* id )
|
---|
| 446 | {
|
---|
| 447 | INT8U tbufdata[4];
|
---|
| 448 |
|
---|
| 449 | *ext = 0;
|
---|
| 450 | *id = 0;
|
---|
| 451 |
|
---|
| 452 | mcp2515_readRegisterS( mcp_addr, tbufdata, 4 );
|
---|
| 453 |
|
---|
| 454 | *id = (tbufdata[MCP_SIDH]<<3) + (tbufdata[MCP_SIDL]>>5);
|
---|
| 455 |
|
---|
| 456 | if ( (tbufdata[MCP_SIDL] & MCP_TXB_EXIDE_M) == MCP_TXB_EXIDE_M )
|
---|
| 457 | {
|
---|
| 458 | /* extended id */
|
---|
| 459 | *id = (*id<<2) + (tbufdata[MCP_SIDL] & 0x03);
|
---|
| 460 | *id = (*id<<8) + tbufdata[MCP_EID8];
|
---|
| 461 | *id = (*id<<8) + tbufdata[MCP_EID0];
|
---|
| 462 | *ext = 1;
|
---|
| 463 | }
|
---|
| 464 | }
|
---|
| 465 |
|
---|
| 466 | /*********************************************************************************************************
|
---|
| 467 | ** Function name: mcp2515_write_canMsg
|
---|
| 468 | ** Descriptions: write msg
|
---|
| 469 | *********************************************************************************************************/
|
---|
| 470 | void MCP_CAN::mcp2515_write_canMsg( INT8U txbid, INT32U id, INT8U len, INT8U *pData, INT8U ext, INT8U rtr )
|
---|
| 471 | {
|
---|
| 472 | INT8U ctrlregs[MCP_N_TXBUFFERS] = { MCP_TXB0CTRL, MCP_TXB1CTRL, MCP_TXB2CTRL };
|
---|
| 473 | INT8U mcp_addr = ctrlregs[txbid] + 1;
|
---|
| 474 |
|
---|
| 475 | mcp2515_setRegisterS(mcp_addr+5, pData, len ); /* write data bytes */
|
---|
| 476 | if ( rtr == 1) /* if RTR set bit in byte */
|
---|
| 477 | {
|
---|
| 478 | len |= MCP_RTR_MASK;
|
---|
| 479 | }
|
---|
| 480 | mcp2515_setRegister((mcp_addr+4), len ); /* write the RTR and DLC */
|
---|
| 481 | mcp2515_write_id(mcp_addr, ext, id ); /* write CAN id */
|
---|
| 482 |
|
---|
| 483 | }
|
---|
| 484 |
|
---|
| 485 | /*********************************************************************************************************
|
---|
| 486 | ** Function name: mcp2515_read_canMsg
|
---|
| 487 | ** Descriptions: read message
|
---|
| 488 | *********************************************************************************************************/
|
---|
| 489 | void MCP_CAN::mcp2515_read_canMsg( INT8U rxbid, INT32U *p_id, INT8U *p_len, INT8U *p_buf, INT8U *p_ext, INT8U *p_rtr) /* read can msg */
|
---|
| 490 | {
|
---|
| 491 | INT8U mcp_addr = (rxbid == 0)? MCP_RXBUF_0 : MCP_RXBUF_1;
|
---|
| 492 | INT8U ctrl;
|
---|
| 493 |
|
---|
| 494 | mcp2515_read_id( mcp_addr, p_ext, p_id );
|
---|
| 495 |
|
---|
| 496 | ctrl = mcp2515_readRegister( mcp_addr-1 );
|
---|
| 497 | *p_len = mcp2515_readRegister( mcp_addr+4 );
|
---|
| 498 |
|
---|
| 499 | if ((ctrl & 0x08)) {
|
---|
| 500 | *p_rtr = 1;
|
---|
| 501 | }
|
---|
| 502 | else {
|
---|
| 503 | *p_rtr = 0;
|
---|
| 504 | }
|
---|
| 505 |
|
---|
| 506 | *p_len &= MCP_DLC_MASK;
|
---|
| 507 | mcp2515_readRegisterS( mcp_addr+5, p_buf, *p_len );
|
---|
| 508 | }
|
---|
| 509 |
|
---|
| 510 | /*********************************************************************************************************
|
---|
| 511 | ** Function name: sendMsg
|
---|
| 512 | ** Descriptions: send message
|
---|
| 513 | *********************************************************************************************************/
|
---|
| 514 | void MCP_CAN::mcp2515_start_transmit(INT8U txbid) /* start transmit */
|
---|
| 515 | {
|
---|
| 516 | INT8U ctrlregs[MCP_N_TXBUFFERS] = { MCP_TXB0CTRL, MCP_TXB1CTRL, MCP_TXB2CTRL };
|
---|
| 517 | INT8U mcp_addr = ctrlregs[txbid];
|
---|
| 518 |
|
---|
| 519 | mcp2515_modifyRegister( mcp_addr, MCP_TXB_TXREQ_M, MCP_TXB_TXREQ_M );
|
---|
| 520 | }
|
---|
| 521 |
|
---|
| 522 | /*********************************************************************************************************
|
---|
| 523 | ** Function name: sendMsg
|
---|
| 524 | ** Descriptions: send message
|
---|
| 525 | *********************************************************************************************************/
|
---|
| 526 | INT8U MCP_CAN::mcp2515_getNextFreeTXBuf(INT8U *txbuf_n) /* get Next free txbuf */
|
---|
| 527 | {
|
---|
| 528 | INT8U res, i, ctrlval;
|
---|
| 529 | INT8U ctrlregs[MCP_N_TXBUFFERS] = { MCP_TXB0CTRL, MCP_TXB1CTRL, MCP_TXB2CTRL };
|
---|
| 530 |
|
---|
| 531 | res = MCP_ALLTXBUSY;
|
---|
| 532 | *txbuf_n = 0x00;
|
---|
| 533 |
|
---|
| 534 | /* check all 3 TX-Buffers */
|
---|
| 535 | for (i=0; i<MCP_N_TXBUFFERS; i++) {
|
---|
| 536 | ctrlval = mcp2515_readRegister( ctrlregs[i] );
|
---|
| 537 | if ( (ctrlval & MCP_TXB_TXREQ_M) == 0 ) {
|
---|
| 538 | *txbuf_n = ctrlregs[i]+1; /* return SIDH-address of Buffe */
|
---|
| 539 | /* r */
|
---|
| 540 | res = MCP2515_OK;
|
---|
| 541 | return res; /* ! function exit */
|
---|
| 542 | }
|
---|
| 543 | }
|
---|
| 544 | return res;
|
---|
| 545 | }
|
---|
| 546 |
|
---|
| 547 | /*********************************************************************************************************
|
---|
| 548 | ** Function name: set CS
|
---|
| 549 | ** Descriptions: init CS pin and set UNSELECTED
|
---|
| 550 | *********************************************************************************************************/
|
---|
| 551 | MCP_CAN::MCP_CAN(INT8U _CS)
|
---|
| 552 | {
|
---|
| 553 | SPICS = _CS;
|
---|
| 554 | pinMode(SPICS, OUTPUT);
|
---|
| 555 | MCP2515_UNSELECT();
|
---|
| 556 | }
|
---|
| 557 |
|
---|
| 558 | /*********************************************************************************************************
|
---|
| 559 | ** Function name: init
|
---|
| 560 | ** Descriptions: init can and set speed
|
---|
| 561 | *********************************************************************************************************/
|
---|
| 562 | INT8U MCP_CAN::begin(INT8U speedset)
|
---|
| 563 | {
|
---|
| 564 | INT8U res;
|
---|
[195] | 565 |
|
---|
| 566 | ENTER_CRITICAL
|
---|
[136] | 567 | SPI.begin();
|
---|
| 568 | res = mcp2515_init(speedset);
|
---|
[195] | 569 | LEAVE_CRITICAL
|
---|
| 570 |
|
---|
[136] | 571 | if (res == MCP2515_OK) return CAN_OK;
|
---|
| 572 | else return CAN_FAILINIT;
|
---|
| 573 | }
|
---|
| 574 |
|
---|
| 575 | /*********************************************************************************************************
|
---|
| 576 | ** Function name: enableInterrupt
|
---|
| 577 | ** Descriptions: Enable Interrupt
|
---|
| 578 | *********************************************************************************************************/
|
---|
| 579 | INT8U MCP_CAN::enableInterrupt(INT8U mask)
|
---|
| 580 | {
|
---|
[195] | 581 | ENTER_CRITICAL
|
---|
[136] | 582 | mcp2515_modifyRegister(MCP_CANINTE, mask, mask);
|
---|
[195] | 583 | LEAVE_CRITICAL
|
---|
| 584 |
|
---|
[136] | 585 | return CAN_OK;
|
---|
| 586 | }
|
---|
| 587 |
|
---|
| 588 | /*********************************************************************************************************
|
---|
| 589 | ** Function name: disableInterrupt
|
---|
| 590 | ** Descriptions: Disable Interrupt
|
---|
| 591 | *********************************************************************************************************/
|
---|
| 592 | INT8U MCP_CAN::disableInterrupt(INT8U mask)
|
---|
| 593 | {
|
---|
[195] | 594 | ENTER_CRITICAL
|
---|
[136] | 595 | mcp2515_modifyRegister(MCP_CANINTE, mask, !mask);
|
---|
[195] | 596 | LEAVE_CRITICAL
|
---|
| 597 |
|
---|
[136] | 598 | return CAN_OK;
|
---|
| 599 | }
|
---|
| 600 |
|
---|
| 601 | /*********************************************************************************************************
|
---|
| 602 | ** Function name: attachInterrupt
|
---|
| 603 | ** Descriptions: Attach Interrupt
|
---|
| 604 | *********************************************************************************************************/
|
---|
| 605 | INT8U MCP_CAN::attachInterrupt(uint32_t ulPin, voidFuncPtr callback)
|
---|
| 606 | {
|
---|
| 607 | ::attachInterrupt( ulPin, callback, FALLING ) ;
|
---|
| 608 | return CAN_OK;
|
---|
| 609 | }
|
---|
| 610 |
|
---|
| 611 | /*********************************************************************************************************
|
---|
| 612 | ** Function name: init_Mask
|
---|
| 613 | ** Descriptions: init canid Masks
|
---|
| 614 | *********************************************************************************************************/
|
---|
| 615 | INT8U MCP_CAN::init_Mask(INT8U num, INT32U ulData, INT8U ext)
|
---|
| 616 | {
|
---|
| 617 | INT8U res = MCP2515_OK;
|
---|
[195] | 618 |
|
---|
| 619 | ENTER_CRITICAL;
|
---|
[136] | 620 | #if DEBUG_MODE
|
---|
| 621 | Serial.print("Begin to set Mask!!\r\n");
|
---|
| 622 | #endif
|
---|
| 623 | res = mcp2515_setCANCTRL_Mode(MODE_CONFIG);
|
---|
| 624 | if(res > 0){
|
---|
| 625 | #if DEBUG_MODE
|
---|
| 626 | Serial.print("Enter setting mode fall\r\n");
|
---|
| 627 | #endif
|
---|
[195] | 628 | LEAVE_CRITICAL;
|
---|
[136] | 629 | return res;
|
---|
| 630 | }
|
---|
| 631 |
|
---|
| 632 | if (num == 0){
|
---|
| 633 | mcp2515_write_id(MCP_RXM0SIDH, ext, ulData);
|
---|
| 634 | }
|
---|
| 635 | else if(num == 1){
|
---|
| 636 | mcp2515_write_id(MCP_RXM1SIDH, ext, ulData);
|
---|
| 637 | }
|
---|
| 638 | else res = MCP2515_FAIL;
|
---|
| 639 |
|
---|
| 640 | res = mcp2515_setCANCTRL_Mode(MODE_NORMAL);
|
---|
| 641 | if(res > 0){
|
---|
| 642 | #if DEBUG_MODE
|
---|
| 643 | Serial.print("Enter normal mode fall\r\n");
|
---|
| 644 | #endif
|
---|
[195] | 645 | LEAVE_CRITICAL;
|
---|
[136] | 646 | return res;
|
---|
| 647 | }
|
---|
| 648 | #if DEBUG_MODE
|
---|
| 649 | Serial.print("set Mask success!!\r\n");
|
---|
| 650 | #endif
|
---|
[195] | 651 | LEAVE_CRITICAL;
|
---|
[136] | 652 | return res;
|
---|
| 653 | }
|
---|
| 654 |
|
---|
| 655 | /*********************************************************************************************************
|
---|
| 656 | ** Function name: init_Filter
|
---|
| 657 | ** Descriptions: init canid filters
|
---|
| 658 | *********************************************************************************************************/
|
---|
| 659 | INT8U MCP_CAN::init_Filter(INT8U num, INT32U ulData, INT8U ext)
|
---|
| 660 | {
|
---|
| 661 | INT8U res = MCP2515_OK;
|
---|
[195] | 662 |
|
---|
| 663 | ENTER_CRITICAL;
|
---|
[136] | 664 | #if DEBUG_MODE
|
---|
| 665 | Serial.print("Begin to set Filter!!\r\n");
|
---|
| 666 | #endif
|
---|
| 667 | res = mcp2515_setCANCTRL_Mode(MODE_CONFIG);
|
---|
| 668 | if(res > 0)
|
---|
| 669 | {
|
---|
| 670 | #if DEBUG_MODE
|
---|
| 671 | Serial.print("Enter setting mode fall\r\n");
|
---|
| 672 | #endif
|
---|
[195] | 673 | LEAVE_CRITICAL;
|
---|
[136] | 674 | return res;
|
---|
| 675 | }
|
---|
| 676 |
|
---|
| 677 | switch( num )
|
---|
| 678 | {
|
---|
| 679 | case 0:
|
---|
| 680 | mcp2515_write_id(MCP_RXF0SIDH, ext, ulData);
|
---|
| 681 | break;
|
---|
| 682 |
|
---|
| 683 | case 1:
|
---|
| 684 | mcp2515_write_id(MCP_RXF1SIDH, ext, ulData);
|
---|
| 685 | break;
|
---|
| 686 |
|
---|
| 687 | case 2:
|
---|
| 688 | mcp2515_write_id(MCP_RXF2SIDH, ext, ulData);
|
---|
| 689 | break;
|
---|
| 690 |
|
---|
| 691 | case 3:
|
---|
| 692 | mcp2515_write_id(MCP_RXF3SIDH, ext, ulData);
|
---|
| 693 | break;
|
---|
| 694 |
|
---|
| 695 | case 4:
|
---|
| 696 | mcp2515_write_id(MCP_RXF4SIDH, ext, ulData);
|
---|
| 697 | break;
|
---|
| 698 |
|
---|
| 699 | case 5:
|
---|
| 700 | mcp2515_write_id(MCP_RXF5SIDH, ext, ulData);
|
---|
| 701 | break;
|
---|
| 702 |
|
---|
| 703 | default:
|
---|
| 704 | res = MCP2515_FAIL;
|
---|
| 705 | }
|
---|
| 706 |
|
---|
| 707 | res = mcp2515_setCANCTRL_Mode(MODE_NORMAL);
|
---|
| 708 | if(res > 0)
|
---|
| 709 | {
|
---|
| 710 | #if DEBUG_MODE
|
---|
| 711 | Serial.print("Enter normal mode fall\r\nSet filter fail!!\r\n");
|
---|
| 712 | #else
|
---|
| 713 | delay(10);
|
---|
| 714 | #endif
|
---|
[195] | 715 | LEAVE_CRITICAL;
|
---|
[136] | 716 | return res;
|
---|
| 717 | }
|
---|
| 718 | #if DEBUG_MODE
|
---|
| 719 | Serial.print("set Filter success!!\r\n");
|
---|
| 720 | #else
|
---|
| 721 | delay(10);
|
---|
| 722 | #endif
|
---|
[195] | 723 | LEAVE_CRITICAL;
|
---|
[136] | 724 | return res;
|
---|
| 725 | }
|
---|
| 726 |
|
---|
| 727 | /*********************************************************************************************************
|
---|
| 728 | ** Function name: startReceive
|
---|
| 729 | ** Descriptions: start Receive
|
---|
| 730 | *********************************************************************************************************/
|
---|
| 731 | INT8U MCP_CAN::startReceive(INT8U rxbid)
|
---|
| 732 | {
|
---|
| 733 | CHECK_RXBID(rxbid);
|
---|
| 734 |
|
---|
[195] | 735 | ENTER_CRITICAL;
|
---|
[136] | 736 | #if (DEBUG_RXANY==1)
|
---|
| 737 | /* enable both receive-buffers */
|
---|
| 738 | /* to receive any message */
|
---|
| 739 | /* and enable rollover */
|
---|
| 740 | if (rxbid == 0) {
|
---|
| 741 | mcp2515_modifyRegister(MCP_RXB0CTRL,
|
---|
| 742 | MCP_RXB_RX_MASK | MCP_RXB_BUKT_MASK,
|
---|
| 743 | MCP_RXB_RX_ANY);
|
---|
| 744 | }else{
|
---|
| 745 | mcp2515_modifyRegister(MCP_RXB1CTRL, MCP_RXB_RX_MASK,
|
---|
| 746 | MCP_RXB_RX_ANY);
|
---|
| 747 | }
|
---|
| 748 | #else
|
---|
| 749 | /* enable both receive-buffers */
|
---|
| 750 | /* to receive messages */
|
---|
| 751 | /* with std. and ext. identifie */
|
---|
| 752 | /* rs */
|
---|
| 753 | /* and enable rollover */
|
---|
| 754 | if (rxbid == 0) {
|
---|
| 755 | mcp2515_modifyRegister(MCP_RXB0CTRL,
|
---|
| 756 | MCP_RXB_RX_MASK | MCP_RXB_BUKT_MASK,
|
---|
| 757 | MCP_RXB_RX_STDEXT);
|
---|
| 758 | }else{
|
---|
| 759 | mcp2515_modifyRegister(MCP_RXB1CTRL, MCP_RXB_RX_MASK,
|
---|
| 760 | MCP_RXB_RX_STDEXT);
|
---|
| 761 | }
|
---|
| 762 | #endif
|
---|
[195] | 763 | LEAVE_CRITICAL;
|
---|
| 764 |
|
---|
[136] | 765 | return CAN_OK;
|
---|
| 766 | }
|
---|
| 767 |
|
---|
| 768 | /*********************************************************************************************************
|
---|
| 769 | ** Function name: sendMsg
|
---|
| 770 | ** Descriptions: send message
|
---|
| 771 | *********************************************************************************************************/
|
---|
| 772 | INT8U MCP_CAN::sendMsg(INT8U txbid, INT32U id, INT8U len, INT8U *p_buf, INT8U ext, INT8U rtr)
|
---|
| 773 | {
|
---|
| 774 | INT8U intf_tbl[MCP_N_TXBUFFERS] = { MCP_TX0IF, MCP_TX1IF, MCP_TX2IF };
|
---|
| 775 | INT8U intf_bit = intf_tbl[txbid];
|
---|
| 776 |
|
---|
| 777 | CHECK_LEN(len);
|
---|
| 778 | CHECK_TXBID(txbid);
|
---|
| 779 |
|
---|
[195] | 780 | ENTER_CRITICAL;
|
---|
[136] | 781 | mcp2515_write_canMsg(txbid, id, len, p_buf, ext, rtr);
|
---|
| 782 | mcp2515_modifyRegister(MCP_CANINTF, intf_bit, 0);
|
---|
| 783 | mcp2515_start_transmit( txbid );
|
---|
[195] | 784 | LEAVE_CRITICAL;
|
---|
[136] | 785 | return CAN_OK;
|
---|
| 786 | }
|
---|
| 787 |
|
---|
| 788 | /*********************************************************************************************************
|
---|
| 789 | ** Function name: sendMsg
|
---|
| 790 | ** Descriptions: send buf
|
---|
| 791 | *********************************************************************************************************/
|
---|
| 792 | INT8U MCP_CAN::sendMsg(INT8U txbid, INT32U id, INT8U len, INT8U *p_buf, INT8U ext)
|
---|
| 793 | {
|
---|
| 794 | return sendMsg(txbid, id, len, p_buf, ext, 0);
|
---|
| 795 | }
|
---|
| 796 |
|
---|
| 797 | /*********************************************************************************************************
|
---|
| 798 | ** Function name: sendMsg
|
---|
| 799 | ** Descriptions: send buf
|
---|
| 800 | *********************************************************************************************************/
|
---|
| 801 | INT8U MCP_CAN::sendMsg(INT8U txbid, INT32U id, INT8U len, INT8U *p_buf)
|
---|
| 802 | {
|
---|
| 803 | return sendMsg(txbid, id, len, p_buf, 0, 0);
|
---|
| 804 | }
|
---|
| 805 |
|
---|
| 806 |
|
---|
| 807 | /*********************************************************************************************************
|
---|
| 808 | ** Function name: readMsg
|
---|
| 809 | ** Descriptions: read message
|
---|
| 810 | *********************************************************************************************************/
|
---|
| 811 | INT8U MCP_CAN::readMsg(INT8U rxbid, INT32U *p_id, INT8U *p_len, INT8U *p_buf, INT8U *p_ext, INT8U *p_rtr)
|
---|
| 812 | {
|
---|
| 813 | INT8U stat, res;
|
---|
| 814 | CHECK_RXBID(rxbid);
|
---|
| 815 | INT8U stat_bit = (rxbid == 0)? MCP_STAT_RX0IF : MCP_STAT_RX1IF;
|
---|
| 816 | INT8U intf_bit = (rxbid == 0)? MCP_RX0IF : MCP_RX1IF;
|
---|
[195] | 817 |
|
---|
| 818 | ENTER_CRITICAL;
|
---|
[136] | 819 | stat = mcp2515_readStatus();
|
---|
| 820 |
|
---|
| 821 | if ( stat & stat_bit )
|
---|
| 822 | {
|
---|
| 823 | mcp2515_read_canMsg(rxbid, p_id, p_len, p_buf, p_ext, p_rtr);
|
---|
| 824 | mcp2515_modifyRegister(MCP_CANINTF, intf_bit, 0);
|
---|
| 825 | res = CAN_OK;
|
---|
| 826 | }
|
---|
| 827 | else {
|
---|
| 828 | res = CAN_NOMSG;
|
---|
| 829 | }
|
---|
[195] | 830 | LEAVE_CRITICAL;
|
---|
[136] | 831 | return res;
|
---|
| 832 | }
|
---|
| 833 |
|
---|
| 834 | /*********************************************************************************************************
|
---|
| 835 | ** Function name: readMsgBuf
|
---|
| 836 | ** Descriptions: read message
|
---|
| 837 | *********************************************************************************************************/
|
---|
| 838 | INT8U MCP_CAN::readMsg(INT8U rxbid, INT32U *p_id, INT8U *p_len, INT8U *p_buf, INT8U *p_ext)
|
---|
| 839 | {
|
---|
| 840 | INT8U rtr;
|
---|
| 841 |
|
---|
| 842 | return readMsg(rxbid, p_id, p_len, p_buf, p_ext, &rtr);
|
---|
| 843 | }
|
---|
| 844 |
|
---|
| 845 | /*********************************************************************************************************
|
---|
| 846 | ** Function name: readMsgBuf
|
---|
| 847 | ** Descriptions: read message
|
---|
| 848 | *********************************************************************************************************/
|
---|
| 849 | INT8U MCP_CAN::readMsg(INT8U rxbid, INT32U *p_id, INT8U *p_len, INT8U *p_buf)
|
---|
| 850 | {
|
---|
| 851 | INT8U ext;
|
---|
| 852 | INT8U rtr;
|
---|
| 853 |
|
---|
| 854 | return readMsg(rxbid, p_id, p_len, p_buf, &ext, &rtr);
|
---|
| 855 | }
|
---|
| 856 |
|
---|
| 857 | /*********************************************************************************************************
|
---|
| 858 | ** Function name: readMsgBuf
|
---|
| 859 | ** Descriptions: read message
|
---|
| 860 | *********************************************************************************************************/
|
---|
| 861 | INT8U MCP_CAN::readMsg(INT8U rxbid, INT8U *p_len, INT8U *p_buf)
|
---|
| 862 | {
|
---|
| 863 | INT32U id;
|
---|
| 864 | INT8U ext;
|
---|
| 865 | INT8U rtr;
|
---|
| 866 |
|
---|
| 867 | return readMsg(rxbid, &id, p_len, p_buf, &ext, &rtr);
|
---|
| 868 | }
|
---|
| 869 |
|
---|
| 870 | /*********************************************************************************************************
|
---|
| 871 | ** Function name: checkReceive
|
---|
| 872 | ** Descriptions: check if got something
|
---|
| 873 | *********************************************************************************************************/
|
---|
| 874 | INT8U MCP_CAN::checkReceive(INT8U rxbid)
|
---|
| 875 | {
|
---|
[205] | 876 | INT8U stat, res = CAN_NOMSG;
|
---|
[136] | 877 | CHECK_RXBID(rxbid);
|
---|
[195] | 878 |
|
---|
| 879 | ENTER_CRITICAL;
|
---|
[205] | 880 | stat = mcp2515_readStatus(); /* RXnIF in Bit 1 and 0 */
|
---|
[136] | 881 | if (rxbid == 0) {
|
---|
[205] | 882 | if ( (stat & MCP_STAT_RX0IF) == MCP_STAT_RX0IF) {
|
---|
[195] | 883 | res = CAN_MSGAVAIL;
|
---|
[136] | 884 | }
|
---|
| 885 | }
|
---|
| 886 | else if (rxbid == 1) {
|
---|
[205] | 887 | if ( (stat & MCP_STAT_RX1IF) == MCP_STAT_RX1IF ) {
|
---|
[195] | 888 | res = CAN_MSGAVAIL;
|
---|
[205] | 889 | }
|
---|
[136] | 890 | }
|
---|
[195] | 891 | LEAVE_CRITICAL;
|
---|
| 892 |
|
---|
| 893 | return res;
|
---|
[136] | 894 | }
|
---|
| 895 |
|
---|
| 896 | /*********************************************************************************************************
|
---|
| 897 | ** Function name: checkSend
|
---|
| 898 | ** Descriptions: check if snt msg
|
---|
| 899 | *********************************************************************************************************/
|
---|
| 900 | INT8U MCP_CAN::checkSend(INT8U txbid)
|
---|
| 901 | {
|
---|
[205] | 902 | INT8U stat, res = CAN_NOSENDWAIT;
|
---|
[136] | 903 | INT8U txbx_ctrl[MCP_N_TXBUFFERS] = { MCP_TXB0CTRL, MCP_TXB1CTRL, MCP_TXB2CTRL };
|
---|
| 904 |
|
---|
| 905 | CHECK_TXBID(txbid);
|
---|
| 906 |
|
---|
[195] | 907 | ENTER_CRITICAL;
|
---|
[205] | 908 | stat = mcp2515_readRegister(txbx_ctrl[txbid]);
|
---|
[136] | 909 |
|
---|
[205] | 910 | if ( (stat & MCP_TXB_TXREQ_M) == MCP_TXB_TXREQ_M) {
|
---|
[195] | 911 | res = CAN_SENDWAIT;
|
---|
[136] | 912 | }
|
---|
[195] | 913 | LEAVE_CRITICAL;
|
---|
| 914 |
|
---|
[205] | 915 | return res;
|
---|
[136] | 916 | }
|
---|
| 917 |
|
---|
| 918 | /*********************************************************************************************************
|
---|
| 919 | ** Function name: checkError
|
---|
| 920 | ** Descriptions: if something error
|
---|
| 921 | *********************************************************************************************************/
|
---|
| 922 | INT8U MCP_CAN::checkError(void)
|
---|
| 923 | {
|
---|
[195] | 924 | INT8U res = CAN_OK;
|
---|
| 925 |
|
---|
| 926 | ENTER_CRITICAL;
|
---|
[136] | 927 | INT8U eflg = mcp2515_readRegister(MCP_EFLG);
|
---|
| 928 |
|
---|
| 929 | if ( eflg & MCP_EFLG_ERRORMASK )
|
---|
| 930 | {
|
---|
[195] | 931 | res = CAN_CTRLERROR;
|
---|
[136] | 932 | }
|
---|
[195] | 933 | LEAVE_CRITICAL;
|
---|
| 934 |
|
---|
| 935 | return res;
|
---|
[136] | 936 | }
|
---|
| 937 |
|
---|
| 938 | /*********************************************************************************************************
|
---|
| 939 | END FILE
|
---|
| 940 | *********************************************************************************************************/
|
---|