lincfg.c

基于摩托罗拉（现在飞思卡尔）系列MC68HC908单片机开发车辆ECU系统！

#define LINCFG_C
/******************************************************************************
*
*       Copyright (C) 2003 Motorola, Inc.
*       All Rights Reserved
*
* Filename:     $RCSfile: lincfg.c,v $
* Author:       $Author: ttz778 $
* Locker:       $Locker:  $
* State:        $State: Exp $
* Revision:     $Revision: 1.0 $
*
* Functions:    LIN Driver internal configuration
*
* History:      Use the RCS command log to display revision history
*               information.
*
* Description:  
*
* Notes:        This file is NOT allowed to modify by user
*
******************************************************************************/

#include <linapi.h>

/********************************************************************************************/
/********************************************************************************************/
/**     Driver hardware configuration                                                      **/
/********************************************************************************************/
/********************************************************************************************/



#if defined(HC08GR16)
/********************************************************************************************/
/* HC08GR16                                                                                 */
/********************************************************************************************/

/* LIN baud rate masks */
#define LIN_BAUDRATE_MASK   0x37u

const struct
{
    unsigned int    LIN_IdleTimeoutClocks;  /* number of LIN_IdleClock() calls per LIN idle timeout */
    unsigned char   LIN_BaudRate;           /* LIN baud rate setting */
#if defined(MASTER)
    unsigned char   LIN_TimerPrescaler;     /* timer prescaler */
#endif /* defined(MASTER) */
} LIN_CfgConst =
{
    LIN_IDLETIMEOUT,
    (LIN_BAUDRATE & LIN_BAUDRATE_MASK),
#if defined(MASTER)
    LIN_TIMERPRESCALER,
#endif /* defined(MASTER) */
};
#endif /* defined(HC08GR16) */





#if defined(MASTER)

/********************************************************************************************/
/********************************************************************************************/
/**     Timeout module constants calculation                                               **/
/********************************************************************************************/
/********************************************************************************************/

#define LIN_MAXTOCOUNTER 0xFFFFul       /* maximal allowed timer 16-bit counter value */
                                        /* it must be long for correct computation */

/********************************************************************************************/
/* Wakeup Delimiter                                                                         */
/********************************************************************************************/
#define LIN_WKUPDELLEN_TO   10ul

    /* dividers set */
#define LIN_TO9DIVIDER1     1ul
#define LIN_TO9DIVIDER2     2ul
#define LIN_TO9DIVIDER3     5ul
#define LIN_TO9DIVIDER4     10ul
    
    /* maximal integral divider search */
#if   ((LIN_WKUPDELLEN_TO / LIN_TO9DIVIDER1) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO9DIVIDER LIN_TO9DIVIDER1
#elif ((LIN_WKUPDELLEN_TO / LIN_TO9DIVIDER2) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO9DIVIDER LIN_TO9DIVIDER2
#elif ((LIN_WKUPDELLEN_TO / LIN_TO9DIVIDER3) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO9DIVIDER LIN_TO9DIVIDER3
#elif ((LIN_WKUPDELLEN_TO / LIN_TO9DIVIDER4) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO9DIVIDER LIN_TO9DIVIDER4
#endif

/********************************************************************************************/
/* MaxFrame Timeout module constants calculation                                            */
/*      Nmax = (10 * Ndata + 45) * 1.4                                                      */
/*      Tmax = Nmax - 15                                                                    */
/*          for HC08: Nmax - 13 - 1 - 1                                                     */
/********************************************************************************************/

/********************************************************************************************/
/* 1 byte:      77 - 15 = 62                                                                */
/********************************************************************************************/
#define LIN_MAXFRAME_1_TIMEOUT  62ul
                                        
    /* dividers set */
#define LIN_TO1DIVIDER1 1ul
#define LIN_TO1DIVIDER2 2ul
#define LIN_TO1DIVIDER3 31ul
#define LIN_TO1DIVIDER4 62ul

    /* maximal integral divider search */
#if   ((LIN_MAXFRAME_1_TIMEOUT / LIN_TO1DIVIDER1) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO1DIVIDER LIN_TO1DIVIDER1
#elif ((LIN_MAXFRAME_1_TIMEOUT / LIN_TO1DIVIDER2) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO1DIVIDER LIN_TO1DIVIDER2
#elif ((LIN_MAXFRAME_1_TIMEOUT / LIN_TO1DIVIDER3) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO1DIVIDER LIN_TO1DIVIDER3
#elif ((LIN_MAXFRAME_1_TIMEOUT / LIN_TO1DIVIDER4) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO1DIVIDER LIN_TO1DIVIDER4
#endif

/********************************************************************************************/
/* 2 bytes:     91 - 15 = 76                                                                */
/********************************************************************************************/
#define LIN_MAXFRAME_2_TIMEOUT  76ul
                                        
    /* dividers set */
#define LIN_TO2DIVIDER1 1ul
#define LIN_TO2DIVIDER2 2ul
#define LIN_TO2DIVIDER3 4ul
#define LIN_TO2DIVIDER4 19ul
#define LIN_TO2DIVIDER5 38ul
#define LIN_TO2DIVIDER6 76ul

    /* maximal integral divider search */
