netx_drv_adc.c

Go to the documentation of this file.

/*!************************************************************************/
#include "netx_drv.h"
#ifdef DRV_ADC_MODULE_ENABLED

/*lint -save -e685 */
/*lint -save -e568 */

static DRV_ADC_DEVICE_T * const s_apDeviceAddressTable[DRV_ADC_DEVICE_COUNT] = DRV_ADC_DEVICE_LIST;

static DRV_ADC_SEQ_DEVICE_T * const s_apSubDeviceAddressTable[DRV_ADC_SEQ_DEVICE_COUNT] = DRV_ADC_SEQ_DEVICE_LIST;

static IRQn_Type const s_apHandleIRQnTable[DRV_ADC_SEQ_DEVICE_COUNT] = DRV_ADC_SEQ_DEVICE_IRQ_LIST;

static DRV_ADC_SEQ_HANDLE_T * s_apHandleAddressTable[DRV_ADC_SEQ_DEVICE_COUNT] = { 0 };

DRV_STATUS_E DRV_ADC_Driver_Init(DRV_ADC_HANDLE_T * const ptDriver)
{
  DRV_STATUS_E eRet = DRV_OK;

  if(ptDriver == NULL)
  {
    return DRV_ERROR_PARAM;
  }
  ptDriver->tLock = DRV_LOCK_INITIALIZER;
  DRV_LOCK(ptDriver);
  if((ptDriver->tConfiguration.eAdcClckPeriod > DRV_ADC_CLK_PERIOD_MAX) || (ptDriver->tConfiguration.eAdcClckPeriod < DRV_ADC_CLK_PERIOD_MIN))
  {
    return DRV_ERROR_PARAM;
  }
  if((ptDriver->tConfiguration.eVrefBufferEnable > DRV_ADC_VREF_BUFFER_MAX) || (ptDriver->tConfiguration.eVrefBufferEnable < DRV_ADC_VREF_BUFFER_MIN))
  {
    return DRV_ERROR_PARAM;
  }
  if((ptDriver->tConfiguration.tStaticCfg01.eSoftReset > DRV_ADC_SOFT_RESET_MAX)
    || (ptDriver->tConfiguration.tStaticCfg01.eSoftReset < DRV_ADC_SOFT_RESET_MIN))
  {
    return DRV_ERROR_PARAM;
  }
  if((ptDriver->tConfiguration.tStaticCfg01.ePowerDown > DRV_ADC_POWER_DOWN_MAX)
    || (ptDriver->tConfiguration.tStaticCfg01.ePowerDown < DRV_ADC_POWER_DOWN_MIN))
  {
    return DRV_ERROR_PARAM;
  }
  if((ptDriver->tConfiguration.tStaticCfg23.eSoftReset > DRV_ADC_SOFT_RESET_MAX)
    || (ptDriver->tConfiguration.tStaticCfg23.eSoftReset < DRV_ADC_SOFT_RESET_MIN))
  {
    return DRV_ERROR_PARAM;
  }
  if((ptDriver->tConfiguration.tStaticCfg23.ePowerDown > DRV_ADC_POWER_DOWN_MAX)
    || (ptDriver->tConfiguration.tStaticCfg23.ePowerDown < DRV_ADC_POWER_DOWN_MIN))
  {
    return DRV_ERROR_PARAM;
  }

  ptDriver->ptDevice = s_apDeviceAddressTable[0];

  /* madc_cfg */
  ptDriver->ptDevice->madc_cfg_b.adcclk_period = ptDriver->tConfiguration.eAdcClckPeriod;

  /* madc_adc01_static_cfg */
  ptDriver->ptDevice->madc_adc01_static_cfg_b.vref_buffer_enable = ptDriver->tConfiguration.eVrefBufferEnable;
  ptDriver->ptDevice->madc_adc01_static_cfg_b.adc01_reset_n = ptDriver->tConfiguration.tStaticCfg01.eSoftReset;
  ptDriver->ptDevice->madc_adc01_static_cfg_b.adc01_enable = ptDriver->tConfiguration.tStaticCfg01.ePowerDown;

  /* madc_adc23_static_cfg */
  ptDriver->ptDevice->madc_adc23_static_cfg_b.adc23_reset_n = ptDriver->tConfiguration.tStaticCfg23.eSoftReset;
  ptDriver->ptDevice->madc_adc23_static_cfg_b.adc23_enable = ptDriver->tConfiguration.tStaticCfg23.ePowerDown;

  DRV_UNLOCK(ptDriver);
  return eRet;
}

DRV_STATUS_E DRV_ADC_Driver_DeInit(DRV_ADC_HANDLE_T * const ptDriver)
{
  if(ptDriver == NULL)
  {
    return DRV_ERROR_PARAM;
  }
  DRV_LOCK(ptDriver);
  size_t iterator;
  for(iterator = 0; iterator < DRV_ADC_DEVICE_COUNT; iterator++)
  {
    if(ptDriver->aptAdcSequencer[iterator] != NULL)
    {
      return DRV_BUSY;
    }
  }
  *ptDriver = (DRV_ADC_HANDLE_T ) { 0 };
  return DRV_OK;
}

