/*
 * Copyright (c) 2016, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
/** ============================================================================
 *  @file       ADCBuf.h
 *
 *  @brief      ADCBuf driver interface
 *
 *  The ADCBuf header file should be included in an application as follows:
 *  @code
 *  #include <ti/drivers/ADCBuf.h>
 *  @endcode
 *
 *  # Operation #
 *  The ADCBuf driver in TI-RTOS samples an analogue waveform at a specified
 *  frequency. The resulting samples are transferred to a buffer provided by
 *  the application. The driver can either take n samples once, or continuously
 *  sample by double-buffering and providing a callback to process each finished
 *  buffer.
 *
 *  The APIs in this driver serve as an interface to a typical TI-RTOS
 *  application. The specific peripheral implementations are responsible to
 *  create all the SYS/BIOS specific primitives to allow for thread-safe
 *  operation.

 *  User can use the ADC driver or the ADCBuf driver. But both ADC and ADCBuf
 *  cannot be used together in an application.
 *
 *  ## Opening the driver #
 *
 *  @code
 *      ADCBuf_Handle adcBufHandle;
 *      ADCBuf_Params adcBufParams;
 *
 *      ADCBuf_Params_init(&adcBufParams);
 *      adcBufHandle = ADCBuf_open(Board_ADCBuf0, &adcBufParams);
 *  @endcode
 *
 *  ## Making a conversion #
 *  In this context, a conversion refers to taking multiple ADC samples and
 *  transferring them to an application-provided buffer.
 *  To start a conversion, the application must configure an ADCBuf_Conversion struct
 *  and call ADCBuf_convert(). In blocking mode, ADCBuf_convert() will return
 *  when the conversion is finished and the desired number of samples have been made.
 *  In callback mode, ADCBuf_convert() will return immediately and the application will
 *  get a callback when the conversion is done.
 *
 *  @code
 *      ADCBuf_Conversion blockingConversion;
 *
 *      blockingConversion.arg = NULL;
 *      blockingConversion.adcChannel = Board_ADCCHANNEL_A1;
 *      blockingConversion.sampleBuffer = sampleBufferOnePtr;
 *      blockingConversion.sampleBufferTwo = NULL;
 *      blockingConversion.samplesRequestedCount = ADCBUFFERSIZE;
 *
 *      if (!ADCBuf_convert(adcBuf, &continuousConversion, 1)) {
 *          // handle error
 *      }
 *  @endcode
 *
 *  ## Canceling a conversion #
 *  ADCBuf_convertCancel() is used to cancel an ADCBuf conversion when the driver is
 *  used in ::ADCBuf_RETURN_MODE_CALLBACK.
 *
 *  Calling this API while no conversion is in progress has no effect. If a
 *  conversion is in progress, it is canceled and the provided callback function
 *  is called.
 *
 *  In ::ADCBuf_RECURRENCE_MODE_CONTINUOUS, this function must be called to stop the
 *  conversion. The driver will continue providing callbacks with fresh samples
 *  until thie ADCBuf_convertCancel() function is called. The callback function is not
 *  called after ADCBuf_convertCancel() while in ::ADCBuf_RECURRENCE_MODE_CONTINUOUS.
 *
 *  # Implementation #
 *
 *  This module serves as the main interface for TI-RTOS applications. Its
 *  purpose is to redirect the module's APIs to specific peripheral
 *  implementations which are specified using a pointer to an ADCBuf_FxnTable.
 *
 *  The ADCBuf driver interface module is joined (at link time) to a
 *  NULL-terminated array of ADCBuf_Config data structures named *ADCBuf_config*.
 *  *ADCBuf_config* is implemented in the application with each entry being an
 *  instance of an ADCBuf peripheral. Each entry in *ADCBuf_config* contains a:
 *  - (ADCBuf_FxnTable *) to a set of functions that implement an ADCBuf peripheral
 *  - (void *) data object that is associated with the ADCBuf_FxnTable
 *  - (void *) hardware attributes that are associated to the ADCBuf_FxnTable
 *
 *  # Instrumentation #
 *
 *  The ADCBuf driver interface produces log statements if instrumentation is
 *  enabled.
 *
 *  Diagnostics Mask | Log details                      |
 *  ---------------- | ---------------------------------|
 *  Diags_USER1      | basic operations performed       |
 *  Diags_USER2      | detailed operations performed    |
 *
 *  ============================================================================
 */

