Subversion Repositories HomeAutomation

/**

 * CAN communication interface. This is a general, high-level interface for CAN

 * communication. Underlying CAN controllers are abstracted by this interface,

 * so the application needs not work directly with the CAN controllers.

 *

 * The interface is fully queued in both directions. Both queues can configured

 * in terms of size, and can also be disabled completely to save both RAM and

 * FLASH space (the queue routines are removed by preprocessor when queues

 * are disabled). When queues are enabled, the application has to call

 * Can_Service as often as possible, so messages can be moved between the CAN

 * controller and the message queues. This might be handled by interrupts in

 * future. When queues are disabled, on the other hand, the application has

 * to call Can_Receive as often as possible in order not to loose any messages.

 *

 * @date    2006-11-21

 *

 * @author  Jimmy Myhrman

 *  

 */

/*-----------------------------------------------------------------------------

 * Includes

 *---------------------------------------------------------------------------*/

#include <string.h>

#include <can.h>

#include <mcu.h>

#include <stdio.h>

#include <timebase.h>

#include <assert.h>

#if CAN_CONTROLLER == CAN_CONTROLLER_MCP2515

    #include "mcp2515.h"

#endif

/*-----------------------------------------------------------------------------

 * Prerequisites

 *---------------------------------------------------------------------------*/

#ifndef CAN_CONTROLLER

    #error CAN_CONTROLLER not specified! Edit can_cfg.h !

#endif

#ifndef CAN_BITRATE

    #error CAN_BITRATE not defined! Edit can_cfg.h !

#endif

#ifndef CAN_QUEUE_SIZE_RX

    #error CAN_QUEUE_SIZE_RX not defined! Edit can_cfg.h !

#endif

#ifndef CAN_QUEUE_SIZE_TX

    #error CAN_QUEUE_SIZE_TX not defined! Edit can_cfg.h !

#endif

#ifndef CAN_CONTROLLER_NR_TX_BUFFERS

    #error CAN_CONTROLLER_NR_TX_BUFFERS not defined! Edit can_cfg.h !

#endif

#ifndef CAN_CONTROLLER_NR_RX_BUFFERS

    #error CAN_CONTROLLER_NR_RX_BUFFERS not defined! Edit can_cfg.h !

#endif

/*-----------------------------------------------------------------------------

 * Type Definitions

 *---------------------------------------------------------------------------*/

#if (CAN_QUEUE_SIZE_TX > 0) || (CAN_QUEUE_SIZE_RX > 0)

/**

 * CAN Message Queue Type. Stores and manages several CAN messages

 * in a FIFO structure.

 */

typedef struct {

    Can_Message_t *dataPtr; /* pointer to the data storage */

    uint8_t head;       /* current OUTPUT position */

    uint8_t tail;       /* current INPUT position */

    uint8_t nrElements; /* nr of elements currently queued */

    uint8_t size;       /* total size of the queue */

} Can_MessageQueue_t;

#endif

/*-----------------------------------------------------------------------------

 * Private (static) variables

 *---------------------------------------------------------------------------*/

#if CAN_QUEUE_SIZE_TX > 0

    /* TX queue object and static memory storage buffer for this queue */

    static Can_MessageQueue_t canTxQueue;

    static Can_Message_t canTxQueueDataStorage[CAN_QUEUE_SIZE_TX];

#endif

#if CAN_QUEUE_SIZE_RX > 0

    /* RX queue object and static memory storage buffer for this queue */

    static Can_MessageQueue_t canRxQueue;

    static Can_Message_t canRxQueueDataStorage[CAN_QUEUE_SIZE_RX];

#endif

/*-----------------------------------------------------------------------------

 * Private Function Prototypes

 *---------------------------------------------------------------------------*/

/* functions that deal with the controller hardware */

static Can_Return_t Can_SendImmediately(Can_Message_t *msg);

static Can_Return_t Can_ReceiveFromController(Can_Message_t *msg, uint8_t rxBuffer);

static uint8_t Can_MessagesAvailableInController(void);