DRV_STATUS_E DRV_ADC_Start(DRV_ADC_HANDLE_T * const ptDriver, DRV_ADC_SEQ_DEVICE_MSK_E eSequencerMask)
{
  if(ptDriver == NULL)
  {
    return DRV_ERROR_PARAM;
  }

  DRV_LOCK(ptDriver);

  if((eSequencerMask > DRV_ADC_SEQ_DEVICE_MSK_MAX) || (eSequencerMask < DRV_ADC_SEQ_DEVICE_MSK_MIN))
  {
    return DRV_ERROR_PARAM;
  }
  //TODO: Make use of DRV_ADC_SEQ_DEVICE_COUNT or DRV_ADC_SEQ_DEVICE_ID_MAX/MIN
  if(eSequencerMask && DRV_ADC_SEQ_DEVICE_MSK_0)
  {
    if(ptDriver->aptAdcSequencer[0] != NULL)
    {
      if(ptDriver->aptAdcSequencer[0]->tConfiguration.eDeviceID == DRV_ADC_SEQ_DEVICE_ID_ADC0)
      {
        if(ptDriver->aptAdcSequencer[0]->tBuffer.fEnable == true)
        {
          ptDriver->aptAdcSequencer[0]->tBuffer.ulPosition = 0;
        }
        if(ptDriver->aptAdcSequencer[0]->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
        {
          ptDriver->aptAdcSequencer[0]->ptDevice->madc_seq_irq_raw = 0x1FFul;
          ptDriver->aptAdcSequencer[0]->ptDevice->madc_seq_irq_mask_set = 0x1FFul;
        }
        else
        {
          ptDriver->aptAdcSequencer[0]->ptDevice->madc_seq_irq_mask_reset = 0x1FFul;
        }
      }
      else
      {
        eSequencerMask = (DRV_ADC_SEQ_DEVICE_MSK_E) ((uint32_t) eSequencerMask & ~((uint32_t) DRV_ADC_SEQ_DEVICE_MSK_0));
      }
    }
    else
    {
      eSequencerMask = (DRV_ADC_SEQ_DEVICE_MSK_E) ((uint32_t) eSequencerMask & ~((uint32_t) DRV_ADC_SEQ_DEVICE_MSK_0));
    }
  }

  if(eSequencerMask && DRV_ADC_SEQ_DEVICE_MSK_1)
  {
    if(ptDriver->aptAdcSequencer[1] != NULL)
    {
      if(ptDriver->aptAdcSequencer[1]->tConfiguration.eDeviceID == DRV_ADC_SEQ_DEVICE_ID_ADC1)
      {
        if(ptDriver->aptAdcSequencer[1]->tBuffer.fEnable == true)
        {
          ptDriver->aptAdcSequencer[1]->tBuffer.ulPosition = 0;
        }
        if(ptDriver->aptAdcSequencer[1]->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
        {
          ptDriver->aptAdcSequencer[1]->ptDevice->madc_seq_irq_raw = 0x1FFul;
          ptDriver->aptAdcSequencer[1]->ptDevice->madc_seq_irq_mask_set = 0x1FFul;
        }
        else
        {
          ptDriver->aptAdcSequencer[1]->ptDevice->madc_seq_irq_mask_reset = 0x1FFul;
        }
      }
      else
      {
        eSequencerMask = (DRV_ADC_SEQ_DEVICE_MSK_E) ((uint32_t) eSequencerMask & ~((uint32_t) DRV_ADC_SEQ_DEVICE_MSK_1));
      }
    }
    else
    {
      eSequencerMask = (DRV_ADC_SEQ_DEVICE_MSK_E) ((uint32_t) eSequencerMask & ~((uint32_t) DRV_ADC_SEQ_DEVICE_MSK_1));
    }
  }

  if(eSequencerMask && DRV_ADC_SEQ_DEVICE_MSK_2)
  {
    if(ptDriver->aptAdcSequencer[2] != NULL)
    {
      if(ptDriver->aptAdcSequencer[2]->tConfiguration.eDeviceID == DRV_ADC_SEQ_DEVICE_ID_ADC2)
      {
        if(ptDriver->aptAdcSequencer[2]->tBuffer.fEnable == true)
        {
          ptDriver->aptAdcSequencer[2]->tBuffer.ulPosition = 0;
        }
        if(ptDriver->aptAdcSequencer[2]->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
        {
          ptDriver->aptAdcSequencer[2]->ptDevice->madc_seq_irq_raw = 0x1FFul;
          ptDriver->aptAdcSequencer[2]->ptDevice->madc_seq_irq_mask_set = 0x1FFul;
        }
        else
        {
          ptDriver->aptAdcSequencer[2]->ptDevice->madc_seq_irq_mask_reset = 0x1FFul;
        }
      }
      else
      {
        eSequencerMask = (DRV_ADC_SEQ_DEVICE_MSK_E) ((uint32_t) eSequencerMask & ~((uint32_t) DRV_ADC_SEQ_DEVICE_MSK_2));
      }
    }
    else
    {
      eSequencerMask = (DRV_ADC_SEQ_DEVICE_MSK_E) ((uint32_t) eSequencerMask & ~((uint32_t) DRV_ADC_SEQ_DEVICE_MSK_2));
    }
  }

  if(eSequencerMask && DRV_ADC_SEQ_DEVICE_MSK_3)
  {
    if(ptDriver->aptAdcSequencer[3] != NULL)
    {
      if(ptDriver->aptAdcSequencer[3]->tConfiguration.eDeviceID == DRV_ADC_SEQ_DEVICE_ID_ADC3)
      {
        if(ptDriver->aptAdcSequencer[3]->tBuffer.fEnable == true)
        {
          ptDriver->aptAdcSequencer[3]->tBuffer.ulPosition = 0;
        }
        if(ptDriver->aptAdcSequencer[3]->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
        {
          ptDriver->aptAdcSequencer[3]->ptDevice->madc_seq_irq_raw = 0x1FFul;
          ptDriver->aptAdcSequencer[3]->ptDevice->madc_seq_irq_mask_set = 0x1FFul;
        }
        else
        {
          ptDriver->aptAdcSequencer[3]->ptDevice->madc_seq_irq_mask_reset = 0x1FFul;
        }
      }
      else
      {
        eSequencerMask = (DRV_ADC_SEQ_DEVICE_MSK_E) ((uint32_t) eSequencerMask & ~((uint32_t) DRV_ADC_SEQ_DEVICE_MSK_3));
      }
    }
    else
    {
      eSequencerMask = (DRV_ADC_SEQ_DEVICE_MSK_E) ((uint32_t) eSequencerMask & ~((uint32_t) DRV_ADC_SEQ_DEVICE_MSK_3));
    }
  }

  /* start all together */
  ptDriver->ptDevice->madc_start = (uint32_t) eSequencerMask;

  DRV_UNLOCK(ptDriver);
  return DRV_OK;
}

DRV_STATUS_E DRV_ADC_Stop(DRV_ADC_HANDLE_T * const ptDriver, DRV_ADC_SEQ_DEVICE_MSK_E eSequencerMask)
{
  if(ptDriver == NULL)
  {
    return DRV_ERROR_PARAM;
  }

  DRV_LOCK(ptDriver);

  if((eSequencerMask > DRV_ADC_SEQ_DEVICE_MSK_MAX) || (eSequencerMask < DRV_ADC_SEQ_DEVICE_MSK_MIN))
  {
    DRV_UNLOCK(ptDriver);
    return DRV_ERROR_PARAM;
  }

  if(eSequencerMask & (unsigned int) DRV_ADC_SEQ_DEVICE_MSK_0)
  {
    ptDriver->aptAdcSequencer[0]->ptDevice->madc_seq_cmd &= ~madc_seq0_madc_seq_cmd_run_Msk;

    if(ptDriver->aptAdcSequencer[0]->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
    {
      ptDriver->aptAdcSequencer[0]->ptDevice->madc_seq_irq_mask_reset = 0x1FFul;
    }
  }

  if(eSequencerMask & (unsigned int) DRV_ADC_SEQ_DEVICE_MSK_1)
  {
    ptDriver->aptAdcSequencer[1]->ptDevice->madc_seq_cmd &= ~madc_seq0_madc_seq_cmd_run_Msk;

    if(ptDriver->aptAdcSequencer[1]->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
    {
      ptDriver->aptAdcSequencer[1]->ptDevice->madc_seq_irq_mask_reset = 0x1FFul;
    }
  }

  if(eSequencerMask & (unsigned int) DRV_ADC_SEQ_DEVICE_MSK_2)
  {
    ptDriver->aptAdcSequencer[2]->ptDevice->madc_seq_cmd &= ~madc_seq0_madc_seq_cmd_run_Msk;

    if(ptDriver->aptAdcSequencer[2]->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
    {
      ptDriver->aptAdcSequencer[2]->ptDevice->madc_seq_irq_mask_reset = 0x1FFul;
    }
  }

  if(eSequencerMask & (unsigned int) DRV_ADC_SEQ_DEVICE_MSK_3)
  {
    ptDriver->aptAdcSequencer[3]->ptDevice->madc_seq_cmd &= ~madc_seq0_madc_seq_cmd_run_Msk;

    if(ptDriver->aptAdcSequencer[3]->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
    {
      ptDriver->aptAdcSequencer[3]->ptDevice->madc_seq_irq_mask_reset = 0x1FFul;
    }
  }

  ptDriver->ptDevice->madc_start = (uint32_t) eSequencerMask;

  DRV_UNLOCK(ptDriver);
  return DRV_OK;
}

DRV_STATUS_E DRV_ADC_Seq_Init(DRV_ADC_SEQ_HANDLE_T * const ptSequencer, DRV_ADC_HANDLE_T * const ptDriver)
{
  DRV_STATUS_E eRet = DRV_OK;
  uint32_t ulIndexLoop;

  if((ptDriver == NULL) || (ptSequencer == NULL))
  {
    return DRV_ERROR_PARAM;
  }
  ptSequencer->tLock = DRV_LOCK_INITIALIZER;
  DRV_LOCK(ptSequencer);

  if((ptSequencer->tConfiguration.eDeviceID > DRV_ADC_SEQ_DEVICE_ID_MAX) || (ptSequencer->tConfiguration.eDeviceID < DRV_ADC_SEQ_DEVICE_ID_MIN))
  {
    return DRV_ERROR_PARAM;
  }
  else
  {
    ptSequencer->ptDevice = s_apSubDeviceAddressTable[(uint32_t) ptSequencer->tConfiguration.eDeviceID - (uint32_t) DRV_ADC_SEQ_DEVICE_ID_MIN];
    s_apHandleAddressTable[(uint32_t) ptSequencer->tConfiguration.eDeviceID - (uint32_t) DRV_ADC_SEQ_DEVICE_ID_MIN] = ptSequencer;
    ptDriver->aptAdcSequencer[(uint32_t) ptSequencer->tConfiguration.eDeviceID - (uint32_t) DRV_ADC_SEQ_DEVICE_ID_MIN] = ptSequencer;
    ptSequencer->ptParent = ptDriver;
  }
  if((ptSequencer->tConfiguration.eOperationMode > DRV_OPERATION_MODE_MAX) || (ptSequencer->tConfiguration.eOperationMode < DRV_OPERATION_MODE_MIN))
  {
    return DRV_ERROR_PARAM;
  }
  if((ptSequencer->tConfiguration.eDmaModeDisable > DRV_ADC_SEQ_DMA_MODE_MAX)
    || (ptSequencer->tConfiguration.eDmaModeDisable < DRV_ADC_SEQ_DMA_MODE_MIN))
  {
    return DRV_ERROR_PARAM;
  }
  if((ptSequencer->tConfiguration.e32BitMode > DRV_ADC_SEQ_32Bit_MODE_MAX) || (ptSequencer->tConfiguration.e32BitMode < DRV_ADC_SEQ_32Bit_MODE_MIN))
  {
    return DRV_ERROR_PARAM;
  }
  if((ptSequencer->tConfiguration.eVrefVdd3 > DRV_ADC_SEQ_VREF_VDD3_MAX) || (ptSequencer->tConfiguration.eVrefVdd3 < DRV_ADC_SEQ_VREF_VDD3_MIN))
  {
    return DRV_ERROR_PARAM;
  }
  if((ptSequencer->tConfiguration.eClkSync > DRV_ADC_SEQ_CLK_SYNC_MAX) || (ptSequencer->tConfiguration.eClkSync < DRV_ADC_SEQ_CLK_SYNC_MIN))
  {
    return DRV_ERROR_PARAM;
  }
  if((ptSequencer->tConfiguration.eClkPhase > DRV_ADC_SEQ_CLK_PHASE_MAX) || (ptSequencer->tConfiguration.eClkPhase < DRV_ADC_SEQ_CLK_PHASE_MIN))
  {
    return DRV_ERROR_PARAM;
  }
  if((ptSequencer->tConfiguration.eClkPeriod > DRV_ADC_SEQ_CLK_PERIOD_MAX) || (ptSequencer->tConfiguration.eClkPeriod < DRV_ADC_SEQ_CLK_PERIOD_MIN))
  {
    return DRV_ERROR_PARAM;
  }
  for(ulIndexLoop = 0; ulIndexLoop < DRV_ADC_INPUTS_MAX; ulIndexLoop++)
  {
    if((ptSequencer->tConfiguration.eChannelTrackingTime[ulIndexLoop] > DRV_ADC_SEQ_CHANNEL_TRACKING_TIME_MAX)
      || (ptSequencer->tConfiguration.eChannelTrackingTime[ulIndexLoop] < DRV_ADC_SEQ_CHANNEL_TRACKING_TIME_MIN))
    {
      return DRV_ERROR_PARAM;
    }
  }
  if((ptSequencer->tConfiguration.eBaseAdr > DRV_ADC_SEQ_BASE_ADDRESS_MAX) || (ptSequencer->tConfiguration.eBaseAdr < DRV_ADC_SEQ_BASE_ADDRESS_MIN))
  {
    return DRV_ERROR_PARAM;
  }
  for(ulIndexLoop = 0; ulIndexLoop < DRV_ADC_MEASUREMENTS_MAX; ulIndexLoop++)
  {
    if((ptSequencer->tConfiguration.tMeasurement[ulIndexLoop].eEnable > DRV_ADC_SEQ_MEAS_ENABLE_MAX)
      || (ptSequencer->tConfiguration.tMeasurement[ulIndexLoop].eEnable < DRV_ADC_SEQ_MEAS_ENABLE_MIN))
    {
      return DRV_ERROR_PARAM;
    }
    if((ptSequencer->tConfiguration.tMeasurement[ulIndexLoop].eAdrOffset > DRV_ADC_SEQ_BASE_ADR_OFFSET_MAX)
      || (ptSequencer->tConfiguration.tMeasurement[ulIndexLoop].eAdrOffset < DRV_ADC_SEQ_BASE_ADR_OFFSET_MIN))
    {
      return DRV_ERROR_PARAM;
    }
    if((ptSequencer->tConfiguration.tMeasurement[ulIndexLoop].eInputChannel > DRV_ADC_SEQ_MEAS_INPUT_CHANNEL_MAX)
      || (ptSequencer->tConfiguration.tMeasurement[ulIndexLoop].eInputChannel < DRV_ADC_SEQ_MEAS_INPUT_CHANNEL_MIN))
    {
      return DRV_ERROR_PARAM;
    }
    if((ptSequencer->tConfiguration.tMeasurement[ulIndexLoop].eOversample > DRV_ADC_SEQ_MEAS_OVERSAMPLING_MAX)
      || (ptSequencer->tConfiguration.tMeasurement[ulIndexLoop].eOversample < DRV_ADC_SEQ_MEAS_OVERSAMPLING_MIN))
    {
      return DRV_ERROR_PARAM;
    }
    if((ptSequencer->tConfiguration.tMeasurement[ulIndexLoop].eTrigger > DRV_ADC_SEQ_MEAS_TRIGGER_MAX)
      || (ptSequencer->tConfiguration.tMeasurement[ulIndexLoop].eTrigger < DRV_ADC_SEQ_MEAS_TRIGGER_MIN))
    {
      return DRV_ERROR_PARAM;
    }
  }

  /* madc_seq_cfg */
  if(ptSequencer->tConfiguration.eOperationMode == DRV_OPERATION_MODE_POLL) /* Pooling mode, DMA is always disable */
  {
    ptSequencer->tConfiguration.eDmaModeDisable = DRV_ADC_SEQ_DMA_MODE_DISABLED;
  }
  else if(ptSequencer->tConfiguration.eOperationMode == DRV_OPERATION_MODE_DMA) /* DMA mode, DMA is always enable */
  {
    ptSequencer->tConfiguration.eDmaModeDisable = DRV_ADC_SEQ_DMA_MODE_ENABLED;
  }

  ptSequencer->ptDevice->madc_seq_cfg_b.dma_disable = ptSequencer->tConfiguration.eDmaModeDisable;
  ptSequencer->ptDevice->madc_seq_cfg_b.dma_32bit_adr = ptSequencer->tConfiguration.e32BitMode;
  ptSequencer->ptDevice->madc_seq_cfg_b.vref_vdd3 = ptSequencer->tConfiguration.eVrefVdd3;
  ptSequencer->ptDevice->madc_seq_cfg_b.adcclk_sync = ptSequencer->tConfiguration.eClkSync;
  ptSequencer->ptDevice->madc_seq_cfg_b.adcclk_phase = ptSequencer->tConfiguration.eClkPhase;
  ptSequencer->ptDevice->madc_seq_cfg_b.adcclk_period = ptSequencer->tConfiguration.eClkPeriod;

  /* madc_seq_ms_en */
  ptSequencer->ptDevice->madc_seq_ms_en_b.m7 = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_7].eEnable;
  ptSequencer->ptDevice->madc_seq_ms_en_b.m6 = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_6].eEnable;
  ptSequencer->ptDevice->madc_seq_ms_en_b.m5 = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_5].eEnable;
  ptSequencer->ptDevice->madc_seq_ms_en_b.m4 = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_4].eEnable;
  ptSequencer->ptDevice->madc_seq_ms_en_b.m3 = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_3].eEnable;
  ptSequencer->ptDevice->madc_seq_ms_en_b.m2 = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_2].eEnable;
  ptSequencer->ptDevice->madc_seq_ms_en_b.m1 = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_1].eEnable;
  ptSequencer->ptDevice->madc_seq_ms_en_b.m0 = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_0].eEnable;

  /* madc_seq_m0 */
  ptSequencer->ptDevice->madc_seq_m0_b.adr_offset = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_0].eAdrOffset;
  ptSequencer->ptDevice->madc_seq_m0_b.mux = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_0].eInputChannel;
  ptSequencer->ptDevice->madc_seq_m0_b.oversample = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_0].eOversample;
  ptSequencer->ptDevice->madc_seq_m0_b.trigger = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_0].eTrigger;

  /* madc_seq_m1 */
  ptSequencer->ptDevice->madc_seq_m1_b.adr_offset = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_1].eAdrOffset;
  ptSequencer->ptDevice->madc_seq_m1_b.mux = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_1].eInputChannel;
  ptSequencer->ptDevice->madc_seq_m1_b.oversample = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_1].eOversample;
  ptSequencer->ptDevice->madc_seq_m1_b.trigger = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_1].eTrigger;

  /* madc_seq_m2 */
  ptSequencer->ptDevice->madc_seq_m2_b.adr_offset = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_2].eAdrOffset;
  ptSequencer->ptDevice->madc_seq_m2_b.mux = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_2].eInputChannel;
  ptSequencer->ptDevice->madc_seq_m2_b.oversample = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_2].eOversample;
  ptSequencer->ptDevice->madc_seq_m2_b.trigger = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_2].eTrigger;

  /* madc_seq_m3 */
  ptSequencer->ptDevice->madc_seq_m3_b.adr_offset = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_3].eAdrOffset;
  ptSequencer->ptDevice->madc_seq_m3_b.mux = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_3].eInputChannel;
  ptSequencer->ptDevice->madc_seq_m3_b.oversample = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_3].eOversample;
  ptSequencer->ptDevice->madc_seq_m3_b.trigger = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_3].eTrigger;

  /* madc_seq_m4 */
  ptSequencer->ptDevice->madc_seq_m4_b.adr_offset = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_4].eAdrOffset;
  ptSequencer->ptDevice->madc_seq_m4_b.mux = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_4].eInputChannel;
  ptSequencer->ptDevice->madc_seq_m4_b.oversample = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_4].eOversample;
  ptSequencer->ptDevice->madc_seq_m4_b.trigger = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_4].eTrigger;

  /* madc_seq_m5 */
  ptSequencer->ptDevice->madc_seq_m5_b.adr_offset = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_5].eAdrOffset;
  ptSequencer->ptDevice->madc_seq_m5_b.mux = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_5].eInputChannel;
  ptSequencer->ptDevice->madc_seq_m5_b.oversample = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_5].eOversample;
  ptSequencer->ptDevice->madc_seq_m5_b.trigger = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_5].eTrigger;

  /* madc_seq_m6 */
  ptSequencer->ptDevice->madc_seq_m6_b.adr_offset = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_6].eAdrOffset;
  ptSequencer->ptDevice->madc_seq_m6_b.mux = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_6].eInputChannel;
  ptSequencer->ptDevice->madc_seq_m6_b.oversample = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_6].eOversample;
  ptSequencer->ptDevice->madc_seq_m6_b.trigger = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_6].eTrigger;

  /* madc_seq_m7 */
  ptSequencer->ptDevice->madc_seq_m7_b.adr_offset = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_7].eAdrOffset;
  ptSequencer->ptDevice->madc_seq_m7_b.mux = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_7].eInputChannel;
  ptSequencer->ptDevice->madc_seq_m7_b.oversample = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_7].eOversample;
  ptSequencer->ptDevice->madc_seq_m7_b.trigger = ptSequencer->tConfiguration.tMeasurement[DRV_ADC_SEQ_MEASUREMENT_7].eTrigger;

  /* madc_seq_tracking_time_muxx */
  ptSequencer->ptDevice->madc_seq_tracking_time_mux0 = (uint32_t) ptSequencer->tConfiguration.eChannelTrackingTime[DRV_ADC_SEQ_MEASUREMENT_0];
  ptSequencer->ptDevice->madc_seq_tracking_time_mux1 = (uint32_t) ptSequencer->tConfiguration.eChannelTrackingTime[DRV_ADC_SEQ_MEASUREMENT_1];
  ptSequencer->ptDevice->madc_seq_tracking_time_mux2 = (uint32_t) ptSequencer->tConfiguration.eChannelTrackingTime[DRV_ADC_SEQ_MEASUREMENT_2];
  ptSequencer->ptDevice->madc_seq_tracking_time_mux3 = (uint32_t) ptSequencer->tConfiguration.eChannelTrackingTime[DRV_ADC_SEQ_MEASUREMENT_3];
  ptSequencer->ptDevice->madc_seq_tracking_time_mux4 = (uint32_t) ptSequencer->tConfiguration.eChannelTrackingTime[DRV_ADC_SEQ_MEASUREMENT_4];
  ptSequencer->ptDevice->madc_seq_tracking_time_mux5 = (uint32_t) ptSequencer->tConfiguration.eChannelTrackingTime[DRV_ADC_SEQ_MEASUREMENT_5];
  ptSequencer->ptDevice->madc_seq_tracking_time_mux6 = (uint32_t) ptSequencer->tConfiguration.eChannelTrackingTime[DRV_ADC_SEQ_MEASUREMENT_6];
  ptSequencer->ptDevice->madc_seq_tracking_time_mux7 = (uint32_t) ptSequencer->tConfiguration.eChannelTrackingTime[DRV_ADC_SEQ_MEASUREMENT_7];

  /* madc_seq_ms_baseadr */
  ptSequencer->ptDevice->madc_seq_ms_baseadr = (uint32_t) ptSequencer->tConfiguration.eBaseAdr;

  if(ptSequencer->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
  {
    DRV_NVIC_ClearPendingIRQ(s_apHandleIRQnTable[(uint32_t) ptSequencer->tConfiguration.eDeviceID - (uint32_t) DRV_ADC_SEQ_DEVICE_ID_MIN]);
    DRV_NVIC_EnableIRQ(s_apHandleIRQnTable[(uint32_t) ptSequencer->tConfiguration.eDeviceID - (uint32_t) DRV_ADC_SEQ_DEVICE_ID_MIN]);

    ptSequencer->ptDevice->madc_seq_irq_raw = 0x1FFul;
    ptSequencer->ptDevice->madc_seq_irq_mask_set = 0x1FFul;
  }

  DRV_UNLOCK(ptSequencer);
  return eRet;
}

