/*!
 * @file tp_cca.c
 * @brief TP layer file according to the 15765-2.
 *
 */
#include "uds_config.h"

/*!
 * Macro. Minumum of the first frame data length
 */
#define MINIMUM_FIRST_FRAME_DATA_LENGTH   8
/*!
 * Macro. Dynamic tp para update enable
 */
#define DYNAMIC_TP_PARA_UPDATE_ENABLE     0

static uint8_t TP_Tx_Message_Status;                  /*!< Transmit Message Status  */
static uint8_t TP_Tx_Block_Size;                      /*!< Transmit Block Size  */
static uint8_t TP_Tx_Block_Size_Constant;             /*!< Transmit Block Size Constant  */
static uint8_t TP_Tx_Separation_Time_Min_Constant;    /*!< Min of Transmit Separation time constant  */
static uint8_t TP_Tx_Separation_Time_min;             /*!< Min of Transmit Separation time  */
static uint8_t TP_Tx_Sequence_Number;                 /*!< Transmit sequence number  */
static uint8_t TP_Transmit_Sub_State;                 /*!< Transmit sub state  */
uint16_t  TP_Tx_Message_DLC;                          /*!< Transmit Message DLC  */
static uint8_t TP_Tx_Frame_Type;                      /*!< Transmit Frame Type  */
static uint16_t TP_Tx_Index;                          /*!< Transmit Index  */
static uint8_t TP_Tx_Frame_DLC;                       /*!< Transmit Frame DLC  */
//static uint8_t TP_Transmit_Message_Number_Physical;   /*!< Transmit transmit message physical number  */

static uint8_t TP_Rx_Message_Status;                  /*!< Receive message Status  */
static uint16_t TP_Rx_Block_Size;                     /*!< Receive Block Size  */
//static uint16_t TP_Rx_Block_Size_Parameter;           /*!< Receive Block size Parameter  */
//static uint8_t TP_Rx_Seperation_Time_Parameter;       /*!< Receive Seperation Time Parameter  */
static uint8_t TP_Rx_Sequence_Number;                 /*!< Receive sequence number  */
static uint8_t TP_Receive_Sub_State;                  /*!< Receive sub state  */
static uint16_t  TP_Rx_Message_DLC;                   /*!< Receive Message DLC  */
static uint8_t TP_Rx_Frame_Type;                      /*!< Receive Frame type  */
uint16_t TP_Rx_Index;                                 /*!< Receive Index  */
static uint16_t TP_Rx_Frame_DLC;                      /*!< Receive Frame DLC  */
//static uint8_t TP_Receive_Message_Number_Physical;    /*!< Receive Message Number Physical  */
//static uint8_t TP_Receivet_Message_Number_Functional; /*!< Receive Message Number Functional  */
 uint16_t  TP_Rx_Message_Length;                      /*!< Receive Message Length  */

static uint16_t  TPN_As_Timer;                        /*!< AS Timer  */
static uint16_t  TPN_Ar_Timer;                        /*!< Ar Timer  */
static uint16_t  TPN_Bs_Timer;                        /*!< Bs Timer  */
static uint16_t  TPN_Cr_Timer;                        /*!< Cr Timer  */
static uint8_t TP_State;                              /*!< State of tp layer  */
static uint16_t TP_Data_Count;                        /*!< Data Count  */
static uint16_t TP_Next_Loop_Count;                   /*!< Next Loop Count  */
static uint8_t Flow_Status;                           /*!< Flow Status  */
static uint8_t TP_Result;                             /*!< Result  */
static uint8_t TP_Change_Parameter_Result;            /*!< Change parameter Result  */
static uint8_t TP_Request_Type;                       /*!< Request type  */

bool Frame_Tx_Complete;                               /*!< Frame transmit complete flag  */
static bool Frame_Available;                          /*!< Frame available flag  */

static bool Load_Consecutive_Frame;                   /*!< Load CF flag  */

static uint8_t TP_Tx_Buffer_Status;                   /*!< Tx Buffer Status  */
static uint8_t TP_Rx_Buffer_Status;                   /*!< Rx Buffer Status  */
static uint8_t TP_N_As_Timer_Control;                 /*!< As Timer Control  */
static uint8_t TP_N_Ar_Timer_Control;                 /*!< Ar Timer Control  */
static uint8_t TP_N_Bs_Timer_Control;                 /*!< Bs Timer Control  */
static uint8_t TP_N_Cr_Timer_Control;                 /*!< Cr Timer Control  */

static bool Update_Tp_Parameter_Req = DYNAMIC_TP_PARA_UPDATE_ENABLE;
uint8_t TP_Buffer[TP_BUFFER_SIZE];                    /*!< TP Buffer  */
//uint8_t TP_Tx_Buffer[TP_BUFFER_SIZE];

static uint8_t TP_Frame_Array[FRAME_DATA_SIZE];       /*!< Frame Buffer  */

/* functions local to TP Module */
static void TP_Transmit_Single_OR_First_Frame (void);
static void TP_Receive_Single_OR_First_Frame (void);
static void TP_Transmit_Consecutive_Frame (void);
static void TP_Receive_Consecutive_Frame (void);
static void TP_Check_Rx_Message_Length (void);
static void TP_Transmit_Flow_Control (void);
static void TP_Update_Timers (void);
static bool TP_Received_DLC_Check (void);
static uint8_t TP_STmin_Calculate (void);
static void TP_Idle_State_Process (void);
static void TP_Wait_For_SFORFF_TxConf_State_Process (void);
static void TP_Wait_For_FCFrame_Rx_State_Process (void);
static void TP_Transmit_CF_State_Process (void);
static void TP_Wait_For_CF_TxConf_State_Process (void);
static void TP_Wait_For_STmin_State_Process (void);
static void TP_Wait_For_FC_TXconf_State_Process (void);
static void TP_Rx_CF_State_Process (void);
static void TP_Wait_For_DataRead_State_Process (void);
static void TP_Tx_To_Idle_Init (uint8_t TP_Result);
static void TP_FC_Frame_Process (void);
static void TP_Rx_To_Idle_Init (uint8_t TP_Result);
static void TP_Transmit_Single_Frame (void);
static void TP_Transmit_First_Frame (void);
static void TP_Receive_Single_Frame (void);
static void TP_Receive_First_Frame (void);
static void TP_Tx_Load_CF_Data_Process (void);
static void TP_Tx_Load_Remaining_Bytes_OF_CF_Process (void);
static void TP_Tx_Load_Remaining_Bytes_OF_Last_CF_Process (void);
static void TP_Load_TL_Buffer_Start_NAs_Timer (void);
static void TP_Update_SN_and_BS (void);
static void TP_Tx_CF_Data_Process (void);
static void TP_Tx_Last_CF_Data_Process (void);
static void TP_Rx_Unload_CF_Data_Process (void);
static void TP_Rx_Unload_Remaining_Bytes_OF_CF_Process (void);
static void TP_Rx_Unload_Remaining_Bytes_OF_Last_CF_Process (void);
static void TP_Rx_CF_Data_Process (void);
static void TP_Rx_Last_CF_Data_Process (void);

/*!
 * @brief TP_Init
 * Read the message numbers from the TL config table, Initialize
 * the state to idle, transmit and recieve status init, buffer status  init,
 * Timers disabling, loads the default value's of BS and STmin to
 * variables.
 */