static Can_Return_t Can_ControllerCheckError(void);

#if (CAN_QUEUE_SIZE_TX > 0) || (CAN_QUEUE_SIZE_RX > 0)

/* functions that deal with the message queues */

static void Can_QueueInit(Can_MessageQueue_t *q, uint8_t size, Can_Message_t *dataPtr);

static Can_Message_t* Can_QueueInsert(Can_MessageQueue_t *q);

static Can_Message_t* Can_QueueReadTailPtr(Can_MessageQueue_t *q);

static void Can_QueueRemoveTail(Can_MessageQueue_t *q);

#endif

/*-----------------------------------------------------------------------------

 * Public Functions

 *---------------------------------------------------------------------------*/

/**

 * Initializes the CAN interface. Edit can_cfg.h to choose bitrate.

 *

 * @return

 *      CAN_OK if initialization was successful.

 *      CAN_INIT_FAIL_SET_BITRATE if bitrate could not be set correctly.

 *      CAN_INIT_FAIL_SET_MODE if the controller could not be set to normal operation mode.

 *      CAN_INIT_FAIL in case of general error.

 */

Can_Return_t Can_Init() {

    #if CAN_QUEUE_SIZE_TX > 0

        /* initialize TX queue */

        Can_QueueInit(&canTxQueue, CAN_QUEUE_SIZE_TX, canTxQueueDataStorage);

    #endif

    #if CAN_QUEUE_SIZE_RX > 0

        /* initialize RX queue */

        Can_QueueInit(&canRxQueue, CAN_QUEUE_SIZE_RX, canRxQueueDataStorage);

    #endif

    #if CAN_CONTROLLER == CAN_CONTROLLER_NULL

        /*

         * Initialize null device.

         */

        return CAN_OK;

    #endif

    #if CAN_CONTROLLER == CAN_CONTROLLER_MCP2515

        /*

         * Initialize MCP2515 device.

         */

        if (MCP2515_Init(CAN_BITRATE) != MCP2515_OK) {

            return CAN_FAIL;

        }

        if (MCP2515_SetCanCtrlMode(MODE_NORMAL) != MCP2515_OK) {

            return CAN_FAIL;

        }

        return CAN_OK;

    #endif

    return CAN_FAIL;

}

/**

 * Sends a CAN message. The message will be put into the transmission queue,

 * and hence, it might not be sent immediately. If the queue is full, the

 * message will not be taken care of, and CAN_FAIL is returned.

 *

 * @param msg

 *      Pointer to the CAN message.

 *

 * @return

 *      CAN_OK if the message was successfully enqueued.

 *      CAN_FAIL if the transmission queue is full.

 */

Can_Return_t Can_Send(Can_Message_t *msg) {

    #if CAN_QUEUE_SIZE_TX == 0

        /* TX queue is disabled, so send immediately */

        return Can_SendImmediately(msg);

    #else

        #if 0

        printf("Can_Send()\n\r");

        printf("    queue size before = %u\n\r", canTxQueue.nrElements);

        #endif

        /* check if there is room available in the tx queue */

        if (canTxQueue.nrElements >= canTxQueue.size) {

            #if 0

            printf("    TX queue full!\n\r");

            #endif

            return CAN_FAIL;

        }

        /* put message in queue */

        Can_Message_t *ptr = Can_QueueInsert(&canTxQueue);

        memcpy(ptr, msg, sizeof(Can_Message_t));

        #if 0

        printf("    queue size after = %u\n\r", canTxQueue.nrElements);

        #endif

        return CAN_OK;

    #endif

}

/**

 * Services the CAN subsystem. Messages waiting in the transmission queue

 * will be transmitted if the controller is not busy, and any messages

 * received by the controller will be moved from the controller buffers

 * into the internal reception queue.

 */

