?? linprot.c
字號:
#define LINPROT_C
#if !defined(USEXGATE)
/******************************************************************************
*
* Copyright (C) 2005 Freescale Semiconductor, Inc.
* All Rights Reserved
*
* Filename: linprot.c
*
* Revision:
*
* Functions: LIN Protocol module. Master and Slave State Machines
*
* Description:
*
* Notes:
*
******************************************************************************/
#include <linbase.h>
#pragma MESSAGE DISABLE C4200 /* WARNING C4200: other segment than in previous declaration */
/****************************************************************************
* Defines
***************************************************************************/
#define LIN_SYNC_FIELD 0x55 /* Sync byte */
#define LIN_REQUEST_COMMAND_FRAME 0x3C /* Master Request Command Frame ID */
#define LIN_RESPONSE_COMMAND_FRAME 0x3D /* Slave Response Command Frame ID */
#define LIN_COMMAND_SLEEP 0x00 /* Command code for Go to Sleep Mode */
/****************************************************************************
* All common-purpose RAM variables shall be declared here.
* Some of the variables (more often used) can be located in the DIRECT page
***************************************************************************/
LIN_ZPAGE LIN_BYTE LIN_ProtBuf[LIN_PROT_BUF_LEN]; /* Protocol buffer */
#if defined(USEZEROPAGE)
#pragma DATA_SEG __SHORT_SEG ZeroSeg
#endif /* defined(USEZEROPAGE) */
LIN_ZPAGE LIN_BYTE LIN_StateFlags; /* State machine status */
LIN_ZPAGE LIN_BYTE LIN_TmpSCIByte; /* byte to receive byte from SCI */
/* it shoud be used only under disabled interrupts */
LIN_ZPAGE LIN_BYTE LIN_ChkSum; /* byte to calculate checksum */
LIN_ZPAGE LIN_BYTE LIN_MsgLength; /* Message length [2, 4, 8] */
LIN_ZPAGE LIN_BYTE LIN_SaveIdx; /* Current processed message index */
LIN_ZPAGE LIN_BYTE LIN_BufCounter; /* ProtBuf counter point to sended byte for FLAG_DATA_SEND */
/* or to first free byte for FLAG_DATA_RECEIVE or FLAG_DATA_IGNORE */
#if defined(MASTER)
LIN_ZPAGE LINMsgIdType LIN_SaveIdentifier; /* Message identifier */
#endif /* defined(MASTER) */
#if defined(USEZEROPAGE)
#pragma DATA_SEG DEFAULT
#endif /* defined(USEZEROPAGE) */
/****************************************************************************
* Functions
***************************************************************************/
#pragma CODE_SEG .lintext
/***************************************************************************
* Function : LIN_CopyToBuf
*
* Description: Copy data from src to LIN_ProtBuf
*
* Returns: none
*
* Notes: OPTIM
**************************************************************************/
void near LIN_CopyToBuf( LIN_BYTE * src )
{
LIN_BYTE i;
#if defined(LINAPI_1_0)
/* reverse copy for LIN API */
for( i = 0; i < LIN_MsgLength; i++ )
{
LIN_ProtBuf[i] = src[LIN_MsgLength - i - 1];
}
#else /* !defined(LINAPI_1_0) */
/* normal copy for Freescale API */
for( i = 0; i < LIN_MsgLength; i++ )
{
LIN_ProtBuf[i] = src[i];
}
#endif
}
/***************************************************************************
* Function : LIN_CopyFromBuf
*
* Description: Copy data from LIN_ProtBuf to dst
*
* Returns: none
*
* Notes: OPTIM
**************************************************************************/
void near LIN_CopyFromBuf( LIN_BYTE * dst )
{
LIN_BYTE i;
#if defined(LINAPI_1_0)
/* reverse copy for LIN API */
for( i = 0; i < LIN_MsgLength; i++ )
{
dst[i] = LIN_ProtBuf[LIN_MsgLength - i - 1];
}
#else /* !defined(LINAPI_1_0) */
/* normal copy for Freescale API */
for( i = 0; i < LIN_MsgLength; i++ )
{
dst[i] = LIN_ProtBuf[i];
}
#endif
}
/***************************************************************************
* Function : LIN_ChkAddByte
*
* Description: Add byte with carry to LIN_ChkSum variable
*
* Returns: none
*
* Notes:
*
**************************************************************************/
#if defined(CW12)
#pragma OPTION ADD handle_register "-Or"
#endif /* defined(CW12) */
void near LIN_ChkAddByte(LIN_BYTE byte)
{
#if defined(CW12)
asm
{
ADDB LIN_ChkSum;
ADCB #0;
STAB LIN_ChkSum;
}
#endif /* defined(CW12) */
}
#if defined(CW12)
#pragma OPTION DEL handle_register
#endif /* defined(CW12) */
/***************************************************************************
* Function : LIN_Error
*
* Description: Set error and go to LIN_FLAG_IGNORE state
*
* Returns: none
*
* Notes: Can be called only from states:
* MASTER: LIN_FLAG_SEND_HEADER,
* LIN_FLAG_SEND_DATA,
* LIN_FLAG_IGNORE_DATA,
* LIN_FLAG_RECEIVE_DATA
* SLAVE: LIN_FLAG_RECEIVE_SYNC,
* LIN_FLAG_RECEIVE_ID,
* LIN_FLAG_SEND_DATA,
* LIN_FLAG_RECEIVE_DATA
*
**************************************************************************/
void near LIN_Error( void )
{
#if defined(MASTER)
LIN_CancelTimeout(); /* Cancel MaxFrame timeout */
#endif /* defined(MASTER) */
/* Check what type of the error occure -- Tx or Rx */
#if defined(MASTER)
if ( LIN_StateFlags & ( LIN_FLAG_SEND_HEADER | LIN_FLAG_SEND_DATA ))
#endif /* defined(MASTER) */
#if defined(SLAVE)
if ( LIN_StateFlags & LIN_FLAG_SEND_DATA )
#endif /* defined(SLAVE) */
{
LIN_SetTxErr();
}
else
{
LIN_SetRxErr();
}
LIN_StateFlags = LIN_FLAG_IGNORE;
}
/***************************************************************************
* Function : LIN_EndOfFrame
*
* Description: Non-error end of frame
*
* Returns: none
*
* Notes: Can be called only from states:
* MASTER:
* LIN_FLAG_SEND_DATA,
* LIN_FLAG_IGNORE_DATA,
* LIN_FLAG_RECEIVE_DATA
* SLAVE:
* LIN_FLAG_RECEIVE_ID,
* LIN_FLAG_SEND_DATA,
* LIN_FLAG_RECEIVE_DATA
*
**************************************************************************/
void near LIN_EndOfFrame( void )
{
#if defined(MASTER)
LIN_CancelTimeout(); /* Cancel MaxFrame timeout */
#endif /* defined(MASTER) */
/* Check what type of frame ended -- Tx or Rx */
if ( LIN_StateFlags & LIN_FLAG_SEND_DATA )
{
LIN_ShiftTxErr();
}
else
{
LIN_ShiftRxErr();
}
#if !defined(LINAPI_1_0)
/* Check Command Frame -- only for Freescale API -- OPTIM */
if (
/* We process Command Frame only if node configured to Receive or send data for it */
( LIN_StateFlags & (LIN_FLAG_SEND_DATA | LIN_FLAG_RECEIVE_DATA) ) &&
/* AND check frame's ID that we have just processed */
#if defined(MASTER)
/* For Master: LIN_SaveIdentifier -- just processed frame's identifier */
( LIN_SaveIdentifier == LIN_REQUEST_COMMAND_FRAME )
#endif /* defined(MASTER) */
#if defined(SLAVE)
/* For Slave: LinMsgId[LIN_SaveIdx] & LIN_MSG_INDEX_MASK -- just processed frame's identifier */
/* NB: LIN_SaveIdx exists becouse we already check that we are not ignore this message */
( (LinMsgId[LIN_SaveIdx] & LIN_MSG_INDEX_MASK) == LIN_REQUEST_COMMAND_FRAME )
#endif /* defined(SLAVE) */
)
{
/* yes, we have just processed Master Command Request Frame */
/* Check Command code */
if ( LIN_ProtBuf[0] == LIN_COMMAND_SLEEP )
{
/* Go to Sleep Mode command */
LIN_StateFlags = LIN_FLAG_IGNORE | LIN_FLAG_SLEEP;
}
/* ... any other commands ... */
else
{
/* not specific command */
LIN_StateFlags = LIN_FLAG_IGNORE;
}
LIN_Command(); /* user hook after any Command */
}
else
#endif /* !defined(LINAPI_1_0) */
{ /* no any commands */
LIN_StateFlags = LIN_FLAG_IGNORE;
}
}
#if defined(SLAVE)
/***************************************************************************
* Function : LIN_TxCompleted
*
* Description: Tx interrupt
*
* Returns: none
*
* Notes:
*
**************************************************************************/
void near LIN_TxCompleted( void )
{
/**********************************************************************/
/*** SLAVE: LIN_FLAG_WAKEUP_TIMEOUT ***/
/**********************************************************************/
if (LIN_StateFlags & LIN_FLAG_WAKEUP_TIMEOUT)
{
LIN_SetIdleTimeout(); /* Set idle timeout again */
LIN_StateFlags = LIN_FLAG_IGNORE;
}
#if defined(LIN_DBG_CHECK_INTERNAL_ERROR)
else
{
LIN_InternalError = LIN_ERROR_7;
while (1)
{}
}
#endif /* defined(LIN_DBG_CHECK_INTERNAL_ERROR) */
}
#endif /* defined(SLAVE) */
/***************************************************************************
* Function : LIN_RxCompleted
*
* Description: Rx interrupt
* LIN_TmpSCIByte = SCI Data Register
*
* Returns: none
*
* Notes: cases are in order of frequency of occuring
*
**************************************************************************/
void near LIN_RxCompleted( void )
{
LIN_BYTE tmp; /* temporary variable: counter or message direction flags */
/**********************************************************************/
/*** MASTER & SLAVE : LIN_FLAG_RECEIVE_DATA ***/
/**********************************************************************/
if (LIN_StateFlags & LIN_FLAG_RECEIVE_DATA )
{
if (LIN_BufCounter < LIN_MsgLength) /* NB: LIN_MsgLength = 1..8 */
{
/* not all bytes received */
/* receive message data */
LIN_ProtBuf[LIN_BufCounter] = LIN_TmpSCIByte;
++LIN_BufCounter;
/* calculate checksum from received byte */
LIN_ChkAddByte(LIN_TmpSCIByte);
}
else
{ /* all data and checksum has been received */
if ( (LIN_ChkSum + LIN_TmpSCIByte) != 0xff )
{
/* Checksum error */
LIN_Error(); /* Rx error */
}
else
{ /* no error */
/* Message received succesfuly so copy it to proper place and update flags */
LIN_CopyFromBuf(LinMsgBuf[LIN_SaveIdx]);
#if defined(LINAPI_1_0)
/* set flags for all signals placed into received message */
for( tmp = LinFlagLookup[LIN_SaveIdx]; tmp < LinFlagLookup[LIN_SaveIdx + 1]; tmp++ )
{
LinSigFlags[tmp] = 0xFFu;
}
#else /* defined(LINAPI_1_0) */
/* set appropriate status for received message */
if (( LinMsgStatus[LIN_SaveIdx] & ((LIN_BYTE)LIN_MSG_OK | (LIN_BYTE)LIN_MSG_OVERRUN )) != 0 )
{
LinMsgStatus[LIN_SaveIdx] = LIN_MSG_OVERRUN;
}
else
{
LinMsgStatus[LIN_SaveIdx] = LIN_MSG_OK;
}
#endif /* defined(LINAPI_1_0) */
LIN_EndOfFrame();
}
}
}
/**********************************************************************/
/*** MASTER & SLAVE: LIN_FLAG_SEND_DATA ***/
/**********************************************************************/
else if (LIN_StateFlags & LIN_FLAG_SEND_DATA)
{
if (LIN_BufCounter < LIN_MsgLength)
{
/* not all bytes sended */
if (LIN_ProtBuf[LIN_BufCounter] != LIN_TmpSCIByte )
{
/* bit error in data */
LIN_Error(); /* Tx error */
}
else
{ /* send next byte */
++LIN_BufCounter;
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -