bdlc.c

J1850源码,该程序给出了美国制定的J1850汽车网络的编程模块,以容错处理.

/*****************************************************************************/
/**
  Copyright (c) 2006 Freescale Semiconductor
  Freescale Confidential Proprietary
  \file      BDLC.c	
  \brief     BDLC Driver initializations and BDLC State Machine\n
             Protocol handling (Transmitions, Receptions, Errors)\n
             are managed by this file.	
  \author    Freescale Semiconductor
  \author    R01160 
  \author    Guadalajara Applications Laboratory RTAC Americas
  \version   v0.2 
  \date      06/June/2006	  
*/
/*****************************************************************************/
#include "BDLC.h"
#include "GMCOLayer.h"
#include "J1850_TxRx_Mgs.h"

/** Pointer to transmitted data */
static UINT8  *BDLCOutBufferPtr;             
/** Length of transmitted data */
static UINT16 TxFrameLenght;                    
/** Number of bytes already transmitted */
static UINT16 TxCount;                  
/** This variable counts the amount of bytes in the frame */
UINT8 FrameIndex = 0;
/** BDLC State Machine Control Variable      */
UINT8 bBDLCDriverStatus = 0;
/** Variable used to acknowledge if a frame has been sent */
UINT8 FrameStatus = 0;
/** Create a struct type variable              */
_BDLCStateFlags BDLCStatusFlags; 
/** Count the number of received bytes         */
UINT8 u8RxPointer = 0;
/** Stores any valid data from the J1850 bus   */
UINT8 u8Data = 0;
/** Saves the last recevied command            */
UINT8 u8ReceiveCmd = 0;
/** Control all the posible errors in the J1850 bus */
_BDLCErrorFlags sBDLCErrFlags;
/** Swaps Receive buffer from 0x1020 to 0x1030 and vice versa*/
UINT8 SwapBuffer = 0;
/** Rx Buffer Location Offset                  */
#define RX_BUFFER       0x0600
/** Backup Rx buffer located after 16 bytes in the RxBuffer location */
#define BACK_RX_BUFFER  0x0610

volatile UINT8 TX_BUFFER    @ 0x0620;

/** Receive and Transmit Buffers    */
struct receive_buffer        *RxBuffer;
struct retransmission_buffer *RETRANSMIT_BUFF;
struct receive_buffer        RX_BUFF @ RX_BUFFER;
struct receive_buffer        *BackRxBuffer;
struct receive_buffer        BACK_RX_BUFF @ BACK_RX_BUFFER;
struct retransmission_buffer var_RETRANSMIT_BUFF;
transmit_buffer              TransmitBuffer; 


/******************************************************************************
 *                         BDLC Initialization Routine                        *
 ******************************************************************************/
void vfnBDLCInit(UINT8 Test)
{
  DLCBARD =  (TransTruePolarity | _16us_delay);      /* True polarity, 16us of delay*/
  DLCBRSR = (BDLCRateSelection);                    /* Calculates the BDLC rate selection using the FBUS variable */
  DLCBCR2 =  16;                                     /* arm SMRST,BDLC module is in digital loopback mode
                                                         NBFS = 1,TEOD will automatically cleared after the first
                                                         CRC bit is sent
                                                      */
  
  DLCBCR1 = (Reset | IMSG_Enabled | BDLC_Int_Enabled | BDLC_Stop); /* Ignore Message disabled, BDLC interrupt enabled
                                                                       Binary clock selected, Stop BDLC while Wait mode
  
                                                                       be active  */
  
  
  /* Initialize BDLC status variables */                                                                    
  
  RETRANSMIT_BUFF                    = &var_RETRANSMIT_BUFF;
  RxBuffer                           = &RX_BUFF;
  BackRxBuffer                       = &RX_BUFF;
  BackRxBuffer->u8Bk_BuffPayLoad     = EMPTY;
  BackRxBuffer->u8BufferPayLoad      = EMPTY;
  BackRxBuffer->u8BufferStatus       = EMPTY;
  BackRxBuffer->u8DataReady          = FALSE;
  BackRxBuffer                       = &RX_BUFF; 
  BDLCStatusFlags.IsAlive            = FALSE;
  BDLCStatusFlags.ErrorDetectedFlag  = FALSE;
  BDLCStatusFlags.TxFrameOut         = FALSE;
  BDLCStatusFlags.ReceivePacketFlag  = FALSE;  
  BDLCStatusFlags.ReTransmit         = FALSE;
  BDLCStatusFlags.RxFrameReady       = FALSE;
  BDLCStatusFlags.TxFlag             = FALSE;
  RETRANSMIT_BUFF->pu8CmdPtr         = (BKTX_BUFF_SIZE - 1);
  RETRANSMIT_BUFF->u8LastCmdPrior    = RETRANSMIT_BUFF->pu8CmdPtr;
  RETRANSMIT_BUFF->u8FreeBuffSpace   = BKTX_BUFF_SIZE;
  RETRANSMIT_BUFF->u8PendingCmds     = FALSE;
  RETRANSMIT_BUFF->u8CmdSize         = FALSE;
  RxBuffer->u8DataReady              = DATA_NOT_READY;
  RxBuffer->u8BufferPayLoad          = EMPTY;
  RxBuffer->u8Bk_BuffPayLoad         = EMPTY;
  RxBuffer->u8BufferStatus           = EMPTY;
  vfnClearAllRxBuffers();
  u8RxPointer                        = 0;                   /* Reset Buffer Pointer                     */
  TransmitBuffer.pu8DataBuffer       = (UINT8 *)&TX_BUFFER;
  TransmitBuffer.u8BufferPayLoad     = EMPTY;
  TransmitBuffer.u8BufferStatus      = EMPTY;
  TransmitBuffer.u8CmdSize           = EMPTY;
  TransmitBuffer.u8CmdType           = EMPTY;
  
  
  if(Test == MakeTest) vfnBDLC_LoopBackTest(dloop);  /* Make LoopBack test */
  bBDLCDriverStatus = BDLC_IDLE_STATE;
  EnableBDLCModule;
}
/******************************************************************************
 *                                 BDLC STATE MACHINE
 ******************************************************************************/