void TP_Init (void)
{
   /* Reads the Message number/Index from the TL config table */
#ifdef  TP_DIAG_PHYSICAL_MSG_SUPPORT
 //  TP_Transmit_Message_Number_Physical = 8;
 //  TP_Receive_Message_Number_Physical  = 8;
#endif
#ifdef  TP_DIAG_FUNCTIONAL_MSG_SUPPORT
  // TP_Receivet_Message_Number_Functional = 8;
#endif
   TP_State = TP_Idle_State;
   TP_Tx_Message_Status = TP_TRANSMIT_IDLE;
   TP_Rx_Message_Status = TP_RECEIVE_IDLE;
   TP_Tx_Buffer_Status = EMPTY;
   TP_Rx_Buffer_Status = EMPTY;
   Frame_Tx_Complete = false;
//   Frame_Tx_Complete_Flag_For_Reset = false;
   Frame_Available = false;
   TP_N_As_Timer_Control = TIMER_STOP;
   TP_N_Ar_Timer_Control = TIMER_STOP;
   TP_N_Bs_Timer_Control = TIMER_STOP;
   TP_N_Cr_Timer_Control = TIMER_STOP;
   Flow_Status = CLEAR_TO_SEND;
   /* default block size  for receive. */
//   TP_Rx_Block_Size_Parameter = TP_RX_BLOCK_SIZE_MAX;
   /* default STmin for receive. */
//   TP_Rx_Seperation_Time_Parameter = TP_RX_SEPARATION_TIME_MIN;
   Load_Consecutive_Frame = false;
}/* End of TP_Init*/
void TP_Task(void)
{
   //U32 context = hwi_disable_interrupts_savestate();
   switch (TP_State)
   {
      case TP_Idle_State:
         TP_Idle_State_Process();
         break;

      case TP_Wait_For_SFORFF_TxConf_State:
         TP_Wait_For_SFORFF_TxConf_State_Process();
         break;

      case TP_Wait_For_FCFrame_Rx_State:
         TP_Wait_For_FCFrame_Rx_State_Process();
         break;

      case TP_Transmit_CF_State:
         TP_Transmit_CF_State_Process();
         break;

      case TP_Wait_For_CF_TxConf_State:
         TP_Wait_For_CF_TxConf_State_Process();
         break;

      case TP_Wait_For_STmin_State:
         TP_Wait_For_STmin_State_Process();
         break;

      case TP_Wait_For_FC_TXconf_State:
         TP_Wait_For_FC_TXconf_State_Process();
         break;

      case TP_Rx_CF_State:
         TP_Rx_CF_State_Process();
         break;

      case TP_Wait_For_DataRead_State:
         TP_Wait_For_DataRead_State_Process();
         break;

      default:
         break;
   }

   //hwi_restore_interrupts( context );

}
/*!
 * @brief TP_Periodic_Task
 * Main task which handles both transmit and receive portion of
 * Network  Layer
 */
void TP_Periodic_Task (void)
{
   TP_Update_Timers();
   TP_Task();
}/* End of TP_Periodic_Task*/
/*!
 * @brief TP_Idle_State_Process
 * This function handles TP_Idle_State
 *
 */
static void TP_Idle_State_Process (void)
{
   if (Frame_Available == true)
   {
      Frame_Available = false;
      TP_Receive_Single_OR_First_Frame();
   }
}
/*!
 * @brief TP_Wait_For_SFORFF_TxConf_State_Process
 * This function handles TP_Wait_For_SFORFF_TxConf_State
 */
static void TP_Wait_For_SFORFF_TxConf_State_Process (void)
{
   if (TPN_As_Timer == 0)
   {
      TP_Result = N_TIMEOUT_A;
      TP_Tx_To_Idle_Init (TP_Result);
   }
   else if (Frame_Tx_Complete == true)
   {
      Frame_Tx_Complete = false;
      TP_N_As_Timer_Control = TIMER_STOP;

      if (TP_Tx_Frame_Type == SINGLE_FRAME)
      {
         TP_Result = N_OK;
         TP_Tx_To_Idle_Init (TP_Result);
      }
      else if (TP_Tx_Frame_Type == FIRST_FRAME)
      {
         Update_Tp_Parameter_Req = TRUE;
         TP_State = TP_Wait_For_FCFrame_Rx_State;
      }
      else
      {
         /* do nothing */
      }
   }
   else
   {
      /* do nothing */
   }
}
/*!
 * @brief TP_Wait_For_FCFrame_Rx_State_Process
 * This function handles TP_Wait_For_FCFrame_Rx_State
 */
static void TP_Wait_For_FCFrame_Rx_State_Process (void)
{
   uint8_t FlowControlStatus;

   if (TPN_Bs_Timer == 0)
   {
      TP_Result = N_TIMEOUTBs;
      TP_Tx_To_Idle_Init (TP_Result);
   }
   else if (Frame_Available == true)
   {
      Frame_Available = false;
      TP_Rx_Frame_Type = TP_Frame_Array[0] & FRAME_TYPE_MASK;

      if (TP_Rx_Frame_Type == FLOW_CONTROL_FRAME)
      {
         TP_N_Bs_Timer_Control = TIMER_STOP;
         FlowControlStatus = TP_Frame_Array[0] & FLOW_STATUS_MASK;

         if (false ==  TP_Received_DLC_Check())
         {
            TP_Result = N_WRONG_DLC;
            TP_Tx_To_Idle_Init (TP_Result);
         }
         else
         {
            if (FlowControlStatus >= RESERVED)
            {
               TP_Result = N_INVALID_FS;
               TP_Tx_To_Idle_Init (TP_Result);
            }
            else if (FlowControlStatus == OVERFLOW)
            {
               TP_Result = N_BUFFER_OVFLW;
               TP_Tx_To_Idle_Init (TP_Result);
            }
            else if (FlowControlStatus == WAIT)
            {
               if (N_WAIT_FRAME_TX_MAX == 0)
               {
                  TP_Result = N_WFT_OVRN;
                  TP_Tx_To_Idle_Init (TP_Result);
               }

               /* A count of 1 less is loaded as Bs timeout was exceeding max set */
               TPN_Bs_Timer = (N_Bs_TIMER_COUNT) - 1;
               TP_N_Bs_Timer_Control = TIMER_RUN;
            }
            else if (FlowControlStatus == CLEAR_TO_SEND)
            {
               TP_FC_Frame_Process();
            }
            else
            {
               /* do nothing */
            }
         }
      }
   }
   else
   {
      /* do nothing */
   }
}
/*!
 * @brief TP_Transmit_CF_State_Process
 * This function handles TP_Transmit_CF_State
 */
static void TP_Transmit_CF_State_Process (void)
{
   TP_Transmit_Consecutive_Frame();

   if (TP_Transmit_Sub_State == TP_TX_LOAD_CF_DATA)
   {
      TP_State = TP_Wait_For_CF_TxConf_State;
   }
}
/*!
 * @brief TP_Wait_For_CF_TxConf_State_Process
 * This function handles TP_Wait_For_CF_TxConf_State
 */
static void TP_Wait_For_CF_TxConf_State_Process (void)
{
   if (TPN_As_Timer == 0)
   {
      TP_Result = N_TIMEOUT_A;
      TP_Tx_To_Idle_Init (TP_Result);
   }
   else if ( (Frame_Tx_Complete == true) || (Load_Consecutive_Frame == true))
   {
      TP_N_As_Timer_Control = TIMER_STOP;
      Frame_Tx_Complete = false;

      if (TP_Tx_Message_DLC == 0)
      {
         TP_Result = N_OK;
         TP_Tx_To_Idle_Init (TP_Result);
      }
      else if ( (TP_Tx_Block_Size_Constant != 0) && (TP_Tx_Block_Size == 0))
      {
         Update_Tp_Parameter_Req = DYNAMIC_TP_PARA_UPDATE_ENABLE;
         TP_State = TP_Wait_For_FCFrame_Rx_State;
      }
      else if ( (TP_Tx_Separation_Time_Min_Constant == ZERO_LOOP_COUNT) ||
                (TP_Tx_Separation_Time_Min_Constant == ONE_LOOP_COUNT))
      {
         TP_Transmit_Consecutive_Frame();

         if (TP_Transmit_Sub_State == TP_TX_LOAD_CF_DATA)
         {
            Load_Consecutive_Frame = false;
         }
         else
         {
            Load_Consecutive_Frame = true;
         }
      }
      else if (TP_Tx_Separation_Time_Min_Constant == TWO_LOOP_COUNT)
      {
         TP_State = TP_Transmit_CF_State;
      }
      else if (TP_Tx_Separation_Time_Min_Constant > TWO_LOOP_COUNT)
      {
         TP_Tx_Separation_Time_min--;
         TP_State = TP_Wait_For_STmin_State;
      }
      else
      {
         /* do nothing */
      }
   }
   else
   {
      /* do nothing */
   }
}
/*!
 * @brief TP_Wait_For_STmin_State_Process
 * This function handles TP_Wait_For_STmin_State
 */
static void TP_Wait_For_STmin_State_Process (void)
{
   TP_Tx_Separation_Time_min--;

   if (TP_Tx_Separation_Time_min <= 1)
   {
      TP_State = TP_Transmit_CF_State;
      TP_Tx_Separation_Time_min = TP_Tx_Separation_Time_Min_Constant;
   }
}
/*!
 * @brief TP_Wait_For_FC_TXconf_State_Process
 * This function handles TP_Wait_For_FC_TXconf_State
 */