DRV_STATUS_E DRV_ADC_Seq_DeInit(DRV_ADC_SEQ_HANDLE_T * const ptSequencer)
{
  if(ptSequencer == NULL)
  {
    return DRV_ERROR_PARAM;
  }
  DRV_LOCK(ptSequencer);
  if(ptSequencer->ptParent->aptAdcSequencer[ptSequencer->tConfiguration.eDeviceID - (unsigned int) DRV_ADC_SEQ_DEVICE_ID_MIN] != ptSequencer)
  {
    return DRV_ERROR;
  }
  else
  {
    ptSequencer->ptParent->aptAdcSequencer[ptSequencer->tConfiguration.eDeviceID - (unsigned int) DRV_ADC_SEQ_DEVICE_ID_MIN] = NULL;
  }
  if(ptSequencer->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
  {
    DRV_NVIC_DisableIRQ(s_apHandleIRQnTable[(uint32_t) ptSequencer->tConfiguration.eDeviceID - (uint32_t) DRV_ADC_SEQ_DEVICE_ID_MIN]);
    ptSequencer->ptDevice->madc_seq_irq_mask_reset = 0x1FFul;
    DRV_NVIC_ClearPendingIRQ(s_apHandleIRQnTable[(uint32_t) ptSequencer->tConfiguration.eDeviceID - (uint32_t) DRV_ADC_SEQ_DEVICE_ID_MIN]);
    ptSequencer->ptDevice->madc_seq_irq_raw = 0x1FFul;
  }
  *ptSequencer = (DRV_ADC_SEQ_HANDLE_T ) { 0 };
  return DRV_OK;
}

DRV_STATUS_E DRV_ADC_Seq_SetMode(DRV_ADC_SEQ_HANDLE_T * const ptSequencer, DRV_ADC_SEQ_CONTINUOUS_MODE_E eMode)
{
  if(ptSequencer == NULL)
  {
    return DRV_ERROR_PARAM;
  }

  DRV_LOCK(ptSequencer);

  if((eMode > DRV_ADC_SEQ_CONTINUOUS_MODE_MAX) || (eMode < DRV_ADC_SEQ_CONTINUOUS_MODE_MIN))
  {
    DRV_UNLOCK(ptSequencer);
    return DRV_ERROR_PARAM;
  }

  ptSequencer->tConfiguration.eContinuousMode = eMode;

  DRV_UNLOCK(ptSequencer);
  return DRV_OK;
}

DRV_STATUS_E DRV_ADC_Seq_Start(DRV_ADC_SEQ_HANDLE_T * const ptSequencer)
{
  if(ptSequencer == NULL)
  {
    return DRV_ERROR_PARAM;
  }

  if(ptSequencer->ptDevice == NULL)
  {
    return DRV_ERROR_PARAM;
  }

  DRV_LOCK(ptSequencer);

  if(ptSequencer->tBuffer.fEnable)
  {
    ptSequencer->tBuffer.ulPosition = 0ul;
  }

  if(ptSequencer->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
  {
    ptSequencer->ptDevice->madc_seq_irq_raw = 0x1FFul;
    ptSequencer->ptDevice->madc_seq_irq_mask_set = 0x1FFul;
  }
  else
  {
    ptSequencer->ptDevice->madc_seq_irq_mask_reset = 0x1FFul;
  }

  ptSequencer->ptDevice->madc_seq_cmd_b.continuous = ptSequencer->tConfiguration.eContinuousMode;
  ptSequencer->ptDevice->madc_seq_cmd_b.run = 1u;

  DRV_UNLOCK(ptSequencer);
  return DRV_OK;
}

DRV_STATUS_E DRV_ADC_Seq_Stop(DRV_ADC_SEQ_HANDLE_T * const ptSequencer)
{
  if(ptSequencer == NULL)
  {
    return DRV_ERROR_PARAM;
  }

  DRV_LOCK(ptSequencer);

  ptSequencer->ptDevice->madc_seq_cmd_b.run = 0u;

  if(ptSequencer->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
  {
    ptSequencer->ptDevice->madc_seq_irq_mask_reset = 0x1FFul;
  }

  DRV_UNLOCK(ptSequencer);
  return DRV_OK;
}

DRV_STATUS_E DRV_ADC_Seq_Reset(DRV_ADC_SEQ_HANDLE_T * const ptSequencer)
{
  if(ptSequencer == NULL)
  {
    return DRV_ERROR_PARAM;
  }

  DRV_LOCK(ptSequencer);

  ptSequencer->tBuffer.fEnable = false;
  ptSequencer->ptDevice->madc_seq_cmd_b.reset = 1u;

  DRV_UNLOCK(ptSequencer);
  return DRV_OK;
}

DRV_STATUS_E DRV_ADC_Seq_Meas_ChangeConfig(DRV_ADC_SEQ_HANDLE_T * const ptSequencer, DRV_ADC_SEQ_MEASUREMENT_E eMeasurement,
  DRV_ADC_SEQ_MEAS_INPUT_CHANNEL_E eInputChannel, DRV_ADC_SEQ_MEAS_OVERSAMPLING_E eOversampling, DRV_ADC_SEQ_MEAS_TRIGGER_E eTrigger)
{
  uint32_t ulMadc_Seq_Mx = 0ul;

  if(ptSequencer == NULL)
  {
    return DRV_ERROR_PARAM;
  }

  DRV_LOCK(ptSequencer);

  if((eMeasurement > DRV_ADC_SEQ_MEASUREMENT_MAX) || (eMeasurement < DRV_ADC_SEQ_MEASUREMENT_MIN))
  {
    DRV_UNLOCK(ptSequencer);
    return DRV_ERROR_PARAM;
  }

  if((eInputChannel > DRV_ADC_SEQ_MEAS_INPUT_CHANNEL_MAX) || (eInputChannel < DRV_ADC_SEQ_MEAS_INPUT_CHANNEL_MIN))
  {
    DRV_UNLOCK(ptSequencer);
    return DRV_ERROR_PARAM;
  }

  if((eOversampling > DRV_ADC_SEQ_MEAS_OVERSAMPLING_MAX) || (eOversampling < DRV_ADC_SEQ_MEAS_OVERSAMPLING_MIN))
  {
    DRV_UNLOCK(ptSequencer);
    return DRV_ERROR_PARAM;
  }

  if((eTrigger > DRV_ADC_SEQ_MEAS_TRIGGER_MAX) || (eTrigger < DRV_ADC_SEQ_MEAS_TRIGGER_MIN))
  {
    DRV_UNLOCK(ptSequencer);
    return DRV_ERROR_PARAM;
  }

  ulMadc_Seq_Mx = ((eInputChannel << madc_seq0_madc_seq_m0_mux_Pos) & madc_seq0_madc_seq_m0_mux_Msk)
    | ((eOversampling << madc_seq0_madc_seq_m0_oversample_Pos) & madc_seq0_madc_seq_m0_oversample_Msk)
    | ((eTrigger << madc_seq0_madc_seq_m0_trigger_Pos) & madc_seq0_madc_seq_m0_trigger_Msk);

  switch (eMeasurement)
  {
  case DRV_ADC_SEQ_MEASUREMENT_0:
    ulMadc_Seq_Mx |= (ptSequencer->ptDevice->madc_seq_m0 & madc_seq0_madc_seq_m0_adr_offset_Msk);
    ptSequencer->ptDevice->madc_seq_m0 = ulMadc_Seq_Mx;
    break;
  case DRV_ADC_SEQ_MEASUREMENT_1:
    ulMadc_Seq_Mx |= (ptSequencer->ptDevice->madc_seq_m1 & madc_seq0_madc_seq_m1_adr_offset_Msk);
    ptSequencer->ptDevice->madc_seq_m1 = ulMadc_Seq_Mx;
    break;
  case DRV_ADC_SEQ_MEASUREMENT_2:
    ulMadc_Seq_Mx |= (ptSequencer->ptDevice->madc_seq_m2 & madc_seq0_madc_seq_m2_adr_offset_Msk);
    ptSequencer->ptDevice->madc_seq_m2 = ulMadc_Seq_Mx;
    break;
  case DRV_ADC_SEQ_MEASUREMENT_3:
    ulMadc_Seq_Mx |= (ptSequencer->ptDevice->madc_seq_m3 & madc_seq0_madc_seq_m3_adr_offset_Msk);
    ptSequencer->ptDevice->madc_seq_m3 = ulMadc_Seq_Mx;
    break;
  case DRV_ADC_SEQ_MEASUREMENT_4:
    ulMadc_Seq_Mx |= (ptSequencer->ptDevice->madc_seq_m4 & madc_seq0_madc_seq_m4_adr_offset_Msk);
    ptSequencer->ptDevice->madc_seq_m4 = ulMadc_Seq_Mx;
    break;
  case DRV_ADC_SEQ_MEASUREMENT_5:
    ulMadc_Seq_Mx |= (ptSequencer->ptDevice->madc_seq_m5 & madc_seq0_madc_seq_m5_adr_offset_Msk);
    ptSequencer->ptDevice->madc_seq_m5 = ulMadc_Seq_Mx;
    break;
  case DRV_ADC_SEQ_MEASUREMENT_6:
    ulMadc_Seq_Mx |= (ptSequencer->ptDevice->madc_seq_m6 & madc_seq0_madc_seq_m6_adr_offset_Msk);
    ptSequencer->ptDevice->madc_seq_m6 = ulMadc_Seq_Mx;
    break;
  case DRV_ADC_SEQ_MEASUREMENT_7:
    ulMadc_Seq_Mx |= (ptSequencer->ptDevice->madc_seq_m7 & madc_seq0_madc_seq_m7_adr_offset_Msk);
    ptSequencer->ptDevice->madc_seq_m7 = ulMadc_Seq_Mx;
    break;
  default:
    DRV_UNLOCK(ptSequencer);
    return DRV_ERROR_PARAM;
  }
  DRV_UNLOCK(ptSequencer);
  return DRV_OK;
}

DRV_STATUS_E DRV_ADC_Seq_GetState(DRV_ADC_SEQ_HANDLE_T * const ptSequencer, DRV_ADC_STATE_T * const ptState)
{
  uint32_t Madc_Seq_Status = 0ul;

  if(ptSequencer == NULL)
  {
    return DRV_ERROR_PARAM;
  }

  /* important: read full sequencer status with one access */
  Madc_Seq_Status = ptSequencer->ptDevice->madc_seq_status;

  ptState->ulHalfClockCycle = (uint8_t) ((Madc_Seq_Status & madc_seq1_madc_seq_status_adc_half_clock_cycle_Msk)
    >> madc_seq1_madc_seq_status_adc_half_clock_cycle_Pos);
  ptState->eActiveMeasurement = (DRV_ADC_STATE_MEASUREMENT_E) ((Madc_Seq_Status & madc_seq1_madc_seq_status_m_nr_Msk)
    >> madc_seq1_madc_seq_status_m_nr_Pos);

  if(ptState->ulHalfClockCycle == 0)
  {
    return DRV_OK;
  }
  return DRV_BUSY;
}

DRV_STATUS_E DRV_ADC_Seq_GetSample(DRV_ADC_SEQ_HANDLE_T * const ptSequencer, uint32_t* const pulSample, uint8_t* const pbMeasNr)
{
  uint32_t Madc_Seq_Result_Current = 0ul;

  if(ptSequencer == NULL)
  {
    return DRV_ERROR_PARAM;
  }

  DRV_LOCK(ptSequencer);

  /* important: read full sequencer result with one access */
  Madc_Seq_Result_Current = ptSequencer->ptDevice->madc_seq_result_current;

  if(pulSample != NULL)
  {
    *pulSample = (Madc_Seq_Result_Current & madc_seq1_madc_seq_result_current_val_Msk) >> madc_seq1_madc_seq_result_current_val_Pos;
  }

  if(pbMeasNr != NULL)
  {
    *pbMeasNr = (Madc_Seq_Result_Current & madc_seq1_madc_seq_result_current_mnr_Msk) >> madc_seq1_madc_seq_result_current_mnr_Pos;
  }

  if(Madc_Seq_Result_Current & madc_seq1_madc_seq_result_current_valid_Msk)
  {
    DRV_UNLOCK(ptSequencer);
    return DRV_OK;
  }
  else
  {
    DRV_UNLOCK(ptSequencer);
    return DRV_BUSY;
  }
}

DRV_STATUS_E DRV_ADC_Seq_GetLastSample(DRV_ADC_SEQ_HANDLE_T * const ptSequencer, uint32_t* const pulSample, uint8_t* const pbMeasNr)
{
  uint32_t Madc_Seq_Result_Last = 0ul;

  if(ptSequencer == NULL)
  {
    return DRV_ERROR_PARAM;
  }

  DRV_LOCK(ptSequencer);

  /* important: read full sequencer last result with one access */
  Madc_Seq_Result_Last = ptSequencer->ptDevice->madc_seq_result_last;

  if(pulSample != NULL)
  {
    *pulSample = (Madc_Seq_Result_Last & madc_seq1_madc_seq_result_last_val_Msk) >> madc_seq1_madc_seq_result_last_val_Pos;
  }

  if(pbMeasNr != NULL)
  {
    *pbMeasNr = (Madc_Seq_Result_Last & madc_seq1_madc_seq_result_last_mnr_Msk) >> madc_seq1_madc_seq_result_last_mnr_Pos;
  }

  if(Madc_Seq_Result_Last & madc_seq1_madc_seq_result_last_valid_Msk)
  {
    DRV_UNLOCK(ptSequencer);
    return DRV_OK;
  }
  else
  {
    DRV_UNLOCK(ptSequencer);
    return DRV_BUSY;
  }
}

DRV_STATUS_E DRV_ADC_Seq_SetSampleSeriesBuffer(DRV_ADC_SEQ_HANDLE_T * const ptSequencer, uint16_t* pulSampleSeries, size_t tSize,
  DRV_CALLBACK_F fnCallback, void* pUser)
{
  if((ptSequencer == NULL) || (pulSampleSeries == NULL) || (tSize < 2))
  {
    return DRV_ERROR_PARAM;
  }

  if(ptSequencer->tConfiguration.eOperationMode != DRV_OPERATION_MODE_IRQ)
  {
    return DRV_NSUPP; /* buffer functions only supported in interrupt mode */
  }
  DRV_LOCK(ptSequencer);

  ptSequencer->tBuffer.fEnable = true;
  ptSequencer->tBuffer.pvBufferAdr = (void*) pulSampleSeries;
  ptSequencer->tBuffer.ulPosition = 0;
  ptSequencer->tBuffer.ulMaxCount = (uint32_t) (tSize / 2);
  ptSequencer->tBuffer.fnWrapCallback = fnCallback;
  ptSequencer->tBuffer.pWrapCallbackkHandle = pUser;

  DRV_UNLOCK(ptSequencer);
  return DRV_OK;
}

__STATIC_INLINE void DRV_ACD_IRQ_SaveResult(DRV_ADC_SEQ_HANDLE_T * const ptSequencer, DRV_ADC_SEQ_MEASUREMENT_E const eMeasurement)
{
  uint32_t ulRawValue;
  uint16_t* pusSample;

  /* If buffer mode active, try to save the result */
  if(ptSequencer->tBuffer.fEnable)
  {
    ulRawValue = ptSequencer->ptDevice->madc_seq_result_current;
    pusSample = (uint16_t*) ptSequencer->tBuffer.pvBufferAdr + ptSequencer->tBuffer.ulPosition;

    /* Check if the result valid and assigned to this measurement.
     * Only the case if this measurement be the last in the sequence or the next is not be triggered yet */
    if(ulRawValue & (0x80000000 + (eMeasurement << madc_seq0_madc_seq_result_current_mnr_Pos)))
    {
      *pusSample = (uint16_t) ulRawValue & madc_seq0_madc_seq_result_current_val_Msk;
    }
    else
    {
      /* Get the last latched result */
      ulRawValue = ptSequencer->ptDevice->madc_seq_result_last;

      /* Check if the last result valid and assigned to this measurement. */
      if(ulRawValue & (0x80000000 + (eMeasurement << madc_seq0_madc_seq_result_last_mnr_Pos)))
      {
        *pusSample = (uint16_t) ptSequencer->ptDevice->madc_seq_result_last & madc_seq0_madc_seq_result_last_val_Msk;
      }
      else
      {
        /* Possible to late and the correct result is overwritten. Possible solution is to activate the DMA mode */
        *pusSample = DRV_ADC_SEQ_CATCHED_NO_RESULT;
      }
    }
    ptSequencer->tBuffer.ulPosition++;
    if(ptSequencer->tBuffer.ulPosition == ptSequencer->tBuffer.ulMaxCount)
    {
      /* Last value to the buffer in this round, chance to execute a callback */
      if(ptSequencer->tBuffer.fnWrapCallback != 0)
      {
        ptSequencer->tBuffer.fnWrapCallback((void*) ptSequencer, ptSequencer->tBuffer.pWrapCallbackkHandle);
      }
      ptSequencer->tBuffer.ulPosition = 0; /* next round for the ring buffer */
    }
  }
  if(ptSequencer->tConfiguration.fnMeasurementCompleteCallback[eMeasurement] != 0)
  {
    ptSequencer->tConfiguration.fnMeasurementCompleteCallback[eMeasurement]((void*) ptSequencer,
      ptSequencer->tConfiguration.pMeasurementCompleteCallbackHandle[eMeasurement]);
  }
}

__STATIC_INLINE void DRV_ACD_IRQ_Inline_Handler(DRV_ADC_SEQ_DEVICE_ID_E const eDeviceID)
{
  uint32_t ulDeviceOffset = (uint32_t) eDeviceID - (uint32_t) DRV_ADC_SEQ_DEVICE_ID_MIN;

  DRV_ADC_SEQ_HANDLE_T* ptSequencer = s_apHandleAddressTable[ulDeviceOffset];
#ifndef NDEBUG
  if(ptSequencer == 0 || ptSequencer->ptDevice != s_apSubDeviceAddressTable[ulDeviceOffset])
  {
    ((DRV_ADC_SEQ_DEVICE_T * const ) s_apSubDeviceAddressTable[ulDeviceOffset])->madc_seq_ms_en = 0ul;
    DRV_NVIC_DisableIRQ(s_apHandleIRQnTable[ulDeviceOffset]);
    return;
  }
#endif

  uint32_t ulIrqMasked = ptSequencer->ptDevice->madc_seq_irq_mask_reset; /* shows bit number of the lowest active bit in IRQ_MASKED */

  switch (ulIrqMasked)
  { /* fall through conditions */
  case madc_seq0_madc_seq_irq_masked_m0_cmpl_Pos:
  case madc_seq0_madc_seq_irq_masked_m1_cmpl_Pos:
  case madc_seq0_madc_seq_irq_masked_m2_cmpl_Pos:
  case madc_seq0_madc_seq_irq_masked_m3_cmpl_Pos:
  case madc_seq0_madc_seq_irq_masked_m4_cmpl_Pos:
  case madc_seq0_madc_seq_irq_masked_m5_cmpl_Pos:
  case madc_seq0_madc_seq_irq_masked_m6_cmpl_Pos:
  case madc_seq0_madc_seq_irq_masked_m7_cmpl_Pos:
    (void) DRV_ACD_IRQ_SaveResult(ptSequencer, (DRV_ADC_SEQ_MEASUREMENT_E) ulIrqMasked);
    break;
  case madc_seq0_madc_seq_irq_masked_seq_cmpl_Pos:
    if(ptSequencer->tConfiguration.fnSequenceCompleteCallback != 0)
    {
      ptSequencer->tConfiguration.fnSequenceCompleteCallback((void*) ptSequencer, ptSequencer->tConfiguration.pSequenceCompleteCallbackHandle);
    }
    break;
  default:
    break;
  }
  /* Resets the appropriate IRQ */
  ptSequencer->ptDevice->madc_seq_irq_raw = 1ul << ulIrqMasked;
}

#define  DRV_ACD_IRQHandler_Generator(id, _) DRV_Default_IRQHandler_Function_Generator(MADC ## id ## _IRQHandler ,DRV_ACD_IRQ_Inline_Handler,DRV_ADC_SEQ_DEVICE_ID_ADC ## id)

/*lint -save -e123 */
DRV_DEF_REPEAT_EVAL(DRV_ADC_SEQ_DEVICE_COUNT, DRV_ACD_IRQHandler_Generator, ~)
/*lint -restore */

/* End of group ADC */

/*lint -restore */
/*lint -restore */

#endif /* DRV_ADC_MODULE_DISABLE */