Mbed Development branch for MeasrueWare

Revision:
6:9d393a9677f4
Parent:
5:0728bde67bdb
Child:
8:2f2775c34640
--- a/src/admw_1001.c	Wed Jun 05 05:39:15 2019 +0000
+++ b/src/admw_1001.c	Sat Jun 15 14:30:49 2019 +0000
@@ -90,7 +90,8 @@
 #include "admw1001/admw1001_host_comms.h"
 
 #include "crc16.h"
-
+#define VERSIONID_MAJOR 1
+#define VERSIONID_MINOR 7
 
 uint32_t    getDataCnt = 0;
 
@@ -106,13 +107,13 @@
 /* Checks if a value is outside the bounds of the specified register field */
 #define CHECK_REG_FIELD_VAL(_field, _val)                               \
     do {                                                                \
-        uint32_t _mask  = BITM_##_field;                       \
-        uint32_t _shift = BITP_##_field;                       \
+        uint32_t _mask  = BITM_##_field;                        \
+        uint32_t _shift = BITP_##_field;                        \
         if ((((_val) << _shift) & ~(_mask)) != 0) {                     \
-            ADMW_LOG_ERROR("Value 0x%08X invalid for register field %s", \
+            ADMW_LOG_ERROR("Value 0x%08X invalid for register field %s",\
                                 (uint32_t)(_val),                       \
-                                STRINGIFY(ADMW_##_field));          \
-            return ADMW_INVALID_PARAM;                             \
+                                STRINGIFY(ADMW_##_field));              \
+            return ADMW_INVALID_PARAM;                              \
         }                                                               \
     } while(false)
 
@@ -122,26 +123,26 @@
  */
 #define WRITE_REG(_hdev, _val, _name, _type)                            \
     do {                                                                \
-        ADMW_RESULT _res;                                          \
+        ADMW_RESULT _res;                                           \
         _type _regval = _val;                                           \
-        _res = admw1001_WriteRegister((_hdev),                    \
-                                            REG_##_name,       \
+        _res = admw1001_WriteRegister((_hdev),                      \
+                                            REG_##_name,        \
                                             &_regval, sizeof(_regval)); \
-        if (_res != ADMW_SUCCESS)                                  \
+        if (_res != ADMW_SUCCESS)                                   \
             return _res;                                                \
     } while(false)
 
 /* Wrapper macro to write a value to a uint32_t register */
-#define WRITE_REG_U32(_hdev, _val, _name)       \
+#define WRITE_REG_U32(_hdev, _val, _name)                       \
     WRITE_REG(_hdev, _val, _name, uint32_t)
 /* Wrapper macro to write a value to a uint16_t register */
-#define WRITE_REG_U16(_hdev, _val, _name)       \
+#define WRITE_REG_U16(_hdev, _val, _name)                       \
     WRITE_REG(_hdev, _val, _name, uint16_t)
 /* Wrapper macro to write a value to a uint8_t register */
-#define WRITE_REG_U8(_hdev, _val, _name)        \
+#define WRITE_REG_U8(_hdev, _val, _name)                        \
     WRITE_REG(_hdev, _val, _name, uint8_t)
 /* Wrapper macro to write a value to a float32_t register */
-#define WRITE_REG_FLOAT(_hdev, _val, _name)     \
+#define WRITE_REG_FLOAT(_hdev, _val, _name)                     \
     WRITE_REG(_hdev, _val, _name, float32_t)
 
 /*
@@ -150,27 +151,27 @@
  */
 #define READ_REG(_hdev, _val, _name, _type)                             \
     do {                                                                \
-        ADMW_RESULT _res;                                          \
+        ADMW_RESULT _res;                                           \
         _type _regval;                                                  \
-        _res = admw1001_ReadRegister((_hdev),                     \
-                                           REG_##_name,        \
+        _res = admw1001_ReadRegister((_hdev),                       \
+                                           REG_##_name,         \
                                            &_regval, sizeof(_regval));  \
-        if (_res != ADMW_SUCCESS)                                  \
+        if (_res != ADMW_SUCCESS)                                   \
             return _res;                                                \
         _val = _regval;                                                 \
     } while(false)
 
 /* Wrapper macro to read a value from a uint32_t register */
-#define READ_REG_U32(_hdev, _val, _name)        \
+#define READ_REG_U32(_hdev, _val, _name)                        \
     READ_REG(_hdev, _val, _name, uint32_t)
 /* Wrapper macro to read a value from a uint16_t register */
-#define READ_REG_U16(_hdev, _val, _name)        \
+#define READ_REG_U16(_hdev, _val, _name)                        \
     READ_REG(_hdev, _val, _name, uint16_t)
 /* Wrapper macro to read a value from a uint8_t register */
-#define READ_REG_U8(_hdev, _val, _name)         \
+#define READ_REG_U8(_hdev, _val, _name)                         \
     READ_REG(_hdev, _val, _name, uint8_t)
 /* Wrapper macro to read a value from a float32_t register */
-#define READ_REG_FLOAT(_hdev, _val, _name)      \
+#define READ_REG_FLOAT(_hdev, _val, _name)                      \
     READ_REG(_hdev, _val, _name, float32_t)
 
 /*
@@ -178,45 +179,45 @@
  * NOTE - this is intended only for writing to a keyhole data register
  */
 #define WRITE_REG_U8_ARRAY(_hdev, _arr, _len, _name)                \
-    do {                                                            \
-        ADMW_RESULT _res;                                      \
-        _res = admw1001_WriteRegister(_hdev,                  \
-                                            REG_##_name,   \
-                                            _arr, _len);            \
-        if (_res != ADMW_SUCCESS)                              \
-            return _res;                                            \
+    do {                                                                \
+        ADMW_RESULT _res;                                           \
+        _res = admw1001_WriteRegister(_hdev,                        \
+                                            REG_##_name,        \
+                                            _arr, _len);                \
+        if (_res != ADMW_SUCCESS)                                   \
+            return _res;                                                \
     } while(false)
 
 /*
  * Wrapper macro to read an array of values from a uint8_t register
  * NOTE - this is intended only for reading from a keyhole data register
  */
-#define READ_REG_U8_ARRAY(_hdev, _arr, _len, _name)                 \
-    do {                                                            \
-        ADMW_RESULT _res;                                      \
-        _res = admw1001_ReadRegister((_hdev),                 \
-                                           REG_##_name,    \
-                                           _arr, _len);             \
-        if (_res != ADMW_SUCCESS)                              \
-            return _res;                                            \
+#define READ_REG_U8_ARRAY(_hdev, _arr, _len, _name)                     \
+    do {                                                                \
+        ADMW_RESULT _res;                                           \
+        _res = admw1001_ReadRegister((_hdev),                       \
+                                           REG##_name,          \
+                                           _arr, _len);                 \
+        if (_res != ADMW_SUCCESS)                                   \
+            return _res;                                                \
     } while(false)
 
-#define ADMW1001_CHANNEL_IS_ADC(c)                                \
-    ((c) >= ADMW1001_CHANNEL_ID_CJC_0 && (c) <= ADMW1001_CHANNEL_ID_CURRENT_0)
-
-#define ADMW1001_CHANNEL_IS_ADC_CJC(c)                            \
-    ((c) >= ADMW1001_CHANNEL_ID_CJC_0 && (c) <= ADMW1001_CHANNEL_ID_CJC_1)
-
-#define ADMW1001_CHANNEL_IS_ADC_SENSOR(c)                         \
-    ((c) >= ADMW1001_CHANNEL_ID_SENSOR_0 && (c) <= ADMW1001_CHANNEL_ID_SENSOR_3)
-
-#define ADMW1001_CHANNEL_IS_ADC_VOLTAGE(c)    \
-    ((c) == ADMW1001_CHANNEL_ID_VOLTAGE_0)
-
-#define ADMW1001_CHANNEL_IS_ADC_CURRENT(c)    \
-    ((c) == ADMW1001_CHANNEL_ID_CURRENT_0)
-
-#define ADMW1001_CHANNEL_IS_VIRTUAL(c)                            \
+#define ADMW1001_CHANNEL_IS_ADC(c)                                  \
+    ((c) >= ADMW1001_CHANNEL_ID_ANALOG_1_UNIVERSAL && (c) <= ADMW1001_CHANNEL_ID_ANALOG_2_DIFFERENTIAL)
+
+#define ADMW1001_CHANNEL_IS_ADC_CJC(c)                              \
+    ((c) >= ADMW1001_CHANNEL_ID_ANALOG_1_UNIVERSAL && (c) <= ADMW1001_CHANNEL_ID_ANALOG_2_UNIVERSAL)
+
+#define ADMW1001_CHANNEL_IS_ADC_SENSOR(c)                           \
+    ((c) >= ADMW1001_CHANNEL_ID_ANALOG_1_UNIVERSAL && (c) <= ADMW1001_CHANNEL_ID_ANALOG_2_UNIVERSAL)
+
+#define ADMW1001_CHANNEL_IS_ADC_VOLTAGE(c)                      \
+    ((c) == ADMW1001_CHANNEL_ID_ANALOG_1_DIFFERENTIAL || ADMW1001_CHANNEL_ID_ANALOG_2_DIFFERENTIAL)
+
+#define ADMW1001_CHANNEL_IS_ADC_CURRENT(c)                      \
+    ((c) == ADMW1001_CHANNEL_ID_ANALOG_1_UNIVERSAL || (c) == ADMW1001_CHANNEL_ID_ANALOG_2_UNIVERSAL)
+
+#define ADMW1001_CHANNEL_IS_VIRTUAL(c)                              \
     ((c) == ADMW1001_CHANNEL_ID_SPI_1 || (c) == ADMW1001_CHANNEL_ID_SPI_2)
 
 typedef struct
@@ -353,8 +354,6 @@
         pStatus->deviceStatus |= ADMW_DEVICE_STATUS_DATAREADY;
     if (statusReg.FIFO_Error)
         pStatus->deviceStatus |= ADMW_DEVICE_STATUS_FIFO_ERROR;
-    if (alert2Reg.Ext_Flash_Error)
-        pStatus->deviceStatus |= ADMW_DEVICE_STATUS_EXT_FLASH_ERROR;
     if (statusReg.Alert_Active)
     {
         pStatus->deviceStatus |= ADMW_DEVICE_STATUS_ALERT;
@@ -427,12 +426,6 @@
 
         if (diagStatusReg.Diag_Checksum_Error)
             pStatus->diagnosticsStatus |= ADMW_DIAGNOSTICS_STATUS_CHECKSUM_ERROR;
-        if (diagStatusReg.Diag_Comms_Error)
-            pStatus->diagnosticsStatus |= ADMW_DIAGNOSTICS_STATUS_COMMS_ERROR;
-        if (diagStatusReg.Diag_Supply_Monitor_Error)
-            pStatus->diagnosticsStatus |= ADMW_DIAGNOSTICS_STATUS_SUPPLY_MONITOR_ERROR;
-        if (diagStatusReg.Diag_Supply_Cap_Error)
-            pStatus->diagnosticsStatus |= ADMW_DIAGNOSTICS_STATUS_SUPPLY_CAP_ERROR;
         if (diagStatusReg.Diag_Conversion_Error)
             pStatus->diagnosticsStatus |= ADMW_DIAGNOSTICS_STATUS_CONVERSION_ERROR;
         if (diagStatusReg.Diag_Calibration_Error)
@@ -477,10 +470,10 @@
 
     /*
      * Don't allow another command to be issued if one is already running, but
-     * make an exception for CORE_COMMAND_NOP which can be used to
+     * make an exception for ENUM_CORE_COMMAND_NOP which can be used to
      * request a running command to be stopped (e.g. continuous measurement)
      */
-    if (command != CORE_COMMAND_NOP)
+    if (command != ENUM_CORE_COMMAND_NOP)
     {
         eRet = admw_GetCommandRunningState(hDevice, &bCommandRunning);
         if (eRet)
@@ -542,14 +535,10 @@
 {
     switch (eMeasurementMode)
     {
-    case ADMW_MEASUREMENT_MODE_HEALTHCHECK:
-        return executeCommand(hDevice, CORE_COMMAND_SYSTEM_CHECK, false);
     case ADMW_MEASUREMENT_MODE_NORMAL:
         return executeCommand(hDevice, CORE_COMMAND_CONVERT_WITH_RAW, false);
     case ADMW_MEASUREMENT_MODE_OMIT_RAW:
         return executeCommand(hDevice, CORE_COMMAND_CONVERT, false);
-    case ADMW_MEASUREMENT_MODE_FFT:
-        return executeCommand(hDevice, CORE_COMMAND_CONVERT_FFT, false);
     default:
         ADMW_LOG_ERROR("Invalid measurement mode %d specified",
                             eMeasurementMode);
@@ -571,12 +560,6 @@
     {
         case ADMW_FLASH_CONFIG_1:
             return executeCommand(hDevice, CORE_COMMAND_SAVE_CONFIG_1, true);
-        case ADMW_FLASH_CONFIG_2:
-            return executeCommand(hDevice, CORE_COMMAND_SAVE_CONFIG_2, true);
-        case ADMW_FLASH_CONFIG_3:
-            return executeCommand(hDevice, CORE_COMMAND_SAVE_CONFIG_3, true);
-        case ADMW_FLASH_CONFIG_4:
-            return executeCommand(hDevice, CORE_COMMAND_SAVE_CONFIG_4, true);
         default:
             ADMW_LOG_ERROR("Invalid user config target slot %d specified",
                                 eSlotId);
@@ -596,12 +579,6 @@
     {
         case ADMW_FLASH_CONFIG_1:
             return executeCommand(hDevice, CORE_COMMAND_LOAD_CONFIG_1, true);
-        case ADMW_FLASH_CONFIG_2:
-            return executeCommand(hDevice, CORE_COMMAND_LOAD_CONFIG_2, true);
-        case ADMW_FLASH_CONFIG_3:
-            return executeCommand(hDevice, CORE_COMMAND_LOAD_CONFIG_3, true);
-        case ADMW_FLASH_CONFIG_4:
-            return executeCommand(hDevice, CORE_COMMAND_LOAD_CONFIG_4, true);
         default:
             ADMW_LOG_ERROR("Invalid user config source slot %d specified",
                                 eSlotId);
@@ -610,126 +587,6 @@
 }
 
 /*
- * Erase the entire external flash memory.
- * No other command must be running when this is called.
- */
-ADMW_RESULT admw_EraseExternalFlash(
-    ADMW_DEVICE_HANDLE    const hDevice)
-{
-    return executeCommand(hDevice, CORE_COMMAND_ERASE_EXTERNAL_FLASH, true);
-}
-
-/*
- * Read the number of samples stored in external flash memory.
- * No other command must be running when this is called.
- */
-ADMW_RESULT admw_GetExternalFlashSampleCount(
-    ADMW_DEVICE_HANDLE    const hDevice,
-    uint32_t * nSampleCount)
-{
-    CORE_Ext_Flash_Sample_Count_t nCount;
-
-    READ_REG_U32(hDevice, nCount.VALUE32, CORE_EXT_FLASH_SAMPLE_COUNT);
-
-    *nSampleCount = nCount.VALUE32;
-
-    return ADMW_SUCCESS;
-}
-
-// DEBUG - TO BE DELETED
-ADMW_RESULT admw_SetExternalFlashIndex(
-    ADMW_DEVICE_HANDLE    const hDevice,
-    uint32_t nStartIndex)
-{
-    WRITE_REG_U32(hDevice, nStartIndex, CORE_EXT_FLASH_INDEX);
-
-    return ADMW_SUCCESS;
-}
-
-/*
- * Read a set of data samples stored in the device external flash memory.
- * This may be called at any time.
- */
-ADMW_RESULT admw_GetExternalFlashData(
-    ADMW_DEVICE_HANDLE    const hDevice,
-    ADMW_DATA_SAMPLE    * const pSamples,
-    uint32_t                   const nStartIndex,
-    uint32_t                   const nRequested,
-    uint32_t                 * const pnReturned)
-{
-    ADMW_DEVICE_CONTEXT *pCtx = hDevice;
-    uint16_t command = ADMW1001_HOST_COMMS_READ_CMD |
-        (REG_CORE_EXT_FLASH_DATA & ADMW1001_HOST_COMMS_ADR_MASK);
-    uint8_t commandData[2] = {
-        command >> 8,
-        command & 0xFF
-    };
-    uint8_t commandResponse[2];
-    unsigned nValidSamples = 0;
-    ADMW_RESULT eRet = ADMW_SUCCESS;
-
-    /* Setup initial sample */
-    WRITE_REG_U32(hDevice, nStartIndex, CORE_EXT_FLASH_INDEX);
-
-    /* Send flash read command */
-    do {
-        eRet = admw_SpiTransfer(pCtx->hSpi, commandData, commandResponse,
-                                     sizeof(command), false);
-        if (eRet)
-        {
-            ADMW_LOG_ERROR("Failed to send read command for external flash");
-            return eRet;
-        }
-        
-        admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
-    } while ((commandResponse[0] != ADMW1001_HOST_COMMS_CMD_RESP_0) ||
-             (commandResponse[1] != ADMW1001_HOST_COMMS_CMD_RESP_1));
-
-    /* Read samples from external flash memory */
-    for (unsigned i = 0; i < nRequested; i++)
-    {
-        ADMW1001_Sensor_Result_t sensorResult;
-        bool bHoldCs = true;
-
-        /* Keep the CS signal asserted for all but the last sample */
-        if ((i + 1) == nRequested)
-            bHoldCs = false;
-
-        eRet = admw_SpiTransfer(pCtx->hSpi, NULL, (uint8_t *) (&sensorResult),
-                                     8, bHoldCs);
-        if (eRet)
-        {
-            ADMW_LOG_ERROR("Failed to read data from external flash");
-            return eRet;
-        }
-
-        ADMW_DATA_SAMPLE *pSample = &pSamples[nValidSamples];
-
-        pSample->status = (ADMW_DEVICE_STATUS_FLAGS)0;
-        if (sensorResult.Ch_Error)
-            pSample->status |= ADMW_DEVICE_STATUS_ERROR;
-        if (sensorResult.Ch_Alert)
-            pSample->status |= ADMW_DEVICE_STATUS_ALERT;
-
-        if (sensorResult.Ch_Raw)
-            pSample->rawValue = sensorResult.Raw_Sample;
-        else
-            pSample->rawValue = 0;
-
-        pSample->channelId = sensorResult.Channel_ID;
-        pSample->processedValue = sensorResult.Sensor_Result;
-
-        nValidSamples++;
-    }
-    *pnReturned = nValidSamples;
-
-    admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
-
-    return eRet;
-}
-
-
-/*
  * Store the LUT data to persistent memory on the device.
  * No other command must be running when this is called.
  * Do not power down the device while this command is running.
@@ -761,28 +618,6 @@
 }
 
 /*
- * Run built-in diagnostic checks on the device.
- * Diagnostics are executed according to the current applied settings.
- * No other command must be running when this is called.
- */
-ADMW_RESULT admw_RunDiagnostics(
-    ADMW_DEVICE_HANDLE    const hDevice)
-{
-    return executeCommand(hDevice, CORE_COMMAND_RUN_DIAGNOSTICS, true);
-}
-
-/*
- * Run self-calibration routines on the device.
- * Calibration is executed according to the current applied settings.
- * No other command must be running when this is called.
- */
-ADMW_RESULT admw_RunCalibration(
-    ADMW_DEVICE_HANDLE    const hDevice)
-{
-    return executeCommand(hDevice, CORE_COMMAND_SELF_CALIBRATION, true);
-}
-
-/*
  * Run digital calibration routines on the device.
  * Calibration is executed according to the current applied settings.
  * No other command must be running when this is called.
@@ -942,6 +777,48 @@
     return ADMW_SUCCESS;
 }
 
+ADMW_RESULT admw1001_Write_Debug_Register(
+    ADMW_DEVICE_HANDLE hDevice,
+    uint16_t nAddress,
+    void *pData,
+    unsigned nLength)
+{
+    ADMW_RESULT eRet;
+    ADMW_DEVICE_CONTEXT *pCtx = hDevice;
+    uint16_t command = ADMW1001_HOST_COMMS_DEBUG_WRITE_CMD |
+        (nAddress & ADMW1001_HOST_COMMS_ADR_MASK);
+    uint8_t commandData[2] = {
+        command >> 8,
+        command & 0xFF
+    };
+    uint8_t commandResponse[2];
+
+    do {
+        eRet = admw_SpiTransfer(pCtx->hSpi, commandData, commandResponse,
+                                     sizeof(command), false);
+        if (eRet)
+        {
+            ADMW_LOG_ERROR("Failed to send write command for register %u",
+                                nAddress);
+            return eRet;
+        }
+
+        admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
+    } while ((commandResponse[0] != ADMW1001_HOST_COMMS_CMD_RESP_0) ||
+             (commandResponse[1] != ADMW1001_HOST_COMMS_CMD_RESP_1));
+
+    eRet = admw_SpiTransfer(pCtx->hSpi, pData, NULL, nLength, false);
+    if (eRet)
+    {
+        ADMW_LOG_ERROR("Failed to write data (%dB) to register %u",
+                            nLength, nAddress);
+        return eRet;
+    }
+
+    admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
+
+    return ADMW_SUCCESS;
+}
 ADMW_RESULT admw1001_ReadRegister(
     ADMW_DEVICE_HANDLE hDevice,
     uint16_t nAddress,
@@ -985,6 +862,48 @@
     return ADMW_SUCCESS;
 }
 
+ADMW_RESULT admw1001_Read_Debug_Register(
+    ADMW_DEVICE_HANDLE hDevice,
+    uint16_t nAddress,
+    void *pData,
+    unsigned nLength)
+{
+    ADMW_RESULT eRet;
+    ADMW_DEVICE_CONTEXT *pCtx = hDevice;
+    uint16_t command = ADMW1001_HOST_COMMS_DEBUG_READ_CMD |
+        (nAddress & ADMW1001_HOST_COMMS_ADR_MASK);
+    uint8_t commandData[2] = {
+        command >> 8,
+        command & 0xFF
+    };
+    uint8_t commandResponse[2];
+
+    do {
+        eRet = admw_SpiTransfer(pCtx->hSpi, commandData, commandResponse,
+                                     sizeof(command), false);
+        if (eRet)
+        {
+            ADMW_LOG_ERROR("Failed to send read command for register %u",
+                                nAddress);
+            return eRet;
+        }
+
+        admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
+    } while ((commandResponse[0] != ADMW1001_HOST_COMMS_CMD_RESP_0) ||
+             (commandResponse[1] != ADMW1001_HOST_COMMS_CMD_RESP_1));
+
+    eRet = admw_SpiTransfer(pCtx->hSpi, NULL, pData, nLength, false);
+    if (eRet)
+    {
+        ADMW_LOG_ERROR("Failed to read data (%uB) from register %u",
+                            nLength, nAddress);
+        return eRet;
+    }
+
+    admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
+
+    return ADMW_SUCCESS;
+}
 ADMW_RESULT admw_GetDeviceReadyState(
     ADMW_DEVICE_HANDLE   const hDevice,
     bool                  * const bReady)
@@ -1013,167 +932,94 @@
     CORE_Mode_t modeReg;
     READ_REG_U8(hDevice, modeReg.VALUE8, CORE_MODE);
 
-    if ((eMeasurementMode == ADMW_MEASUREMENT_MODE_HEALTHCHECK) ||
-        (modeReg.Conversion_Mode == CORE_MODE_SINGLECYCLE))
+    if (eMeasurementMode == (modeReg.Conversion_Mode == CORE_MODE_SINGLECYCLE))
         *peOperatingMode = ADMW1001_OPERATING_MODE_SINGLECYCLE;
     else if (modeReg.Conversion_Mode == CORE_MODE_MULTICYCLE)
         *peOperatingMode = ADMW1001_OPERATING_MODE_MULTICYCLE;
     else
         *peOperatingMode = ADMW1001_OPERATING_MODE_CONTINUOUS;
 
-
-    /* FFT mode is quite different to the other modes:
-     * - Each FFT result produces a batch of samples
-     * - The size of the batch depends on selected FFT size and output config options
-     * - DATAREADY will fire for each FFT result (once per channel)
-     * - The size of the cycle depends on the number of channels enabled for FFT
-     */
-    if (eMeasurementMode == ADMW_MEASUREMENT_MODE_FFT)
+    if (eMeasurementMode == ADMW_MEASUREMENT_MODE_OMIT_RAW)
     {
-        CORE_FFT_Config_t fftConfigReg;
-
-        unsigned nFftChannels;
-        unsigned nSamplesPerChannel;
-
-        READ_REG_U32(hDevice, fftConfigReg.VALUE32, CORE_FFT_CONFIG);
-
-        nFftChannels = fftConfigReg.FFT_Num_Channels + 1;
-
-        if (fftConfigReg.FFT_Output == CORE_FFT_CONFIG_FFT_OUTPUT_MAX16)
-        {
-            nSamplesPerChannel = 16;
-            *pnBytesPerSample = 8;
-        }
-        else if (fftConfigReg.FFT_Output == CORE_FFT_CONFIG_FFT_OUTPUT_FULL)
-        {
-            nSamplesPerChannel = (256 << fftConfigReg.FFT_Num_Bins) >> 1;
-            *pnBytesPerSample = 5;
-        }
-        else if (fftConfigReg.FFT_Output == CORE_FFT_CONFIG_FFT_OUTPUT_FULL_WITH_RAW)
-        {
-            nSamplesPerChannel = (256 << fftConfigReg.FFT_Num_Bins);
-            *pnBytesPerSample = 8;
-        }
-        else
-        {
-            ADMW_LOG_ERROR("Invalid FFT output format option %d configured",
-                                fftConfigReg.FFT_Output);
-            return ADMW_INVALID_PARAM;
-        }
-
-        *pnSamplesPerDataready = nSamplesPerChannel;
-        *pnSamplesPerCycle = nSamplesPerChannel * nFftChannels;
-
-        *peDataReadyMode = ADMW1001_DATAREADY_PER_CYCLE;
-
-        if (modeReg.FFT_Mode == CORE_MODE_FFT_MODE_CONTINUOUS)
-        {
-            *peOperatingMode = ADMW1001_OPERATING_MODE_CONTINUOUS;
-        }
-        else
-        {
-            *peOperatingMode = ADMW1001_OPERATING_MODE_SINGLECYCLE;
-        }
+    *pnBytesPerSample = 5;
     }
     else
     {
-        if (eMeasurementMode == ADMW_MEASUREMENT_MODE_OMIT_RAW)
-        {
-            *pnBytesPerSample = 5;
-        }
-        else
-        {
-            *pnBytesPerSample = 8;
-        }
-
-        for (ADMW1001_CHANNEL_ID chId = ADMW1001_CHANNEL_ID_CJC_0;
-             chId < ADMW1001_MAX_CHANNELS;
-             chId++)
+    *pnBytesPerSample = 8;
+    }
+  
+    for (ADMW1001_CHANNEL_ID chId = ADMW1001_CHANNEL_ID_ANALOG_1_UNIVERSAL;
+     chId < ADMW1001_MAX_CHANNELS;
+     chId++)
+    {
+    CORE_Sensor_Details_t sensorDetailsReg;
+    CORE_Channel_Count_t channelCountReg;
+  
+    if (ADMW1001_CHANNEL_IS_VIRTUAL(chId))
+        continue;
+  
+    READ_REG_U8(hDevice, channelCountReg.VALUE8, CORE_CHANNEL_COUNTn(chId));
+    READ_REG_U32(hDevice, sensorDetailsReg.VALUE32, CORE_SENSOR_DETAILSn(chId));
+  
+    if (channelCountReg.Channel_Enable && !sensorDetailsReg.Do_Not_Publish)
+    {
+        CORE_Sensor_Type_t sensorTypeReg;
+        unsigned nActualChannels = 1;
+  
+        READ_REG_U16(hDevice, sensorTypeReg.VALUE16, CORE_SENSOR_TYPEn(chId));
+  
+        if (chId == ADMW1001_CHANNEL_ID_SPI_0)
         {
-            CORE_Sensor_Details_t sensorDetailsReg;
-            CORE_Channel_Count_t channelCountReg;
-
-            if (ADMW1001_CHANNEL_IS_VIRTUAL(chId))
-                continue;
-
-            READ_REG_U8(hDevice, channelCountReg.VALUE8, CORE_CHANNEL_COUNTn(chId));
-            READ_REG_U32(hDevice, sensorDetailsReg.VALUE32, CORE_SENSOR_DETAILSn(chId));
-
-            if (channelCountReg.Channel_Enable && !sensorDetailsReg.Do_Not_Publish)
-            {
-                CORE_Sensor_Type_t sensorTypeReg;
-                unsigned nActualChannels = 1;
-
-                READ_REG_U16(hDevice, sensorTypeReg.VALUE16, CORE_SENSOR_TYPEn(chId));
-
-                if (chId == ADMW1001_CHANNEL_ID_SPI_0)
-                {
-                    /* Some sensors automatically generate samples on additional "virtual" channels
-                     * so these channels must be counted as active when those sensors are selected
-                     * and we use the count from the corresponding "physical" channel */
-                    if ((sensorTypeReg.Sensor_Type >=
-                         CORE_SENSOR_TYPE_SENSOR_SPI_ACCELEROMETER_A_DEF_L1) &&
-                        (sensorTypeReg.Sensor_Type <=
-                         CORE_SENSOR_TYPE_SENSOR_SPI_ACCELEROMETER_B_ADV_L2))
-                        nActualChannels += 2;
-                }
-
-                nChannelsEnabled += nActualChannels;
-                if (eMeasurementMode == ADMW_MEASUREMENT_MODE_HEALTHCHECK)
-                    /* Assume a single sample per channel in test mode */
-                    nSamplesPerCycle += nActualChannels;
-                else
-                    nSamplesPerCycle += nActualChannels *
-                        (channelCountReg.Channel_Count + 1);
-            }
+          /* Some sensors automatically generate samples on additional "virtual" channels
+           * so these channels must be counted as active when those sensors are selected
+           * and we use the count from the corresponding "physical" channel */
+          if ((sensorTypeReg.Sensor_Type >=
+             CORE_SENSOR_TYPE_SPI_ACCELEROMETER_A) &&
+            (sensorTypeReg.Sensor_Type <=
+             CORE_SENSOR_TYPE_SPI_ACCELEROMETER_B))
+            nActualChannels += 2;
         }
-
-        if (nChannelsEnabled == 0)
-        {
-            *pnSamplesPerDataready = 0;
-            *pnSamplesPerCycle = 0;
-            return ADMW_SUCCESS;
-        }
-
-        *pnSamplesPerCycle = nSamplesPerCycle;
-
-        if (modeReg.Drdy_Mode == CORE_MODE_DRDY_PER_CONVERSION)
-        {
-            *pnSamplesPerDataready = 1;
-        }
-        else if (modeReg.Drdy_Mode == CORE_MODE_DRDY_PER_CYCLE)
-        {
-            *pnSamplesPerDataready = nSamplesPerCycle;
-        }
-        else
-        {
-            /* Assume DRDY will be asserted after max. 1 cycle in test mode */
-            if (eMeasurementMode == ADMW_MEASUREMENT_MODE_HEALTHCHECK)
-            {
-                *pnSamplesPerDataready = nSamplesPerCycle;
-            }
-            else
-            {
-                CORE_Fifo_Num_Cycles_t fifoNumCyclesReg;
-                READ_REG_U8(hDevice, fifoNumCyclesReg.VALUE8, CORE_FIFO_NUM_CYCLES);
-
-                *pnSamplesPerDataready =
-                nSamplesPerCycle * fifoNumCyclesReg.Fifo_Num_Cycles;
-            }
-        }
-
-        if (modeReg.Drdy_Mode == CORE_MODE_DRDY_PER_CONVERSION)
-            *peDataReadyMode = ADMW1001_DATAREADY_PER_CONVERSION;
-        else if (modeReg.Drdy_Mode == CORE_MODE_DRDY_PER_CYCLE)
-            *peDataReadyMode = ADMW1001_DATAREADY_PER_CYCLE;
-        else
-        {
-            /* Assume DRDY will be asserted after max. 1 cycle in test mode */
-            if (eMeasurementMode == ADMW_MEASUREMENT_MODE_HEALTHCHECK)
-                *peDataReadyMode = ADMW1001_DATAREADY_PER_CYCLE;
-            else
-                *peDataReadyMode = ADMW1001_DATAREADY_PER_MULTICYCLE_BURST;
-        }
+  
+        nChannelsEnabled += nActualChannels;
+        
+        nSamplesPerCycle += nActualChannels *
+            (channelCountReg.Channel_Count + 1);
+    }
+    }
+  
+    if (nChannelsEnabled == 0)
+    {
+    *pnSamplesPerDataready = 0;
+    *pnSamplesPerCycle = 0;
+    return ADMW_SUCCESS;
+    }
+  
+    *pnSamplesPerCycle = nSamplesPerCycle;
+  
+    if (modeReg.Drdy_Mode == ENUM_CORE_MODE_DRDY_PER_CONVERSION)
+    {
+    *pnSamplesPerDataready = 1;
+    }
+    else if (modeReg.Drdy_Mode == ENUM_CORE_MODE_DRDY_PER_CYCLE)
+    {
+    *pnSamplesPerDataready = nSamplesPerCycle;
+    }
+    else
+    {
+         CORE_Fifo_Num_Cycles_t fifoNumCyclesReg;
+         READ_REG_U8(hDevice, fifoNumCyclesReg.VALUE8, CORE_FIFO_NUM_CYCLES);
+         
+         *pnSamplesPerDataready =
+         nSamplesPerCycle * fifoNumCyclesReg.Fifo_Num_Cycles;
+    }
+  
+    if (modeReg.Drdy_Mode == ENUM_CORE_MODE_DRDY_PER_CONVERSION)
+    *peDataReadyMode = ADMW1001_DATAREADY_PER_CONVERSION;
+    else if (modeReg.Drdy_Mode == ENUM_CORE_MODE_DRDY_PER_CYCLE)
+    *peDataReadyMode = ADMW1001_DATAREADY_PER_CYCLE;
+    else
+    {
+    *peDataReadyMode = ADMW1001_DATAREADY_PER_MULTICYCLE_BURST;
     }
 
     return ADMW_SUCCESS;
@@ -1200,17 +1046,13 @@
 {
     CORE_Power_Config_t powerConfigReg;
 
-    if (powerMode == ADMW1001_POWER_MODE_LOW)
-    {
-        powerConfigReg.Power_Mode_ADC = CORE_POWER_CONFIG_ADC_LOW_POWER;
-    }
-    else if (powerMode == ADMW1001_POWER_MODE_MID)
+    if (powerMode == ADMW1001_POWER_MODE_HIBERNATION)
     {
-        powerConfigReg.Power_Mode_ADC = CORE_POWER_CONFIG_ADC_MID_POWER;
+        powerConfigReg.Power_Mode_MCU = CORE_POWER_CONFIG_HIBERNATION;
     }
-    else if (powerMode == ADMW1001_POWER_MODE_FULL)
+    else if (powerMode == ADMW1001_POWER_MODE_ACTIVE)
     {
-        powerConfigReg.Power_Mode_ADC = CORE_POWER_CONFIG_ADC_FULL_POWER;
+        powerConfigReg.Power_Mode_MCU = CORE_POWER_CONFIG_ACTIVE_MODE;
     }
     else
     {
@@ -1243,7 +1085,6 @@
     ADMW_DEVICE_HANDLE hDevice,
     ADMW1001_OPERATING_MODE eOperatingMode,
     ADMW1001_DATAREADY_MODE eDataReadyMode,
-    ADMW1001_CALIBRATION_MODE eCalibrationMode,
     bool bEnableExtFlash)
 {
     CORE_Mode_t modeReg;
@@ -1297,25 +1138,6 @@
         return ADMW_INVALID_PARAM;
     }
 
-    if (eCalibrationMode == ADMW1001_NO_CALIBRATION)
-    {
-        modeReg.Calibration_Method = CORE_MODE_NO_CAL;
-    }
-    else if (eCalibrationMode == ADMW1001_DO_CALIBRATION)
-    {
-        modeReg.Calibration_Method = CORE_MODE_DO_CAL;
-    }
-    else
-    {
-        ADMW_LOG_ERROR("Invalid calibration mode %d specified",
-                            eCalibrationMode);
-        return ADMW_INVALID_PARAM;
-    }
-
-    modeReg.Ext_Flash_Store = (bEnableExtFlash ?
-                                CORE_MODE_EXT_FLASH_USED :
-                                CORE_MODE_EXT_FLASH_NOT_USED);
-
     WRITE_REG_U8(hDevice, modeReg.VALUE8, CORE_MODE);
 
     return ADMW_SUCCESS;
@@ -1323,13 +1145,13 @@
 
 ADMW_RESULT admw_SetCycleControl(
     ADMW_DEVICE_HANDLE hDevice,
-    uint32_t nCycleInterval,
+    uint32_t nCycleInterval
 
 #ifdef __V2_3_CFG_FMT__    
-    ADMW1001_CYCLE_TYPE eCycleType,
+    , ADMW1001_CYCLE_TYPE eCycleType,
     ADMW1001_FILTER_SETTLING eFilterSettling)
 #else
-    ADMW1001_CYCLE_TYPE eCycleType)
+    )
 #endif
 {
     CORE_Cycle_Control_t cycleControlReg;
@@ -1354,20 +1176,6 @@
     CHECK_REG_FIELD_VAL(CORE_CYCLE_CONTROL_CYCLE_TIME, nCycleInterval);
     cycleControlReg.Cycle_Time = nCycleInterval;
 
-    if (eCycleType == ADMW1001_CYCLE_TYPE_SWITCH)
-    {
-        cycleControlReg.Cycle_Type = CORE_CYCLE_CONTROL_CYCLE_TYPE_SWITCH;
-    }
-    else if (eCycleType == ADMW1001_CYCLE_TYPE_FULL)
-    {
-        cycleControlReg.Cycle_Type = CORE_CYCLE_CONTROL_CYCLE_TYPE_FULL;
-    }
-    else
-    {
-        ADMW_LOG_ERROR("Invalid cycle type %d specified", eCycleType);
-        return ADMW_INVALID_PARAM;
-    }
-
 #ifdef __V2_3_CFG_FMT__   
     if (eFilterSettling == ADMW1001_FILTER_SETTLING_ALWAYS)
     {
@@ -1407,11 +1215,9 @@
 
 static ADMW_RESULT admw_SetExternalReferenceValues(
     ADMW_DEVICE_HANDLE hDevice,
-    float32_t externalRef1Value,
-    float32_t externalRef2Value)
+    float32_t externalRef1Value)
 {
-    WRITE_REG_FLOAT(hDevice, externalRef1Value, CORE_EXTERNAL_REFERENCE1);
-    WRITE_REG_FLOAT(hDevice, externalRef2Value, CORE_EXTERNAL_REFERENCE2);
+    WRITE_REG_FLOAT(hDevice, externalRef1Value, CORE_EXTERNAL_REFERENCE_RESISTOR);
 
     return ADMW_SUCCESS;
 }
@@ -1425,7 +1231,6 @@
     eRet = admw_SetMode(hDevice,
                              pMeasConfig->operatingMode,
                              pMeasConfig->dataReadyMode,
-                             pMeasConfig->calibrationMode,
                              pMeasConfig->enableExternalFlash);
     if (eRet != ADMW_SUCCESS)
     {
@@ -1434,8 +1239,7 @@
     }
 
     eRet = admw_SetCycleControl(hDevice,
-                                     pMeasConfig->cycleInterval,
-                                     pMeasConfig->cycleType);
+                                     pMeasConfig->cycleInterval);
     if (eRet != ADMW_SUCCESS)
     {
         ADMW_LOG_ERROR("Failed to set cycle control");
@@ -1452,10 +1256,12 @@
             return eRet;
         }
     }
-
-    eRet = admw_SetExternalReferenceValues(hDevice,
-                                                pMeasConfig->externalRef1Value,
-                                                pMeasConfig->externalRef2Value);
+    if(pMeasConfig->externalRef1Value>0)
+          eRet = admw_SetExternalReferenceValues(hDevice,
+                                                pMeasConfig->externalRef1Value);
+    else
+        ;
+        
     if (eRet != ADMW_SUCCESS)
     {
         ADMW_LOG_ERROR("Failed to set external reference values");
@@ -1508,118 +1314,6 @@
     return ADMW_SUCCESS;
 }
 
-ADMW_RESULT admw1001_SetFftConfig(
-    ADMW_DEVICE_HANDLE hDevice,
-    ADMW1001_FFT_CONFIG *pFftConfig,
-    ADMW1001_CHANNEL_CONFIG *pChannels)
-{
-    CORE_FFT_Config_t fftConfigReg;
-    CORE_Mode_t modeReg;
-    uint32_t numFftChannels = 0;
-
-    fftConfigReg.VALUE32 = REG_RESET_VAL(CORE_FFT_CONFIG);
-
-    for (ADMW1001_CHANNEL_ID id = ADMW1001_CHANNEL_ID_CJC_0;
-         id < ADMW1001_MAX_CHANNELS;
-         id++)
-    {
-        if (pChannels[id].enableFFT)
-        {
-            if (numFftChannels >= 4) /* TODO - temporary limit */
-            {
-                ADMW_LOG_ERROR("Maximum limit of 4 FFT channels exceeded");
-                return ADMW_INVALID_PARAM;
-            }
-
-            numFftChannels++;
-        }
-    }
-
-    if (numFftChannels > 0)
-    {
-        fftConfigReg.FFT_Num_Channels = numFftChannels - 1;
-
-        switch (pFftConfig->size)
-        {
-        case ADMW1001_FFT_SIZE_256:
-            fftConfigReg.FFT_Num_Bins = CORE_FFT_CONFIG_FFT_BINS_256;
-            break;
-        case ADMW1001_FFT_SIZE_512:
-            fftConfigReg.FFT_Num_Bins = CORE_FFT_CONFIG_FFT_BINS_512;
-            break;
-        case ADMW1001_FFT_SIZE_1024:
-            fftConfigReg.FFT_Num_Bins = CORE_FFT_CONFIG_FFT_BINS_1024;
-            break;
-        case ADMW1001_FFT_SIZE_2048:
-            fftConfigReg.FFT_Num_Bins = CORE_FFT_CONFIG_FFT_BINS_2048;
-            break;
-        default:
-            ADMW_LOG_ERROR("Invalid FFT size option %d specified",
-                                pFftConfig->size);
-            return ADMW_INVALID_PARAM;
-        }
-
-        switch (pFftConfig->window)
-        {
-        case ADMW1001_FFT_WINDOW_NONE:
-            fftConfigReg.FFT_Window = CORE_FFT_CONFIG_FFT_WINDOW_NONE;
-            break;
-        case ADMW1001_FFT_WINDOW_HANN:
-            fftConfigReg.FFT_Window = CORE_FFT_CONFIG_FFT_WINDOW_HANN;
-            break;
-        case ADMW1001_FFT_WINDOW_BLACKMAN_HARRIS:
-            fftConfigReg.FFT_Window = CORE_FFT_CONFIG_FFT_WINDOW_BLACKMANN_HARRIS;
-            break;
-        default:
-            ADMW_LOG_ERROR("Invalid FFT window option %d specified",
-                                pFftConfig->window);
-            return ADMW_INVALID_PARAM;
-        }
-
-        switch (pFftConfig->output)
-        {
-        case ADMW1001_FFT_OUTPUT_FULL:
-            fftConfigReg.FFT_Output = CORE_FFT_CONFIG_FFT_OUTPUT_FULL;
-            break;
-        case ADMW1001_FFT_OUTPUT_MAX16:
-            fftConfigReg.FFT_Output = CORE_FFT_CONFIG_FFT_OUTPUT_MAX16;
-            break;
-        case ADMW1001_FFT_OUTPUT_FULL_WITH_RAW:
-            fftConfigReg.FFT_Output = CORE_FFT_CONFIG_FFT_OUTPUT_FULL_WITH_RAW;
-            break;
-        default:
-            ADMW_LOG_ERROR("Invalid FFT output format option %d specified",
-                                pFftConfig->output);
-            return ADMW_INVALID_PARAM;
-        }
-    }
-    WRITE_REG_U32(hDevice, fftConfigReg.VALUE32, CORE_FFT_CONFIG);
-
-    if (numFftChannels > 0)
-    {
-        READ_REG_U8(hDevice, modeReg.VALUE8, CORE_MODE);
-
-        if (pFftConfig->mode == ADMW1001_FFT_MODE_SINGLE)
-        {
-            modeReg.FFT_Mode = CORE_MODE_FFT_MODE_SINGLE;
-        }
-        else if (pFftConfig->mode == ADMW1001_FFT_MODE_CONTINUOUS)
-        {
-            modeReg.FFT_Mode = CORE_MODE_FFT_MODE_CONTINUOUS;
-        }
-        else
-        {
-            ADMW_LOG_ERROR("Invalid FFT mode %d specified",
-                                pFftConfig->mode);
-            return ADMW_INVALID_PARAM;
-        }
-
-        WRITE_REG_U8(hDevice, modeReg.VALUE8, CORE_MODE);
-    }
-
-    return ADMW_SUCCESS;
-}
-
 ADMW_RESULT admw1001_SetChannelCount(
     ADMW_DEVICE_HANDLE hDevice,
     ADMW1001_CHANNEL_ID eChannelId,
@@ -1652,8 +1346,7 @@
 ADMW_RESULT admw1001_SetChannelOptions(
     ADMW_DEVICE_HANDLE hDevice,
     ADMW1001_CHANNEL_ID eChannelId,
-    ADMW1001_CHANNEL_PRIORITY ePriority,
-    bool bEnableFft)
+    ADMW1001_CHANNEL_PRIORITY ePriority)
 {
     CORE_Channel_Options_t channelOptionsReg;
 
@@ -1661,7 +1354,6 @@
 
     CHECK_REG_FIELD_VAL(CORE_CHANNEL_OPTIONS_CHANNEL_PRIORITY, ePriority);
     channelOptionsReg.Channel_Priority = ePriority;
-    channelOptionsReg.FFT_Enable_Ch = bEnableFft ? 1 : 0;
 
     WRITE_REG_U8(hDevice, channelOptionsReg.VALUE8, CORE_CHANNEL_OPTIONSn(eChannelId));
 
@@ -1698,153 +1390,145 @@
     /* Ensure that the sensor type is valid for this channel */
     switch(sensorType)
     {
-    case ADMW1001_ADC_SENSOR_THERMOCOUPLE_J_DEF_L1:
-    case ADMW1001_ADC_SENSOR_THERMOCOUPLE_K_DEF_L1:
-    case ADMW1001_ADC_SENSOR_THERMOCOUPLE_T_DEF_L1:
-    case ADMW1001_ADC_SENSOR_THERMOCOUPLE_1_DEF_L2:
-    case ADMW1001_ADC_SENSOR_THERMOCOUPLE_2_DEF_L2:
-    case ADMW1001_ADC_SENSOR_THERMOCOUPLE_3_DEF_L2:
-    case ADMW1001_ADC_SENSOR_THERMOCOUPLE_4_DEF_L2:
-    case ADMW1001_ADC_SENSOR_THERMOCOUPLE_J_ADV_L1:
-    case ADMW1001_ADC_SENSOR_THERMOCOUPLE_K_ADV_L1:
-    case ADMW1001_ADC_SENSOR_THERMOCOUPLE_T_ADV_L1:
-    case ADMW1001_ADC_SENSOR_THERMOCOUPLE_1_ADV_L2:
-    case ADMW1001_ADC_SENSOR_THERMOCOUPLE_2_ADV_L2:
-    case ADMW1001_ADC_SENSOR_THERMOCOUPLE_3_ADV_L2:
-    case ADMW1001_ADC_SENSOR_THERMOCOUPLE_4_ADV_L2:
-    case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE_1_DEF_L2:
-    case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE_2_DEF_L2:
-    case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE_3_DEF_L2:
-    case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE_4_DEF_L2:
-    case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE_1_ADV_L2:
-    case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE_2_ADV_L2:
-    case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE_3_ADV_L2:
-    case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE_4_ADV_L2:
-    case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE_1_DEF_L2:
-    case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE_2_DEF_L2:
-    case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE_3_DEF_L2:
-    case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE_4_DEF_L2:
-    case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE_1_ADV_L2:
-    case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE_2_ADV_L2:
-    case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE_3_ADV_L2:
-    case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE_4_ADV_L2:
-        if (! ADMW1001_CHANNEL_IS_ADC_SENSOR(eChannelId))
-        {
-            ADMW_LOG_ERROR(
-                "Invalid ADC sensor type %d specified for channel %d",
-                sensorType, eChannelId);
+        case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT100_DEF_L1:
+        case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT1000_DEF_L1:
+        case ADMW1001_ADC_SENSOR_RTD_3WIRE_1_DEF_L2:
+        case ADMW1001_ADC_SENSOR_RTD_3WIRE_2_DEF_L2:
+        case ADMW1001_ADC_SENSOR_RTD_3WIRE_3_DEF_L2:
+        case ADMW1001_ADC_SENSOR_RTD_3WIRE_4_DEF_L2:
+        case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT100_ADV_L1:
+        case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT1000_ADV_L1:
+        case ADMW1001_ADC_SENSOR_RTD_3WIRE_1_ADV_L2:
+        case ADMW1001_ADC_SENSOR_RTD_3WIRE_2_ADV_L2:
+        case ADMW1001_ADC_SENSOR_RTD_3WIRE_3_ADV_L2:
+        case ADMW1001_ADC_SENSOR_RTD_3WIRE_4_ADV_L2:
+        case ADMW1001_ADC_SENSOR_RTD_4WIRE_PT100_DEF_L1:
+        case ADMW1001_ADC_SENSOR_RTD_4WIRE_PT1000_DEF_L1:
+        case ADMW1001_ADC_SENSOR_RTD_4WIRE_1_DEF_L2:
+        case ADMW1001_ADC_SENSOR_RTD_4WIRE_2_DEF_L2:
+        case ADMW1001_ADC_SENSOR_RTD_4WIRE_3_DEF_L2:
+        case ADMW1001_ADC_SENSOR_RTD_4WIRE_4_DEF_L2:
+        case ADMW1001_ADC_SENSOR_RTD_4WIRE_PT100_ADV_L1:
+        case ADMW1001_ADC_SENSOR_RTD_4WIRE_PT1000_ADV_L1:
+        case ADMW1001_ADC_SENSOR_RTD_4WIRE_1_ADV_L2:
+        case ADMW1001_ADC_SENSOR_RTD_4WIRE_2_ADV_L2:
+        case ADMW1001_ADC_SENSOR_RTD_4WIRE_3_ADV_L2:
+        case ADMW1001_ADC_SENSOR_RTD_4WIRE_4_ADV_L2:
+        case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE_1_DEF_L2:
+        case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE_2_DEF_L2:
+        case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE_3_DEF_L2:
+        case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE_4_DEF_L2:
+        case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE_1_ADV_L2:
+        case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE_2_ADV_L2:
+        case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE_3_ADV_L2:
+        case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE_4_ADV_L2:
+        case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE_1_DEF_L2:
+        case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE_2_DEF_L2:
+        case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE_3_DEF_L2:
+        case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE_4_DEF_L2:
+        case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE_1_ADV_L2:
+        case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE_2_ADV_L2:
+        case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE_3_ADV_L2:
+        case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE_4_ADV_L2:
+        case ADMW1001_ADC_SENSOR_MICROPHONE_A_DEF_L1:
+        case ADMW1001_ADC_SENSOR_MICROPHONE_B_DEF_L1:
+        case ADMW1001_ADC_SENSOR_MICROPHONE_1_DEF_L2:
+        case ADMW1001_ADC_SENSOR_MICROPHONE_2_DEF_L2:
+        case ADMW1001_ADC_SENSOR_MICROPHONE_A_ADV_L1:
+        case ADMW1001_ADC_SENSOR_MICROPHONE_B_ADV_L1:
+        case ADMW1001_ADC_SENSOR_MICROPHONE_1_ADV_L2:
+        case ADMW1001_ADC_SENSOR_MICROPHONE_2_ADV_L2:
+        case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT100_DEF_L1:
+        case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT1000_DEF_L1:
+        case ADMW1001_ADC_SENSOR_RTD_2WIRE_1_DEF_L2:
+        case ADMW1001_ADC_SENSOR_RTD_2WIRE_2_DEF_L2:
+        case ADMW1001_ADC_SENSOR_RTD_2WIRE_3_DEF_L2:
+        case ADMW1001_ADC_SENSOR_RTD_2WIRE_4_DEF_L2:
+        case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT100_ADV_L1:
+        case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT1000_ADV_L1:
+        case ADMW1001_ADC_SENSOR_RTD_2WIRE_1_ADV_L2:
+        case ADMW1001_ADC_SENSOR_RTD_2WIRE_2_ADV_L2:
+        case ADMW1001_ADC_SENSOR_RTD_2WIRE_3_ADV_L2:
+        case ADMW1001_ADC_SENSOR_RTD_2WIRE_4_ADV_L2:
+        case ADMW1001_ADC_SENSOR_DIODE_2C_TYPEA_DEF_L1:
+        case ADMW1001_ADC_SENSOR_DIODE_3C_TYPEA_DEF_L1:
+        case ADMW1001_ADC_SENSOR_DIODE_2C_1_DEF_L2:
+        case ADMW1001_ADC_SENSOR_DIODE_3C_1_DEF_L2:
+        case ADMW1001_ADC_SENSOR_DIODE_2C_TYPEA_ADV_L1:
+        case ADMW1001_ADC_SENSOR_DIODE_3C_TYPEA_ADV_L1:
+        case ADMW1001_ADC_SENSOR_DIODE_2C_1_ADV_L2:
+        case ADMW1001_ADC_SENSOR_DIODE_3C_1_ADV_L2:
+        case ADMW1001_ADC_SENSOR_THERMISTOR_A_10K_DEF_L1:
+        case ADMW1001_ADC_SENSOR_THERMISTOR_B_10K_DEF_L1:
+        case ADMW1001_ADC_SENSOR_THERMISTOR_1_DEF_L2:
+        case ADMW1001_ADC_SENSOR_THERMISTOR_2_DEF_L2:
+        case ADMW1001_ADC_SENSOR_THERMISTOR_3_DEF_L2:
+        case ADMW1001_ADC_SENSOR_THERMISTOR_4_DEF_L2:
+        case ADMW1001_ADC_SENSOR_THERMISTOR_A_10K_ADV_L1:
+        case ADMW1001_ADC_SENSOR_THERMISTOR_B_10K_ADV_L1:
+        case ADMW1001_ADC_SENSOR_THERMISTOR_1_ADV_L2:
+        case ADMW1001_ADC_SENSOR_THERMISTOR_2_ADV_L2:
+        case ADMW1001_ADC_SENSOR_THERMISTOR_3_ADV_L2:
+        case ADMW1001_ADC_SENSOR_THERMISTOR_4_ADV_L2:
+            if (! (ADMW1001_CHANNEL_IS_ADC_SENSOR(eChannelId) ||
+                   ADMW1001_CHANNEL_IS_ADC_CJC(eChannelId)))
+            {
+                ADMW_LOG_ERROR(
+                    "Invalid ADC sensor type %d specified for channel %d",
+                    sensorType, eChannelId);
+                return ADMW_INVALID_PARAM;
+            }
+            break;
+        case ADMW1001_ADC_SENSOR_VOLTAGE:
+        case ADMW1001_ADC_SENSOR_VOLTAGE_PRESSURE_A_DEF_L1:
+        case ADMW1001_ADC_SENSOR_VOLTAGE_PRESSURE_B_DEF_L1:
+        case ADMW1001_ADC_SENSOR_VOLTAGE_PRESSURE_1_DEF_L2:
+        case ADMW1001_ADC_SENSOR_VOLTAGE_PRESSURE_2_DEF_L2:
+        case ADMW1001_ADC_SENSOR_VOLTAGE_PRESSURE_A_ADV_L1:
+        case ADMW1001_ADC_SENSOR_VOLTAGE_PRESSURE_B_ADV_L1:
+        case ADMW1001_ADC_SENSOR_VOLTAGE_PRESSURE_1_ADV_L2:
+        case ADMW1001_ADC_SENSOR_VOLTAGE_PRESSURE_2_ADV_L2:
+        case ADMW1001_ADC_SENSOR_THERMOCOUPLE_J_DEF_L1:
+        case ADMW1001_ADC_SENSOR_THERMOCOUPLE_K_DEF_L1:
+        case ADMW1001_ADC_SENSOR_THERMOCOUPLE_T_DEF_L1:
+        case ADMW1001_ADC_SENSOR_THERMOCOUPLE_1_DEF_L2:
+        case ADMW1001_ADC_SENSOR_THERMOCOUPLE_2_DEF_L2:
+        case ADMW1001_ADC_SENSOR_THERMOCOUPLE_3_DEF_L2:
+        case ADMW1001_ADC_SENSOR_THERMOCOUPLE_4_DEF_L2:
+        case ADMW1001_ADC_SENSOR_THERMOCOUPLE_J_ADV_L1:
+        case ADMW1001_ADC_SENSOR_THERMOCOUPLE_K_ADV_L1:
+        case ADMW1001_ADC_SENSOR_THERMOCOUPLE_T_ADV_L1:
+        case ADMW1001_ADC_SENSOR_THERMOCOUPLE_1_ADV_L2:
+        case ADMW1001_ADC_SENSOR_THERMOCOUPLE_2_ADV_L2:
+        case ADMW1001_ADC_SENSOR_THERMOCOUPLE_3_ADV_L2:
+        case ADMW1001_ADC_SENSOR_THERMOCOUPLE_4_ADV_L2:
+            if (! ADMW1001_CHANNEL_IS_ADC_VOLTAGE(eChannelId))
+            {
+                ADMW_LOG_ERROR(
+                    "Invalid ADC sensor type %d specified for channel %d",
+                    sensorType, eChannelId);
+                return ADMW_INVALID_PARAM;
+            }
+            break;
+        case ADMW1001_ADC_SENSOR_CURRENT:
+        case ADMW1001_ADC_SENSOR_CURRENT_PRESSURE_A_DEF_L1:
+        case ADMW1001_ADC_SENSOR_CURRENT_PRESSURE_1_DEF_L2:
+        case ADMW1001_ADC_SENSOR_CURRENT_PRESSURE_2_DEF_L2:
+        case ADMW1001_ADC_SENSOR_CURRENT_PRESSURE_A_ADV_L1:
+        case ADMW1001_ADC_SENSOR_CURRENT_PRESSURE_1_ADV_L2:
+        case ADMW1001_ADC_SENSOR_CURRENT_PRESSURE_2_ADV_L2:
+            if (! ADMW1001_CHANNEL_IS_ADC_CURRENT(eChannelId))
+            {
+                ADMW_LOG_ERROR(
+                    "Invalid ADC sensor type %d specified for channel %d",
+                    sensorType, eChannelId);
+                return ADMW_INVALID_PARAM;
+            }
+            break;
+        default:
+            ADMW_LOG_ERROR("Invalid/unsupported ADC sensor type %d specified",
+                                sensorType);
             return ADMW_INVALID_PARAM;
-        }
-        break;
-    case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT100_DEF_L1:
-    case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT1000_DEF_L1:
-    case ADMW1001_ADC_SENSOR_RTD_2WIRE_1_DEF_L2:
-    case ADMW1001_ADC_SENSOR_RTD_2WIRE_2_DEF_L2:
-    case ADMW1001_ADC_SENSOR_RTD_2WIRE_3_DEF_L2:
-    case ADMW1001_ADC_SENSOR_RTD_2WIRE_4_DEF_L2:
-    case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT100_ADV_L1:
-    case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT1000_ADV_L1:
-    case ADMW1001_ADC_SENSOR_RTD_2WIRE_1_ADV_L2:
-    case ADMW1001_ADC_SENSOR_RTD_2WIRE_2_ADV_L2:
-    case ADMW1001_ADC_SENSOR_RTD_2WIRE_3_ADV_L2:
-    case ADMW1001_ADC_SENSOR_RTD_2WIRE_4_ADV_L2:
-    case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT100_DEF_L1:
-    case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT1000_DEF_L1:
-    case ADMW1001_ADC_SENSOR_RTD_3WIRE_1_DEF_L2:
-    case ADMW1001_ADC_SENSOR_RTD_3WIRE_2_DEF_L2:
-    case ADMW1001_ADC_SENSOR_RTD_3WIRE_3_DEF_L2:
-    case ADMW1001_ADC_SENSOR_RTD_3WIRE_4_DEF_L2:
-    case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT100_ADV_L1:
-    case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT1000_ADV_L1:
-    case ADMW1001_ADC_SENSOR_RTD_3WIRE_1_ADV_L2:
-    case ADMW1001_ADC_SENSOR_RTD_3WIRE_2_ADV_L2:
-    case ADMW1001_ADC_SENSOR_RTD_3WIRE_3_ADV_L2:
-    case ADMW1001_ADC_SENSOR_RTD_3WIRE_4_ADV_L2:
-    case ADMW1001_ADC_SENSOR_RTD_4WIRE_PT100_DEF_L1:
-    case ADMW1001_ADC_SENSOR_RTD_4WIRE_PT1000_DEF_L1:
-    case ADMW1001_ADC_SENSOR_RTD_4WIRE_1_DEF_L2:
-    case ADMW1001_ADC_SENSOR_RTD_4WIRE_2_DEF_L2:
-    case ADMW1001_ADC_SENSOR_RTD_4WIRE_3_DEF_L2:
-    case ADMW1001_ADC_SENSOR_RTD_4WIRE_4_DEF_L2:
-    case ADMW1001_ADC_SENSOR_RTD_4WIRE_PT100_ADV_L1:
-    case ADMW1001_ADC_SENSOR_RTD_4WIRE_PT1000_ADV_L1:
-    case ADMW1001_ADC_SENSOR_RTD_4WIRE_1_ADV_L2:
-    case ADMW1001_ADC_SENSOR_RTD_4WIRE_2_ADV_L2:
-    case ADMW1001_ADC_SENSOR_RTD_4WIRE_3_ADV_L2:
-    case ADMW1001_ADC_SENSOR_RTD_4WIRE_4_ADV_L2:
-            if (!ADMW1001_CHANNEL_IS_ADC_CJC(eChannelId))
-        {
-            ADMW_LOG_ERROR(
-                "Invalid ADC sensor type %d specified for channel %d",
-                sensorType, eChannelId);
-            return ADMW_INVALID_PARAM;
-        }
-        break;
-    case ADMW1001_ADC_SENSOR_DIODE_2C_TYPEA_DEF_L1:
-    case ADMW1001_ADC_SENSOR_DIODE_3C_TYPEA_DEF_L1:
-    case ADMW1001_ADC_SENSOR_DIODE_2C_1_DEF_L2:
-    case ADMW1001_ADC_SENSOR_DIODE_3C_1_DEF_L2:
-    case ADMW1001_ADC_SENSOR_DIODE_2C_TYPEA_ADV_L1:
-    case ADMW1001_ADC_SENSOR_DIODE_3C_TYPEA_ADV_L1:
-    case ADMW1001_ADC_SENSOR_DIODE_2C_1_ADV_L2:
-    case ADMW1001_ADC_SENSOR_DIODE_3C_1_ADV_L2:
-    case ADMW1001_ADC_SENSOR_THERMISTOR_A_10K_DEF_L1:
-    case ADMW1001_ADC_SENSOR_THERMISTOR_B_10K_DEF_L1:
-    case ADMW1001_ADC_SENSOR_THERMISTOR_1_DEF_L2:
-    case ADMW1001_ADC_SENSOR_THERMISTOR_2_DEF_L2:
-    case ADMW1001_ADC_SENSOR_THERMISTOR_3_DEF_L2:
-    case ADMW1001_ADC_SENSOR_THERMISTOR_4_DEF_L2:
-    case ADMW1001_ADC_SENSOR_THERMISTOR_A_10K_ADV_L1:
-    case ADMW1001_ADC_SENSOR_THERMISTOR_B_10K_ADV_L1:
-    case ADMW1001_ADC_SENSOR_THERMISTOR_1_ADV_L2:
-    case ADMW1001_ADC_SENSOR_THERMISTOR_2_ADV_L2:
-    case ADMW1001_ADC_SENSOR_THERMISTOR_3_ADV_L2:
-    case ADMW1001_ADC_SENSOR_THERMISTOR_4_ADV_L2:
-        if (! (ADMW1001_CHANNEL_IS_ADC_SENSOR(eChannelId) ||
-               ADMW1001_CHANNEL_IS_ADC_CJC(eChannelId)))
-        {
-            ADMW_LOG_ERROR(
-                "Invalid ADC sensor type %d specified for channel %d",
-                sensorType, eChannelId);
-            return ADMW_INVALID_PARAM;
-        }
-        break;
-    case ADMW1001_ADC_SENSOR_VOLTAGE:
-    case ADMW1001_ADC_SENSOR_VOLTAGE_PRESSURE_A_DEF_L1:
-    case ADMW1001_ADC_SENSOR_VOLTAGE_PRESSURE_B_DEF_L1:
-    case ADMW1001_ADC_SENSOR_VOLTAGE_PRESSURE_1_DEF_L2:
-    case ADMW1001_ADC_SENSOR_VOLTAGE_PRESSURE_2_DEF_L2:
-    case ADMW1001_ADC_SENSOR_VOLTAGE_PRESSURE_A_ADV_L1:
-    case ADMW1001_ADC_SENSOR_VOLTAGE_PRESSURE_B_ADV_L1:
-    case ADMW1001_ADC_SENSOR_VOLTAGE_PRESSURE_1_ADV_L2:
-    case ADMW1001_ADC_SENSOR_VOLTAGE_PRESSURE_2_ADV_L2:
-        if (! ADMW1001_CHANNEL_IS_ADC_VOLTAGE(eChannelId))
-        {
-            ADMW_LOG_ERROR(
-                "Invalid ADC sensor type %d specified for channel %d",
-                sensorType, eChannelId);
-            return ADMW_INVALID_PARAM;
-        }
-        break;
-    case ADMW1001_ADC_SENSOR_CURRENT:
-    case ADMW1001_ADC_SENSOR_CURRENT_PRESSURE_A_DEF_L1:
-    case ADMW1001_ADC_SENSOR_CURRENT_PRESSURE_1_DEF_L2:
-    case ADMW1001_ADC_SENSOR_CURRENT_PRESSURE_2_DEF_L2:
-    case ADMW1001_ADC_SENSOR_CURRENT_PRESSURE_A_ADV_L1:
-    case ADMW1001_ADC_SENSOR_CURRENT_PRESSURE_1_ADV_L2:
-    case ADMW1001_ADC_SENSOR_CURRENT_PRESSURE_2_ADV_L2:
-        if (! ADMW1001_CHANNEL_IS_ADC_CURRENT(eChannelId))
-        {
-            ADMW_LOG_ERROR(
-                "Invalid ADC sensor type %d specified for channel %d",
-                sensorType, eChannelId);
-            return ADMW_INVALID_PARAM;
-        }
-        break;
-    default:
-        ADMW_LOG_ERROR("Invalid/unsupported ADC sensor type %d specified",
-                            sensorType);
-        return ADMW_INVALID_PARAM;
     }
 
     sensorTypeReg.Sensor_Type = sensorType;
@@ -1908,10 +1592,7 @@
     switch(pRefConfig->type)
     {
     case ADMW1001_ADC_REFERENCE_RESISTOR_INTERNAL_1:
-        sensorDetailsReg.Reference_Select = CORE_SENSOR_DETAILS_REF_RINT1;
-        break;
-    case ADMW1001_ADC_REFERENCE_RESISTOR_INTERNAL_2:
-        sensorDetailsReg.Reference_Select = CORE_SENSOR_DETAILS_REF_RINT2;
+        sensorDetailsReg.Reference_Select = CORE_SENSOR_DETAILS_REF_INT;
         break;
     case ADMW1001_ADC_REFERENCE_VOLTAGE_INTERNAL:
         sensorDetailsReg.Reference_Select = CORE_SENSOR_DETAILS_REF_INT;
@@ -1922,15 +1603,6 @@
     case ADMW1001_ADC_REFERENCE_RESISTOR_EXTERNAL_1:
         sensorDetailsReg.Reference_Select = CORE_SENSOR_DETAILS_REF_REXT1;
         break;
-    case ADMW1001_ADC_REFERENCE_RESISTOR_EXTERNAL_2:
-        sensorDetailsReg.Reference_Select = CORE_SENSOR_DETAILS_REF_REXT2;
-        break;
-    case ADMW1001_ADC_REFERENCE_VOLTAGE_EXTERNAL_1:
-        sensorDetailsReg.Reference_Select = CORE_SENSOR_DETAILS_REF_VEXT1;
-        break;
-    case ADMW1001_ADC_REFERENCE_VOLTAGE_EXTERNAL_2:
-        sensorDetailsReg.Reference_Select = CORE_SENSOR_DETAILS_REF_VEXT2;
-        break;
     case ADMW1001_ADC_REFERENCE_BRIDGE_EXCITATION:
         sensorDetailsReg.Reference_Select = CORE_SENSOR_DETAILS_REF_EXC;
         break;
@@ -1939,7 +1611,7 @@
                             pRefConfig->type);
         return ADMW_INVALID_PARAM;
     }
-
+    
     switch(pAdcChannelConfig->gain)
     {
     case ADMW1001_ADC_GAIN_1X:
@@ -1972,16 +1644,31 @@
         return ADMW_INVALID_PARAM;
     }
 
+    switch(pAdcChannelConfig->rtdCurve)
+    {
+    case ADMW1001_ADC_RTD_CURVE_EUROPEAN:
+        sensorDetailsReg.RTD_Curve = CORE_SENSOR_DETAILS_EUROPEAN_CURVE;
+        break;
+    case ADMW1001_ADC_RTD_CURVE_AMERICAN:
+        sensorDetailsReg.RTD_Curve = CORE_SENSOR_DETAILS_AMERICAN_CURVE;
+        break;
+    case ADMW1001_ADC_RTD_CURVE_JAPANESE:
+        sensorDetailsReg.RTD_Curve = CORE_SENSOR_DETAILS_JAPANESE_CURVE;
+        break;
+    case ADMW1001_ADC_RTD_CURVE_ITS90:
+        sensorDetailsReg.RTD_Curve = CORE_SENSOR_DETAILS_ITS90_CURVE;
+        break;
+    default:
+        ADMW_LOG_ERROR("Invalid RTD Curve %d specified",
+                            pAdcChannelConfig->rtdCurve);
+        return ADMW_INVALID_PARAM;
+    }
+
     if (pAdcChannelConfig->enableVbias)
         sensorDetailsReg.Vbias = 1;
     else
         sensorDetailsReg.Vbias = 0;
 
-    if (pAdcChannelConfig->reference.disableBuffer)
-        sensorDetailsReg.Reference_Buffer_Disable = 1;
-    else
-        sensorDetailsReg.Reference_Buffer_Disable = 0;
-
     if (pChannelConfig->disablePublishing)
         sensorDetailsReg.Do_Not_Publish = 1;
     else
@@ -2002,22 +1689,18 @@
     ADMW1001_CHANNEL_ID eChannelId,
     ADMW1001_ADC_FILTER_CONFIG *pFilterConfig)
 {
-    CORE_Filter_Select_t filterSelectReg;
-
-    filterSelectReg.VALUE32 = REG_RESET_VAL(CORE_FILTER_SELECTn);
+    CORE_Measurement_Setup_t MeasSetupReg;
+    MeasSetupReg.VALUE32 = REG_RESET_VAL(CORE_MEASUREMENT_SETUPn);
 
     if (pFilterConfig->type == ADMW1001_ADC_FILTER_SINC4)
     {
-        filterSelectReg.ADC_Filter_Type = CORE_FILTER_SELECT_FILTER_SINC4;
-        filterSelectReg.ADC_FS = pFilterConfig->fs;
+        MeasSetupReg.ADC_Filter_Type = CORE_MEASUREMENT_SETUP_ENABLE_SINC4;
+        MeasSetupReg.ADC_SF = pFilterConfig->sf;
     }
-    else if (pFilterConfig->type == ADMW1001_ADC_FILTER_FIR_20SPS)
+    else if (pFilterConfig->type == ADMW1001_ADC_FILTER_SINC3)
     {
-        filterSelectReg.ADC_Filter_Type = CORE_FILTER_SELECT_FILTER_FIR_20SPS;
-    }
-    else if (pFilterConfig->type == ADMW1001_ADC_FILTER_FIR_25SPS)
-    {
-        filterSelectReg.ADC_Filter_Type = CORE_FILTER_SELECT_FILTER_FIR_25SPS;
+        MeasSetupReg.ADC_Filter_Type = CORE_MEASUREMENT_SETUP_ENABLE_SINC3;
+      MeasSetupReg.ADC_SF = pFilterConfig->sf;
     }
     else
     {
@@ -2025,8 +1708,32 @@
                             pFilterConfig->type);
         return ADMW_INVALID_PARAM;
     }
-
-    WRITE_REG_U32(hDevice, filterSelectReg.VALUE32, CORE_FILTER_SELECTn(eChannelId));
+    
+    if(pFilterConfig->filterChop) 
+          MeasSetupReg.Chop_Mode = 1;
+    else
+        MeasSetupReg.Chop_Mode = 1;
+    
+    if(pFilterConfig->notch1p2)
+        MeasSetupReg.NOTCH_EN_2 = 1;
+    else
+        MeasSetupReg.NOTCH_EN_2 = 0;
+    
+    switch(pFilterConfig->groundSwitch)
+    {
+    case ADMW1001_ADC_GND_SW_OPEN:
+        MeasSetupReg.GND_SW = CORE_MEASUREMENT_SETUP_GND_SW_OPEN;
+        break;
+    case ADMW1001_ADC_GND_SW_CLOSED:
+        MeasSetupReg.GND_SW = CORE_MEASUREMENT_SETUP_GND_SW_CLOSED;
+        break;
+    default:
+        ADMW_LOG_ERROR("Invalid ground switch state %d specified",
+                            pFilterConfig->groundSwitch);
+        return ADMW_INVALID_PARAM;
+    }
+   
+    WRITE_REG_U32(hDevice, MeasSetupReg.VALUE32, CORE_MEASUREMENT_SETUPn(eChannelId));
 
     return ADMW_SUCCESS;
 }
@@ -2038,44 +1745,61 @@
 {
     CORE_Channel_Excitation_t channelExcitationReg;
 
-    channelExcitationReg.VALUE8 = REG_RESET_VAL(CORE_CHANNEL_EXCITATIONn);
-
-    if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_NONE)
-    {
-        channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_IEXC_OFF;
-    }
+    channelExcitationReg.VALUE16 = REG_RESET_VAL(CORE_CHANNEL_EXCITATIONn);
+
+
+    if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_EXTERNAL)
+        channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_EXTERNAL;
+    if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_50uA)
+        channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_IEXC_50UA;
+    else if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_100uA)
+        channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_IEXC_100UA;
+    else if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_250uA)
+        channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_IEXC_250UA;
+    else if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_500uA)
+        channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_IEXC_500UA;
+    else if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_1000uA)
+        channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_IEXC_1000UA;
     else
     {
-        if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_50uA)
-            channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_IEXC_50UA;
-        else if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_100uA)
-            channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_IEXC_100UA;
-        else if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_250uA)
-            channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_IEXC_250UA;
-        else if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_500uA)
-            channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_IEXC_500UA;
-        else if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_750uA)
-            channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_IEXC_750UA;
-        else if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_1000uA)
-            channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_IEXC_1000UA;
-        else
-        {
-            ADMW_LOG_ERROR("Invalid ADC excitation current %d specified",
-                                pCurrentConfig->outputLevel);
-            return ADMW_INVALID_PARAM;
-        }
+        ADMW_LOG_ERROR("Invalid ADC excitation current %d specified",
+                       pCurrentConfig->outputLevel);
+        return ADMW_INVALID_PARAM;
     }
 