#ifndef ti_drivers_adcbuf__include
#define ti_drivers_adcbuf__include

#ifdef __cplusplus
extern "C" {
#endif

#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>

/**
 *  @defgroup ADCBUF_CONTROL ADCBuf_control command and status codes
 *  These ADCBuf macros are reservations for ADCBuf.h
 *  @{
 */

/*!
 * Common ADCBuf_control command code reservation offset.
 * ADC driver implementations should offset command codes with ADCBuf_CMD_RESERVED
 * growing positively
 *
 * Example implementation specific command codes:
 * @code
 * #define ADCXYZ_COMMAND0         ADCBuf_CMD_RESERVED + 0
 * #define ADCXYZ_COMMAND1         ADCBuf_CMD_RESERVED + 1
 * @endcode
 */
#define ADCBuf_CMD_RESERVED             (32)

/*!
 * Common ADCBuf_control status code reservation offset.
 * ADC driver implementations should offset status codes with
 * ADCBuf_STATUS_RESERVED growing negatively.
 *
 * Example implementation specific status codes:
 * @code
 * #define ADCXYZ_STATUS_ERROR0    ADCBuf_STATUS_RESERVED - 0
 * #define ADCXYZ_STATUS_ERROR1    ADCBuf_STATUS_RESERVED - 1
 * #define ADCXYZ_STATUS_ERROR2    ADCBuf_STATUS_RESERVED - 2
 * @endcode
 */
#define ADCBuf_STATUS_RESERVED          (-32)

/*!
 * \brief  Success status code returned by:
 * ADCBuf_control()
 *
 * Functions return ADCBuf_STATUS_SUCCESS if the call was executed
 * successfully.
 *  @{
 *  @ingroup ADCBUF_CONTROL
 */
#define ADCBuf_STATUS_SUCCESS           (0)

/*!
 * \brief   Generic error status code returned by ADCBuf_control().
 *
 * ADCBuf_control() returns ADCBuf_STATUS_ERROR if the control code was not executed
 * successfully.
 */
#define ADCBuf_STATUS_ERROR             (-1)

/*!
 * \brief   An error status code returned by ADCBuf_control() for undefined
 * command codes.
 *
 * ADCBuf_control() returns ADCBuf_STATUS_UNDEFINEDCMD if the control code is not
 * recognized by the driver implementation.
 */
#define ADCBuf_STATUS_UNDEFINEDCMD      (-2)

/*!
 * \brief   An error status code returned by ADCBuf_adjustRawValues() if the
 * function is not supported by a particular driver implementation.
 *
 * ADCBuf_adjustRawValues() returns ADCBuf_STATUS_UNSUPPORTED if the function is
 * not supported by the driver implementation.
 */
#define ADCBuf_STATUS_UNSUPPORTED      (-3)
/** @}*/

/**
 *  @defgroup ADCBUF_CMD Command Codes
 *  ADCBUF_CMD_* macros are general command codes for I2C_control(). Not all ADCBuf
 *  driver implementations support these command codes.
 *  @{
 *  @ingroup ADCBUF_CONTROL
 */

/* Add ADCBUF_CMD_<commands> here */

/** @}*/

/** @}*/


/*!
 *  @brief      A handle that is returned from an ADCBuf_open() call.
 */
typedef struct ADCBuf_Config_              *ADCBuf_Handle;

/*!
 *  @brief
 *  An ::ADCBuf_Conversion data structure is used with ADCBuf_convert(). It indicates
 *  which channel to perform the ADC conversion on, how many conversions to make, and where to put them.
 *  The arg variable is an user-definable argument which gets passed to the
 *  ::ADCBuf_Callback when the ADC driver is in ::ADCBuf_RETURN_MODE_CALLBACK.
 */
typedef struct ADCBuf_Conversion_ {
    uint16_t            samplesRequestedCount;      /*!< Number of samples to convert and return */
    void                *sampleBuffer;              /*!< Buffer the results of the conversions are stored in */
    void                *sampleBufferTwo;           /*!< A second buffer that is filled in ::ADCBuf_RECURRENCE_MODE_CONTINUOUS mode while
                                                        the first buffer is processed by the application. The value is not used in
                                                        ::ADCBuf_RECURRENCE_MODE_ONE_SHOT mode. */
    void                *arg;                       /*!< Argument to be passed to the callback function in ::ADCBuf_RETURN_MODE_CALLBACK */
    uint32_t            adcChannel;                 /*!< Channel to perform the ADC conversion on. Mapping of channel to pin or internal signal is device specific. */
} ADCBuf_Conversion;

/*!
 *  @brief      The definition of a callback function used by the ADC driver
 *              when used in ::ADCBuf_RETURN_MODE_CALLBACK. It is called in a HWI or SWI context depending on the device specific implementation.
 */
typedef void (*ADCBuf_Callback)            (ADCBuf_Handle handle,
                                            ADCBuf_Conversion *conversion,
                                            void *completedADCBuffer,
                                            uint32_t completedChannel);
/*!
 *  @brief     ADC trigger mode settings
 *
 *  This enum defines if the driver should make n conversions and return
 *  or run indefinitely and run a callback function every n conversions.
 */
typedef enum ADCBuf_Recurrence_Mode_ {
    /*!
     *  The driver makes n measurements and returns or runs a callback function depending
     *  on the ::ADCBuf_Return_Mode setting.
     */
    ADCBuf_RECURRENCE_MODE_ONE_SHOT,
    /*!
     *  The driver makes n measurements and then runs a callback function. This process happens
     *  until the application calls ::ADCBuf_ConvertCancelFxn(). This setting can only be used in
     *  ::ADCBuf_RETURN_MODE_CALLBACK.
     */
    ADCBuf_RECURRENCE_MODE_CONTINUOUS
} ADCBuf_Recurrence_Mode;

/*!
 *  @brief      ADC return mode settings
 *
 *  This enum defines how the ADCBuf_convert() function returns.
 *  It either blocks or returns immediately and calls a callback function when the provided buffer has been filled.
 */
typedef enum ADCBuf_Return_Mode_ {
    /*!
      *  Uses a semaphore to block while ADC conversions are performed.  Context of the call
      *  must be a Task.
      *
      *  @note   Blocking return mode cannot be used in combination with ::ADCBuf_RECURRENCE_MODE_CONTINUOUS
      */
    ADCBuf_RETURN_MODE_BLOCKING,

    /*!
     *  Non-blocking and will return immediately.  When the conversion
     *  is finished the configured callback function is called.
     */
    ADCBuf_RETURN_MODE_CALLBACK
} ADCBuf_Return_Mode;


/*!
 *  @brief ADC Parameters
 *
 *  ADC Parameters are used to with the ADCBuf_open() call. Default values for
 *  these parameters are set using ADCBuf_Params_init().
 *
 *  @sa     ADCBuf_Params_init()
 */
typedef struct ADCBuf_Params_ {
    uint32_t                    blockingTimeout;    /*!< Timeout for semaphore in ::ADCBuf_RETURN_MODE_BLOCKING */
    uint32_t                    samplingFrequency;  /*!< The frequency at which the ADC will produce a sample */
    ADCBuf_Return_Mode          returnMode;         /*!< Return mode for all conversions */
    ADCBuf_Callback             callbackFxn;        /*!< Pointer to callback function */
    ADCBuf_Recurrence_Mode      recurrenceMode;     /*!< One-shot or continuous conversion  */
    void                        *custom;            /*!< Pointer to a device specific extension of the ADCBuf_Params */
} ADCBuf_Params;

/*!
 *  @brief      A function pointer to a driver specific implementation of
 *              ADCBuf_close().
 */
typedef void (*ADCBuf_CloseFxn)                  (ADCBuf_Handle handle);


/*!
 *  @brief      A function pointer to a driver specific implementation of
 *              ADCBuf_open().
 */
typedef ADCBuf_Handle (*ADCBuf_OpenFxn)          (ADCBuf_Handle handle,
                                                  const ADCBuf_Params *params);

/*!
 *  @brief      A function pointer to a driver specific implementation of
 *              ADCBuf_control().
 */
typedef int_fast16_t (*ADCBuf_ControlFxn)        (ADCBuf_Handle handle,
                                                  uint_fast8_t cmd,
                                                  void *arg);
/*
 *  @brief      A function pointer to a driver specific implementation of
 *              ADCBuf_init().
 */
typedef void (*ADCBuf_InitFxn)                   (ADCBuf_Handle handle);

/*!
 *  @brief      A function pointer to a driver specific implementation of
 *              ADCBuf_convert().
 */
typedef int_fast16_t (*ADCBuf_ConvertFxn)     (ADCBuf_Handle handle,
                                               ADCBuf_Conversion conversions[],
                                               uint_fast8_t channelCount);
/*!
 *  @brief      A function pointer to a driver specific implementation of
 *              ADCBuf_convertCancel().
 */
typedef int_fast16_t (*ADCBuf_ConvertCancelFxn)(ADCBuf_Handle handle);

/*!
 *  @brief      A function pointer to a driver specific implementation of
 *              ADCBuf_GetResolution();
 */
typedef uint_fast8_t (*ADCBuf_GetResolutionFxn)     (ADCBuf_Handle handle);

/*!
 *  @brief      A function pointer to a driver specific implementation of
 *              ADCBuf_adjustRawValues();
 */
typedef int_fast16_t (*ADCBuf_adjustRawValuesFxn)(ADCBuf_Handle handle,
                                                void *sampleBuffer,
                                                uint_fast16_t sampleCount,
                                                uint32_t adcChannel);

/*!
 *  @brief      A function pointer to a driver specific implementation of
 *              ADCBuf_convertAdjustedToMicroVolts();
 */
typedef int_fast16_t (*ADCBuf_convertAdjustedToMicroVoltsFxn)  (ADCBuf_Handle handle,
                                                            uint32_t  adcChannel,
                                                            void *adjustedSampleBuffer,
                                                            uint32_t outputMicroVoltBuffer[],
                                                            uint_fast16_t sampleCount);

/*!
 *  @brief      The definition of an ADCBuf function table that contains the
 *              required set of functions to control a specific ADC driver
 *              implementation.
 */
typedef struct ADCBuf_FxnTable_ {
    /*! Function to close the specified peripheral */
    ADCBuf_CloseFxn            closeFxn;
    /*! Function to driver implementation specific control function */
    ADCBuf_ControlFxn          controlFxn;
    /*! Function to initialize the given data object */
    ADCBuf_InitFxn             initFxn;
    /*! Function to open the specified peripheral */
    ADCBuf_OpenFxn             openFxn;
    /*! Function to start an ADC conversion with the specified peripheral */
    ADCBuf_ConvertFxn          convertFxn;
    /*! Function to abort a conversion being carried out by the specified peripheral */
    ADCBuf_ConvertCancelFxn    convertCancelFxn;
    /*! Function to get the resolution in bits of the ADC */
    ADCBuf_GetResolutionFxn    getResolutionFxn;
    /*! Function to adjust raw ADC return bit values to values comparable between devices of the same type */
    ADCBuf_adjustRawValuesFxn   adjustRawValuesFxn;
    /*! Function to convert adjusted ADC values to microvolts */
    ADCBuf_convertAdjustedToMicroVoltsFxn   convertAdjustedToMicroVoltsFxn;
} ADCBuf_FxnTable;

/*!
 *  @brief ADCBuf Global configuration
 *
 *  The ADCBuf_Config structure contains a set of pointers used to characterise
 *  the ADC driver implementation.
 *
 *  This structure needs to be defined before calling ADCBuf_init() and it must
 *  not be changed thereafter.
 *
 *  @sa     ADCBuf_init()
 */
typedef struct ADCBuf_Config_ {
    /*! Pointer to a table of driver-specific implementations of ADC APIs */
    const ADCBuf_FxnTable   *fxnTablePtr;

    /*! Pointer to a driver specific data object */
    void                    *object;

    /*! Pointer to a driver specific hardware attributes structure */
    void const              *hwAttrs;
} ADCBuf_Config;

/*!
 *  @brief  Function to close an ADC peripheral specified by the ADC handle
 *
 *  @pre    ADCBuf_open() has to be called first.
 *
 *  @pre    In ADCBuf_RECURRENCE_MODE_CONTINUOUS, the application must call ADCBuf_convertCancel() first.
 *
 *  @param  handle      An ADCBuf handle returned from ADCBuf_open()
 *
 *  @sa     ADCBuf_open()
 */
extern void ADCBuf_close(ADCBuf_Handle handle);


/*!
 *  @brief  Function performs implementation specific features on a given
 *          ADCBuf_Handle.
 *
 *  @pre    ADCBuf_open() has to be called first.
 *
 *  @param  handle      An ADCBuf handle returned from ADCBuf_open()
 *
 *  @param  cmd         A command value defined by the driver specific
 *                      implementation
 *
 *  @param  cmdArg      A pointer to an optional R/W (read/write) argument that
 *                      is accompanied with cmd
 *
 *  @return An ADCBuf_Status describing an error or success state. Negative values
 *          indicates an error.
 *
 *  @sa     ADCBuf_open()
 */
extern int_fast16_t ADCBuf_control(ADCBuf_Handle handle, uint_fast16_t cmd, void *cmdArg);

/*!
 *  @brief  This function initializes the ADC module. This function must
 *
 *  @pre    The ADCBuf_Config structure must exist and be persistent before this
 *          function can be called.
 *          This function call does not modify any peripheral registers.
 *          Function should only be called once.
 */
extern void ADCBuf_init(void);

/*!
 *  @brief  This function sets all fields of a specified ADCBuf_Params structure to their
 *          default values.
 *
 *  @param  params      A pointer to ADCBuf_Params structure for initialization
 *
 *  Default values are:
 *                      returnMode         = ADCBuf_RETURN_MODE_BLOCKING,
 *                      blockingTimeout    = 25000,
 *                      callbackFxn        = NULL,
 *                      recurrenceMode     = ADCBuf_RECURRENCE_MODE_ONE_SHOT,
 *                      samplingFrequency  = 10000,
 *                      custom             = NULL
 *
 *  ADCBuf_Params::blockingTimeout should be set large enough to allow for the desired number of samples to be
 *  collected with the specified frequency.
 */
extern void ADCBuf_Params_init(ADCBuf_Params *params);

/*!
 *  @brief  This function opens a given ADCBuf peripheral.
 *
 *  @param  index       Logical peripheral number for the ADCBuf indexed into
 *                      the ADCBuf_config table
 *
 *  @param  params      Pointer to an parameter block, if NULL it will use
 *                      default values.
 *
 *  @return An ADCBuf_Handle on success or a NULL on an error or if it has been
 *          opened already. If NULL is returned further ADC API calls will
 *          result in undefined behaviour.
 *
 *  @sa     ADCBuf_close()
 */
extern ADCBuf_Handle ADCBuf_open(uint_least8_t index, ADCBuf_Params *params);

/*!
 *  @brief  This function starts a set of conversions on one or more channels.
 *
 *  @param  handle          An ADCBuf handle returned from ADCBuf_open()
 *
 *  @param  conversions     A pointer to an array of ADCBuf_Conversion structs with the specific parameters
 *                          for each channel. Only use one ADCBuf_Conversion struct per channel.
 *
 *  @param  channelCount    The number of channels to convert on in this call. Should be the length of the conversions array.
 *                          Depending on the device, multiple simultaneous conversions may not be supported. See device
 *                          specific implementation.
 *
 *  @return ADCBuf_STATUS_SUCCESS if the operation was successful. ADCBuf_STATUS_ERROR or a device specific status is returned otherwise.
 *
 *  @pre    ADCBuf_open() must have been called prior.
 *
 *  @sa     ADCBuf_convertCancel()
 */
extern int_fast16_t ADCBuf_convert(ADCBuf_Handle handle, ADCBuf_Conversion conversions[],  uint_fast8_t channelCount);

/*!
 *  @brief  This function cancels an ADC conversion that is in progress.
 *
 *  This function must be called before calling ADCBuf_close().
 *
 *  @param  handle      An ADCBuf handle returned from ADCBuf_open()
 *
 *  @return ADCBuf_STATUS_SUCCESS if the operation was successful. ADCBuf_STATUS_ERROR or a device specific status is returned otherwise.
 *
 *  @sa     ADCBuf_convert()
 */
extern int_fast16_t ADCBuf_convertCancel(ADCBuf_Handle handle);

/*!
 *  @brief  This function returns the resolution in bits of the specified ADC.
 *
 *  @param  handle      An ADCBuf handle returned from ADCBuf_open().
 *
 *  @return The resolution in bits of the specified ADC.
 *
 *  @pre    ADCBuf_open() must have been called prior.
 */
extern uint_fast8_t ADCBuf_getResolution(ADCBuf_Handle handle);

 /*!
 *  @brief  This function adjusts a raw ADC output buffer such that the result is comparable between devices of the same make.
 *          The function does the adjustment in-place.
 *
 *  @param  handle          An ADCBuf handle returned from ADCBuf_open().
 *
 *  @param  sampleBuf       A buffer full of raw sample values.
 *
 *  @param  sampleCount     The number of samples to adjust.
 *
 *  @param  adcChan         The channel the buffer was sampled on.
 *
 *  @return A buffer full of adjusted samples contained in sampleBuffer.
 *
 *  @return ADCBuf_STATUS_SUCCESS if the operation was successful. ADCBuf_STATUS_ERROR or a device specific status is returned otherwise.
 *
 *  @pre    ADCBuf_open() must have been called prior.
 */
extern int_fast16_t ADCBuf_adjustRawValues(ADCBuf_Handle handle, void *sampleBuf, uint_fast16_t sampleCount, uint32_t adcChan);

 /*!
 *  @brief  This function converts a raw ADC output value to a value scaled in micro volts.
 *
 *  @param  handle      An ADCBuf handle returned from ADCBuf_open()
 *
 *  @param  adcChan     The ADC channel the samples stem from. This parameter is only necessary for certain devices.
 *                      See device specific implementation for details.
 *
 *  @param  adjustedSampleBuffer    A buffer full of adjusted samples.
 *
 *  @param  outputMicroVoltBuffer   The output buffer. The conversion does not occur in place due to the differing data type sizes.
 *
 *  @param  sampleCount             The number of samples to convert.
 *
 *  @return A number of measurements scaled in micro volts inside outputMicroVoltBuffer.
 *
 *  @return ADCBuf_STATUS_SUCCESS if the operation was successful. ADCBuf_STATUS_ERROR or a device specific status is returned otherwise.
 *
 *  @pre    ADCBuf_open() must have been called prior.
 *
 *  @pre    ADCBuf_adjustRawValues() must be called on adjustedSampleBuffer prior.
 */
extern int_fast16_t ADCBuf_convertAdjustedToMicroVolts(ADCBuf_Handle handle, uint32_t  adcChan, void *adjustedSampleBuffer, uint32_t outputMicroVoltBuffer[], uint_fast16_t sampleCount);

#ifdef __cplusplus
}
#endif
#endif /* ti_drivers_adcbuf__include */