void Can_Service() {

    #if CAN_QUEUE_SIZE_TX > 0

        /* try to transmit messages waiting in the transmission queue */

        for (uint8_t i=0; i<CAN_CONTROLLER_NR_TX_BUFFERS; i++) {

            if (canTxQueue.nrElements > 0) {

                #if 0

                printf("msg in TX queue. trying to send...\n");

                #endif

                /* ensure the queue operations are atomic */

                Mcu_DisableIRQ();

                Can_Message_t *txMsg = Can_QueueReadTailPtr(&canTxQueue);

                if (Can_SendImmediately(txMsg) == CAN_OK) {

                    /* transmission OK, remove from queue */

                    Can_QueueRemoveTail(&canTxQueue);

                }

                Mcu_EnableIRQ();

            }

            else {

                /* quit the loop if the queue is empty */

                break;

            }

        }

    #endif

    #if CAN_QUEUE_SIZE_RX > 0

        /* move all received messages from CAN controller to reception queue */

        Can_Message_t rxMsg;

        /* all RX buffers have to be checked (and in correct order) */

        for (uint8_t buf=0; buf<CAN_CONTROLLER_NR_RX_BUFFERS; buf++) {

            /* if buffer contains a message, handle it */

            if (Can_ReceiveFromController(&rxMsg, buf) == CAN_OK) {

                /* ensure the queue operations are atomic */

                Mcu_DisableIRQ();

                /* try to get access to the queue */

                Can_Message_t *destPtr = Can_QueueInsert(&canRxQueue);

                /* if we can insert into queue, copy the message */

                if (destPtr != 0) {

                    memcpy(destPtr, &rxMsg, sizeof(Can_Message_t));

                }

                else {

                    /* otherwise, the received message will be discarded... */

                }

                Mcu_EnableIRQ();

            }

        }

    #endif

    /* TODO: check error status in controller */

}

/**

 * Receives a CAN message that is waiting in the reception queue. If no

 * messages have been received, CAN_NO_MSG_AVAILABLE is returned.

 * Otherwise, a CAN message is copied into the specified message buffer

 * and deleted from the internal message reception queue. In this case,

 * CAN_OK is returned.

 *

 * @param msg

 *          Pointer to the message storage buffer into which the message

 *          should be copied.

 *

 * @return

 *          CAN_OK if a received message was successfully copied into the buffer.

 *          CAN_NO_MSG_AVAILABLE if no messages are available.

 */

Can_Return_t Can_Receive(Can_Message_t *msg) {

    #if CAN_QUEUE_SIZE_RX > 0

        /*

         * RX queue is enabled, so try to get message from queue.

         */

        Can_Message_t *pSrc;    /* Source pointer */

        /* Check if there is anything available in the RxQueue */

        if (canRxQueue.nrElements == 0) {

            return CAN_NO_MSG_AVAILABLE;

        }

        /* ensure the queue operations are atomic */

        Mcu_DisableIRQ();

        pSrc = Can_QueueReadTailPtr(&canRxQueue);

        /* copy frame from queue, and then remove from queue */

        memcpy(msg, pSrc, sizeof(Can_Message_t));

        Can_QueueRemoveTail(&canRxQueue);

        Mcu_EnableIRQ();

        /* a message has successfully been copied and removed from queue */

        return CAN_OK;

    #else

        /*

         * RX queue is disabled, so try to get message from controller.

         * We don't know which buffer to get the message from, so best

         * we can do is to get from buf0 first time, and then increase

         * buffer number at each call, finally wrapping around at

         * CAN_CONTROLLER_NR_RX_BUFFERS.

         */

        static uint8_t rxBuffer = 0;

        /* worst case is that we need to check all available rx buffers in order to find a message */

        for (uint8_t i=0; i<CAN_CONTROLLER_NR_RX_BUFFERS; i++) {

            /* is there a message available in this buffer? */

            if (Can_ReceiveFromController(msg, rxBuffer) == CAN_OK) {

                /* increase buffer number and return the message */

                rxBuffer = (rxBuffer + 1) % CAN_CONTROLLER_NR_RX_BUFFERS;

                return CAN_OK;

            }

            /* increase buffer number so we can check next buffer */

            rxBuffer = (rxBuffer + 1) % CAN_CONTROLLER_NR_RX_BUFFERS;

        }

        /* all buffers were checked, but no message found */

        return CAN_NO_MSG_AVAILABLE;

    #endif

}