-    if (pCurrentConfig->diodeRatio == ADMW1001_ADC_EXC_CURRENT_IOUT_DIODE_DEFAULT)
-    {
-        channelExcitationReg.IOUT_Diode_Ratio = 0;
+    
+    switch(pCurrentConfig->diodeRatio) {
+    case ADMW1001_ADC_EXC_CURRENT_IOUT_DIODE_10UA_100UA:
+        channelExcitationReg.IOUT_Diode_Ratio = CORE_CHANNEL_EXCITATION_DIODE_2PT_10UA_100UA;
+        break;
+    case ADMW1001_ADC_EXC_CURRENT_IOUT_DIODE_20UA_160UA:
+        channelExcitationReg.IOUT_Diode_Ratio = CORE_CHANNEL_EXCITATION_DIODE_2PT_20UA_160UA;
+        break;
+    case ADMW1001_ADC_EXC_CURRENT_IOUT_DIODE_50UA_300UA:
+        channelExcitationReg.IOUT_Diode_Ratio = CORE_CHANNEL_EXCITATION_DIODE_2PT_50UA_300UA;
+        break;
+    case ADMW1001_ADC_EXC_CURRENT_IOUT_DIODE_100UA_600UA:
+        channelExcitationReg.IOUT_Diode_Ratio = CORE_CHANNEL_EXCITATION_DIODE_2PT_100UA_600UA;
+        break;
+    case ADMW1001_ADC_EXC_CURRENT_IOUT_DIODE_10UA_50UA_100UA:
+        channelExcitationReg.IOUT_Diode_Ratio = CORE_CHANNEL_EXCITATION_DIODE_3PT_10UA_50UA_100UA;
+        break;
+    case ADMW1001_ADC_EXC_CURRENT_IOUT_DIODE_20UA_100UA_160UA:
+        channelExcitationReg.IOUT_Diode_Ratio = CORE_CHANNEL_EXCITATION_DIODE_3PT_20UA_100UA_160UA;
+        break;
+    case ADMW1001_ADC_EXC_CURRENT_IOUT_DIODE_50UA_150UA_300UA:
+        channelExcitationReg.IOUT_Diode_Ratio = CORE_CHANNEL_EXCITATION_DIODE_3PT_50UA_150UA_300UA;
+        break;
+    case ADMW1001_ADC_EXC_CURRENT_IOUT_DIODE_100UA_300UA_600UA:
+        channelExcitationReg.IOUT_Diode_Ratio = CORE_CHANNEL_EXCITATION_DIODE_3PT_100UA_300UA_600UA;
+        break;
+    default:
+        ADMW_LOG_ERROR("Invalid diode ratio %d specified",
+                            pCurrentConfig->diodeRatio);
+        return ADMW_INVALID_PARAM;
     }
-    else
-    {
-        channelExcitationReg.IOUT_Diode_Ratio = 1;
-    }
-
-    WRITE_REG_U8(hDevice, channelExcitationReg.VALUE8, CORE_CHANNEL_EXCITATIONn(eChannelId));
+
+    WRITE_REG_U16(hDevice, channelExcitationReg.VALUE16, CORE_CHANNEL_EXCITATIONn(eChannelId));
 
     return ADMW_SUCCESS;
 }
