Details | Last modification | View Log | SVN | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 240 | andfri | 1 | /** |
| 2 | * CAN communication interface. This is a general, high-level interface for CAN |
||
| 3 | * communication. Underlying CAN controllers are abstracted by this interface, |
||
| 4 | * so the application needs not work directly with the CAN controllers. |
||
| 5 | * |
||
| 6 | * The interface is fully queued in both directions. Both queues can configured |
||
| 7 | * in terms of size, and can also be disabled completely to save both RAM and |
||
| 8 | * FLASH space (the queue routines are removed by preprocessor when queues |
||
| 9 | * are disabled). When queues are enabled, the application has to call |
||
| 10 | * Can_Service as often as possible, so messages can be moved between the CAN |
||
| 11 | * controller and the message queues. This might be handled by interrupts in |
||
| 12 | * future. When queues are disabled, on the other hand, the application has |
||
| 13 | * to call Can_Receive as often as possible in order not to loose any messages. |
||
| 14 | * |
||
| 15 | * @date 2006-11-21 |
||
| 16 | * |
||
| 17 | * @author Jimmy Myhrman |
||
| 18 | * |
||
| 19 | */ |
||
| 20 | |||
| 21 | /*----------------------------------------------------------------------------- |
||
| 22 | * Includes |
||
| 23 | *---------------------------------------------------------------------------*/ |
||
| 24 | //#include <string.h> |
||
| 25 | #include "can.h" |
||
| 26 | //#include <mcu.h> |
||
| 27 | //#include <stdio.h> |
||
| 28 | //#include <timebase.h> |
||
| 29 | //#include <assert.h> |
||
| 30 | #if CAN_CONTROLLER == CAN_CONTROLLER_MCP2515 |
||
| 31 | #include "mcp2515/mcp2515.h" |
||
| 32 | #endif |
||
| 33 | |||
| 34 | |||
| 35 | /*----------------------------------------------------------------------------- |
||
| 36 | * Prerequisites |
||
| 37 | *---------------------------------------------------------------------------*/ |
||
| 38 | #ifndef CAN_CONTROLLER |
||
| 39 | #error CAN_CONTROLLER not specified! Edit can_cfg.h ! |
||
| 40 | #endif |
||
| 41 | |||
| 42 | #ifndef CAN_BITRATE |
||
| 43 | #error CAN_BITRATE not defined! Edit can_cfg.h ! |
||
| 44 | #endif |
||
| 45 | |||
| 46 | #ifndef CAN_QUEUE_SIZE_RX |
||
| 47 | #error CAN_QUEUE_SIZE_RX not defined! Edit can_cfg.h ! |
||
| 48 | #endif |
||
| 49 | |||
| 50 | #ifndef CAN_QUEUE_SIZE_TX |
||
| 51 | #error CAN_QUEUE_SIZE_TX not defined! Edit can_cfg.h ! |
||
| 52 | #endif |
||
| 53 | |||
| 54 | #ifndef CAN_CONTROLLER_NR_TX_BUFFERS |
||
| 55 | #error CAN_CONTROLLER_NR_TX_BUFFERS not defined! Edit can_cfg.h ! |
||
| 56 | #endif |
||
| 57 | |||
| 58 | #ifndef CAN_CONTROLLER_NR_RX_BUFFERS |
||
| 59 | #error CAN_CONTROLLER_NR_RX_BUFFERS not defined! Edit can_cfg.h ! |
||
| 60 | #endif |
||
| 61 | |||
| 62 | |||
| 63 | /*----------------------------------------------------------------------------- |
||
| 64 | * Type Definitions |
||
| 65 | *---------------------------------------------------------------------------*/ |
||
| 66 | |||
| 67 | #if (CAN_QUEUE_SIZE_TX > 0) || (CAN_QUEUE_SIZE_RX > 0) |
||
| 68 | /** |
||
| 69 | * CAN Message Queue Type. Stores and manages several CAN messages |
||
| 70 | * in a FIFO structure. |
||
| 71 | */ |
||
| 72 | typedef struct { |
||
| 73 | Can_Message_t *dataPtr; /* pointer to the data storage */ |
||
| 74 | uint8_t head; /* current OUTPUT position */ |
||
| 75 | uint8_t tail; /* current INPUT position */ |
||
| 76 | uint8_t nrElements; /* nr of elements currently queued */ |
||
| 77 | uint8_t size; /* total size of the queue */ |
||
| 78 | } Can_MessageQueue_t; |
||
| 79 | #endif |
||
| 80 | |||
| 81 | |||
| 82 | /*----------------------------------------------------------------------------- |
||
| 83 | * Private (static) variables |
||
| 84 | *---------------------------------------------------------------------------*/ |
||
| 85 | |||
| 86 | #if CAN_QUEUE_SIZE_TX > 0 |
||
| 87 | /* TX queue object and static memory storage buffer for this queue */ |
||
| 88 | static Can_MessageQueue_t canTxQueue; |
||
| 89 | static Can_Message_t canTxQueueDataStorage[CAN_QUEUE_SIZE_TX]; |
||
| 90 | #endif |
||
| 91 | #if CAN_QUEUE_SIZE_RX > 0 |
||
| 92 | /* RX queue object and static memory storage buffer for this queue */ |
||
| 93 | static Can_MessageQueue_t canRxQueue; |
||
| 94 | static Can_Message_t canRxQueueDataStorage[CAN_QUEUE_SIZE_RX]; |
||
| 95 | #endif |
||
| 96 | |||
| 97 | |||
| 98 | /*----------------------------------------------------------------------------- |
||
| 99 | * Private Function Prototypes |
||
| 100 | *---------------------------------------------------------------------------*/ |
||
| 101 | |||
| 102 | /* functions that deal with the controller hardware */ |
||
| 103 | static Can_Return_t Can_SendImmediately(Can_Message_t *msg); |
||
| 104 | static Can_Return_t Can_ReceiveFromController(Can_Message_t *msg, uint8_t rxBuffer); |
||
| 105 | static uint8_t Can_MessagesAvailableInController(void) __attribute__((unused)); |
||
| 106 | static Can_Return_t Can_ControllerCheckError(void) __attribute__((unused)); |
||
| 107 | |||
| 108 | #if (CAN_QUEUE_SIZE_TX > 0) || (CAN_QUEUE_SIZE_RX > 0) |
||
| 109 | /* functions that deal with the message queues */ |
||
| 110 | static void Can_QueueInit(Can_MessageQueue_t *q, uint8_t size, Can_Message_t *dataPtr); |
||
| 111 | static Can_Message_t* Can_QueueInsert(Can_MessageQueue_t *q); |
||
| 112 | static Can_Message_t* Can_QueueReadTailPtr(Can_MessageQueue_t *q); |
||
| 113 | static void Can_QueueRemoveTail(Can_MessageQueue_t *q); |
||
| 114 | #endif |
||
| 115 | |||
| 116 | |||
| 117 | /*----------------------------------------------------------------------------- |
||
| 118 | * Public Functions |
||
| 119 | *---------------------------------------------------------------------------*/ |
||
| 120 | |||
| 121 | /** |
||
| 122 | * Initializes the CAN interface. Edit can_cfg.h to choose bitrate. |
||
| 123 | * |
||
| 124 | * @return |
||
| 125 | * CAN_OK if initialization was successful. |
||
| 126 | * CAN_INIT_FAIL_SET_BITRATE if bitrate could not be set correctly. |
||
| 127 | * CAN_INIT_FAIL_SET_MODE if the controller could not be set to normal operation mode. |
||
| 128 | * CAN_INIT_FAIL in case of general error. |
||
| 129 | */ |
||
| 130 | Can_Return_t Can_Init() { |
||
| 131 | #if CAN_QUEUE_SIZE_TX > 0 |
||
| 132 | /* initialize TX queue */ |
||
| 133 | Can_QueueInit(&canTxQueue, CAN_QUEUE_SIZE_TX, canTxQueueDataStorage); |
||
| 134 | #endif |
||
| 135 | #if CAN_QUEUE_SIZE_RX > 0 |
||
| 136 | /* initialize RX queue */ |
||
| 137 | Can_QueueInit(&canRxQueue, CAN_QUEUE_SIZE_RX, canRxQueueDataStorage); |
||
| 138 | #endif |
||
| 139 | |||
| 140 | #if CAN_CONTROLLER == CAN_CONTROLLER_NULL |
||
| 141 | /* |
||
| 142 | * Initialize null device. |
||
| 143 | */ |
||
| 144 | return CAN_OK; |
||
| 145 | #endif |
||
| 146 | |||
| 147 | #if CAN_CONTROLLER == CAN_CONTROLLER_MCP2515 |
||
| 148 | /* |
||
| 149 | * Initialize MCP2515 device. |
||
| 150 | */ |
||
| 244 | andfri | 151 | if (MCP2515_Init() != MCP2515_OK) { |
| 240 | andfri | 152 | return CAN_FAIL; |
| 153 | } |
||
| 154 | if (MCP2515_SetCanCtrlMode(MODE_NORMAL) != MCP2515_OK) { |
||
| 155 | return CAN_FAIL; |
||
| 156 | } |
||
| 157 | return CAN_OK; |
||
| 158 | #endif |
||
| 159 | |||
| 160 | return CAN_FAIL; |
||
| 161 | } |
||
| 162 | |||
| 163 | |||
| 164 | /** |
||
| 165 | * Sends a CAN message. The message will be put into the transmission queue, |
||
| 166 | * and hence, it might not be sent immediately. If the queue is full, the |
||
| 167 | * message will not be taken care of, and CAN_FAIL is returned. |
||
| 168 | * |
||
| 169 | * @param msg |
||
| 170 | * Pointer to the CAN message. |
||
| 171 | * |
||
| 172 | * @return |
||
| 173 | * CAN_OK if the message was successfully enqueued. |
||
| 174 | * CAN_FAIL if the transmission queue is full. |
||
| 175 | */ |
||
| 176 | Can_Return_t Can_Send(Can_Message_t *msg) { |
||
| 177 | #if CAN_QUEUE_SIZE_TX == 0 |
||
| 178 | /* TX queue is disabled, so send immediately */ |
||
| 179 | return Can_SendImmediately(msg); |
||
| 180 | #else |
||
| 181 | #if 0 |
||
| 182 | printf("Can_Send()\n\r"); |
||
| 183 | printf(" queue size before = %u\n\r", canTxQueue.nrElements); |
||
| 184 | #endif |
||
| 185 | /* check if there is room available in the tx queue */ |
||
| 186 | if (canTxQueue.nrElements >= canTxQueue.size) { |
||
| 187 | #if 0 |
||
| 188 | printf(" TX queue full!\n\r"); |
||
| 189 | #endif |
||
| 190 | return CAN_FAIL; |
||
| 191 | } |
||
| 192 | /* put message in queue */ |
||
| 193 | Can_Message_t *ptr = Can_QueueInsert(&canTxQueue); |
||
| 194 | memcpy(ptr, msg, sizeof(Can_Message_t)); |
||
| 195 | #if 0 |
||
| 196 | printf(" queue size after = %u\n\r", canTxQueue.nrElements); |
||
| 197 | #endif |
||
| 198 | return CAN_OK; |
||
| 199 | #endif |
||
| 200 | } |
||
| 201 | |||
| 202 | |||
| 203 | /** |
||
| 204 | * Services the CAN subsystem. Messages waiting in the transmission queue |
||
| 205 | * will be transmitted if the controller is not busy, and any messages |
||
| 206 | * received by the controller will be moved from the controller buffers |
||
| 207 | * into the internal reception queue. |
||
| 208 | */ |
||
| 209 | void Can_Service() { |
||
| 210 | #if CAN_QUEUE_SIZE_TX > 0 |
||
| 211 | /* try to transmit messages waiting in the transmission queue */ |
||
| 212 | for (uint8_t i=0; i<CAN_CONTROLLER_NR_TX_BUFFERS; i++) { |
||
| 213 | if (canTxQueue.nrElements > 0) { |
||
| 214 | #if 0 |
||
| 215 | printf("msg in TX queue. trying to send...\n"); |
||
| 216 | #endif |
||
| 217 | /* ensure the queue operations are atomic */ |
||
| 218 | cli(); |
||
| 219 | Can_Message_t *txMsg = Can_QueueReadTailPtr(&canTxQueue); |
||
| 220 | if (Can_SendImmediately(txMsg) == CAN_OK) { |
||
| 221 | /* transmission OK, remove from queue */ |
||
| 222 | Can_QueueRemoveTail(&canTxQueue); |
||
| 223 | } |
||
| 224 | //TODO: dont enable interrupts, restore previous state |
||
| 225 | sei(); |
||
| 226 | } |
||
| 227 | else { |
||
| 228 | /* quit the loop if the queue is empty */ |
||
| 229 | break; |
||
| 230 | } |
||
| 231 | } |
||
| 232 | #endif |
||
| 233 | |||
| 234 | #if CAN_QUEUE_SIZE_RX > 0 |
||
| 235 | /* move all received messages from CAN controller to reception queue */ |
||
| 236 | Can_Message_t rxMsg; |
||
| 237 | /* all RX buffers have to be checked (and in correct order) */ |
||
| 238 | for (uint8_t buf=0; buf<CAN_CONTROLLER_NR_RX_BUFFERS; buf++) { |
||
| 239 | /* if buffer contains a message, handle it */ |
||
| 240 | if (Can_ReceiveFromController(&rxMsg, buf) == CAN_OK) { |
||
| 241 | /* ensure the queue operations are atomic */ |
||
| 242 | cli(); |
||
| 243 | /* try to get access to the queue */ |
||
| 244 | Can_Message_t *destPtr = Can_QueueInsert(&canRxQueue); |
||
| 245 | /* if we can insert into queue, copy the message */ |
||
| 246 | if (destPtr != 0) { |
||
| 247 | memcpy(destPtr, &rxMsg, sizeof(Can_Message_t)); |
||
| 248 | } |
||
| 249 | else { |
||
| 250 | /* otherwise, the received message will be discarded... */ |
||
| 251 | } |
||
| 252 | //TODO: dont enable interrupts, restore previous state |
||
| 253 | sei(); |
||
| 254 | } |
||
| 255 | } |
||
| 256 | #endif |
||
| 257 | |||
| 258 | /* TODO: check error status in controller */ |
||
| 259 | } |
||
| 260 | |||
| 261 | |||
| 262 | /** |
||
| 263 | * Receives a CAN message that is waiting in the reception queue. If no |
||
| 264 | * messages have been received, CAN_NO_MSG_AVAILABLE is returned. |
||
| 265 | * Otherwise, a CAN message is copied into the specified message buffer |
||
| 266 | * and deleted from the internal message reception queue. In this case, |
||
| 267 | * CAN_OK is returned. |
||
| 268 | * |
||
| 269 | * @param msg |
||
| 270 | * Pointer to the message storage buffer into which the message |
||
| 271 | * should be copied. |
||
| 272 | * |
||
| 273 | * @return |
||
| 274 | * CAN_OK if a received message was successfully copied into the buffer. |
||
| 275 | * CAN_NO_MSG_AVAILABLE if no messages are available. |
||
| 276 | */ |
||
| 277 | Can_Return_t Can_Receive(Can_Message_t *msg) { |
||
| 278 | |||
| 279 | #if CAN_QUEUE_SIZE_RX > 0 |
||
| 280 | /* |
||
| 281 | * RX queue is enabled, so try to get message from queue. |
||
| 282 | */ |
||
| 283 | Can_Message_t *pSrc; /* Source pointer */ |
||
| 284 | /* Check if there is anything available in the RxQueue */ |
||
| 285 | if (canRxQueue.nrElements == 0) { |
||
| 286 | return CAN_NO_MSG_AVAILABLE; |
||
| 287 | } |
||
| 288 | /* ensure the queue operations are atomic */ |
||
| 289 | cli(); |
||
| 290 | pSrc = Can_QueueReadTailPtr(&canRxQueue); |
||
| 291 | /* copy frame from queue, and then remove from queue */ |
||
| 292 | memcpy(msg, pSrc, sizeof(Can_Message_t)); |
||
| 293 | Can_QueueRemoveTail(&canRxQueue); |
||
| 294 | //TODO: dont enable interrupts, restore previous state |
||
| 295 | sei(); |
||
| 296 | /* a message has successfully been copied and removed from queue */ |
||
| 297 | return CAN_OK; |
||
| 298 | #else |
||
| 299 | /* |
||
| 300 | * RX queue is disabled, so try to get message from controller. |
||
| 301 | * We don't know which buffer to get the message from, so best |
||
| 302 | * we can do is to get from buf0 first time, and then increase |
||
| 303 | * buffer number at each call, finally wrapping around at |
||
| 304 | * CAN_CONTROLLER_NR_RX_BUFFERS. |
||
| 305 | */ |
||
| 306 | static uint8_t rxBuffer = 0; |
||
| 307 | uint8_t i; |
||
| 308 | /* worst case is that we need to check all available rx buffers in order to find a message */ |
||
| 309 | for (i=0; i<CAN_CONTROLLER_NR_RX_BUFFERS; i++) { |
||
| 310 | /* is there a message available in this buffer? */ |
||
| 311 | if (Can_ReceiveFromController(msg, rxBuffer) == CAN_OK) { |
||
| 312 | /* increase buffer number and return the message */ |
||
| 313 | rxBuffer = (rxBuffer + 1) % CAN_CONTROLLER_NR_RX_BUFFERS; |
||
| 314 | return CAN_OK; |
||
| 315 | } |
||
| 316 | /* increase buffer number so we can check next buffer */ |
||
| 317 | rxBuffer = (rxBuffer + 1) % CAN_CONTROLLER_NR_RX_BUFFERS; |
||
| 318 | } |
||
| 319 | /* all buffers were checked, but no message found */ |
||
| 320 | return CAN_NO_MSG_AVAILABLE; |
||
| 321 | #endif |
||
| 322 | } |
||
| 323 | |||
| 324 | |||
| 325 | |||
| 326 | /*----------------------------------------------------------------------------- |
||
| 327 | * Private Functions |
||
| 328 | *---------------------------------------------------------------------------*/ |
||
| 329 | |||
| 330 | /** |
||
| 331 | * Sends a CAN message immediately with the controller hardware. If the CAN |
||
| 332 | * controller is busy, the function will return CAN_SEND_FAIL_TX_BUSY. |
||
| 333 | * |
||
| 334 | * @param msg |
||
| 335 | * Pointer to the CAN message storage buffer. |
||
| 336 | * |
||
| 337 | * @return |
||
| 338 | * CAN_OK if the message was successfully sent to the controller. |
||
| 339 | * CAN_FAIL if the controller is busy. |
||
| 340 | */ |
||
| 341 | static Can_Return_t Can_SendImmediately(Can_Message_t* msg) { |
||
| 342 | #if CAN_CONTROLLER == CAN_CONTROLLER_NULL |
||
| 343 | /* |
||
| 344 | * Send with null device. |
||
| 345 | */ |
||
| 346 | return CAN_OK; |
||
| 347 | #endif |
||
| 348 | |||
| 349 | #if CAN_CONTROLLER == CAN_CONTROLLER_MCP2515 |
||
| 350 | /* |
||
| 351 | * Send with MCP2515 device. |
||
| 352 | */ |
||
| 353 | uint8_t res, txbuf_n; |
||
| 354 | res = MCP2515_GetNextFreeTXBuf(&txbuf_n); // info = addr. |
||
| 355 | if (res == MCP_ALLTXBUSY) { |
||
| 356 | return CAN_FAIL; |
||
| 357 | } |
||
| 358 | MCP2515_WriteCanMsg(txbuf_n, msg); |
||
| 359 | MCP2515_StartTransmit(txbuf_n); |
||
| 360 | return CAN_OK; |
||
| 361 | #endif |
||
| 362 | } |
||
| 363 | |||
| 364 | |||
| 365 | /** |
||
| 366 | * Receives a CAN message from the CAN controller hardware. |
||
| 367 | * |
||
| 368 | * @param msg |
||
| 369 | * Pointer to the message storage buffer into which the message should be copied. |
||
| 370 | * |
||
| 371 | * @param rxBuffer |
||
| 372 | * Identifies the RX buffer in the controller. Range is [0,CAN_CONTROLLER_NR_RX_BUFFERS-1]. |
||
| 373 | * |
||
| 374 | * @return |
||
| 375 | * CAN_OK if a received message was successfully copied into the buffer. |
||
| 376 | * CAN_NO_MSG_AVAILABLE if there are is no message available in the specified buffer. |
||
| 377 | * CAN_FAIL if the rxBuffer parameter i out of range for the specified controller. |
||
| 378 | */ |
||
| 379 | static Can_Return_t Can_ReceiveFromController(Can_Message_t *msg, uint8_t rxBuffer) { |
||
| 380 | #if CAN_CONTROLLER == CAN_CONTROLLER_NULL |
||
| 381 | /* |
||
| 382 | * Receive from null device. |
||
| 383 | */ |
||
| 384 | return CAN_NO_MSG_AVAILABLE; |
||
| 385 | #endif |
||
| 386 | |||
| 387 | #if CAN_CONTROLLER == CAN_CONTROLLER_MCP2515 |
||
| 388 | /* |
||
| 389 | * Receive from MCP2515 device. |
||
| 390 | */ |
||
| 391 | uint8_t stat; |
||
| 392 | stat = MCP2515_ReadStatus(); |
||
| 393 | if (rxBuffer == 0) { |
||
| 394 | /* check BUF0 */ |
||
| 395 | if (stat & MCP_STAT_RX0IF) { |
||
| 396 | /* Msg in Buffer 0 */ |
||
| 397 | MCP2515_ReadCanMsg(MCP_RXBUF_0, msg); |
||
| 398 | MCP2515_ModifyRegister(MCP_CANINTF, MCP_RX0IF, 0); |
||
| 399 | return CAN_OK; |
||
| 400 | } |
||
| 401 | } |
||
| 402 | else if (rxBuffer == 1) { |
||
| 403 | /* check BUF1 */ |
||
| 404 | if (stat & MCP_STAT_RX1IF) { |
||
| 405 | /* Msg in Buffer 1 */ |
||
| 406 | MCP2515_ReadCanMsg(MCP_RXBUF_1, msg); |
||
| 407 | MCP2515_ModifyRegister(MCP_CANINTF, MCP_RX1IF, 0); |
||
| 408 | return CAN_OK; |
||
| 409 | } |
||
| 410 | } |
||
| 411 | else { |
||
| 412 | /* invalid parameters */ |
||
| 413 | return CAN_FAIL; |
||
| 414 | } |
||
| 415 | return CAN_NO_MSG_AVAILABLE; |
||
| 416 | #endif |
||
| 417 | } |
||
| 418 | |||
| 419 | |||
| 420 | /** |
||
| 421 | * Checks how many messages are available in the CAN controller hardware. |
||
| 422 | * |
||
| 423 | * @return |
||
| 424 | * The number of messages available (0 if none). |
||
| 425 | */ |
||
| 426 | static uint8_t Can_MessagesAvailableInController() { |
||
| 427 | #if CAN_CONTROLLER == CAN_CONTROLLER_NULL |
||
| 428 | /* |
||
| 429 | * Check for messages in null device. |
||
| 430 | */ |
||
| 431 | return 0; |
||
| 432 | #endif |
||
| 433 | |||
| 434 | #if CAN_CONTROLLER == CAN_CONTROLLER_MCP2515 |
||
| 435 | /* |
||
| 436 | * Check for message in MCP2515 device. |
||
| 437 | */ |
||
| 438 | uint8_t res; |
||
| 439 | res = MCP2515_ReadStatus(); /* RXnIF in Bit 1 and 0 */ |
||
| 440 | if (res & MCP_STAT_RXIF_MASK) { |
||
| 441 | //TODO: check how many messages are available |
||
| 442 | return 1; /* at least one message available */ |
||
| 443 | } |
||
| 444 | else { |
||
| 445 | return 0; /* no messages available */ |
||
| 446 | } |
||
| 447 | #endif |
||
| 448 | |||
| 449 | return 0; |
||
| 450 | } |
||
| 451 | |||
| 452 | |||
| 453 | /* |
||
| 454 | * Checks Controller-Error-State. |
||
| 455 | * |
||
| 456 | * @return |
||
| 457 | * CAN_OK if the controller is OK. |
||
| 458 | * CAN_FAIL if errors have occured. |
||
| 459 | * |
||
| 460 | * @todo |
||
| 461 | * Styr upp denna funktion lite b�ttre. |
||
| 462 | */ |
||
| 463 | static Can_Return_t Can_ControllerCheckError() { |
||
| 464 | #if CAN_CONTROLLER == CAN_CONTROLLER_NULL |
||
| 465 | /* |
||
| 466 | * Check for errors in null device. |
||
| 467 | */ |
||
| 468 | return CAN_OK; |
||
| 469 | #endif |
||
| 470 | |||
| 471 | #if CAN_CONTROLLER == CAN_CONTROLLER_MCP2515 |
||
| 472 | /* |
||
| 473 | * Check for errors in MCP2515 device. |
||
| 474 | */ |
||
| 475 | uint8_t eflg = MCP2515_ReadRegister(MCP_EFLG); |
||
| 476 | if (eflg & MCP_EFLG_ERRORMASK) { |
||
| 477 | return CAN_FAIL; /* errors found */ |
||
| 478 | } |
||
| 479 | else { |
||
| 480 | return CAN_OK; /* no errors found */ |
||
| 481 | } |
||
| 482 | #endif |
||
| 483 | } |
||
| 484 | |||
| 485 | |||
| 486 | #if (CAN_QUEUE_SIZE_TX > 0) || (CAN_QUEUE_SIZE_RX > 0) |
||
| 487 | /** |
||
| 488 | * Initializes a CAN queue. |
||
| 489 | * |
||
| 490 | * @param q |
||
| 491 | * Pointer to the queue object. |
||
| 492 | * |
||
| 493 | * @param size |
||
| 494 | * Size of the queue (number of messages that can be queued). |
||
| 495 | * |
||
| 496 | * @param dataPtr |
||
| 497 | * Pointer to the message storage buffer that should be used by the queue. |
||
| 498 | */ |
||
| 499 | static void Can_QueueInit(Can_MessageQueue_t *q, uint8_t size, Can_Message_t *dataPtr) { |
||
| 500 | q->dataPtr = dataPtr; |
||
| 501 | q->head = 0; |
||
| 502 | q->tail = 0; |
||
| 503 | q->nrElements = 0; |
||
| 504 | q->size = size; |
||
| 505 | } |
||
| 506 | |||
| 507 | |||
| 508 | /** |
||
| 509 | * Inserts a new element in a queue and returns a pointer to the new element. |
||
| 510 | * If the queue is full, the last element (the tail) will be overwritten by |
||
| 511 | * the new element. |
||
| 512 | * |
||
| 513 | * @param q |
||
| 514 | * Pointer to the queue object. |
||
| 515 | * |
||
| 516 | * @return |
||
| 517 | * Pointer to the new message element. Use this pointer to copy data into the queue. |
||
| 518 | */ |
||
| 519 | static Can_Message_t* Can_QueueInsert(Can_MessageQueue_t *q) { |
||
| 520 | Can_Message_t *ptr; |
||
| 521 | #if 0 |
||
| 522 | printf("INSERT: bef=%u, ", q->nrElements); |
||
| 523 | #endif |
||
| 524 | if ((q->nrElements+1) > q->size) { |
||
| 525 | q->tail = (q->tail + 1) % q->size; |
||
| 526 | q->nrElements--; |
||
| 527 | #if 0 |
||
| 528 | printf("Can_QueueInsertViaPtr: QUEUE OVERRUN!\n\r"); |
||
| 529 | #endif |
||
| 530 | } |
||
| 531 | ptr = &(q->dataPtr[q->head]); |
||
| 532 | #if 0 |
||
| 533 | if (q->handled[q->head] == 0) { |
||
| 534 | printf("Can_QueueInsertViaPtr: discarding non-handled msg!\n\r"); |
||
| 535 | } |
||
| 536 | #endif |
||
| 537 | q->head = (q->head + 1) % q->size; |
||
| 538 | q->nrElements++; |
||
| 539 | #if 0 |
||
| 540 | printf("aft=%u\n\n", q->nrElements); |
||
| 541 | #endif |
||
| 542 | return ptr; |
||
| 543 | } |
||
| 544 | |||
| 545 | |||
| 546 | /** |
||
| 547 | * Returns a pointer to the last element in the queue (the tail). Use this pointer |
||
| 548 | * to extract the message, and then call Can_QueueRemoveTail to actually remove |
||
| 549 | * the element. |
||
| 550 | * |
||
| 551 | * @param q |
||
| 552 | * Pointer to the queue object. |
||
| 553 | * |
||
| 554 | * @return |
||
| 555 | * Pointer to the tail message element. |
||
| 556 | */ |
||
| 557 | static Can_Message_t* Can_QueueReadTailPtr(Can_MessageQueue_t *q) { |
||
| 558 | if (q->nrElements > 0) { |
||
| 559 | return &(q->dataPtr[q->tail]); |
||
| 560 | } |
||
| 561 | else { |
||
| 562 | return 0; |
||
| 563 | } |
||
| 564 | } |
||
| 565 | |||
| 566 | |||
| 567 | /** |
||
| 568 | * Removes the last element in the queue (the tail). You should have extracted |
||
| 569 | * the data using Can_QueueReadTailPtr before using this function. |
||
| 570 | * |
||
| 571 | * @param q |
||
| 572 | * Pointer to the queue object. |
||
| 573 | */ |
||
| 574 | static void Can_QueueRemoveTail(Can_MessageQueue_t *q) { |
||
| 575 | if (q->nrElements > 0) { |
||
| 576 | q->tail = (q->tail + 1) % q->size; |
||
| 577 | q->nrElements--; |
||
| 578 | #if 0 |
||
| 579 | printf("queue size = %u\n", q->nrElements); |
||
| 580 | #endif |
||
| 581 | } |
||
| 582 | } |
||
| 583 | |||
| 584 | #endif |