/*-----------------------------------------------------------------------------

 * Private Functions

 *---------------------------------------------------------------------------*/  

/**

 * Sends a CAN message immediately with the controller hardware. If the CAN

 * controller is busy, the function will return CAN_SEND_FAIL_TX_BUSY.

 *

 * @param msg

 *      Pointer to the CAN message storage buffer.

 *

 * @return

 *      CAN_OK if the message was successfully sent to the controller.

 *      CAN_FAIL if the controller is busy.

 */

static Can_Return_t Can_SendImmediately(Can_Message_t* msg) {

    #if CAN_CONTROLLER == CAN_CONTROLLER_NULL

        /*

         * Send with null device.

         */

        return CAN_OK;

    #endif

    #if CAN_CONTROLLER == CAN_CONTROLLER_MCP2515

        /*

         * Send with MCP2515 device.

         */

        uint8_t res, txbuf_n;

        res = MCP2515_GetNextFreeTXBuf(&txbuf_n); // info = addr.

        if (res == MCP_ALLTXBUSY) {

            return CAN_FAIL;

        }

        MCP2515_WriteCanMsg(txbuf_n, msg);

        MCP2515_StartTransmit(txbuf_n);

        return CAN_OK;

    #endif

}

/**

 * Receives a CAN message from the CAN controller hardware.

 *

 * @param msg

 *      Pointer to the message storage buffer into which the message should be copied.

 *

 * @param rxBuffer

 *      Identifies the RX buffer in the controller. Range is [0,CAN_CONTROLLER_NR_RX_BUFFERS-1].

 *

 * @return

 *      CAN_OK if a received message was successfully copied into the buffer.

 *      CAN_NO_MSG_AVAILABLE if there are is no message available in the specified buffer.

 *      CAN_FAIL if the rxBuffer parameter i out of range for the specified controller.

 */

static Can_Return_t Can_ReceiveFromController(Can_Message_t *msg, uint8_t rxBuffer) {

    #if CAN_CONTROLLER == CAN_CONTROLLER_NULL

        /*

         * Receive from null device.

         */

        return CAN_NO_MSG_AVAILABLE;

    #endif

    #if CAN_CONTROLLER == CAN_CONTROLLER_MCP2515

        /*

         * Receive from MCP2515 device.

         */

        uint8_t stat;

        stat = MCP2515_ReadStatus();

        if (rxBuffer == 0) {

            /* check BUF0 */

            if (stat & MCP_STAT_RX0IF) {

                /* Msg in Buffer 0 */

                MCP2515_ReadCanMsg(MCP_RXBUF_0, msg);

                MCP2515_ModifyRegister(MCP_CANINTF, MCP_RX0IF, 0);

                return CAN_OK;

            }

        }

        else if (rxBuffer == 1) {

            /* check BUF1 */

            if (stat & MCP_STAT_RX1IF) {

                /* Msg in Buffer 1 */

                MCP2515_ReadCanMsg(MCP_RXBUF_1, msg);

                MCP2515_ModifyRegister(MCP_CANINTF, MCP_RX1IF, 0);

                return CAN_OK;

            }

        }

        else {

            /* invalid parameters */

            return CAN_FAIL;

        }

        return CAN_NO_MSG_AVAILABLE;

    #endif

}

/**

 * Checks how many messages are available in the CAN controller hardware.

 *

 * @return

 *      The number of messages available (0 if none).

 */

static uint8_t Can_MessagesAvailableInController() {

    #if CAN_CONTROLLER == CAN_CONTROLLER_NULL

        /*

         * Check for messages in null device.

         */

        return 0;

    #endif

    #if CAN_CONTROLLER == CAN_CONTROLLER_MCP2515

        /*

         * Check for message in MCP2515 device.

         */

        uint8_t res;

        res = MCP2515_ReadStatus(); /* RXnIF in Bit 1 and 0 */

        if (res & MCP_STAT_RXIF_MASK) {

            //TODO: check how many messages are available

            return 1;   /* at least one message available */

        }

        else {

            return 0;   /* no messages available */

        }

    #endif

    return 0;

}

