📄 mscandrvlite.c
字号:
}
else
{
if (interruptBufferBit & 0x02)
{
interruptBufferNo = 1;
TX_Buff = TX_BUFF1;
CANTIER &= ~0x02; /* disable interrupt */
}
else
{
interruptBufferNo = 2;
TX_Buff = TX_BUFF2;
CANTIER &= ~0x04; /* disable interrupt */
}
#if (NO_OF_MSCAN_TXBUFFER != 3)
#error msCAN buffer not checked
#endif
}
buffer = MB_MSCAN[interruptBufferNo]; /* buffer number */
MB_MSCAN[interruptBufferNo] = 0xff; /* clear Message Buffer from MB_MSCAN */
MBP_MSCAN[interruptBufferNo] = 0xff; /* initialise message buffer priority */
if (CANTAAK & interruptBufferBit) /* transmission aborted */
{
if (BufferStatus_CAN0[buffer] == QUEUED2) /* aborted due to higher priority queued MB */
{
BufferStatus_CAN0[buffer] = QUEUED; /* set MB Queued to put back in queue */
if (buffer < LowestQueuedBuffer)
{
nextBuffer = LowestQueuedBuffer = buffer;
}
}
else
{
if (BufferStatus_CAN0[buffer] == ABORTREQ) /* aborted due to AbortMB_CAN */
{
BufferStatus_CAN0[buffer] = ABORTED;
}
} /* otherwise aborted due to ConfigMB_CAN */
}
else /* transmission completed */
{
if (BufferMode_CAN0[buffer] == TXRF) /* transmitted remote frame */
{
BufferMode_CAN0[buffer] = RXDF; /* receive data frame */
BufferStatus_CAN0[buffer] = NODATA;
}
else /* transmitted Data TXDF or AUTOTXDF */
{
BufferStatus_CAN0[buffer] = TRANSMITTED;
}
if (TimeStampOption)
{
CANTBSEL = interruptBufferBit;
BufferTimeStamp_CAN0[buffer] = TX_BUFF_TSR;
}
} /* end: else transmission completed */
/* source of interrupt now dealt with */
/* find highest priority queued MB */
if(AbortMessage == 0xff) /* No abort due to higher priority MO */
{
for(buffer = LowestQueuedBuffer; buffer < NoOfMB; buffer++)
{
if (BufferStatus_CAN0[buffer] == QUEUED)
{
if(nextBuffer == LowestQueuedBuffer) /* Search for next queued MB */
{
nextBuffer = buffer;
}
if (BufferID_Ref_CAN0[buffer] < highestPriority) /* Search for highest priority queued buffer */
{
highestPriority = BufferID_Ref_CAN0[buffer];
highestPriorityBuffer = buffer;
}
}
}
if (highestPriorityBuffer == LowestQueuedBuffer)
{
LowestQueuedBuffer = nextBuffer; /* start of search for next TxISR */
}
}
else /* Highest priority MB known */
{
/* copy the message number that caused the abort */
highestPriorityBuffer = AbortMessage;
highestPriority = BufferID_Ref_CAN0[highestPriorityBuffer];
AbortMessage = 0xff; /* show that this message has been handled */
}
if (highestPriority == 0xff) /* no MBs queued: assume < 256 Message buffers */
{
if (DriverFlags & SLEEP)
{
if (CANTFLG == 0x07) /* msCAN transmit buffers all transmitted */
{
CANCTL0 |= SLPRQ; /* set msCAN SLEEP request */
CANRIER |= WUPIE; /* enable wakeup interrupt */
DriverFlags &= ~SLEEP; /* clear sleep request */
}
}
}
else
/* Message queued: copy highest priority MO into msCAN buffer and schedule transmission */
{
MSCAN_L_Load_Buff (TX_Buff, highestPriorityBuffer, BufferID_Ref_CAN0[highestPriorityBuffer]);
CANTFLG = interruptBufferBit; /* write 1 to TXE to schedule buffer */
CANTIER |= interruptBufferBit; /* enable interrupt for this buffer */
MB_MSCAN[interruptBufferNo] = highestPriorityBuffer; /* write buffer # */
MBP_MSCAN[interruptBufferNo] = highestPriority; /* write priority of buffer */
} /* end else: MB queued */
#ifdef BENCHMARK
PORTB &= ~0x02; /* clear bit 1 */
#endif
return;
}
/******************************************************************************
Function Name : CAN0_ReceiveISR
Engineer : Stuart Robb
Date : 10/8/98
Arguments : void
Return : void
Notes : HC08 Hicross compiler version 5.0.7 fixes bug
******************************************************************************/
#ifdef HICROSS
#pragma TRAP_PROC
#endif
#ifdef COSMIC
@interrupt
#endif
void
CAN0_ReceiveISR (void)
{
UINT8 *MO_ID8_CAN_Ptr;
UINT8 *bufferDataPtr;
UINT8 RX_IdentifierType,
RX_FrameType,
MB_ID_Type,
MB_ID_Ref,
match,
dataLength,
buffer,
i,
bufferMode;
#ifdef BENCHMARK
PORTB |= 0x01; /* set bit 0 */
#endif
if (DriverFlags & SLEEP)
{
DriverFlags &= ~SLEEP; /* clear SLEEP request */
CANRIER &= ~WUPIE; /* clear wakeup interrupt enable */
}
/* Find received Identifier Type and Frame Type */
RX_IdentifierType = RX_BUFF_IDR1 & IDE; /* test IDE bit */
if (RX_IdentifierType == STANDARD) /* IDE clear */
{
RX_FrameType = RX_BUFF_IDR1 & SRTR; /* test RTR bit */
}
else /* Extended ID */
{
RX_FrameType = RX_BUFF_IDR3 & ERTR; /* test RTR bit */
}
match = FALSE;
/* Find matching buffer (if any): for each buffer:
* If Data Frame received and buffer mode = RXDF
* or Remote Frame received and buffer mode = AUTOTXDF,
* and if received Identifier type = buffer identifier type,
* then compare received Identifier with buffer identifier,
* until match found or all buffers tested.
*
* Note: TXRF buffers are not tested although ReceiveISR_CAN may
* theoretically be executed before TransmitISR_CAN
*/
for (buffer = 0; buffer < NoOfMB; buffer++)
{
bufferMode = BufferMode_CAN0[buffer];
if ( ((RX_FrameType == DATAFRAME) && (bufferMode == RXDF))
|| ((RX_FrameType != DATAFRAME) && (bufferMode == AUTOTXDF)))
{
MB_ID_Ref = BufferID_Ref_CAN0[buffer];
MB_ID_Type = M_IdentifierType_CAN0[MB_ID_Ref] & 0x08;
MO_ID8_CAN_Ptr = (UINT8*)&(M_Identifier_CAN0[MB_ID_Ref]);
if (RX_IdentifierType == STANDARD)
{
if (MB_ID_Type == STANDARD) /* MB_ID_Type matches */
{
if ( (RX_BUFF_IDR0 == MO_ID8_CAN_Ptr[0]) /* ID10 to ID3 match */
&& ((RX_BUFF_IDR1 & 0xE0) == MO_ID8_CAN_Ptr[1])) /* ID2 to ID0 match */
{
match = TRUE; /* match found */
break;
}
}
} /* end: if identifier == STANDARD */
else /* MO_IdentiferType == EXTENDED */
{
if (MB_ID_Type != STANDARD) /* MB_ID_Type matches */
{
if ( (RX_BUFF_IDR0 == MO_ID8_CAN_Ptr[0]) /* ID28 to ID21 match */
&& (RX_BUFF_IDR1 == MO_ID8_CAN_Ptr[1]) /* ID20 to ID15 match */
&& (RX_BUFF_IDR2 == MO_ID8_CAN_Ptr[2]) /* ID14 to ID7 match */
&& ((RX_BUFF_IDR3 & 0xFE) == MO_ID8_CAN_Ptr[3])) /* ID6 to ID0 match */
{
match = TRUE; /* match found */
break;
}
} /* end: if identifier type match */
} /* end: else identifier = extended */
} /* end: if buffer mode */
} /* end: for buffer < NO_OF_MB */
if (match)
{
if (bufferMode == AUTOTXDF)
{
CAN_L_QueueMB (buffer); /* queue buffer, copy to msCAN if buffer available, */
/* abort msCAN buffer if all full and this buffer higher priority */
}
else /* bufferMode == RXDF */
{
dataLength = RX_BUFF_DLR & 0x0F; /* mask upper nibble - undefined */
if (dataLength > 8)
{
dataLength = 8;
}
BufferDLC_CAN0[buffer] = dataLength; /* copy DLC */
bufferDataPtr = BufferData_CAN0[buffer]; /* calculate first dimension */
for (i = 0; i < dataLength; i++)
{
bufferDataPtr[i] = RX_BUFF_DSR_Ptr[i]; /* copy data */
}
if (TimeStampOption) /* copy timestamp to Message Buffer */
{
BufferTimeStamp_CAN0[buffer] = RX_BUFF_TSR;
}
if ( (BufferStatus_CAN0[buffer] == READDATA)
||(BufferStatus_CAN0[buffer] == NODATA))
{
BufferStatus_CAN0[buffer] = NEWDATA;
}
else
{
BufferStatus_CAN0[buffer] = OVERRUN; /* previous data not read */
}
} /* end: bufferMode == RXDF */
} /* end: match == TRUE */
CANRFLG = RXF; /* write 1 to clear RXF */
#ifdef BENCHMARK
PORTB &= ~0x01; /* clear bit 0 */
#endif
return;
}
/******************************************************************************
Function Name : CAN0_WakeupISR
Engineer : Stuart Robb
Date : 10/8/98
Arguments : none
Return : none
******************************************************************************/
#ifdef HICROSS
#pragma TRAP_PROC
#endif
#ifdef COSMIC
@interrupt
#endif
void
CAN0_WakeupISR(void)
{
CANRFLG = WUPIF; /* clear wakeup interrupt flag */
CANRIER &= ~WUPIE; /* clear wakeup interrupt enable */
}
/******************************************************************************
Function Name : CAN_GetVersion
Engineer : Stuart Robb
Date : 11/3/99
Arguments : none
Return : Version number
******************************************************************************/
UINT8
CAN_GetVersion (void)
{
return (VERSION);
}
/*****************************************************************************/
/* end msCANdrv.c */
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -