#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
#define LIN_TO4DIVIDER LIN_TO4DIVIDER4
#elif ((LIN_MAXFRAME_4_TIMEOUT / LIN_TO4DIVIDER5) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO4DIVIDER LIN_TO4DIVIDER5
#elif ((LIN_MAXFRAME_4_TIMEOUT / LIN_TO4DIVIDER6) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO4DIVIDER LIN_TO4DIVIDER6
#elif ((LIN_MAXFRAME_4_TIMEOUT / LIN_TO4DIVIDER7) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO4DIVIDER LIN_TO4DIVIDER7
#elif ((LIN_MAXFRAME_4_TIMEOUT / LIN_TO4DIVIDER8) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO4DIVIDER LIN_TO4DIVIDER8
#endif

/********************************************************************************************/
/* 5 bytes:     133 - 15 = 118                                                              */
/********************************************************************************************/
#define LIN_MAXFRAME_5_TIMEOUT  118ul
                                        
    /* dividers set */
#define LIN_TO5DIVIDER1 1ul
#define LIN_TO5DIVIDER2 2ul
#define LIN_TO5DIVIDER3 59ul
#define LIN_TO5DIVIDER4 118ul

    /* maximal integral divider search */
#if   ((LIN_MAXFRAME_5_TIMEOUT / LIN_TO5DIVIDER1) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO5DIVIDER LIN_TO5DIVIDER1
#elif ((LIN_MAXFRAME_5_TIMEOUT / LIN_TO5DIVIDER2) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO5DIVIDER LIN_TO5DIVIDER2
#elif ((LIN_MAXFRAME_5_TIMEOUT / LIN_TO5DIVIDER3) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO5DIVIDER LIN_TO5DIVIDER3
#elif ((LIN_MAXFRAME_5_TIMEOUT / LIN_TO5DIVIDER4) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO5DIVIDER LIN_TO5DIVIDER4
#endif

/********************************************************************************************/
/* 6 bytes:     147 - 15 = 132                                                              */
/********************************************************************************************/
#define LIN_MAXFRAME_6_TIMEOUT  132ul
                                        
    /* dividers set */
#define LIN_TO6DIVIDER1 1ul
#define LIN_TO6DIVIDER2 2ul
#define LIN_TO6DIVIDER3 3ul
#define LIN_TO6DIVIDER4 4ul
#define LIN_TO6DIVIDER5 6ul
#define LIN_TO6DIVIDER6 11ul
#define LIN_TO6DIVIDER7 12ul
#define LIN_TO6DIVIDER8 22ul
#define LIN_TO6DIVIDER9 33ul
#define LIN_TO6DIVIDER10 44ul
#define LIN_TO6DIVIDER11 66ul
#define LIN_TO6DIVIDER12 132ul

    /* maximal integral divider search */
#if   ((LIN_MAXFRAME_6_TIMEOUT / LIN_TO6DIVIDER1) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO6DIVIDER LIN_TO6DIVIDER1
#elif ((LIN_MAXFRAME_6_TIMEOUT / LIN_TO6DIVIDER2) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO6DIVIDER LIN_TO6DIVIDER2
#elif ((LIN_MAXFRAME_6_TIMEOUT / LIN_TO6DIVIDER3) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO6DIVIDER LIN_TO6DIVIDER3
#elif ((LIN_MAXFRAME_6_TIMEOUT / LIN_TO6DIVIDER4) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO6DIVIDER LIN_TO6DIVIDER4
#elif ((LIN_MAXFRAME_6_TIMEOUT / LIN_TO6DIVIDER5) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO6DIVIDER LIN_TO6DIVIDER5
#elif ((LIN_MAXFRAME_6_TIMEOUT / LIN_TO6DIVIDER6) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO6DIVIDER LIN_TO6DIVIDER6
#elif ((LIN_MAXFRAME_6_TIMEOUT / LIN_TO6DIVIDER7) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO6DIVIDER LIN_TO6DIVIDER7
#elif ((LIN_MAXFRAME_6_TIMEOUT / LIN_TO6DIVIDER8) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO6DIVIDER LIN_TO6DIVIDER8
#elif ((LIN_MAXFRAME_6_TIMEOUT / LIN_TO6DIVIDER9) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO6DIVIDER LIN_TO6DIVIDER9
#elif ((LIN_MAXFRAME_6_TIMEOUT / LIN_TO6DIVIDER10) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO6DIVIDER LIN_TO6DIVIDER10
#elif ((LIN_MAXFRAME_6_TIMEOUT / LIN_TO6DIVIDER11) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO6DIVIDER LIN_TO6DIVIDER11
#elif ((LIN_MAXFRAME_6_TIMEOUT / LIN_TO6DIVIDER12) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO6DIVIDER LIN_TO6DIVIDER12
#endif