@@ -2169,7 +1893,6 @@
         sensorDetailsReg.Unity_LUT_Select = 0;
 
     sensorDetailsReg.Vbias = 0;
-    sensorDetailsReg.Reference_Buffer_Disable = 1;
 
     WRITE_REG_U32(hDevice, sensorDetailsReg.VALUE32, CORE_SENSOR_DETAILSn(eChannelId));
 
@@ -2512,73 +2235,6 @@
                                 pDigitalComms->spiClock);
             return ADMW_INVALID_PARAM;
         }
-
-        switch (pDigitalComms->uartLineConfig)
-        {
-        case ADMW1001_DIGITAL_SENSOR_COMMS_UART_LINE_CONFIG_8N1:
-            digitalSensorComms.Uart_Mode = CORE_DIGITAL_SENSOR_COMMS_LINECONTROL_8N1;
-            break;
-        case ADMW1001_DIGITAL_SENSOR_COMMS_UART_LINE_CONFIG_8N2:
-            digitalSensorComms.Uart_Mode = CORE_DIGITAL_SENSOR_COMMS_LINECONTROL_8N2;
-            break;
-        case ADMW1001_DIGITAL_SENSOR_COMMS_UART_LINE_CONFIG_8N3:
-            digitalSensorComms.Uart_Mode = CORE_DIGITAL_SENSOR_COMMS_LINECONTROL_8N3;
-            break;
-        case ADMW1001_DIGITAL_SENSOR_COMMS_UART_LINE_CONFIG_8E1:
-            digitalSensorComms.Uart_Mode = CORE_DIGITAL_SENSOR_COMMS_LINECONTROL_8E1;
-            break;
-        case ADMW1001_DIGITAL_SENSOR_COMMS_UART_LINE_CONFIG_8E2:
-            digitalSensorComms.Uart_Mode = CORE_DIGITAL_SENSOR_COMMS_LINECONTROL_8E2;
-            break;
-        case ADMW1001_DIGITAL_SENSOR_COMMS_UART_LINE_CONFIG_8E3:
-            digitalSensorComms.Uart_Mode = CORE_DIGITAL_SENSOR_COMMS_LINECONTROL_8E3;
-            break;
-        case ADMW1001_DIGITAL_SENSOR_COMMS_UART_LINE_CONFIG_8O1:
-            digitalSensorComms.Uart_Mode = CORE_DIGITAL_SENSOR_COMMS_LINECONTROL_8O1;
-            break;
-        case ADMW1001_DIGITAL_SENSOR_COMMS_UART_LINE_CONFIG_8O2:
-            digitalSensorComms.Uart_Mode = CORE_DIGITAL_SENSOR_COMMS_LINECONTROL_8O2;
-            break;
-        case ADMW1001_DIGITAL_SENSOR_COMMS_UART_LINE_CONFIG_8O3:
-            digitalSensorComms.Uart_Mode = CORE_DIGITAL_SENSOR_COMMS_LINECONTROL_8O3;
-            break;
-        default:
-            ADMW_LOG_ERROR("Invalid UART mode %d specified",
-                                pDigitalComms->uartLineConfig);
-            return ADMW_INVALID_PARAM;
-        }
-
-        switch (pDigitalComms->uartBaudRate)
-        {
-        case ADMW1001_DIGITAL_SENSOR_COMMS_UART_BAUD_RATE_115200:
-            digitalSensorComms.Uart_Baud = CORE_DIGITAL_SENSOR_COMMS_UART_115200;
-            break;
-        case ADMW1001_DIGITAL_SENSOR_COMMS_UART_BAUD_RATE_57600:
-            digitalSensorComms.Uart_Baud = CORE_DIGITAL_SENSOR_COMMS_UART_57600;
-            break;
-        case ADMW1001_DIGITAL_SENSOR_COMMS_UART_BAUD_RATE_38400:
-            digitalSensorComms.Uart_Baud = CORE_DIGITAL_SENSOR_COMMS_UART_38400;
-            break;
-        case ADMW1001_DIGITAL_SENSOR_COMMS_UART_BAUD_RATE_19200:
-            digitalSensorComms.Uart_Baud = CORE_DIGITAL_SENSOR_COMMS_UART_19200;
-            break;
-        case ADMW1001_DIGITAL_SENSOR_COMMS_UART_BAUD_RATE_9600:
-            digitalSensorComms.Uart_Baud = CORE_DIGITAL_SENSOR_COMMS_UART_9600;
-            break;
-        case ADMW1001_DIGITAL_SENSOR_COMMS_UART_BAUD_RATE_4800:
-            digitalSensorComms.Uart_Baud = CORE_DIGITAL_SENSOR_COMMS_UART_4800;
-            break;
-        case ADMW1001_DIGITAL_SENSOR_COMMS_UART_BAUD_RATE_2400:
-            digitalSensorComms.Uart_Baud = CORE_DIGITAL_SENSOR_COMMS_UART_2400;
-            break;
-        case ADMW1001_DIGITAL_SENSOR_COMMS_UART_BAUD_RATE_1200:
-            digitalSensorComms.Uart_Baud = CORE_DIGITAL_SENSOR_COMMS_UART_1200;
-            break;
-        default:
-            ADMW_LOG_ERROR("Invalid UART baud rate %d specified",
-                                pDigitalComms->uartBaudRate);
-            return ADMW_INVALID_PARAM;
-        }
     }
     else
     {
@@ -2769,87 +2425,6 @@
     return ADMW_SUCCESS;
 }
 