const void (* vfnpaBDLC_Driver[])(void)	=
{
  vfnBDLC_Idle, 
  vfnBDLC_ReceiveFrame,
  vfnBDLC_SendFrame,     
  vfnBDLC_ErrChecking
};

/** BDLC Pointer Driver */
void vfnBDLC_Driver(void)
{
  void (* lvfnpBDLCFunctionPtr)(void) = vfnpaBDLC_Driver[bBDLCDriverStatus];
  lvfnpBDLCFunctionPtr(); 
}  


void vfnBDLC_Idle(void)
{
  bBDLCDriverStatus = RX_MSG_STATE;
}
void vfnBDLC_ReceiveFrame(void)
{
  if(BackRxBuffer->u8DataReady == DATA_READY) 
  {
    vfnSwapRxBuffer();                          /* Swap Rx Buffer                    */    
    RxBuffer = BackRxBuffer;                   /* point to actual data              */
    BDLCStatusFlags.RxFrameReady = TRUE;       /* Clear Command ready flag          */ 
  }
  
  bBDLCDriverStatus = TX_MSG_STATE;
}
void vfnBDLC_SendFrame(void)
{
  /** Tx Status Variable */
  UINT8 u8ReadStatus = 0;
  
  if(TransmitBuffer.u8BufferStatus == DATA_READY)
  {
    u8ReadStatus = u8fnBDLCTransmit();   
    TransmitBuffer.u8BufferStatus = DATA_NOT_READY;
  }
  
  bBDLCDriverStatus = ERR_STATE;
}
void vfnBDLC_ErrChecking(void)
{
  UINT8 u8HighPriorCmd = 0;
  
  if(BDLCStatusFlags.TxFrameOut)          /* Check if cmd has been sent */
  {
    
    if((RETRANSMIT_BUFF->u8PendingCmds) && (BDLCStatusFlags.ReTransmit))
    {
      u8HighPriorCmd = u8fCheckBufferPriority();
      // retransmit   
      RETRANSMIT_BUFF->u8Command[RETRANSMIT_BUFF->pu8CmdPtr] = NULL; /* Update Command status pointer       */
    }else
    {
      RETRANSMIT_BUFF->u8Command[++RETRANSMIT_BUFF->u8LastCmdPrior] = NULL; /* Update Command status pointer       */   
      RETRANSMIT_BUFF->pu8CmdPtr = RETRANSMIT_BUFF->u8LastCmdPrior;
    }
    
     RETRANSMIT_BUFF->u8FreeBuffSpace = (BKTX_BUFF_SIZE - (RETRANSMIT_BUFF->u8PendingCmds--));
     BDLCStatusFlags.TxFrameOut = FALSE; 
    
  }
 
  bBDLCDriverStatus = BDLC_IDLE_STATE;
}
/*****************************************************************************/
void vfnSwapRxBuffer(void)
{
  SwapBuffer ^=1;       /* Change variable state */
    
    if(SwapBuffer)
    {
      BackRxBuffer = &BACK_RX_BUFF;    /* Point to 0x0712 */
      BackRxBuffer->u8Bk_BuffPayLoad = EMPTY;
      BackRxBuffer->u8BufferPayLoad  = EMPTY;
      BackRxBuffer->u8DataReady      = FALSE;          /* Clear Rx Buffer ready flag        */
    }else