/********************************************************************************************/
/* 7 bytes:     161 - 15 = 146                                                              */
/********************************************************************************************/
#define LIN_MAXFRAME_7_TIMEOUT  146ul
                                        
    /* dividers set */
#define LIN_TO7DIVIDER1 1ul
#define LIN_TO7DIVIDER2 2ul
#define LIN_TO7DIVIDER3 73ul
#define LIN_TO7DIVIDER4 146ul

    /* maximal integral divider search */
#if   ((LIN_MAXFRAME_7_TIMEOUT / LIN_TO7DIVIDER1) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO7DIVIDER LIN_TO7DIVIDER1
#elif ((LIN_MAXFRAME_7_TIMEOUT / LIN_TO7DIVIDER2) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO7DIVIDER LIN_TO7DIVIDER2
#elif ((LIN_MAXFRAME_7_TIMEOUT / LIN_TO7DIVIDER3) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO7DIVIDER LIN_TO7DIVIDER3
#elif ((LIN_MAXFRAME_7_TIMEOUT / LIN_TO7DIVIDER4) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO7DIVIDER LIN_TO7DIVIDER4
#endif

/********************************************************************************************/
/* 8 bytes:     175 - 15 = 160                                                              */
/********************************************************************************************/
#define LIN_MAXFRAME_8_TIMEOUT  160ul
                                        
    /* dividers set */
#define LIN_TO8DIVIDER1 1ul
#define LIN_TO8DIVIDER2 2ul
#define LIN_TO8DIVIDER3 4ul
#define LIN_TO8DIVIDER4 5ul
#define LIN_TO8DIVIDER5 8ul
#define LIN_TO8DIVIDER6 10ul
#define LIN_TO8DIVIDER7 16ul
#define LIN_TO8DIVIDER8 20ul
#define LIN_TO8DIVIDER9 32ul
#define LIN_TO8DIVIDER10 40ul
#define LIN_TO8DIVIDER11 80ul
#define LIN_TO8DIVIDER12 160ul

    /* maximal integral divider search */
#if   ((LIN_MAXFRAME_8_TIMEOUT / LIN_TO8DIVIDER1) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO8DIVIDER LIN_TO8DIVIDER1
#elif ((LIN_MAXFRAME_8_TIMEOUT / LIN_TO8DIVIDER2) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO8DIVIDER LIN_TO8DIVIDER2
#elif ((LIN_MAXFRAME_8_TIMEOUT / LIN_TO8DIVIDER3) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO8DIVIDER LIN_TO8DIVIDER3
#elif ((LIN_MAXFRAME_8_TIMEOUT / LIN_TO8DIVIDER4) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO8DIVIDER LIN_TO8DIVIDER4
#elif ((LIN_MAXFRAME_8_TIMEOUT / LIN_TO8DIVIDER5) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO8DIVIDER LIN_TO8DIVIDER5
#elif ((LIN_MAXFRAME_8_TIMEOUT / LIN_TO8DIVIDER6) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO8DIVIDER LIN_TO8DIVIDER6
#elif ((LIN_MAXFRAME_8_TIMEOUT / LIN_TO8DIVIDER7) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO8DIVIDER LIN_TO8DIVIDER7
#elif ((LIN_MAXFRAME_8_TIMEOUT / LIN_TO8DIVIDER8) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO8DIVIDER LIN_TO8DIVIDER8
#elif ((LIN_MAXFRAME_8_TIMEOUT / LIN_TO8DIVIDER9) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO8DIVIDER LIN_TO8DIVIDER9
#elif ((LIN_MAXFRAME_8_TIMEOUT / LIN_TO8DIVIDER10) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO8DIVIDER LIN_TO8DIVIDER10
#elif ((LIN_MAXFRAME_8_TIMEOUT / LIN_TO8DIVIDER11) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO8DIVIDER LIN_TO8DIVIDER11
#elif ((LIN_MAXFRAME_8_TIMEOUT / LIN_TO8DIVIDER12) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO8DIVIDER LIN_TO8DIVIDER12
#endif


/********************************************************************************************/
/********************************************************************************************/
/**     Configuration arrays with timeout module constants                                 **/
/********************************************************************************************/
/********************************************************************************************/

/********************************************************************************************/
/* Number of timer interrupts counted for each timeout                                      */
/********************************************************************************************/

const unsigned char LIN_MTO_Counter[] = 
{ 
    LIN_TO9DIVIDER,             /* Wakeup Delimiter             */
    LIN_TO1DIVIDER,             /* MaxFrame for 1 byte  message */
    LIN_TO2DIVIDER,             /* MaxFrame for 2 bytes message */
    LIN_TO3DIVIDER,             /* MaxFrame for 3 bytes message */
    LIN_TO4DIVIDER,             /* MaxFrame for 4 bytes message */
    LIN_TO5DIVIDER,             /* MaxFrame for 5 bytes message */
    LIN_TO6DIVIDER,             /* MaxFrame for 6 bytes message */
    LIN_TO7DIVIDER,             /* MaxFrame for 7 bytes message */
    LIN_TO8DIVIDER,             /* MaxFrame for 8 bytes message */
};

/********************************************************************************************/
/* Number of timer ticks per one timer interrupt                                            */
/********************************************************************************************/

const unsigned int LIN_MTO_Ticks[] = 
{ 
    (LIN_WKUPDELLEN_TO / LIN_TO9DIVIDER) * LIN_BITTIME,         /* Wakeup Delimiter         */
    (LIN_MAXFRAME_1_TIMEOUT / LIN_TO1DIVIDER) * LIN_BITTIME,    /* MaxFrame for 1 byte  msg */
    (LIN_MAXFRAME_2_TIMEOUT / LIN_TO2DIVIDER) * LIN_BITTIME,    /* MaxFrame for 2 bytes msg */
    (LIN_MAXFRAME_3_TIMEOUT / LIN_TO3DIVIDER) * LIN_BITTIME,    /* MaxFrame for 3 bytes msg */
    (LIN_MAXFRAME_4_TIMEOUT / LIN_TO4DIVIDER) * LIN_BITTIME,    /* MaxFrame for 4 bytes msg */
    (LIN_MAXFRAME_5_TIMEOUT / LIN_TO5DIVIDER) * LIN_BITTIME,    /* MaxFrame for 5 bytes msg */
    (LIN_MAXFRAME_6_TIMEOUT / LIN_TO6DIVIDER) * LIN_BITTIME,    /* MaxFrame for 6 bytes msg */
    (LIN_MAXFRAME_7_TIMEOUT / LIN_TO7DIVIDER) * LIN_BITTIME,    /* MaxFrame for 7 bytes msg */
    (LIN_MAXFRAME_8_TIMEOUT / LIN_TO8DIVIDER) * LIN_BITTIME,    /* MaxFrame for 8 bytes msg */
};

#endif /* defined(MASTER) */