nikon/CANopenNode
1
0
Fork 0
Code Activity Actions
CANopenNode/stack/MCF5282/CO_driver.c

470 lines
17 KiB
C
Raw Blame History

/*
* CAN module object for Freescale MCF5282 ColdFire V2 microcontroller.
*
* @file CO_driver.c
* @author Janez Paternoster
* @author Laurent Grosbois
* @copyright 2004 - 2012 Janez Paternoster
*
* This file is part of CANopenNode, an opensource CANopen Stack.
* Project home page is <http://canopennode.sourceforge.net>.
* For more information on CANopen see <http://www.can-cia.org/>.
*
* CANopenNode is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 2.1 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "CO_driver.h"
#include "CO_Emergency.h"
extern const CO_CANbitRateData_t CO_CANbitRateData[8];
/******************************************************************************/
void CO_CANsetConfigurationMode(uint16_t CANbaseAddress){
/* sets the module as running */
MCF_FlexCAN_CANMCR &= ~MCF_FlexCAN_CANMCR_STOP;
/* enter debug mode */
MCF_FlexCAN_CANMCR |= MCF_FlexCAN_CANMCR_FRZ | MCF_FlexCAN_CANMCR_HALT;
/* wait for entering in the mode */
while(!(MCF_FlexCAN_CANMCR&MCF_FlexCAN_CANMCR_FRZACK)){};
}
/******************************************************************************/
void CO_CANsetNormalMode(uint16_t CANbaseAddress){
/* sets the module as running & exit debug mode */
MCF_FlexCAN_CANMCR &= ~MCF_FlexCAN_CANMCR_STOP & ~MCF_FlexCAN_CANMCR_FRZ & ~MCF_FlexCAN_CANMCR_HALT;
/* wait for entering in the mode */
while(!(MCF_FlexCAN_CANMCR&&MCF_FlexCAN_CANMCR_NOTRDY)){};
}
/******************************************************************************/
CO_ReturnError_t CO_CANmodule_init(
CO_CANmodule_t *CANmodule,
uint16_t CANbaseAddress,
CO_CANrx_t rxArray[],
uint16_t rxSize,
CO_CANtx_t txArray[],
uint16_t txSize,
uint16_t CANbitRate)
{
uint16_t i;
uint8_t nb_CANbuff = 16; //16 CAN buffers
/* verify arguments */
if(CANmodule==NULL || rxArray==NULL || txArray==NULL){
return CO_ERROR_ILLEGAL_ARGUMENT;
}
/* Configure object variables */
CANmodule->CANbaseAddress = CANbaseAddress;
CANmodule->CANmsgBuffSize = nb_CANbuff;
CANmodule->rxArray = rxArray;
CANmodule->rxSize = rxSize;
CANmodule->txArray = txArray;
CANmodule->txSize = txSize;
CANmodule->useCANrxFilters = false; //no filters or ((rxSize <= xx) ? true : false;)
CANmodule->bufferInhibitFlag = false;
CANmodule->firstCANtxMessage = true;
CANmodule->CANtxCount = 0U;
CANmodule->errOld = 0U;
CANmodule->em = NULL;
for(i=0U; i<rxSize; i++){
rxArray[i].ident = 0U;
rxArray[i].pFunct = NULL;
}
for(i=0U; i<txSize; i++){
txArray[i].bufferFull = false;
}
/**** HARDWARE CONFIGURATION ****/
/* soft reset */
MCF_FlexCAN_CANMCR |= MCF_FlexCAN_CANMCR_SOFTRST;
/* Tx & Rx pin modes */
MCF_FlexCAN_CANCTRL0 &= ~MCF_FlexCAN_CANCTRL0_BOFFMSK & ~MCF_FlexCAN_CANCTRL0_ERRMSK & ~MCF_FlexCAN_CANCTRL0_RXMODE & ~MCF_FlexCAN_CANCTRL0_TXMODE(0);
/* - no Bus off interrupt
- no error interrupt
- Rx mode : 0 is dominant bit
- Tx mode : full CMOS positive */
//reset ctrl registers
MCF_FlexCAN_CANCTRL1 = 0x00;
MCF_FlexCAN_CANCTRL2 = 0x00;
/* Configure CAN timing */
switch(CANbitRate){
default:
case 125: i=3; break;
case 1000: i=7; break;
}
MCF_FlexCAN_CANCTRL1 |= MCF_FlexCAN_CANCTRL1_PROPSEG(CO_CANbitRateData[i].PROP);
MCF_FlexCAN_CANCTRL2 |= MCF_FlexCAN_CANCTRL2_RJW(CO_CANbitRateData[i].SJW);
MCF_FlexCAN_CANCTRL2 |= MCF_FlexCAN_CANCTRL2_PSEG1(CO_CANbitRateData[i].phSeg1);
MCF_FlexCAN_CANCTRL2 |= MCF_FlexCAN_CANCTRL2_PSEG2(CO_CANbitRateData[i].phSeg2);
MCF_FlexCAN_PRESDIV = CO_CANbitRateData[i].BRP;
/*** here should go specific option concerning CTRL1 & CTRL2 registers ***/
/* CAN module hardware filters */
//clear all filter control registers
MCF_FlexCAN_RXGMASK = 0x00; //mask for Rx[0-13]
MCF_FlexCAN_RX14MASK = 0x00; //mask for Rx14
MCF_FlexCAN_RX15MASK = 0x00; //mask for Rx15
//Set masks to accept all all messages with standard 11-bit identifier
MCF_FlexCAN_RXGMASK = 0x00080000;
MCF_FlexCAN_RX14MASK = 0x00080000;
MCF_FlexCAN_RX15MASK = 0x00080000;
/*
if(CANmodule->useCANrxFilters){
//CAN module filters are used, they will be configured with
//CO_CANrxBufferInit() functions, called by separate CANopen
//init functions.
//Configure all masks so, that received message must match filter
MCF_FlexCAN_RXGMASK = 0xFFE80000;
MCF_FlexCAN_RX14MASK = 0xFFE80000;
MCF_FlexCAN_RX15MASK = 0xFFE80000;
}
else{
//CAN module filters are not used, all messages with standard 11-bit
//identifier will be received
//Configure all mask so, that all messages with standard identifier are accepted
MCF_FlexCAN_RXGMASK = 0x00080000;
MCF_FlexCAN_RX14MASK = 0x00080000;
MCF_FlexCAN_RX15MASK = 0x00080000;
}*/
/* CAN Module configuration register */
MCF_FlexCAN_CANMCR &= ~MCF_FlexCAN_CANMCR_STOP & ~MCF_FlexCAN_CANMCR_FRZ & ~MCF_FlexCAN_CANMCR_HALT;
/* configure buffers 0-13 as input buffers */
for(i=0;i<14;i++)
{
MCF_CANMB_CTRL(i) = MCF_CANMB_CTRL_CODE(0b0100);
}
/* configure buffers 14-15 as output buffers */
MCF_CANMB_CTRL14 = MCF_CANMB_CTRL_CODE(0b1000);
MCF_CANMB_CTRL15 = MCF_CANMB_CTRL_CODE(0b1000);
/* CAN interrupt registers */
//Enable all buffer interrupts (can be either Rx or Tx interrupt depending on buffer configuration)
MCF_FlexCAN_IMASK = 0xFF;
MCF_FlexCAN_IFLAG = 0xFF;
return CO_ERROR_NO;
}
/******************************************************************************/
void CO_CANmodule_disable(CO_CANmodule_t *CANmodule){
CO_CANsetConfigurationMode(CANmodule->CANbaseAddress);
}
/******************************************************************************/
uint16_t CO_CANrxMsg_readIdent(const CO_CANrxMsg_t *rxMsg){
return (uint16_t) (rxMsg->sid>>5);
}
/******************************************************************************/
CO_ReturnError_t CO_CANrxBufferInit(
CO_CANmodule_t *CANmodule,
uint16_t index,
uint16_t ident,
uint16_t mask,
bool_t rtr,
void *object,
void (*pFunct)(void *object, const CO_CANrxMsg_t *message))
{
CO_ReturnError_t ret = CO_ERROR_NO;
if((CANmodule!=NULL) && (object!=NULL) && (pFunct!=NULL) && (index < CANmodule->rxSize)){
/* buffer, which will be configured */
CO_CANrx_t *buffer = &CANmodule->rxArray[index];
/* Configure object variables */
buffer->object = object;
buffer->pFunct = pFunct;
/* CAN identifier and CAN mask, bit aligned with CAN module */
buffer->ident = (uint16_t) ((ident & 0x07FF)<<5);
if(rtr){
buffer->ident |= 0x0010;
}
buffer->mask = (uint16_t) (((mask & 0x07FF)<<5) | 0x0080);
/* Set CAN hardware module filter and mask. */
if(CANmodule->useCANrxFilters){
//filters are not used.
}
}
else{
ret = CO_ERROR_ILLEGAL_ARGUMENT;
}
return ret;
}
/******************************************************************************/
CO_CANtx_t *CO_CANtxBufferInit(
CO_CANmodule_t *CANmodule,
uint16_t index,
uint16_t ident,
bool_t rtr,
uint8_t noOfBytes,
bool_t syncFlag)
{
CO_CANtx_t *buffer = NULL;
if((CANmodule != NULL) && (index < CANmodule->txSize)){
/* get specific buffer */
buffer = &CANmodule->txArray[index];
/* CAN identifier, DLC and rtr, bit aligned with CAN module transmit buffer */
buffer->ident = (uint16_t) ((ident & 0x07FF)<<5);
if(rtr) buffer->ident |= 0x0010;
buffer->DLC = noOfBytes;
buffer->bufferFull = false;
buffer->syncFlag = syncFlag;
}
return buffer;
}
/******************************************************************************/
CO_ReturnError_t CO_CANsend(CO_CANmodule_t *CANmodule, CO_CANtx_t *buffer){
CO_ReturnError_t err = CO_ERROR_NO;
uint16_t addr = CANmodule->CANbaseAddress;
uint8_t i;
/* Verify overflow */
if(buffer->bufferFull){
if(!CANmodule->firstCANtxMessage){
/* don't set error, if bootup message is still on buffers */
CO_errorReport((CO_EM_t*)CANmodule->em, CO_EM_CAN_TX_OVERFLOW, CO_EMC_CAN_OVERRUN, buffer->CMSGSID);
}
err = CO_ERROR_TX_OVERFLOW;
}
/* Try to find a free sending buffer */
/* Here, we use buffer 14 & 15 for Tx */
i=14; //initial sending buffer index
while( (MCF_CANMB_CTRL(i) != MCF_CANMB_CTRL_CODE(0b1000))&&
(MCF_CANMB_CTRL(i) != MCF_CANMB_CTRL_CODE(0b0100))&&
(MCF_CANMB_CTRL(i) != MCF_CANMB_CTRL_CODE(0b1010))&&
i<16)//end sending buffer index+1
{
i++;
}
CO_LOCK_CAN_SEND();
/* if CAN TX buffer is free, copy message to it */
if(i<16){
MCF_CANMB_CTRL(i) = 0x0000|MCF_CANMB_CTRL_CODE(0b1000); //Tx MB inactive
MCF_CANMB_SID(i) = buffer->ident;
MCF_CANMB_DATA_WORD_1(i) = (uint16_t) (((buffer->data[0])<<8) | (buffer->data[1]));
MCF_CANMB_DATA_WORD_2(i) = (uint16_t) (((buffer->data[2])<<8) | (buffer->data[3]));
MCF_CANMB_DATA_WORD_3(i) = (uint16_t) (((buffer->data[4])<<8) | (buffer->data[5]));
MCF_CANMB_DATA_WORD_4(i) = (uint16_t) (((buffer->data[6])<<8) | (buffer->data[7]));
MCF_CANMB_CTRL(i) = (uint8_t) (MCF_CANMB_CTRL_CODE(0b1000) | MCF_CANMB_CTRL_LENGTH(buffer->DLC) ); //Tx MB active
}
/* if no buffer is free, message will be sent by interrupt */
else{
buffer->bufferFull = true;
CANmodule->CANtxCount++;
}
CO_UNLOCK_CAN_SEND();
return err;
}
/******************************************************************************/
void CO_CANclearPendingSyncPDOs(CO_CANmodule_t *CANmodule){
CO_LOCK_CAN_SEND();
if(CANmodule->bufferInhibitFlag){
MCF_CANMB_CTRL14 = MCF_CANMB_CTRL_CODE(0b1000); //clear TXREQ
MCF_CANMB_CTRL15 = MCF_CANMB_CTRL_CODE(0b1000); //clear TXREQ
CO_UNLOCK_CAN_SEND();
CO_errorReport((CO_emergencyReport_t*)CANmodule->em, ERROR_TPDO_OUTSIDE_WINDOW, 0);
}
else{
CO_UNLOCK_CAN_SEND();
}
}
/******************************************************************************/
void CO_CANverifyErrors(CO_CANmodule_t *CANmodule){
unsigned rxErrors, txErrors, ESTAT;
uint32_t err;
CO_emergencyReport_t* em = (CO_emergencyReport_t*)CANmodule->em;
rxErrors = MCF_FlexCAN_RXECTR;
txErrors = MCF_FlexCAN_TXECTR;
ESTAT = MCF_FlexCAN_ESTAT & 0xFF00;
if(txErrors > 0xFFFF) txErrors = 0xFFFF;
if(rxErrors > 0xFF) rxErrors = 0xFF;
err = (uint32_t) (txErrors << 16 | rxErrors << 8 | ESTAT>>8);
if(CANmodule->errOld != err){
CANmodule->errOld = err;
if(txErrors >= 256){ //bus off
CO_errorReport(em, ERROR_CAN_TX_BUS_OFF, err);
}
else{ //not bus off
CO_errorReset(em, ERROR_CAN_TX_BUS_OFF, err);
if(rxErrors >= 96 || txErrors >= 96){ //bus warning
CO_errorReport(em, ERROR_CAN_BUS_WARNING, err);
}
if(rxErrors >= 128){ //RX bus passive
CO_errorReport(em, ERROR_CAN_RX_BUS_PASSIVE, err);
}
else{
CO_errorReset(em, ERROR_CAN_RX_BUS_PASSIVE, err);
}
if(txErrors >= 128){ //TX bus passive
if(!CANmodule->firstCANtxMessage){
CO_errorReport(em, ERROR_CAN_TX_BUS_PASSIVE, err);
}
}
else{
int16_t wasCleared;
wasCleared = CO_errorReset(em, ERROR_CAN_TX_BUS_PASSIVE, err);
if(wasCleared == 1) CO_errorReset(em, ERROR_CAN_TX_OVERFLOW, err);
}
if(rxErrors < 96 && txErrors < 96){ //no error
int16_t wasCleared;
wasCleared = CO_errorReset(em, ERROR_CAN_BUS_WARNING, err);
if(wasCleared == 1) CO_errorReset(em, ERROR_CAN_TX_OVERFLOW, err);
}
}
if(ESTAT&MCF_FlexCAN_ESTAT_TXWARN && ESTAT&MCF_FlexCAN_ESTAT_RXWARN){//bus warning
CO_errorReport(em, ERROR_CAN_BUS_WARNING, err);
}
else{
CO_errorReset(em, ERROR_CAN_BUS_WARNING, err);
}
}
}
/******************************************************************************/
void CO_CANinterrupt(CO_CANmodule_t *CANmodule, uint16_t ICODE){
/* receive interrupt (New CAN message is available in one of the Rx buffers) */
if(ICODE <= 13){
CO_CANrxMsg_t *rcvMsg; /* pointer to received message in CAN module */
uint16_t index; /* index of received message */
uint16_t rcvMsgIdent; /* identifier of the received message */
CO_CANrx_t *buffer = NULL; /* receive message buffer from CO_CANmodule_t object. */
bool_t msgMatched = false;
rcvMsg = &MCF_CANMB_MSG(ICODE); //structures are aligned
rcvMsgIdent = (uint16_t) rcvMsg->sid;
if(rcvMsg->RTR) rcvMsgIdent |= 0x0800;
/* CAN module filters are not used, message with any standard 11-bit identifier */
/* has been received. Search rxArray form CANmodule for the same CAN-ID. */
buffer = &CANmodule->rxArray[0];
for(index = CANmodule->rxSize; index > 0U; index--){
if(((rcvMsgIdent ^ buffer->ident) & buffer->mask) == 0U){
msgMatched = true;
break;
}
buffer++;
}
/* Call specific function, which will process the message */
if(msgMatched && (buffer != NULL) && (buffer->pFunct != NULL)){
buffer->pFunct(buffer->object, rcvMsg);
}
}
/* transmit interrupt (TX buffer 14 or 15 has finished sending) */
else if(ICODE >14 ){
/* First CAN message (bootup) was sent successfully */
CANmodule->firstCANtxMessage = false;
/* clear flag from previous message */
CANmodule->bufferInhibitFlag = false;
/* Are there any new messages waiting to be send */
if(CANmodule->CANtxCount > 0U){
uint16_t i; /* index of transmitting message */
CO_CANtx_t *buffer; /* Tx buffer */
/* first buffer */
buffer = &CANmodule->txArray[0];
/* search through whole array of pointers to transmit message buffers. */
for(i = CANmodule->txSize; i > 0U; i--){
/* if message buffer is full, send it. */
if(buffer->bufferFull){
buffer->bufferFull = false;
CANmodule->CANtxCount--;
/* Copy message to CAN buffer */
CANmodule->bufferInhibitFlag = buffer->syncFlag;
MCF_CANMB_CTRL(ICODE) = 0x0000|MCF_CANMB_CTRL_CODE(0b1000); //Tx MB inactive
MCF_CANMB_SID(ICODE) = buffer->ident;
MCF_CANMB_DATA_WORD_1(ICODE) = (uint16_t) (((buffer->data[0])<<8) | (buffer->data[1]));
MCF_CANMB_DATA_WORD_2(ICODE) = (uint16_t) (((buffer->data[2])<<8) | (buffer->data[3]));
MCF_CANMB_DATA_WORD_3(ICODE) = (uint16_t) (((buffer->data[4])<<8) | (buffer->data[5]));
MCF_CANMB_DATA_WORD_4(ICODE) = (uint16_t) (((buffer->data[6])<<8) | (buffer->data[7]));
MCF_CANMB_CTRL(ICODE) = (uint8_t) (MCF_CANMB_CTRL_CODE(0b1000) | MCF_CANMB_CTRL_LENGTH(buffer->DLC) ); //Tx MB active
break; /* exit for loop */
}
buffer++;
}/* end of for loop */
/* Clear counter if no more messages */
if(i == 0U){
CANmodule->CANtxCount = 0U;
}
}
}
}
View git blame Copy permalink