-static ADMW_RESULT admw_SetChannelUartSensorType(
-    ADMW_DEVICE_HANDLE hDevice,
-    ADMW1001_CHANNEL_ID eChannelId,
-    ADMW1001_UART_SENSOR_TYPE sensorType)
-{
-    CORE_Sensor_Type_t sensorTypeReg;
-
-    sensorTypeReg.VALUE16 = REG_RESET_VAL(CORE_SENSOR_TYPEn);
-
-    /* Ensure that the sensor type is valid for this channel */
-    switch(sensorType)
-    {
-    case ADMW1001_UART_SENSOR_UART_CO2_A_DEF_L1:
-    case ADMW1001_UART_SENSOR_UART_CO2_B_DEF_L1:
-    case ADMW1001_UART_SENSOR_UART_CO2_A_DEF_L2:
-    case ADMW1001_UART_SENSOR_UART_CO2_B_DEF_L2:
-    case ADMW1001_UART_SENSOR_UART_CO2_A_ADV_L1:
-    case ADMW1001_UART_SENSOR_UART_CO2_B_ADV_L1:
-    case ADMW1001_UART_SENSOR_UART_CO2_A_ADV_L2:
-    case ADMW1001_UART_SENSOR_UART_CO2_B_ADV_L2:
-        sensorTypeReg.Sensor_Type = sensorType;
-        break;
-    default:
-        ADMW_LOG_ERROR("Unsupported UART sensor type %d specified", sensorType);
-        return ADMW_INVALID_PARAM;
-    }
-
-    WRITE_REG_U16(hDevice, sensorTypeReg.VALUE16, CORE_SENSOR_TYPEn(eChannelId));
-
-    return ADMW_SUCCESS;
-}
-
-ADMW_RESULT admw_SetUartChannelConfig(
-    ADMW_DEVICE_HANDLE hDevice,
-    ADMW1001_CHANNEL_ID eChannelId,
-    ADMW1001_CHANNEL_CONFIG *pChannelConfig)
-{
-    ADMW_RESULT eRet;
-    ADMW1001_UART_CHANNEL_CONFIG *pUartChannelConfig =
-        &pChannelConfig->uartChannelConfig;
-
-    eRet = admw_SetChannelUartSensorType(hDevice, eChannelId,
-                                             pUartChannelConfig->sensor);
-    if (eRet != ADMW_SUCCESS)
-    {
-        ADMW_LOG_ERROR("Failed to set UART sensor type for channel %d",
-                            eChannelId);
-        return eRet;
-    }
-
-    eRet = admw_SetChannelDigitalSensorDetails(hDevice, eChannelId,
-                                                    pChannelConfig);
-    if (eRet != ADMW_SUCCESS)
-    {
-        ADMW_LOG_ERROR("Failed to set UART sensor details for channel %d",
-                            eChannelId);
-        return eRet;
-    }
-
-    eRet = admw_SetDigitalCalibrationParam(hDevice, eChannelId,
-                                            &pUartChannelConfig->digitalCalibrationParam);
-    if (eRet != ADMW_SUCCESS)
-    {
-        ADMW_LOG_ERROR("Failed to set UART digital calibration param for channel %d",
-                            eChannelId);
-        return eRet;
-    }
-
-    eRet = admw_SetDigitalChannelComms(hDevice, eChannelId,
-                                            &pUartChannelConfig->configureComms);
-    if (eRet != ADMW_SUCCESS)
-    {
-        ADMW_LOG_ERROR("Failed to set UART comms for channel %d",
-                            eChannelId);
-        return eRet;
-    }
-
-
-    return ADMW_SUCCESS;
-}
-
 ADMW_RESULT admw1001_SetChannelThresholdLimits(
     ADMW_DEVICE_HANDLE hDevice,
     ADMW1001_CHANNEL_ID eChannelId,
@@ -2962,8 +2537,7 @@
         }
 
         eRet = admw1001_SetChannelOptions(hDevice, eChannelId,
-                                                pChannelConfig->priority,
-                                                pChannelConfig->enableFFT);
+                                                pChannelConfig->priority);
         if (eRet != ADMW_SUCCESS)
         {
             ADMW_LOG_ERROR("Failed to set priority for channel %d",
@@ -2972,7 +2546,7 @@
         }
 
         /* If the channel is not enabled, we can skip the following steps */
-        if (pChannelConfig->enableChannel || pChannelConfig->enableFFT)
+        if (pChannelConfig->enableChannel)
         {
             eRet = admw1001_SetChannelSkipCount(hDevice, eChannelId,
                                                       pChannelConfig->cycleSkipCount);
@@ -2985,14 +2559,10 @@
 
             switch (eChannelId)
             {
-            case ADMW1001_CHANNEL_ID_CJC_0:
-            case ADMW1001_CHANNEL_ID_CJC_1:
-            case ADMW1001_CHANNEL_ID_SENSOR_0:
-            case ADMW1001_CHANNEL_ID_SENSOR_1:
-            case ADMW1001_CHANNEL_ID_SENSOR_2:
-            case ADMW1001_CHANNEL_ID_SENSOR_3:
-            case ADMW1001_CHANNEL_ID_VOLTAGE_0:
-            case ADMW1001_CHANNEL_ID_CURRENT_0:
+            case ADMW1001_CHANNEL_ID_ANALOG_1_UNIVERSAL:
+            case ADMW1001_CHANNEL_ID_ANALOG_2_UNIVERSAL:
+            case ADMW1001_CHANNEL_ID_ANALOG_1_DIFFERENTIAL:
+            case ADMW1001_CHANNEL_ID_ANALOG_2_DIFFERENTIAL:
                 eRet = admw_SetAdcChannelConfig(hDevice, eChannelId, pChannelConfig);
                 break;
             case ADMW1001_CHANNEL_ID_I2C_0:
@@ -3002,9 +2572,6 @@
             case ADMW1001_CHANNEL_ID_SPI_0:
                 eRet = admw_SetSpiChannelConfig(hDevice, eChannelId, pChannelConfig);
                 break;
-            case ADMW1001_CHANNEL_ID_UART:
-                eRet = admw_SetUartChannelConfig(hDevice, eChannelId, pChannelConfig);
-                break;
             default:
                 ADMW_LOG_ERROR("Invalid channel ID %d specified", eChannelId);
                 return ADMW_INVALID_PARAM;
@@ -3021,7 +2588,7 @@
         }
     }
 
-    if (pChannelConfig->enableChannel || pChannelConfig->enableFFT)
+    if (pChannelConfig->enableChannel)
     {
         /* Threshold limits can be configured individually for virtual channels */
         eRet = admw1001_SetChannelThresholdLimits(hDevice, eChannelId,
@@ -3073,7 +2640,15 @@
                             pConfig->productId, ADMW_PRODUCT_ID_ADMW1001);
         return ADMW_INVALID_PARAM;
     }
-
+   
+    if(!((pConfig->versionId.major==VERSIONID_MAJOR) && (pConfig->versionId.minor==VERSIONID_MINOR)))
+    {
+      ADMW_LOG_ERROR("Configuration Version ID (0x%X) is not supported",
+                            pConfig->versionId);
+        return ADMW_INVALID_PARAM;
+    }
+    
+    
     /* Check that the actual Product ID is a match? */
     eRet = admw_GetProductID(hDevice, &productId);
     if (eRet)
@@ -3111,7 +2686,7 @@
         return eRet;
     }
 
-    for (ADMW1001_CHANNEL_ID id = ADMW1001_CHANNEL_ID_CJC_0;
+    for (ADMW1001_CHANNEL_ID id = ADMW1001_CHANNEL_ID_ANALOG_1_UNIVERSAL;
          id < ADMW1001_MAX_CHANNELS;
          id++)
     {
@@ -3124,17 +2699,10 @@
         }
     }
 
-    eRet = admw1001_SetFftConfig(hDevice, &pDeviceConfig->fft,
-                                       pDeviceConfig->channels);
-    if (eRet)
-    {
-        ADMW_LOG_ERROR("Failed to set FFT configuration");
-        return eRet;
-    }
-
     return ADMW_SUCCESS;
 }
 
+
 ADMW_RESULT admw1001_SetLutData(
     ADMW_DEVICE_HANDLE    const hDevice,
     ADMW1001_LUT       * const pLutData)
@@ -3339,4 +2907,3 @@
 
     return ADMW_SUCCESS;
 }
-