Diff: src/admw_1001.c

Revision:

51:e013f4d2fb9a

Parent:

50:d84305e5e1c0

--- a/src/admw_1001.c	Mon Feb 17 11:23:39 2020 +0000
+++ b/src/admw_1001.c	Fri Mar 06 17:03:18 2020 +0000
@@ -388,7 +388,7 @@
     return ADMW_SUCCESS;
 }
 
-ADMW_RESULT admw_deviceInformation(ADMW_DEVICE_HANDLE hDevice)
+ADMW_RESULT deviceInformation(ADMW_DEVICE_HANDLE hDevice)
 {
     uint16_t nAddress = REG_CORE_REVISION;
     char nData[ADMW_VERSION_REG_VAL_SIZE];  //4 Bytes of version register data
@@ -401,7 +401,7 @@
     } else {
         char buffer[ADMW_FORMATTED_VERSION_SIZE]; //00.00.0000  8 digits + 2 Bytes "." + one null character at the end
         strcat(nData, buffer);
-        ADMW_LOG_INFO("Firmware Version Id is %X.%X.%X",nData[3],nData[2],nData[0]);
+        ADMW_LOG_INFO("Firmware Version Id is %X.%X",nData[2],nData[0]);
     }
     return ADMW_SUCCESS;
 }
@@ -433,8 +433,8 @@
 
     if (bWaitForCompletion) {
         do {
-            /* Allow a minimum 100usec delay for status update before checking */
-            admw_TimeDelayUsec(100);
+            /* Allow a minimum 50usec delay for status update before checking */
+            admw_TimeDelayUsec(50);
 
             eRet = admw_GetCommandRunningState(hDevice, &bCommandRunning);
             if (eRet)
@@ -648,6 +648,7 @@
 
     for (unsigned i = 0; i < nRequested; i++) {
         bool bHoldCs = true;
+
         /* Keep the CS signal asserted for all but the last sample */
         if ((i + 1) == nRequested)
             bHoldCs = false;
@@ -777,8 +778,8 @@
                            nAddress);
             return eRet;
         }
-        wait_ms(100);
-        //admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
+
+        admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
     } while ((commandResponse[0] != ADMW1001_HOST_COMMS_CMD_RESP_0) ||
              (commandResponse[1] != ADMW1001_HOST_COMMS_CMD_RESP_1));
 