static void TP_Wait_For_FC_TXconf_State_Process (void)
{
   if (Frame_Tx_Complete == true)
   {
      Frame_Tx_Complete = false;
      TP_N_Ar_Timer_Control = TIMER_STOP;
      TP_State = TP_Rx_CF_State;
      TPN_Cr_Timer = N_Cr_TIMER_COUNT;
      TP_N_Cr_Timer_Control = TIMER_RUN;
   }
   else if (TPN_Ar_Timer == 0)
   {
      TP_Result = N_TIMEOUT_A;
      TP_Rx_To_Idle_Init (TP_Result);
   }
   else
   {
      /* do nothing */
   }
}
/*!
 * @brief TP_Rx_CF_State_Process
 * This function handles TP_Rx_CF_State
 */
static void TP_Rx_CF_State_Process (void)
{
   if (TPN_Cr_Timer == 0)
   {
      TP_Result = N_TIMEOUTCr;
      TP_Rx_To_Idle_Init (TP_Result);
   }
   else if (Frame_Available == true)
   {
      Frame_Available = false;
      TP_N_Cr_Timer_Control = TIMER_STOP;
      TP_Rx_Frame_Type = TP_Frame_Array[0] & FRAME_TYPE_MASK;

      if ( (TP_Rx_Frame_Type == SINGLE_FRAME) ||
           (TP_Rx_Frame_Type ==  FIRST_FRAME))
      {
         TP_Result = N_UNEXP_PDU;
         TP_Rx_To_Idle_Init (TP_Result);
         TP_Receive_Single_OR_First_Frame();
      }
      else if (TP_Rx_Frame_Type == CONSECUTIVE_FRAME)
      {
         if (false ==  TP_Received_DLC_Check())
         {
            TP_Result = N_WRONG_DLC;
            TP_Rx_To_Idle_Init (TP_Result);
         }
         else
         {
            if (TP_Rx_Sequence_Number == (TP_Frame_Array[0] &
                                          SEQUENCE_NUMBER_MASK))
            {
               TP_Receive_Sub_State = TP_RX_UNLOAD_CF_DATA;
               TP_Receive_Consecutive_Frame();
               TPN_Cr_Timer = N_Cr_TIMER_COUNT;
               TP_N_Cr_Timer_Control = TIMER_RUN;

               if (TP_Receive_Sub_State == TP_RX_UNLOAD_CF_DATA)
               {
                  TP_Check_Rx_Message_Length();
               }
            }
            else
            {
               TP_Result = N_WRONG_SN;
               TP_Rx_To_Idle_Init (TP_Result);
            }
         }
      }
      else
      {
         /* do nothing */
      }
   }
   else
   {
      /* do nothing */
   }
}
/*!
 * @brief TP_Wait_For_DataRead_State_Process
 * This function handles TP_Wait_For_DataRead_State
 */
static void TP_Wait_For_DataRead_State_Process (void)
{
   if (TPN_Cr_Timer == 0)
   {
      TP_Result = N_TIMEOUTCr;
      TP_Rx_To_Idle_Init (TP_Result);
   }
   else if (Frame_Available == true)
   {
      Frame_Available = false;
      TP_Result = TP_BUFFER_OVER_FLOW;
      TP_Rx_To_Idle_Init (TP_Result);
   }
   else
   {
      TP_Receive_Consecutive_Frame();

      if (TP_Receive_Sub_State == TP_RX_UNLOAD_CF_DATA)
      {
         TP_Check_Rx_Message_Length();
      }
   }
}
/*!
 * @brief TP_Tx_To_Idle_Init
 * This function handles TP transmit variables initialization
 * when transmit operation is completed suceesfully / unsuceesfully
 *
 * @param TP_Result TP Result
 */
static void TP_Tx_To_Idle_Init (uint8_t TP_Result)
{
   UCB_TP_N_USData_Confirm (TP_Result);
   TP_State = TP_Idle_State;
   TP_Tx_Message_Status = TP_TRANSMIT_IDLE;
   TP_Tx_Buffer_Status = EMPTY;
   Frame_Tx_Complete = false;
}
/*!
 * @brief TP_FC_Frame_Process
 * This function handles flow control parameter processing
 */
static void TP_FC_Frame_Process (void)
{
   if (Update_Tp_Parameter_Req)
   {
      TP_Tx_Block_Size_Constant = TP_Frame_Array[1];
      /* function to calcualte stmin */
      TP_Tx_Separation_Time_Min_Constant =
         TP_STmin_Calculate();
   }

   TP_Tx_Block_Size = TP_Tx_Block_Size_Constant;
   TP_Tx_Separation_Time_min =
      TP_Tx_Separation_Time_Min_Constant;
   TP_Transmit_Sub_State = TP_TX_LOAD_CF_DATA;
   TP_Transmit_Consecutive_Frame();

   if (TP_Transmit_Sub_State == TP_TX_LOAD_CF_DATA)
   {
      TP_State = TP_Wait_For_CF_TxConf_State;
   }
   else
   {
      TP_State = TP_Transmit_CF_State;
   }
}
/*!
 * @brief TP_Rx_To_Idle_Init
 * This function handles TP receive variables initialization
 * when receive operation is completed suceesfully / unsuceesfully
 */
static void TP_Rx_To_Idle_Init (uint8_t TP_Result)
{
   UCB_TP_N_USData_Indication (TP_Rx_Message_DLC, TP_Result);
   TP_State = TP_Idle_State;
   TP_Rx_Message_Status = TP_RECEIVE_IDLE;
   TP_Rx_Buffer_Status = EMPTY;
}
/*!
 * @brief TP_Transmit_Single_OR_First_Frame
 * This function handles transmission of 'single' or 'first'
 * frame
 */
static void TP_Transmit_Single_OR_First_Frame (void)
{
   if (TP_Tx_Frame_Type == SINGLE_FRAME)
   {
      TP_Transmit_Single_Frame();
   }
   else if (TP_Tx_Frame_Type == FIRST_FRAME)
   {
      TP_Transmit_First_Frame();
   }
   else
   {
      /* do nothing */
   }

   /* for CF1 count starts with '1'. Becomes '0' if it reaches 16 */
   TP_Tx_Sequence_Number = 1;
   /* TL API is called to set DLC */
   HAL_UDS_Set_Tx_DLC (TP_Tx_Frame_DLC);
   HAL_UDS_Set_Tx_Buf (TP_Frame_Array);
   /* TL API is called to transmit a frame */
   TP_State = TP_Wait_For_SFORFF_TxConf_State;
   TPN_As_Timer = N_As_TIMER_COUNT;
   TP_N_As_Timer_Control = TIMER_RUN;
}/* End of TP_Transmit_Single_OR_First_Frame*/
/*!
 * @brief TP_Transmit_Single_Frame
 * This function handles transmission of 'single' frame
 */
static void TP_Transmit_Single_Frame (void)
{
   uint8_t Frame_Array_Index, Data_Count ;
   /* store N_PCI  and message length in the first byte of Frame buffer */
   TP_Frame_Array[0] = (uint8_t) (SINGLE_FRAME |  TP_Tx_Message_DLC);
   Data_Count = 1;

   for (Frame_Array_Index = 1; Frame_Array_Index <= TP_Tx_Message_DLC;
        Frame_Array_Index++)
   {
      /* copy the data bytes from TP buffer to frame buffer */
      TP_Frame_Array[Frame_Array_Index] = TP_Buffer[TP_Tx_Index];
      TP_Tx_Index++;
      Data_Count++;
   }

   /* DLC of the frame to be transmitted: Data bytes + N_PCI */
   TP_Tx_Frame_DLC = (uint8_t) (TP_Tx_Message_DLC + 1);

   if (PADDING_OPERATION == true)
   {
      if (Data_Count <= CAN_FRAME_BYTES_UPPER_RANGE)
      {
         /* padd the remaining space in the frame buffer */
         for (; Data_Count <= CAN_FRAME_BYTES_UPPER_RANGE;
              Data_Count++)
         {
            TP_Frame_Array[Data_Count] = PADDING_BYTE;
         }

         /* DLC of the frame to be transmitted: DLC Max bytes */
         TP_Tx_Frame_DLC = NW_DLC_MAX_BYTES;
      }
   }
}
/*!
 * @brief TP_Transmit_First_Frame
 * This function handles transmission of 'first' frame
 */