#if   ((LIN_MAXFRAME_2_TIMEOUT / LIN_TO2DIVIDER1) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO2DIVIDER LIN_TO2DIVIDER1
#elif ((LIN_MAXFRAME_2_TIMEOUT / LIN_TO2DIVIDER2) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO2DIVIDER LIN_TO2DIVIDER2
#elif ((LIN_MAXFRAME_2_TIMEOUT / LIN_TO2DIVIDER3) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO2DIVIDER LIN_TO2DIVIDER3
#elif ((LIN_MAXFRAME_2_TIMEOUT / LIN_TO2DIVIDER4) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO2DIVIDER LIN_TO2DIVIDER4
#elif ((LIN_MAXFRAME_2_TIMEOUT / LIN_TO2DIVIDER5) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO2DIVIDER LIN_TO2DIVIDER5
#elif ((LIN_MAXFRAME_2_TIMEOUT / LIN_TO2DIVIDER6) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO2DIVIDER LIN_TO2DIVIDER6
#endif

/********************************************************************************************/
/* 3 bytes:     105 - 15 = 90                                                               */
/********************************************************************************************/
#define LIN_MAXFRAME_3_TIMEOUT  90ul
                                        
    /* dividers set */
#define LIN_TO3DIVIDER1 1ul
#define LIN_TO3DIVIDER2 2ul
#define LIN_TO3DIVIDER3 3ul
#define LIN_TO3DIVIDER4 5ul
#define LIN_TO3DIVIDER5 6ul
#define LIN_TO3DIVIDER6 9ul
#define LIN_TO3DIVIDER7 10ul
#define LIN_TO3DIVIDER8 15ul
#define LIN_TO3DIVIDER9 18ul
#define LIN_TO3DIVIDER10 30ul
#define LIN_TO3DIVIDER11 45ul
#define LIN_TO3DIVIDER12 90ul

    /* maximal integral divider search */
#if   ((LIN_MAXFRAME_3_TIMEOUT / LIN_TO3DIVIDER1) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO3DIVIDER LIN_TO3DIVIDER1
#elif ((LIN_MAXFRAME_3_TIMEOUT / LIN_TO3DIVIDER2) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO3DIVIDER LIN_TO3DIVIDER2
#elif ((LIN_MAXFRAME_3_TIMEOUT / LIN_TO3DIVIDER3) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO3DIVIDER LIN_TO3DIVIDER3
#elif ((LIN_MAXFRAME_3_TIMEOUT / LIN_TO3DIVIDER4) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO3DIVIDER LIN_TO3DIVIDER4
#elif ((LIN_MAXFRAME_3_TIMEOUT / LIN_TO3DIVIDER5) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO3DIVIDER LIN_TO3DIVIDER5
#elif ((LIN_MAXFRAME_3_TIMEOUT / LIN_TO3DIVIDER6) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO3DIVIDER LIN_TO3DIVIDER6
#elif ((LIN_MAXFRAME_3_TIMEOUT / LIN_TO3DIVIDER7) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO3DIVIDER LIN_TO3DIVIDER7
#elif ((LIN_MAXFRAME_3_TIMEOUT / LIN_TO3DIVIDER8) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO3DIVIDER LIN_TO3DIVIDER8
#elif ((LIN_MAXFRAME_3_TIMEOUT / LIN_TO3DIVIDER9) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO3DIVIDER LIN_TO3DIVIDER9
#elif ((LIN_MAXFRAME_3_TIMEOUT / LIN_TO3DIVIDER10) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO3DIVIDER LIN_TO3DIVIDER10
#elif ((LIN_MAXFRAME_3_TIMEOUT / LIN_TO3DIVIDER11) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO3DIVIDER LIN_TO3DIVIDER11
#elif ((LIN_MAXFRAME_3_TIMEOUT / LIN_TO3DIVIDER12) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO3DIVIDER LIN_TO3DIVIDER12
#endif

/********************************************************************************************/
/* 4 bytes:     119 - 15 = 104                                                              */
/********************************************************************************************/
#define LIN_MAXFRAME_4_TIMEOUT  104ul
                                        
    /* dividers set */
#define LIN_TO4DIVIDER1 1ul
#define LIN_TO4DIVIDER2 2ul
#define LIN_TO4DIVIDER3 4ul
#define LIN_TO4DIVIDER4 8ul
#define LIN_TO4DIVIDER5 13ul
#define LIN_TO4DIVIDER6 26ul
#define LIN_TO4DIVIDER7 52ul
#define LIN_TO4DIVIDER8 104ul

    /* maximal integral divider search */
#if   ((LIN_MAXFRAME_4_TIMEOUT / LIN_TO4DIVIDER1) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO4DIVIDER LIN_TO4DIVIDER1
#elif ((LIN_MAXFRAME_4_TIMEOUT / LIN_TO4DIVIDER2) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO4DIVIDER LIN_TO4DIVIDER2
#elif ((LIN_MAXFRAME_4_TIMEOUT / LIN_TO4DIVIDER3) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO4DIVIDER LIN_TO4DIVIDER3
#elif ((LIN_MAXFRAME_4_TIMEOUT / LIN_TO4DIVIDER4) * LIN_BITTIME) < LIN_MAXTOCOUNTER