@@ -908,9 +909,9 @@
         *peOperatingMode = ADMW1001_OPERATING_MODE_CONTINUOUS;
 
     if (eMeasurementMode == ADMW_MEASUREMENT_MODE_OMIT_RAW) {
-        *pnBytesPerSample = 8;
+        *pnBytesPerSample = 5;
     } else {
-        *pnBytesPerSample = 12;
+        *pnBytesPerSample = 8;
     }
 
     for (ADMW1001_CH_ID chId = ADMW1001_CH_ID_ANLG_1_UNIVERSAL;
@@ -925,26 +926,29 @@
         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) {
+        if (channelCountReg.Channel_Enable && !sensorDetailsReg.Do_Not_Publish)
+        {
             unsigned nActualChannels = 1;
 
-            if (chId == ADMW1001_CH_ID_DIG_SPI_0) {
+            if (chId == ADMW1001_CH_ID_DIG_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 0 /* SPI sensors arent supported at present to be added back once there is
+#if 0 /* SPI sensors arent supported at present to be added back once there is 
        * support for these sensors
        */
                 ADMW_CORE_Sensor_Type_t sensorTypeReg;
 
                 READ_REG_U16(hDevice, sensorTypeReg.VALUE16, CORE_SENSOR_TYPEn(chId));
-
+      
                 if ((sensorTypeReg.Sensor_Type >=
-                        CORE_SENSOR_TYPE_SPI_ACCELEROMETER_A) &&
-                        (sensorTypeReg.Sensor_Type <=
-                         CORE_SENSOR_TYPE_SPI_ACCELEROMETER_B)) {
+                    CORE_SENSOR_TYPE_SPI_ACCELEROMETER_A) &&
+                    (sensorTypeReg.Sensor_Type <=
+                    CORE_SENSOR_TYPE_SPI_ACCELEROMETER_B))
+                {
                     nActualChannels += 2;
                 }
 #endif
@@ -967,30 +971,14 @@
 
     if (modeReg.Drdy_Mode == CORE_MODE_DRDY_PER_CONVERSION) {
         *pnSamplesPerDataready = 1;
-    } else if (modeReg.Drdy_Mode == CORE_MODE_DRDY_PER_CYCLE) {
+    } else {
         *pnSamplesPerDataready = nSamplesPerCycle;
-    } else if (modeReg.Drdy_Mode == CORE_MODE_DRDY_PER_FIFO_FILL) {
-        ADMW_CORE_Fifo_Num_Cycles_t fifoNumCyclesReg;
-
-        READ_REG_U8(hDevice, fifoNumCyclesReg.VALUE8, CORE_FIFO_NUM_CYCLES);
-
-        *pnSamplesPerDataready = nSamplesPerCycle * fifoNumCyclesReg.Fifo_Num_Cycles;
-    } else {
-        ADMW_LOG_ERROR("Invalid DRDY mode %d specified",
-                       modeReg.Drdy_Mode);
-        return ADMW_INVALID_PARAM;
     }
 
     if (modeReg.Drdy_Mode == CORE_MODE_DRDY_PER_CONVERSION) {
         *peDataReadyMode = ADMW1001_DATAREADY_PER_CONVERSION;
-    } else if (modeReg.Drdy_Mode == CORE_MODE_DRDY_PER_CYCLE) {
+    } else {
         *peDataReadyMode = ADMW1001_DATAREADY_PER_CYCLE;
-    } else if (modeReg.Drdy_Mode == CORE_MODE_DRDY_PER_FIFO_FILL) {
-        *peDataReadyMode = ADMW1001_DATAREADY_PER_FIFO_FILL;
-    } else {
-        ADMW_LOG_ERROR("Invalid DRDY mode %d specified",
-                       modeReg.Drdy_Mode);
-        return ADMW_INVALID_PARAM;
     }
 
     return ADMW_SUCCESS;
@@ -1015,7 +1003,7 @@
     ADMW_DEVICE_HANDLE hDevice,
     ADMW1001_POWER_MODE powerMode)
 {
-    ADMW_CORE_Power_Config_t powerConfigReg = { 0 };
+    ADMW_CORE_Power_Config_t powerConfigReg;
 
     if (powerMode == ADMW1001_POWER_MODE_HIBERNATION) {
         powerConfigReg.Power_Mode_MCU = CORE_POWER_CONFIG_HIBERNATION;
@@ -1050,13 +1038,13 @@
     ADMW_DEVICE_HANDLE hDevice,
     float32_t RSenseValue)
 {
-    ADMW_CORE_External_Reference_Resistor_t RefResistorConfigReg;
-
-    RefResistorConfigReg.Ext_Refin1_Value = RSenseValue;
-
-    WRITE_REG_FLOAT(hDevice, RefResistorConfigReg.VALUE32, CORE_EXTERNAL_REFERENCE_RESISTOR);
-
-    return ADMW_SUCCESS;
+   ADMW_CORE_External_Reference_Resistor_t RefResistorConfigReg;
+  
+   RefResistorConfigReg.Ext_Refin1_Value = RSenseValue;
+   
+   WRITE_REG_FLOAT(hDevice, RefResistorConfigReg.VALUE32, CORE_EXTERNAL_REFERENCE_RESISTOR);
+   
+   return ADMW_SUCCESS;
 
 }
 static ADMW_RESULT admw_SetMode(
@@ -1082,8 +1070,6 @@
         modeReg.Drdy_Mode = CORE_MODE_DRDY_PER_CONVERSION;
     } else if (eDataReadyMode == ADMW1001_DATAREADY_PER_CYCLE) {
         modeReg.Drdy_Mode = CORE_MODE_DRDY_PER_CYCLE;
-    } else if (eDataReadyMode == ADMW1001_DATAREADY_PER_FIFO_FILL) {
-        modeReg.Drdy_Mode = CORE_MODE_DRDY_PER_FIFO_FILL;
     } else {
         ADMW_LOG_ERROR("Invalid data-ready mode %d specified", eDataReadyMode);
         return ADMW_INVALID_PARAM;
@@ -1096,19 +1082,18 @@
 
 ADMW_RESULT admw_SetCycleControl(ADMW_DEVICE_HANDLE hDevice,
                                  uint32_t           nCycleInterval,
-                                 bool               vBiasEnable,
-                                 bool           vPostExecCurrentState,
-                                 bool               vGroundSwitch)
+                                 bool               vBiasEnable)
 {
     ADMW_CORE_Cycle_Control_t cycleControlReg;
 
     cycleControlReg.VALUE16 = REG_RESET_VAL(CORE_CYCLE_CONTROL);
 
-    if (nCycleInterval < (1 << 12)) {
-        cycleControlReg.Cycle_Time_Units = CORE_CYCLE_CONTROL_SECONDS;
+    if (nCycleInterval < (1000 * (1 << 12))) {
+        cycleControlReg.Cycle_Time_Units = CORE_CYCLE_CONTROL_MILLISECONDS;
+        nCycleInterval /= 1000;
     } else {
-        ADMW_LOG_ERROR("Invalid nCycleInterval %d specified", nCycleInterval);
-        return ADMW_INVALID_PARAM;
+        cycleControlReg.Cycle_Time_Units = CORE_CYCLE_CONTROL_SECONDS;
+        nCycleInterval /= 1000000;
     }
 
     if (vBiasEnable == true) {
@@ -1117,32 +1102,6 @@
     CHECK_REG_FIELD_VAL(CORE_CYCLE_CONTROL_CYCLE_TIME, nCycleInterval);
     cycleControlReg.Cycle_Time = nCycleInterval;
 
-    switch(vPostExecCurrentState) {
-        case ADMW1001_ADC_EXC_STATE_CYCLE_POWER:
-            cycleControlReg.PST_MEAS_EXC_CTRL = CORE_CYCLE_CONTROL_POWERCYCLE;
-            break;
-        case ADMW1001_ADC_EXC_STATE_ALWAYS_ON:
-            cycleControlReg.PST_MEAS_EXC_CTRL = CORE_CYCLE_CONTROL_ALWAYSON;
-            break;
-        default:
-            ADMW_LOG_ERROR("Invalid Post measurement Excitation Current state %d specified",
-                           vPostExecCurrentState);
-            return ADMW_INVALID_PARAM;
-    }
-
-    switch(vGroundSwitch) {
-        case ADMW1001_ADC_GND_SW_OPEN:
-            cycleControlReg.GND_SW_CTRL = CORE_CYCLE_CONTROL_OPEN_SW;
-            break;
-        case ADMW1001_ADC_GND_SW_CLOSED:
-            cycleControlReg.GND_SW_CTRL = CORE_CYCLE_CONTROL_CLOSE_SW;
-            break;
-        default:
-            ADMW_LOG_ERROR("Invalid ground switch state %d specified",
-                           vGroundSwitch);
-            return ADMW_INVALID_PARAM;
-    }
-
     WRITE_REG_U16(hDevice, cycleControlReg.VALUE16, CORE_CYCLE_CONTROL);
 
     return ADMW_SUCCESS;
@@ -1155,14 +1114,6 @@
 
     return ADMW_SUCCESS;
 }
-static ADMW_RESULT admw_SetFifoNumCycles(
-    ADMW_DEVICE_HANDLE hDevice,
-    uint8_t fifoNumCycles)
-{
-    WRITE_REG_U8(hDevice, fifoNumCycles, CORE_FIFO_NUM_CYCLES);
-
-    return ADMW_SUCCESS;
-}
 
 static ADMW_RESULT admw_SetExternalReferenceValues(
     ADMW_DEVICE_HANDLE hDevice,
@@ -1172,15 +1123,6 @@
 
     return ADMW_SUCCESS;
 }
-static ADMW_RESULT admw_SetAVDDVoltage(
-    ADMW_DEVICE_HANDLE hDevice,
-    float32_t AVDDVoltage)
-{
-
-    WRITE_REG_FLOAT(hDevice, AVDDVoltage, CORE_AVDD_VOLTAGE);
-
-    return ADMW_SUCCESS;
-}
 
 ADMW_RESULT admw1001_SetMeasurementConfig(
     ADMW_DEVICE_HANDLE hDevice,
@@ -1197,25 +1139,13 @@
     }
 
     eRet = admw_SetCycleControl(hDevice, pMeasConfig->cycleInterval,
-                                pMeasConfig->vBiasEnable,
-                                pMeasConfig->excitationState,
-                                pMeasConfig->groundSwitch );
+                                pMeasConfig->vBiasEnable);
     if (eRet != ADMW_SUCCESS) {
         ADMW_LOG_ERROR("Failed to set cycle control");
         return eRet;
     }
 
-    if (pMeasConfig->fifoNumCycles > 0) {
-        eRet = admw_SetFifoNumCycles(hDevice,
-                                     pMeasConfig->fifoNumCycles);
-    }
-
-    if (eRet != ADMW_SUCCESS) {
-        ADMW_LOG_ERROR("Failed to set the FIFO number of cycles.");
-        return eRet;
-    }
-
-    if(pMeasConfig->externalRef1Value > 0) {
+    if(pMeasConfig->externalRef1Value>0) {
         eRet = admw_SetExternalReferenceValues(hDevice,
                                                pMeasConfig->externalRef1Value);
     }
@@ -1225,30 +1155,23 @@
         return eRet;
     }
 
-    if((pMeasConfig->AVDDVoltage >= 3.0) && (pMeasConfig->AVDDVoltage <= 3.6)) {
-        eRet = admw_SetAVDDVoltage(hDevice,
-                                   pMeasConfig->AVDDVoltage);
-    }
-
-    if (eRet != ADMW_SUCCESS) {
-        ADMW_LOG_ERROR("Failed to set AVDD Voltge");
-        return eRet;
-    }
-
     eRet = admw_SetRSenseValue(hDevice, pMeasConfig->RSenseValue);
-    if (eRet != ADMW_SUCCESS) {
+    if (eRet != ADMW_SUCCESS)
+    {
         ADMW_LOG_ERROR("Failed to set RSenseValue");
         return eRet;
     }
-
+    
     eRet = admw_SetExternalReferenceVoltage(hDevice, pMeasConfig->externalRefVoltage);
-    if (eRet != ADMW_SUCCESS) {
+    if (eRet != ADMW_SUCCESS)
+    {
         ADMW_LOG_ERROR("Failed to set External reference Voltage");
         return eRet;
-    }
-
+    }    
+          
     return ADMW_SUCCESS;
 }
+
 ADMW_RESULT admw1001_SetDiagnosticsConfig(
     ADMW_DEVICE_HANDLE hDevice,
     ADMW1001_DIAGNOSTICS_CONFIG *pDiagnosticsConfig)
@@ -1262,16 +1185,26 @@
     else
         diagnosticsControlReg.Diag_Meas_En = 1;
 
-    if(pDiagnosticsConfig->osdFrequency <= 0x7F)
+    switch (pDiagnosticsConfig->osdFrequency)
     {
-      diagnosticsControlReg.Diag_OSD_Freq = pDiagnosticsConfig->osdFrequency;
-    }
-    else
-    {
+    case ADMW1001_OPEN_SENSOR_DIAGNOSTICS_DISABLED:
+        diagnosticsControlReg.Diag_OSD_Freq = CORE_DIAGNOSTICS_CONTROL_OCD_OFF;
+        break;
+    case ADMW1001_OPEN_SENSOR_DIAGNOSTICS_PER_CYCLE:
+        diagnosticsControlReg.Diag_OSD_Freq = CORE_DIAGNOSTICS_CONTROL_OCD_PER_1_CYCLE;
+        break;
+    case ADMW1001_OPEN_SENSOR_DIAGNOSTICS_PER_100_CYCLES:
+        diagnosticsControlReg.Diag_OSD_Freq = CORE_DIAGNOSTICS_CONTROL_OCD_PER_10_CYCLES;
+        break;
+    case ADMW1001_OPEN_SENSOR_DIAGNOSTICS_PER_1000_CYCLES:
+        diagnosticsControlReg.Diag_OSD_Freq = CORE_DIAGNOSTICS_CONTROL_OCD_PER_100_CYCLES;
+        break;
+    default:
         ADMW_LOG_ERROR("Invalid open-sensor diagnostic frequency %d specified",
                         pDiagnosticsConfig->osdFrequency);
         return ADMW_INVALID_PARAM;
     }
+
     WRITE_REG_U8(hDevice, diagnosticsControlReg.VALUE8, CORE_DIAGNOSTICS_CONTROL);
 
     return ADMW_SUCCESS;
@@ -1349,37 +1282,18 @@
 
     /* Ensure that the sensor type is valid for this channel */
     switch(sensorType) {
-        case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT10:
-
-        case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT50:
-        case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT100:
-        case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT200:
-        case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT500:
-        case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT1000:
-        case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT1000_0P00375:
-        case ADMW1001_ADC_SENSOR_RTD_2WIRE_NI120:
-        case ADMW1001_ADC_SENSOR_RTD_2WIRE_CUSTOM:
-        case ADMW1001_ADC_SENSOR_RTD_4WIRE_PT10:
-
-        case ADMW1001_ADC_SENSOR_RTD_4WIRE_PT50:
+        case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT100:
+        case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT1000:
+        case ADMW1001_ADC_SENSOR_RTD_3WIRE_1:
+        case ADMW1001_ADC_SENSOR_RTD_3WIRE_2:
+        case ADMW1001_ADC_SENSOR_RTD_3WIRE_3:
+        case ADMW1001_ADC_SENSOR_RTD_3WIRE_4:
         case ADMW1001_ADC_SENSOR_RTD_4WIRE_PT100:
-        case ADMW1001_ADC_SENSOR_RTD_4WIRE_PT200:
-        case ADMW1001_ADC_SENSOR_RTD_4WIRE_PT500:
         case ADMW1001_ADC_SENSOR_RTD_4WIRE_PT1000:
-        case ADMW1001_ADC_SENSOR_RTD_4WIRE_PT1000_0P00375:
-        case ADMW1001_ADC_SENSOR_RTD_4WIRE_NI120:
-        case ADMW1001_ADC_SENSOR_RTD_4WIRE_CUSTOM:
-        case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT10:
-
-        case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT50:
-        case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT100:
-        case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT200:
-        case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT500:
-        case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT1000:
-        case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT1000_0P00375 :
-
-        case ADMW1001_ADC_SENSOR_RTD_3WIRE_NI120:
-        case ADMW1001_ADC_SENSOR_RTD_3WIRE_CUSTOM:
+        case ADMW1001_ADC_SENSOR_RTD_4WIRE_1:
+        case ADMW1001_ADC_SENSOR_RTD_4WIRE_2:
+        case ADMW1001_ADC_SENSOR_RTD_4WIRE_3:
+        case ADMW1001_ADC_SENSOR_RTD_4WIRE_4:
         case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE_1:
         case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE_2:
         case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE_3:
@@ -1388,23 +1302,29 @@
         case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE_2:
         case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE_3:
         case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE_4:
-        case ADMW1001_ADC_SENSOR_DIODE:
-        case ADMW1001_ADC_SENSOR_THERMISTOR_44004_44033_2P252K_AT_25C:
-        case ADMW1001_ADC_SENSOR_THERMISTOR_44005_44030_3K_AT_25C:
-        case ADMW1001_ADC_SENSOR_THERMISTOR_44007_44034_5K_AT_25C:
-        case ADMW1001_ADC_SENSOR_THERMISTOR_44006_44031_10K_AT_25C:
-        case ADMW1001_ADC_SENSOR_THERMISTOR_44008_44032_30K_AT_25C:
-        case ADMW1001_ADC_SENSOR_THERMISTOR_YSI_400:
-        case ADMW1001_ADC_SENSOR_THERMISTOR_SPECTRUM_1003K_1K:
-        case ADMW1001_ADC_SENSOR_THERMISTOR_CUSTOM_STEINHART_HART:
-        case ADMW1001_ADC_SENSOR_THERMISTOR_CUSTOM_TABLE:
+        case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT100:
+        case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT1000:
+        case ADMW1001_ADC_SENSOR_RTD_2WIRE_1:
+        case ADMW1001_ADC_SENSOR_RTD_2WIRE_2:
+        case ADMW1001_ADC_SENSOR_RTD_2WIRE_3:
+        case ADMW1001_ADC_SENSOR_RTD_2WIRE_4:
+        case ADMW1001_ADC_SENSOR_DIODE_2C_TYPEA:
+        case ADMW1001_ADC_SENSOR_DIODE_3C_TYPEA:
+        case ADMW1001_ADC_SENSOR_DIODE_2C_1:
+        case ADMW1001_ADC_SENSOR_DIODE_3C_1:
+        case ADMW1001_ADC_SENSOR_THERMISTOR_A_10K:
+        case ADMW1001_ADC_SENSOR_THERMISTOR_B_10K:
+        case ADMW1001_ADC_SENSOR_THERMISTOR_1:
+        case ADMW1001_ADC_SENSOR_THERMISTOR_2:
+        case ADMW1001_ADC_SENSOR_THERMISTOR_3:
+        case ADMW1001_ADC_SENSOR_THERMISTOR_4:
         case ADMW1001_ADC_SENSOR_SINGLE_ENDED_ABSOLUTE:
         case ADMW1001_ADC_SENSOR_DIFFERENTIAL_ABSOLUTE:
         case ADMW1001_ADC_SENSOR_SINGLE_ENDED_RATIO:
         case ADMW1001_ADC_SENSOR_DIFFERENTIAL_RATIO:
-
-            if (! (ADMW1001_CHANNEL_IS_ADC_CJC(eChannelId) ||
-                    ADMW1001_CHANNEL_IS_ADC(eChannelId) )) {
+            if (! (ADMW1001_CHANNEL_IS_ADC_SENSOR(eChannelId) ||
+                   ADMW1001_CHANNEL_IS_ADC_CJC(eChannelId) || ADMW1001_CHANNEL_IS_ADC(eChannelId) ))
+            {
                 ADMW_LOG_ERROR(
                     "Invalid ADC sensor type %d specified for channel %d",
                     sensorType, eChannelId);
@@ -1419,12 +1339,10 @@
         case ADMW1001_ADC_SENSOR_THERMOCOUPLE_J:
         case ADMW1001_ADC_SENSOR_THERMOCOUPLE_K:
         case ADMW1001_ADC_SENSOR_THERMOCOUPLE_T:
-        case ADMW1001_ADC_SENSOR_THERMOCOUPLE_E:
-        case ADMW1001_ADC_SENSOR_THERMOCOUPLE_N:
-        case ADMW1001_ADC_SENSOR_THERMOCOUPLE_R:
-        case ADMW1001_ADC_SENSOR_THERMOCOUPLE_S:
-        case ADMW1001_ADC_SENSOR_THERMOCOUPLE_B:
-        case ADMW1001_ADC_SENSOR_THERMOCOUPLE_CUSTOM:
+        case ADMW1001_ADC_SENSOR_THERMOCOUPLE_1:
+        case ADMW1001_ADC_SENSOR_THERMOCOUPLE_2:
+        case ADMW1001_ADC_SENSOR_THERMOCOUPLE_3:
+        case ADMW1001_ADC_SENSOR_THERMOCOUPLE_4:
             if (! ADMW1001_CHANNEL_IS_ADC_VOLTAGE(eChannelId)) {
                 ADMW_LOG_ERROR(
                     "Invalid ADC sensor type %d specified for channel %d",
@@ -1575,6 +1493,7 @@
 
     switch (pChannelConfig->lutSelect) {
         case ADMW1001_LUT_DEFAULT:
+        case ADMW1001_LUT_UNITY:
         case ADMW1001_LUT_CUSTOM:
             sensorDetailsReg.LUT_Select = pChannelConfig->lutSelect;
             break;
@@ -1597,8 +1516,9 @@
     ADMW_CORE_Measurement_Setup_t MeasSetupReg;
     ADMW1001_ADC_FILTER_CONFIG *pFilterConfig = &pAdcChannelConfig->filter;
     MeasSetupReg.VALUE32 = REG_RESET_VAL(CORE_MEASUREMENT_SETUPn);
+    MeasSetupReg.PST_MEAS_EXC_CTRL = pAdcChannelConfig->current.excitationState;
     MeasSetupReg.Buffer_Bypass = pAdcChannelConfig->bufferBypass;
-
+    
     if (pFilterConfig->type == ADMW1001_ADC_FILTER_SINC4) {
         MeasSetupReg.ADC_Filter_Type = CORE_MEASUREMENT_SETUP_ENABLE_SINC4;
         MeasSetupReg.ADC_SF = pFilterConfig->sf;
@@ -1619,6 +1539,19 @@
     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;
@@ -1684,7 +1617,7 @@
     }
 
     eRet = admw_SetChannelAdcMeasurementSetup(hDevice, eChannelId,
-            pAdcChannelConfig);
+                                         pAdcChannelConfig);
     if (eRet != ADMW_SUCCESS) {
         ADMW_LOG_ERROR("Failed to set ADC filter for channel %d",
                        eChannelId);
@@ -1831,7 +1764,6 @@
     switch(sensorType) {
         case ADMW1001_I2C_SENSOR_HUMIDITY_A:
         case ADMW1001_I2C_SENSOR_HUMIDITY_B:
-        case ADMW1001_I2C_SENSOR_TEMPERATURE_ADT742X:
             sensorTypeReg.Sensor_Type = sensorType;
             break;
         default:
@@ -1865,6 +1797,7 @@
     digitalSensorComms.VALUE16 = REG_RESET_VAL(CORE_DIGITAL_SENSOR_COMMSn);
 
     if(pDigitalComms->useCustomCommsConfig) {
+        digitalSensorComms.Digital_Sensor_Comms_En = 1;
 
         if(pDigitalComms->i2cClockSpeed == ADMW1001_DIGITAL_SENSOR_COMMS_I2C_CLOCK_SPEED_100K) {
             digitalSensorComms.I2C_Clock = CORE_DIGITAL_SENSOR_COMMS_I2C_100K;
@@ -1944,9 +1877,10 @@
                                pDigitalComms->spiClock);
                 return ADMW_INVALID_PARAM;
         }
+    } else {
+        digitalSensorComms.Digital_Sensor_Comms_En = 0;
     }
 
-
     WRITE_REG_U16(hDevice, digitalSensorComms.VALUE16, CORE_DIGITAL_SENSOR_COMMSn(eChannelId));
 
     return ADMW_SUCCESS;
@@ -2157,6 +2091,16 @@
 {
     ADMW_CORE_Settling_Time_t settlingTimeReg;
 
+    if (nSettlingTime < (1 << 12)) {
+        settlingTimeReg.Settling_Time_Units = CORE_SETTLING_TIME_MICROSECONDS;
+    } else if (nSettlingTime < (1000 * (1 << 12))) {
+        settlingTimeReg.Settling_Time_Units = CORE_SETTLING_TIME_MILLISECONDS;
+        nSettlingTime /= 1000;
+    } else {
+        settlingTimeReg.Settling_Time_Units = CORE_SETTLING_TIME_SECONDS;
+        nSettlingTime /= 1000000;
+    }
+
     CHECK_REG_FIELD_VAL(CORE_SETTLING_TIME_SETTLING_TIME, nSettlingTime);
     settlingTimeReg.Settling_Time = nSettlingTime;
 
@@ -2322,7 +2266,8 @@
     }
 
     eRet = admw1001_SetDiagnosticsConfig(hDevice, &pDeviceConfig->diagnostics);
-    if (eRet) {
+    if (eRet)
+    {
         ADMW_LOG_ERROR("Failed to set diagnostics configuration");
         return eRet;
     }
@@ -2347,7 +2292,6 @@
 {
     ADMW1001_LUT_HEADER *pLutHeader = &pLutData->header;
     ADMW1001_LUT_TABLE  *pLutTable = pLutData->tables;
-
     unsigned actualLength = 0;
 
     if (pLutData->header.signature != ADMW_LUT_SIGNATURE) {
@@ -2355,10 +2299,7 @@
                        ADMW_LUT_SIGNATURE, pLutHeader->signature);
         return ADMW_INVALID_SIGNATURE;
     }
-    if ((pLutData->tables->descriptor.geometry!= ADMW1001_LUT_GEOMETRY_NES_1D) &&
-            (pLutData->tables->data.lut1dNes.nElements > MAX_LUT_NUM_ENTRIES)) {
-        return ADMW_INVALID_PARAM;
-    }
+
     for (unsigned i = 0; i < pLutHeader->numTables; i++) {
         ADMW1001_LUT_DESCRIPTOR *pDesc = &pLutTable->descriptor;
         ADMW1001_LUT_TABLE_DATA *pData = &pLutTable->data;
@@ -2381,6 +2322,14 @@
                 }
                 break;
             case ADMW1001_LUT_GEOMETRY_NES_1D:
+            case ADMW1001_LUT_GEOMETRY_NES_2D:
+            case ADMW1001_LUT_GEOMETRY_ES_1D:
+            case ADMW1001_LUT_GEOMETRY_ES_2D:
+                if (pDesc->equation != ADMW1001_LUT_EQUATION_LUT) {
+                    ADMW_LOG_ERROR("Invalid equation %u specified for LUT table %u",
+                                   pDesc->equation, i);
+                    return ADMW_INVALID_PARAM;
+                }
                 break;
             default:
                 ADMW_LOG_ERROR("Invalid geometry %u specified for LUT table %u",
@@ -2430,6 +2379,7 @@
 
     return ADMW_SUCCESS;
 }
+
 ADMW_RESULT admw1001_SetLutDataRaw(
     ADMW_DEVICE_HANDLE    const hDevice,
     ADMW1001_LUT_RAW   * const pLutData)
@@ -2446,11 +2396,22 @@
     switch (pDesc->geometry) {
         case ADMW1001_LUT_GEOMETRY_COEFFS:
             if (pDesc->equation == ADMW1001_LUT_EQUATION_BIVARIATE_POLYN)
+                *pLength = ADMW1001_LUT_2D_POLYN_COEFF_LIST_SIZE(pData->coeffList2d);
+            else
                 *pLength = ADMW1001_LUT_COEFF_LIST_SIZE(pData->coeffList);
             break;
         case ADMW1001_LUT_GEOMETRY_NES_1D:
             *pLength = ADMW1001_LUT_1D_NES_SIZE(pData->lut1dNes);
             break;
+        case ADMW1001_LUT_GEOMETRY_NES_2D:
+            *pLength = ADMW1001_LUT_2D_NES_SIZE(pData->lut2dNes);
+            break;
+        case ADMW1001_LUT_GEOMETRY_ES_1D:
+            *pLength = ADMW1001_LUT_1D_ES_SIZE(pData->lut1dEs);
+            break;
+        case ADMW1001_LUT_GEOMETRY_ES_2D:
+            *pLength = ADMW1001_LUT_2D_ES_SIZE(pData->lut2dEs);
+            break;
         default:
             ADMW_LOG_ERROR("Invalid LUT table geometry %d specified\r\n",
                            pDesc->geometry);