static void TP_Transmit_First_Frame (void)
{
   uint8_t Frame_Array_Index;
   /*store N_PCI and message length in the first and second byte of Frame buffer*/
   TP_Frame_Array[0] = (uint8_t) (FIRST_FRAME | ( (TP_Tx_Message_DLC & 0X0F00) >> 8));
   TP_Frame_Array[1] = (uint8_t) (TP_Tx_Message_DLC & 0X00FF);

   for (Frame_Array_Index = 2; Frame_Array_Index <=
        CAN_FRAME_BYTES_UPPER_RANGE; Frame_Array_Index++)
   {
      TP_Frame_Array[Frame_Array_Index] = TP_Buffer[TP_Tx_Index];
      TP_Tx_Index++;
      TP_Tx_Message_DLC--;
   }

   /* DLC of the frame to be  transmitted: DLC Max bytes */
   TP_Tx_Frame_DLC = NW_DLC_MAX_BYTES;
}
/*!
 * @brief TP_Receive_Single_OR_First_Frame
 * This function handles reception of 'single' or 'first' frame
 */
static void TP_Receive_Single_OR_First_Frame (void)
{
   /* first byte: MSB Nibble indicates frame type :-N_PCI */
   TP_Rx_Frame_Type = TP_Frame_Array[0] & FRAME_TYPE_MASK;
   TP_Rx_Index = 0;
   TP_Request_Type = PHYSICAL_ADDRESS_TYPE;

   UdsService.FrameType=TP_Rx_Frame_Type;

   if (TP_Rx_Frame_Type == SINGLE_FRAME)
   {
      TP_Receive_Single_Frame();
   }
   else if (TP_Rx_Frame_Type == FIRST_FRAME)
   {
      TP_Receive_First_Frame();
   }
   else
   {
      /* do nothing */
   }
}/* End of TP_Receive_Single_OR_First_Frame*/
/*!
 * @brief TP_Receive_Single_Frame
 * This function handles reception of 'single' frame
 */
static void TP_Receive_Single_Frame (void)//THT
{
   uint8_t Frame_Array_Index;
   /* first byte: LSB Nibble indicates data length */
   TP_Rx_Message_DLC = TP_Frame_Array[0] & SINGLE_FRAME_DATA_LENGTH_MASK;
   //UdsService.RxDlc = TP_Rx_Message_DLC;
   for (Frame_Array_Index = 1; Frame_Array_Index <= TP_Rx_Message_DLC;
        Frame_Array_Index++)
   {
      TP_Buffer[TP_Rx_Index] = TP_Frame_Array[Frame_Array_Index];
      TP_Rx_Index++;
   }

   if (false ==  TP_Received_DLC_Check())
   {
      TP_Result = N_WRONG_DLC;
      UCB_TP_N_USData_Indication (TP_Rx_Message_DLC, TP_Result);
   }
   else
   {
      TP_Result = N_OK;
      UCB_TP_N_USData_Indication (TP_Rx_Message_DLC, TP_Result);
   }
}
/*!
 * @brief TP_Receive_First_Frame
 * This function handles reception of 'first' frame
 */
static void TP_Receive_First_Frame (void)
{
   uint8_t Frame_Array_Index;
   TP_Rx_Message_DLC = ( (uint16_t) ( (TP_Frame_Array[0] &
                                          FIRST_FRAME_DATA_LENGTH_MSB_NIBBLE_MASK) << 8) | TP_Frame_Array[1]);
   TP_Rx_Message_Length =  TP_Rx_Message_DLC;
   if ( (RECEIVE_MULTI_BUFFER_SUPPORT == false) &&
        (TP_Rx_Message_DLC > TP_BUFFER_SIZE))
   {
      TP_Result = TP_RX_LENGTH_INVALID;
      UCB_TP_N_USData_Indication (TP_Rx_Message_DLC, TP_Result);
      Flow_Status = OVERFLOW;
      TP_Transmit_Flow_Control();
      Flow_Status = CLEAR_TO_SEND;
      TP_State = TP_Idle_State;
   }
   else
   {
      if (TP_Rx_Message_DLC >= MINIMUM_FIRST_FRAME_DATA_LENGTH)
      {
         if (false ==  TP_Received_DLC_Check())
         {
            TP_Result = N_WRONG_DLC;
            UCB_TP_N_USData_Indication (TP_Rx_Message_DLC, TP_Result);
         }
         else
         {
            for (Frame_Array_Index = 2; Frame_Array_Index <=
                 CAN_FRAME_BYTES_UPPER_RANGE; Frame_Array_Index++)
            {
               TP_Buffer[TP_Rx_Index] = TP_Frame_Array[Frame_Array_Index];
               TP_Rx_Message_Length--;
               TP_Rx_Index++;
            }

            TP_Rx_Sequence_Number = 1;
            /* User call back  function to notify the first frame of multiframe message
             arrival */
            UCB_TP_N_USData_FF_Indication (TP_Rx_Message_DLC);
            TP_Rx_Message_Status = TP_RECEIVE_START;
            /* After receiveing first frame this API is called to transmit flow control
            frame */
            TP_Transmit_Flow_Control();
         }
      }
   }
}
/*!
 * @brief TP_Transmit_Consecutive_Frame
 * Handles the consecutive frame transmission with respect to
 * total message length  and the TP buffer
 */
static void TP_Transmit_Consecutive_Frame (void)
{
   switch (TP_Transmit_Sub_State)
   {
      case TP_TX_LOAD_CF_DATA:
         TP_Tx_Load_CF_Data_Process();
         break;

      case TP_TX_LOAD_REMAINING_BYTES_OF_CF:
         TP_Tx_Load_Remaining_Bytes_OF_CF_Process();
         break;

      case TP_TX_LOAD_REMAINING_BYTES_OF_LAST_CF:
         TP_Tx_Load_Remaining_Bytes_OF_Last_CF_Process();
         break;

      default:
         break;
   }/* end of TP_Transmit_Sub_State switch */
}/* End of TP_Transmit_Consecutive_Frame*/
/*!
 * @brief TP_Tx_Load_CF_Data_Process
 * Handles the consecutive frame transmission with respect to
 * total message length  and the TP buffer
 */
static void TP_Tx_Load_CF_Data_Process (void)
{
   TP_Frame_Array[0] = CONSECUTIVE_FRAME | TP_Tx_Sequence_Number;
   TP_Data_Count = TP_BUFFER_SIZE - TP_Tx_Index;

   if (TP_Tx_Message_DLC >= CONSECUTIVE_FRAME_DATA_BYTE)
   {
      TP_Tx_CF_Data_Process();
   }
   else if (TP_Tx_Message_DLC < CONSECUTIVE_FRAME_DATA_BYTE)
   {
      TP_Tx_Last_CF_Data_Process();
   }
   else
   {
      /* do nothing */
   }
}
/*!
 * @brief TP_Tx_CF_Data_Process
 * Checks the data availability in TP buffer and loads the CF
 * accordingly when CF is other than last CF
 */
static void TP_Tx_CF_Data_Process (void)
{
   uint8_t Frame_Array_Index;

   if (TP_Data_Count < CONSECUTIVE_FRAME_DATA_BYTE)
   {
      TP_Next_Loop_Count = 1;

      for (Frame_Array_Index = 1; Frame_Array_Index <=
           TP_Data_Count; Frame_Array_Index++)
      {
         TP_Frame_Array[Frame_Array_Index] = TP_Buffer[TP_Tx_Index];
         TP_Tx_Index++;
         TP_Tx_Message_DLC--;
         TP_Next_Loop_Count++;
      }

      TP_Transmit_Sub_State =  TP_TX_LOAD_REMAINING_BYTES_OF_CF;
      TP_Tx_Buffer_Status = EMPTY;
      UCB_TP_Transmit_Buffer_Empty();
      TP_Tx_Index = 0;
   }
   else if (TP_Data_Count >= CONSECUTIVE_FRAME_DATA_BYTE)
   {
      for (Frame_Array_Index = 1; Frame_Array_Index <=
           CAN_FRAME_BYTES_UPPER_RANGE; Frame_Array_Index++)
      {
         TP_Frame_Array[Frame_Array_Index] = TP_Buffer[TP_Tx_Index];
         TP_Tx_Index++;
         TP_Tx_Message_DLC--;
      }

      TP_Tx_Frame_DLC = NW_DLC_MAX_BYTES;
      TP_Load_TL_Buffer_Start_NAs_Timer();
      TP_State = TP_Wait_For_CF_TxConf_State;
      TP_Update_SN_and_BS();
   }
   else
   {
      /* do nothing */
   }
}
/*!
 * @brief TP_Tx_Last_CF_Data_Process
 * Checks the data availability in TP buffer and loads the CF
 * accordingly for last CF
 */
static void TP_Tx_Last_CF_Data_Process (void)//THT
{
   uint8_t Frame_Array_Index, Data_Count, TempLoopCount;

   if (TP_Data_Count >= TP_Tx_Message_DLC)
   {
      Data_Count = 1;
      TempLoopCount = (uint8_t) TP_Tx_Message_DLC;

      for (Frame_Array_Index = 1; Frame_Array_Index <=
           TempLoopCount; Frame_Array_Index++)
      {
         TP_Frame_Array[Frame_Array_Index] =
            TP_Buffer[TP_Tx_Index];
         TP_Tx_Index++;
         TP_Tx_Message_DLC--;
         Data_Count++;
      }

      TP_Tx_Frame_DLC = TempLoopCount;

      if (PADDING_OPERATION == true)
      {
         for (; Data_Count <=
              CAN_FRAME_BYTES_UPPER_RANGE; Data_Count++)
         {
            TP_Frame_Array[Data_Count] = PADDING_BYTE;
         }

         TP_Tx_Frame_DLC = NW_DLC_MAX_BYTES;
      }

      TP_Load_TL_Buffer_Start_NAs_Timer();
      TP_State = TP_Wait_For_CF_TxConf_State;
   }
   else if (TP_Data_Count < TP_Tx_Message_DLC)
   {
      TP_Next_Loop_Count = 1;

      for (Frame_Array_Index = 1; Frame_Array_Index <=
           TP_Data_Count; Frame_Array_Index++)
      {
         TP_Frame_Array[Frame_Array_Index] =
            TP_Buffer[TP_Tx_Index];
         TP_Tx_Index++;
         TP_Tx_Message_DLC--;
         TP_Next_Loop_Count++;
      }

      TP_Transmit_Sub_State = TP_TX_LOAD_REMAINING_BYTES_OF_LAST_CF;
      TP_Tx_Buffer_Status = EMPTY;
      UCB_TP_Transmit_Buffer_Empty();
      TP_Tx_Index = 0;
   }
   else
   {
      /* do nothing */
   }
}
/*!
 * @brief TP_Tx_Load_Remaining_Bytes_OF_CF_Process
 * Handles the consecutive frame transmission with respect to
 * remaining bytes of CF
 */
static void TP_Tx_Load_Remaining_Bytes_OF_CF_Process (void)
{
   if (TP_Tx_Buffer_Status == FILLED)
   {
      for (; TP_Next_Loop_Count <=
           CAN_FRAME_BYTES_UPPER_RANGE; TP_Next_Loop_Count++)
      {
         TP_Frame_Array[TP_Next_Loop_Count] = TP_Buffer[TP_Tx_Index];
         TP_Tx_Index++;
         TP_Tx_Message_DLC--;
      }

      TP_Tx_Frame_DLC = NW_DLC_MAX_BYTES;
      TP_Load_TL_Buffer_Start_NAs_Timer();
      TP_Transmit_Sub_State =  TP_TX_LOAD_CF_DATA;
      TP_State = TP_Wait_For_CF_TxConf_State;
      TP_Update_SN_and_BS();
   }
}
/*!
 * @brief TP_Tx_Load_Remaining_Bytes_OF_Last_CF_Process
 * Handles the consecutive frame transmission with respect to
 * remaining bytes of last CF
 */
static void TP_Tx_Load_Remaining_Bytes_OF_Last_CF_Process (void)
{
  uint8_t Data_Count;
	//uint8_t	TempLoopCount;

   if (TP_Tx_Buffer_Status == FILLED)
   {
      Data_Count = (uint8_t) TP_Next_Loop_Count;
      //TempLoopCount = (uint8_t) TP_Tx_Message_DLC;
      TP_Tx_Frame_DLC = (uint8_t) (TP_Next_Loop_Count  + TP_Tx_Message_DLC);

      for (; TP_Next_Loop_Count < TP_Tx_Frame_DLC
           ; TP_Next_Loop_Count++)
      {
         TP_Frame_Array[TP_Next_Loop_Count] =
            TP_Buffer[TP_Tx_Index];
         TP_Tx_Index++;
         TP_Tx_Message_DLC--;
         Data_Count++;
      }

      if (PADDING_OPERATION == true)
      {
         for (; Data_Count <= CAN_FRAME_BYTES_UPPER_RANGE;
              Data_Count++)
         {
            TP_Frame_Array[Data_Count] = PADDING_BYTE;
         }

         TP_Tx_Frame_DLC = NW_DLC_MAX_BYTES;
      }

      TP_Load_TL_Buffer_Start_NAs_Timer();
      TP_Transmit_Sub_State =  TP_TX_LOAD_CF_DATA;
      TP_State = TP_Wait_For_CF_TxConf_State;
   }
}
/*!
 * @brief TP_Load_TL_Buffer_Start_NAs_Timer
 * Loads the frame into TL s/w buffer and starts the NAs timer
 * counter.
 */
static void TP_Load_TL_Buffer_Start_NAs_Timer (void)
{
   HAL_UDS_Set_Tx_DLC (TP_Tx_Frame_DLC);
   HAL_UDS_Set_Tx_Buf (TP_Frame_Array);
   TPN_As_Timer = N_As_TIMER_COUNT;
   TP_N_As_Timer_Control = TIMER_RUN;
}
/*!
 * @brief TP_Update_SN_and_BS
 * updates the sequence number and the block size parameters
 */
static void TP_Update_SN_and_BS (void)
{
   TP_Tx_Sequence_Number++;

   if (TP_Tx_Sequence_Number == SEQUENCE_NUMBER_MAX)
   {
      TP_Tx_Sequence_Number = 0;
   }

   if (TP_Tx_Block_Size_Constant != 0)
   {
      TP_Tx_Block_Size--;
   }
}
/*!
 * @brief TP_Receive_Consecutive_Frame
 * Handles the consecutive frame reception with respect to total
 * message length  and the TP buffer
 */
static void TP_Receive_Consecutive_Frame (void)
{
   switch (TP_Receive_Sub_State)
   {
      case TP_RX_UNLOAD_CF_DATA:
         TP_Rx_Unload_CF_Data_Process();
         break;

      case TP_RX_UNLOAD_REMAINING_BYTES_OF_CF:
         TP_Rx_Unload_Remaining_Bytes_OF_CF_Process();
         break;

      case TP_RX_UNLOAD_REMAINING_BYTES_OF_LAST_CF:
         TP_Rx_Unload_Remaining_Bytes_OF_Last_CF_Process();
         break;

      default:
         break;
   }/* end of TP_Receive_Sub_State switch */
}/* End of TP_Receive_Consecutive_Frame */
/*!
 * @brief TP_Rx_Unload_CF_Data_Process
 * Handles the consecutive frame reception with respect to total
 * message length  and the TP buffer
 */
static void TP_Rx_Unload_CF_Data_Process (void)
{
   TP_Data_Count = TP_BUFFER_SIZE - TP_Rx_Index;

   if (TP_Rx_Message_Length >= CONSECUTIVE_FRAME_DATA_BYTE)
   {
      TP_Rx_CF_Data_Process();
   }
   else if (TP_Rx_Message_Length < CONSECUTIVE_FRAME_DATA_BYTE)
   {
      TP_Rx_Last_CF_Data_Process();
   }
   else
   {
      /* do nothing */
   }
}
/*!
 * @brief TP_Rx_CF_Data_Process
 * Checks the memory availability in TP buffer and unloads the CF
 * accordingly when CF is other than last CF ( From TL to TP Buffer)
 */
static void TP_Rx_CF_Data_Process (void)
{
   uint8_t Frame_Array_Index;

   if (TP_Data_Count < CONSECUTIVE_FRAME_DATA_BYTE)
   {
      TP_Next_Loop_Count = 1;

      for (Frame_Array_Index = 1; Frame_Array_Index <=
           TP_Data_Count; Frame_Array_Index++)
      {
         TP_Buffer[TP_Rx_Index] = TP_Frame_Array[Frame_Array_Index];
         TP_Rx_Index++;
         TP_Rx_Message_Length--;
         TP_Next_Loop_Count++;
      }
      if(!TP_Rx_Message_Length)
      {
    	  UdsService.MultFrameComp=1;
      }
      TP_Receive_Sub_State =  TP_RX_UNLOAD_REMAINING_BYTES_OF_CF;
      TP_State = TP_Wait_For_DataRead_State;
      TP_Rx_Buffer_Status = FILLED;
#ifdef RX_MULTI_BUFFER_SUPPORT
      UCB_TP_Receive_Buffer_Filled();
#endif
      TP_Rx_Index = 0;
   }
   else if (TP_Data_Count >= CONSECUTIVE_FRAME_DATA_BYTE)
   {
      for (Frame_Array_Index = 1; Frame_Array_Index <=
           CAN_FRAME_BYTES_UPPER_RANGE; Frame_Array_Index++)
      {
         TP_Buffer[TP_Rx_Index] = TP_Frame_Array[Frame_Array_Index];
         TP_Rx_Index++;
         TP_Rx_Message_Length--;  // THT
      }
      if(!TP_Rx_Message_Length)
      {
    	  UdsService.MultFrameComp=1;
      }
   }
   else
   {
      /* do nothing */
   }
}
/*!
 * @brief TP_Rx_Last_CF_Data_Process
 * Checks the memory availability in TP buffer and unloads the CF
 * accordingly for last CF  ( From TL to TP Buffer)
 */
static void TP_Rx_Last_CF_Data_Process (void)
{
   uint8_t TempLoopCount, Frame_Array_Index;

   if (TP_Data_Count >= TP_Rx_Message_Length)
   {
      TempLoopCount = (uint8_t) TP_Rx_Message_Length;

      for (Frame_Array_Index = 1; Frame_Array_Index <=
           TempLoopCount; Frame_Array_Index++)
      {
         TP_Buffer[TP_Rx_Index] = TP_Frame_Array[Frame_Array_Index];
         TP_Rx_Index++;
         TP_Rx_Message_Length--;
      }
      if(!TP_Rx_Message_Length)//THT
      {
          UdsService.MultFrameComp=1;
      }
   }
   else if (TP_Data_Count < TP_Rx_Message_Length)
   {
      TP_Next_Loop_Count = 1;

      for (Frame_Array_Index = 1; Frame_Array_Index <=
           TP_Data_Count; Frame_Array_Index++)
      {
         TP_Buffer[TP_Rx_Index] = TP_Frame_Array[Frame_Array_Index];
         TP_Rx_Index++;
         TP_Rx_Message_Length--;
         TP_Next_Loop_Count++;
      }

      TP_Receive_Sub_State = TP_RX_UNLOAD_REMAINING_BYTES_OF_LAST_CF;
      TP_State = TP_Wait_For_DataRead_State;
      TP_Rx_Buffer_Status = FILLED;
#ifdef RX_MULTI_BUFFER_SUPPORT
      UCB_TP_Receive_Buffer_Filled();
#endif
      TP_Rx_Index = 0;
   }
   else
   {
      /* do nothing */
   }
}
/*!
 * @brief TP_Rx_Unload_Remaining_Bytes_Of_CFProcess
 * Handles the consecutive frame reception with respect to
 * remaining bytes of CF
 */
static void TP_Rx_Unload_Remaining_Bytes_OF_CF_Process (void)
{
   if (TP_Rx_Buffer_Status == EMPTY)
   {
      for (; TP_Next_Loop_Count <=
           CAN_FRAME_BYTES_UPPER_RANGE; TP_Next_Loop_Count++)
      {
         TP_Buffer[TP_Rx_Index] = TP_Frame_Array[TP_Next_Loop_Count];
         TP_Rx_Index++;
         TP_Rx_Message_Length--;
      }

      TP_Receive_Sub_State =  TP_RX_UNLOAD_CF_DATA;
      TP_State = TP_Rx_CF_State;
   }
}
/*!
 * @brief TP_Rx_Unload_Remaining_Bytes_OF_Last_CF_Process
 * Handles the consecutive frame reception with respect to
 * remaining bytes of last CF
 */
static void TP_Rx_Unload_Remaining_Bytes_OF_Last_CF_Process (void)
{
		uint8_t TempLoopCount;
		//uint8_t Data_Count;

   if (TP_Rx_Buffer_Status == EMPTY)
   {
     // Data_Count = 0;
      TempLoopCount = (uint8_t) TP_Rx_Message_Length;

      for (; TP_Next_Loop_Count <=
           (TempLoopCount + 1); TP_Next_Loop_Count++)
      {
         TP_Buffer[TP_Rx_Index] = TP_Frame_Array[TP_Next_Loop_Count];
         TP_Rx_Index++;
         TP_Rx_Message_Length--;
      }

      TP_Receive_Sub_State =  TP_RX_UNLOAD_CF_DATA;
      TP_State = TP_Rx_CF_State;
   }
}
/*!
 * @brief TP_Transmit_Buffer_Filled
 * Sets the TP buffer to true state. After filling the buffer,
 * application will call the function to indicate TP layer that buffer has
 * been filled.
 */
void TP_Transmit_Buffer_Filled (void)
{
   TP_Tx_Buffer_Status = FILLED;
}/* End of TP_Transmit_Buffer_Filled*/
/*!
 * @brief TP_Receive_Buffer_Read
 * Clears the TP buffer to false state. After emptying the buffer,
 * application will call the function to indicate TP layer that buffer is
 * emptied.
 */
void TP_Receive_Buffer_Read (void)
{
   TP_Rx_Buffer_Status = EMPTY;
}/* End of TP_Receive_Buffer_Read */
/*!
 * @brief TP_Check_Rx_Message_Length
 * This API checks for the remaining length. If all the bytes are
 * received it goes to idle stste. Otherwise it goes to a state to receive
 * next CF
 */
static void TP_Check_Rx_Message_Length (void)
{
   if (TP_Rx_Message_Length == 0)
   {
      TP_N_Cr_Timer_Control = TIMER_STOP;
      TP_State = TP_Idle_State;
      TP_Rx_Message_Status = TP_RECEIVE_IDLE;
      TP_Rx_Buffer_Status = EMPTY;
      TP_Result = N_OK;
      UCB_TP_N_USData_Indication (TP_Rx_Message_DLC, TP_Result);
   }
   else
   {
      if (TP_RX_BLOCK_SIZE_MAX == 0)
      {
         TP_State = TP_Rx_CF_State;
      }
      else
      {
         TP_Rx_Block_Size--;

         if (TP_Rx_Block_Size == 0)
         {
            TP_Transmit_Flow_Control();
            TP_State = TP_Wait_For_FC_TXconf_State;
         }
      }

      TP_Rx_Sequence_Number++;

      if (TP_Rx_Sequence_Number == SEQUENCE_NUMBER_MAX)
      {
         TP_Rx_Sequence_Number = 0;
      }
   }
}/* End of TP_Check_Rx_Message_Length */
/*!
 * @brief TP_Transmit_Flow_Control
 * This API is responsible for framing the flowcontrol message
 * and transmitting to the transmitter using TL API's
 */