/*

 * Checks Controller-Error-State.

 *

 * @return

 *      CAN_OK if the controller is OK.

 *      CAN_FAIL if errors have occured.

 *

 * @todo

 *      Styr upp denna funktion lite bättre.

 */

static Can_Return_t Can_ControllerCheckError() {

    #if CAN_CONTROLLER == CAN_CONTROLLER_NULL

        /*

         * Check for errors in null device.

         */

        return CAN_OK;

    #endif

    #if CAN_CONTROLLER == CAN_CONTROLLER_MCP2515

        /*

         * Check for errors in MCP2515 device.

         */

        uint8_t eflg = MCP2515_ReadRegister(MCP_EFLG);

        if (eflg & MCP_EFLG_ERRORMASK) {

            return CAN_FAIL;    /* errors found */

        }

        else {

            return CAN_OK;      /* no errors found */

        }

    #endif

}

#if (CAN_QUEUE_SIZE_TX > 0) || (CAN_QUEUE_SIZE_RX > 0)

/**

 * Initializes a CAN queue.

 *

 * @param q

 *      Pointer to the queue object.

 *

 * @param size

 *      Size of the queue (number of messages that can be queued).

 *

 * @param dataPtr

 *      Pointer to the message storage buffer that should be used by the queue.

 */

static void Can_QueueInit(Can_MessageQueue_t *q, uint8_t size, Can_Message_t *dataPtr) {

    q->dataPtr = dataPtr;

    q->head = 0;

    q->tail = 0;

    q->nrElements = 0;

    q->size = size;

}

/**

 * Inserts a new element in a queue and returns a pointer to the new element.

 * If the queue is full, the last element (the tail) will be overwritten by

 * the new element.

 *

 * @param q

 *      Pointer to the queue object.

 *

 * @return

 *      Pointer to the new message element. Use this pointer to copy data into the queue.

 */

static Can_Message_t* Can_QueueInsert(Can_MessageQueue_t *q) {

    Can_Message_t *ptr;

    #if 0

    printf("INSERT: bef=%u, ", q->nrElements);

    #endif

    if ((q->nrElements+1) > q->size) {

        q->tail = (q->tail + 1) % q->size;

        q->nrElements--;

    #if 0

        printf("Can_QueueInsertViaPtr: QUEUE OVERRUN!\n\r");

    #endif

    }

    ptr = &(q->dataPtr[q->head]);

    #if 0

    if (q->handled[q->head] == 0) {

        printf("Can_QueueInsertViaPtr: discarding non-handled msg!\n\r");

    }

    #endif

    q->head = (q->head + 1) % q->size;

    q->nrElements++;

    #if 0

    printf("aft=%u\n\n", q->nrElements);

    #endif

    return ptr;

}

/**

 * Returns a pointer to the last element in the queue (the tail). Use this pointer

 * to extract the message, and then call Can_QueueRemoveTail to actually remove

 * the element.

 *

 * @param q

 *      Pointer to the queue object.

 *

 * @return

 *      Pointer to the tail message element.

 */

static Can_Message_t* Can_QueueReadTailPtr(Can_MessageQueue_t *q) {

    if (q->nrElements > 0) {

        return &(q->dataPtr[q->tail]);

    }

    else {

        return 0;

    }

}

/**

 * Removes the last element in the queue (the tail). You should have extracted

 * the data using Can_QueueReadTailPtr before using this function.

 *

 * @param q

 *      Pointer to the queue object.

 */

static void Can_QueueRemoveTail(Can_MessageQueue_t *q) {

    if (q->nrElements > 0) {

        q->tail = (q->tail + 1) % q->size;

        q->nrElements--;

        #if 0

        printf("queue size = %u\n", q->nrElements);

        #endif

    }

}

#endif