static void TP_Transmit_Flow_Control (void)
{
   uint8_t Frame_Array_Index;
   /* frame a control-frame using modifiable parameters */
   /* store N_PCI and flow status, as first byte */
   TP_Frame_Array[0] = FLOW_CONTROL_FRAME | Flow_Status;
   /* store ECU's BS parameter for receiving, as second byte */
   TP_Frame_Array[1] = TP_RX_BLOCK_SIZE_MAX;  // 20190315 lbin
   /* store ECU's STmin  parameter for receiving, as third byte */
   TP_Frame_Array[2] = TP_RX_SEPARATION_TIME_MIN;//TP_Rx_Seperation_Time_Parameter;
   /* store BS to another variable */
   TP_Rx_Block_Size = TP_RX_BLOCK_SIZE_MAX;
   TP_Tx_Frame_DLC = FLOW_CONTROL_N_PCI_PLUS_DATA_BYTE;

   if (PADDING_OPERATION == true)
   {
      for (Frame_Array_Index = 3; Frame_Array_Index <=
           CAN_FRAME_BYTES_UPPER_RANGE; Frame_Array_Index++)
      {
         TP_Frame_Array[Frame_Array_Index] = PADDING_BYTE;
      }

      TP_Tx_Frame_DLC = NW_DLC_MAX_BYTES;
   }
   HAL_UDS_Set_Tx_ID(0);
   HAL_UDS_Set_Tx_DLC (TP_Tx_Frame_DLC);
   HAL_UDS_Set_Tx_Buf (TP_Frame_Array);
   TP_State = TP_Wait_For_FC_TXconf_State;
   TPN_Ar_Timer = N_Ar_TIMER_COUNT;
   TP_N_Ar_Timer_Control = TIMER_RUN;
}/* End of TP_Transmit_Flow_Control */
/*!
 * @brief TP_Received_DLC_Check
 * This API checks for the received DLC.If the received DLC is
 * less than the expected DLC it returns false. Otherwise it returns true.
 */
static bool TP_Received_DLC_Check (void)
{
   bool ReceivedDLCResult = false;
   //uint8_t len=0;
   switch (TP_Rx_Frame_Type)//THT
   {
      case SINGLE_FRAME:
         //len = (TP_Rx_Message_DLC + SINGLE_FRAME_N_PCI_BYTE);
         if (TP_Rx_Message_DLC !=  0)
         {
            if (TP_Rx_Frame_DLC < (TP_Rx_Message_DLC + SINGLE_FRAME_N_PCI_BYTE))
            {
               ReceivedDLCResult =  false;
            }
            else
            {
               ReceivedDLCResult =  true;
            }
         }
         break;

      case FIRST_FRAME:
         if (TP_Rx_Frame_DLC < FIRST_FRAME_N_PCI_PLUS_DATA_BYTE)
         {
            ReceivedDLCResult =  false;
         }
         else
         {
            ReceivedDLCResult =  true;
         }

         break;

      case CONSECUTIVE_FRAME:
         if (TP_Rx_Message_Length >= CONSECUTIVE_FRAME_DATA_BYTE)
         {
            if (TP_Rx_Frame_DLC < CONSECUTIVE_FRAME_N_PCI_PLUS_DATA_BYTE)
            {
               ReceivedDLCResult =  false;
            }
            else
            {
               ReceivedDLCResult =  true;
            }
         }
         else
         {
            if (TP_Rx_Frame_DLC < (TP_Rx_Message_Length +
                                   CONSECUTIVE_FRAME_N_PCI_BYTE))
            {
               ReceivedDLCResult =  false;
            }
            else
            {
               ReceivedDLCResult =  true;
            }
         }

         break;

      case FLOW_CONTROL_FRAME:
         if (TP_Rx_Frame_DLC < FLOW_CONTROL_N_PCI_PLUS_DATA_BYTE)
         {
            ReceivedDLCResult =  false;
         }
         else
         {
            ReceivedDLCResult =  true;
         }

         break;

      default:
         break;
   }

   return (ReceivedDLCResult);
}/* End of TP_Received_DLC_Check */
/*!
 * @brief TP_Update_Timers
 * If the timers are enabled, timercount for each timer is
 * decremented. Timers are: N_As, N_Ar, N_Bs and N_Cr
 */
static void TP_Update_Timers (void)
{
   if (TP_N_As_Timer_Control == TIMER_RUN)
   {
      if (TPN_As_Timer > 0)
      {
         TPN_As_Timer--;
      }
      else
      {
         //  _P101 = 0x00;  TBD-PVD : Timer needs to be identified.
      }
   }

   if (TP_N_Ar_Timer_Control == TIMER_RUN)
   {
      if (TPN_Ar_Timer > 0)
      {
         TPN_Ar_Timer--;
      }
   }

   if (TP_N_Bs_Timer_Control == TIMER_RUN)
   {
      if (TPN_Bs_Timer > 0)
      {
         TPN_Bs_Timer--;
      }
   }

   if (TP_N_Cr_Timer_Control == TIMER_RUN)
   {
      if (TPN_Cr_Timer > 0)
      {
         TPN_Cr_Timer--;
      }
   }
}/* End of TP_Update_Timers */
/*!
 * @brief TP_GetBufferSize
 * User calls this API to get the size of the buffer.
 * decremented. Timers are: N_As, N_Ar, N_Bs and N_Cr
 *
 * @return TP Buffer size
 */
uint16_t TP_Get_Message_Buffer_Size (void)
{
   return (TP_BUFFER_SIZE);     /* size of the TP_Buffer as configured in the
 config file */
}/* End of TP_Get_Message_Buffer_Size */
/*!
 * @brief TP_GetBufferPointer
 * User calls this API to get the pointer(address)of the
 * TP_Buffer.
 *
 * @return Address of the TP buffer
 */

uint8_t *TP_Get_Message_Buffer_Pointer (void)
{
    //memset(TP_Tx_Buffer,0x0,TP_BUFFER_SIZE);
   // memcpy(TP_Tx_Buffer,TP_Buffer,TP_BUFFER_SIZE);
   // memset(TP_Buffer,0x0,TP_BUFFER_SIZE);
    return (TP_Buffer); /* returns the starting address of the TP buffer */
}/* End of TP_Get_Message_Buffer_Pointer */
/*!
 * @brief TP_Get_Request_Type
 * User calls this API to get the type of
 * request(physical/functional).
 *
 * @return Address of the TP buffer
 */
uint8_t TP_Get_Request_Type (void)
{
   return (TP_Request_Type); /* returns the type of request */
}/* End of TP_Get_Request_Type */
/*!
 * @brief TP_N_USData_Request
 * User calls this API to transmit a message. It passes the length
 * of the message to be transmitted.
 *
 * @param TPTransmitMessageLength Transmit message length
 */
void TP_N_USData_Request (uint16_t TPTransmitMessageLength)
{
   TP_Tx_Message_DLC = TPTransmitMessageLength;

   if (TP_Tx_Message_DLC <= MAXIMUM_SINGLE_FRAME_DATA_BYTE)
   {
      TP_Tx_Frame_Type = SINGLE_FRAME;
   }
   else
   {
      TP_Tx_Frame_Type = FIRST_FRAME;
   }

   TP_Tx_Message_Status = TP_TRANSMIT_START;
   TP_Tx_Index = 0;

   if (TP_Tx_Buffer_Status == FILLED)
   {
      TP_Transmit_Single_OR_First_Frame();
   }
   else
   {
      TP_Result = TP_BUFFER_NOT_FILLED;
      UCB_TP_N_USData_Confirm (TP_Result);
      TP_Tx_Message_Status = TP_TRANSMIT_IDLE;
   }

}/* End of TP_N_USData_Request */
/*!
 * @brief TP_D_UUData_Confirm
 * This is a callback function called by TL after transmitting
 * a message corresponding to TP. Flag is set to inform the TP about frame
 * transmission completion.
 *
 */
void TP_D_UUData_Confirm (void)
{
   Frame_Tx_Complete = true;
   TP_N_As_Timer_Control = TIMER_STOP;

   if ( (TP_State == TP_Wait_For_SFORFF_TxConf_State) &&
        (TP_Tx_Frame_Type == FIRST_FRAME))
   {
      UCB_TP_N_USData_FF_Confirmation();
   }

   if ( ( (TP_State == TP_Wait_For_SFORFF_TxConf_State) &&
          (TP_Tx_Frame_Type == FIRST_FRAME)) ||
        ( (TP_Tx_Block_Size_Constant != 0) && (TP_Tx_Block_Size == 0)))
   {
      TPN_Bs_Timer = N_Bs_TIMER_COUNT;
      TP_N_Bs_Timer_Control = TIMER_RUN;
      TP_Tx_Message_Status = WAITINGFORFLOWCONTROL;
   }

   if ( ( (TP_Tx_Message_Status == TP_TRANSMIT_START) &&
          (TP_Tx_Separation_Time_Min_Constant == 0)) ||
        (SINGLE_FRAME == TP_Tx_Frame_Type) ||
        ( (TP_State == TP_Wait_For_CF_TxConf_State) && (0 == TP_Tx_Message_DLC)))
   {
      /* to transmit 2nd CF onwards if stmin =0......*/
      /* to handle next request within loop time of response */
      TP_Task();
   }

   if ( (TP_Rx_Message_Status == TP_RECEIVE_START) &&
        (TP_State == TP_Wait_For_FC_TXconf_State))
   {
      /* to notify flow control tx so that cf's can be received(any time)*/
      TP_Task();
   }
}/* End of TP_D_UUData_Confirm */
/*!
 * @brief TP_D_UUData_Indication_Physical
 * This is a callback function called by TL after receiving
 * a message(Physical) corresponding to TP. If the ECU is transmitting,
 * and if it receives a frame it is ignored. Flag is set to inform the TP about
 * frame arrival.Data is copied from the software buffer to TP's Frame buffer.
 *
 */
bool TpRxFlg=false;
uint8_t g_ucTpRxStatusCnt;
void TP_D_UUData_Indication_Physical (void)
{
   //uint8_t Frame_Array_Index;
   uint8_t FlowControlStatus;

   if (TP_Tx_Message_Status != TP_TRANSMIT_START)
   {
      Frame_Available = true;
      TP_Rx_Frame_DLC = HAL_UDS_Rx_DLC();
      HAL_UDS_Get_Buf(TP_Frame_Array);
      FlowControlStatus = TP_Frame_Array[0] & FLOW_STATUS_MASK;

      if ( (TP_Tx_Message_Status == WAITINGFORFLOWCONTROL) &&
           (FlowControlStatus == CLEAR_TO_SEND))
      {
         TP_Tx_Message_Status = TP_TRANSMIT_START;
      }

      if ( (TP_Rx_Message_Status == TP_RECEIVE_START))
      {
         TP_Task();   /* to receive cf's......*/
      }
      g_ucTpRxStatusCnt=0;
      TpRxFlg=true;
      UdsService.PhyFlg = true;
      //Debug("UDS REC:\r\n"); //
   }
   else
   {
       if(++g_ucTpRxStatusCnt>=2)
       {
            UDS_Service_Init();
            TP_Init();
            //TP_Rx_To_Idle_Init(TP_Result);
            //Debug("UDS g_ucTpRxStatusCnt:\r\n");
            g_ucTpRxStatusCnt=0;
            TP_Tx_Message_Status=TP_TRANSMIT_IDLE;
            TP_State =TP_Idle_State;
            HAL_Response_Pocessing = false;
        }
   }
}/* End of TP_D_UUData_Indication_Physical */
#ifdef  TP_DIAG_FUNCTIONAL_MSG_SUPPORT
/*!
 * @brief TP_D_UUData_Indication_Functional
 * This is a callback function called by TL after receiving
 * a message(functional) corresponding to TP. If the ECU is transmitting,
 * and if it receives a frame it is ignored. Flag is set to inform the TP about
 * frame arrival. Data is copied from the software buffer to TP's Frame buffer
 */
void TP_D_UUData_Indication_Functional (void)
{
  // uint8_t *ReceivedMessageAddress;
   uint8_t Frame_Array_Index;
   uint8_t      FlowControlStatus;

   if (TP_Tx_Message_Status != TP_TRANSMIT_START) //if ((TP_Tx_Message_Status == TP_TRANSMIT_IDLE)||(TP_Tx_Message_Status != TP_TRANSMIT_START))
   {
      if ((UdsService.PhyFlg == true) && (TP_Rx_Message_Status == TP_RECEIVE_START)) {
         return;
      }
      TP_Rx_Frame_DLC = HAL_UDS_Rx_DLC();
      HAL_UDS_Get_Buf(TP_Frame_Array);
      TP_Rx_Frame_Type = TP_Frame_Array[0] & FRAME_TYPE_MASK;
      TP_Rx_Index = 0;
      UdsService.RxDlc = TP_Rx_Message_DLC;

      UdsService.PhyFlg = false;
      FlowControlStatus = TP_Frame_Array[0] & FLOW_STATUS_MASK;

      if ( (TP_Tx_Message_Status == WAITINGFORFLOWCONTROL) &&
           (FlowControlStatus == CLEAR_TO_SEND))
      {
         TP_Tx_Message_Status = TP_TRANSMIT_START;
      }
      if ( (TP_Rx_Message_Status == TP_RECEIVE_START))
      {
         TP_Task();   /* to receive cf's......*/
      }

      if (TP_Rx_Frame_Type == SINGLE_FRAME)
      {
         TP_Rx_Message_DLC = TP_Frame_Array[0] &
                             SINGLE_FRAME_DATA_LENGTH_MASK;

         for (Frame_Array_Index = 1; Frame_Array_Index <=
              TP_Rx_Message_DLC; Frame_Array_Index++)
         {
            TP_Buffer[TP_Rx_Index] = TP_Frame_Array[Frame_Array_Index];
            TP_Rx_Index++;
         }

         if (false ==  TP_Received_DLC_Check())
         {
            TP_Result = N_WRONG_DLC;
            UCB_TP_N_USData_Indication (TP_Rx_Message_DLC, TP_Result);
         }
         else
         {
            TP_Request_Type = FUNCTIONAL_ADDRESS_TYPE;
            TP_Result = N_OK;
            UCB_TP_N_USData_Indication (TP_Rx_Message_DLC, TP_Result);
         }
      }
   }
}/* End of TP_D_UUData_Indication_Functional */
#endif
/*!
 * @brief TP_N_Change_Parameters_Request
 * This API is called by user to change the parameter values of
 * the parameters BlockSize and the Minimum SeparationTime
 *
 * @param Parameter Parameter
 * @param ParameterValue Parameter Value
 */
void TP_N_Change_Parameters_Request (uint8_t Parameter, uint16_t ParameterValue)
{
   /* if it is in the multiframe  receive mode, change is not permitted */
   if (TP_Rx_Message_Status != TP_RECEIVE_START)
   {
      switch (Parameter)
      {
         case N_BLOCKSIZE:
            if ((ParameterValue <= 0xff))
            {
//               TP_Rx_Block_Size_Parameter = (uint8_t) ParameterValue;
               TP_Change_Parameter_Result = N_OK_R;
               UCB_TP_N_Change_Parameter_Confirm (Parameter,
                                                  TP_Change_Parameter_Result);
            }
            else
            {
               TP_Change_Parameter_Result = N_WRONG_VALUE;
               UCB_TP_N_Change_Parameter_Confirm (Parameter,
                                                  TP_Change_Parameter_Result);
            }

            break;

         case N_SEPERATIONTIME:
            if ((ParameterValue <= 0xff))
            {
//               TP_Rx_Seperation_Time_Parameter = (uint8_t) ParameterValue;
               TP_Change_Parameter_Result = N_OK_R;
               UCB_TP_N_Change_Parameter_Confirm (Parameter,
                                                  TP_Change_Parameter_Result);
               //Debug("TP_Rx_Seperation_Time_Parameter=%d",TP_Rx_Seperation_Time_Parameter);
            }
            else
            {
               TP_Change_Parameter_Result = N_WRONG_VALUE;
               UCB_TP_N_Change_Parameter_Confirm (Parameter,
                                                  TP_Change_Parameter_Result);
            }

            break;

         default:
            TP_Change_Parameter_Result = N_WRONG_PARAMETER;
            UCB_TP_N_Change_Parameter_Confirm (Parameter,
                                               TP_Change_Parameter_Result);
            break;
      }
   }
   else
   {
      TP_Change_Parameter_Result = N_RX_ON;
      UCB_TP_N_Change_Parameter_Confirm (Parameter,
                                         TP_Change_Parameter_Result);
   }
}/* End of TP_N_Change_Parameters_Request */
static uint8_t TP_STmin_Calculate (void)
{
   uint8_t TP_STmin_Result,TP_FC_STmin;
   TP_FC_STmin = TP_Frame_Array[2];

   if (TP_FC_STmin != 0)
   {
      if (TP_FC_STmin > 0x7F)
      {
         TP_FC_STmin = 0x7F;
      }

      TP_STmin_Result = TP_FC_STmin / CALL_RATE_TP;

      TP_STmin_Result += 1;

   }
   else
   {
      if (STmin_ZERO == CALL_RATE_TP)
      {
         TP_STmin_Result = 1;
      }
      else
      {
         TP_STmin_Result = 0;
      }
   }

   return (TP_STmin_Result);
}/*/TP_STmin_Calculate*/