Mbed Development branch for MeasrueWare

Revision:
63:2655a04c00f5
Parent:
61:0f16a2e3b58b
Child:
64:e8670e971e22
--- a/src/admw_1001.c	Wed Apr 08 10:05:08 2020 +0000
+++ b/src/admw_1001.c	Tue Apr 14 06:43:47 2020 +0000
@@ -184,8 +184,6 @@
 #define ADMW1001_CHANNEL_IS_ADC_CURRENT(c)                              \
     ((c) == ADMW1001_CH_ID_ANLG_1_UNIVERSAL || (c) == ADMW1001_CH_ID_ANLG_2_UNIVERSAL)
 
-#define ADMW1001_CHANNEL_IS_VIRTUAL(c)                                  \
-    ((c) == ADMW1001_CH_ID_DIG_SPI_1 || (c) == ADMW1001_CH_ID_DIG_SPI_2)
 
 //typedef struct {
 //    unsigned nDeviceIndex;
@@ -920,37 +918,13 @@
         ADMW_CORE_Sensor_Details_t sensorDetailsReg;
         ADMW_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) {
             unsigned nActualChannels = 1;
-
-            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
-       * 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)) {
-                    nActualChannels += 2;
-                }
-#endif
-            }
-
+            
             nChannelsEnabled += nActualChannels;
 
             nSamplesPerCycle += nActualChannels *
@@ -1515,9 +1489,6 @@
         case ADMW1001_ADC_GAIN_64X:
             sensorDetailsReg.PGA_Gain = CORE_SENSOR_DETAILS_PGA_GAIN_64;
             break;
-        case ADMW1001_ADC_GAIN_128X:
-            sensorDetailsReg.PGA_Gain = CORE_SENSOR_DETAILS_PGA_GAIN_128;
-            break;
         default:
             ADMW_LOG_ERROR("Invalid ADC gain %d specified",
                            pAdcChannelConfig->gain);
@@ -1769,30 +1740,6 @@
     return ADMW_SUCCESS;
 }
 
-static ADMW_RESULT admw_SetDigitalCalibrationParam(
-    ADMW_DEVICE_HANDLE hDevice,
-    ADMW1001_CH_ID eChannelId,
-    ADMW1001_DIGITAL_CALIBRATION_COMMAND *pCalibrationParam)
-{
-//    ADMW_CORE_Calibration_Parameter_t calibrationParamReg;
-//
-//    calibrationParamReg.VALUE32 = REG_RESET_VAL(CORE_CALIBRATION_PARAMETERn);
-//
-//    if (pCalibrationParam->enableCalibrationParam == false)
-//        calibrationParamReg.Calibration_Parameter_Enable = 0;
-//    else
-//        calibrationParamReg.Calibration_Parameter_Enable = 1;
-//
-//    CHECK_REG_FIELD_VAL(CORE_CALIBRATION_PARAMETER_CALIBRATION_PARAMETER,
-//        pCalibrationParam->calibrationParam);
-//
-//    calibrationParamReg.Calibration_Parameter = pCalibrationParam->calibrationParam;
-//
-//    WRITE_REG_U32(hDevice, calibrationParamReg.VALUE32,
-//                  CORE_CALIBRATION_PARAMETERn(eChannelId));
-//
-    return ADMW_SUCCESS;
-}
 
 static ADMW_RESULT admw_SetChannelI2cSensorType(
     ADMW_DEVICE_HANDLE hDevice,
@@ -1850,78 +1797,7 @@
                            pDigitalComms->i2cClockSpeed);
             return ADMW_INVALID_PARAM;
         }
-
-        if(pDigitalComms->spiMode == ADMW1001_DIGITAL_SENSOR_COMMS_SPI_MODE_0) {
-            digitalSensorComms.SPI_Mode = CORE_DIGITAL_SENSOR_COMMS_SPI_MODE_0;
-        } else if(pDigitalComms->spiMode == ADMW1001_DIGITAL_SENSOR_COMMS_SPI_MODE_1) {
-            digitalSensorComms.SPI_Mode = CORE_DIGITAL_SENSOR_COMMS_SPI_MODE_1;
-        } else if(pDigitalComms->spiMode == ADMW1001_DIGITAL_SENSOR_COMMS_SPI_MODE_2) {
-            digitalSensorComms.SPI_Mode = CORE_DIGITAL_SENSOR_COMMS_SPI_MODE_2;
-        } else if(pDigitalComms->spiMode == ADMW1001_DIGITAL_SENSOR_COMMS_SPI_MODE_3) {
-            digitalSensorComms.SPI_Mode = CORE_DIGITAL_SENSOR_COMMS_SPI_MODE_3;
-        } else {
-            ADMW_LOG_ERROR("Invalid SPI mode %d specified",
-                           pDigitalComms->spiMode);
-            return ADMW_INVALID_PARAM;
-        }
-
-        switch (pDigitalComms->spiClock) {
-            case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_8MHZ:
-                digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_8MHZ;
-                break;
-            case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_4MHZ:
-                digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_4MHZ;
-                break;
-            case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_2MHZ:
-                digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_2MHZ;
-                break;
-            case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_1MHZ:
-                digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_1MHZ;
-                break;
-            case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_500KHZ:
-                digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_500KHZ;
-                break;
-            case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_250KHZ:
-                digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_250KHZ;
-                break;
-            case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_125KHZ:
-                digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_125KHZ;
-                break;
-            case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_62P5KHZ:
-                digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_62P5KHZ;
-                break;
-            case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_31P3KHZ:
-                digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_31P3KHZ;
-                break;
-            case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_15P6KHZ:
-                digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_15P6KHZ;
-                break;
-            case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_7P8KHZ:
-                digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_7P8KHZ;
-                break;
-            case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_3P9KHZ:
-                digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_3P9KHZ;
-                break;
-            case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_1P9KHZ:
-                digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_1P9KHZ;
-                break;
-            case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_977HZ:
-                digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_977HZ;
-                break;
-            case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_488HZ:
-                digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_488HZ;
-                break;
-            case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_244HZ:
-                digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_244HZ;
-                break;
-            default:
-                ADMW_LOG_ERROR("Invalid SPI clock %d specified",
-                               pDigitalComms->spiClock);
-                return ADMW_INVALID_PARAM;
-        }
-    }
-
-
+}
     WRITE_REG_U16(hDevice, digitalSensorComms.VALUE16, CORE_DIGITAL_SENSOR_COMMSn(eChannelId));
 
     return ADMW_SUCCESS;
@@ -1968,13 +1844,6 @@
         return eRet;
     }
 
-    eRet = admw_SetDigitalCalibrationParam(hDevice, eChannelId,
-                                           &pI2cChannelConfig->digitalCalibrationParam);
-    if (eRet != ADMW_SUCCESS) {
-        ADMW_LOG_ERROR("Failed to set I2C digital calibration param for channel %d",
-                       eChannelId);
-        return eRet;
-    }
 
     eRet = admw_SetDigitalChannelComms(hDevice, eChannelId,
                                        &pI2cChannelConfig->configureComms);
@@ -2012,57 +1881,6 @@
     return ADMW_SUCCESS;
 }
 
-ADMW_RESULT admw_SetSpiChannelConfig(
-    ADMW_DEVICE_HANDLE hDevice,
-    ADMW1001_CH_ID eChannelId,
-    ADMW1001_CHANNEL_CONFIG *pChannelConfig)
-{
-    ADMW_RESULT eRet;
-    ADMW1001_SPI_CHANNEL_CONFIG *pSpiChannelConfig =
-        &pChannelConfig->spiChannelConfig;
-
-    eRet = admw_SetChannelSpiSensorType(hDevice, eChannelId,
-                                        pSpiChannelConfig->sensor);
-    if (eRet != ADMW_SUCCESS) {
-        ADMW_LOG_ERROR("Failed to set SPI sensor type for channel %d",
-                       eChannelId);
-        return eRet;
-    }
-
-    eRet = admw_SetChannelDigitalSensorDetails(hDevice, eChannelId,
-            pChannelConfig);
-    if (eRet != ADMW_SUCCESS) {
-        ADMW_LOG_ERROR("Failed to set SPI sensor details for channel %d",
-                       eChannelId);
-        return eRet;
-    }
-
-    eRet = admw_SetDigitalSensorFormat(hDevice, eChannelId,
-                                       &pSpiChannelConfig->dataFormat);
-    if (eRet != ADMW_SUCCESS) {
-        ADMW_LOG_ERROR("Failed to set SPI sensor data format for channel %d",
-                       eChannelId);
-        return eRet;
-    }
-
-    eRet = admw_SetDigitalCalibrationParam(hDevice, eChannelId,
-                                           &pSpiChannelConfig->digitalCalibrationParam);
-    if (eRet != ADMW_SUCCESS) {
-        ADMW_LOG_ERROR("Failed to set SPI digital calibration param for channel %d",
-                       eChannelId);
-        return eRet;
-    }
-
-    eRet = admw_SetDigitalChannelComms(hDevice, eChannelId,
-                                       &pSpiChannelConfig->configureComms);
-    if (eRet != ADMW_SUCCESS) {
-        ADMW_LOG_ERROR("Failed to set SPI comms for channel %d",
-                       eChannelId);
-        return eRet;
-    }
-
-    return ADMW_SUCCESS;
-}
 
 ADMW_RESULT admw1001_SetChannelThresholdLimits(
     ADMW_DEVICE_HANDLE hDevice,
@@ -2145,7 +1963,6 @@
 {
     ADMW_RESULT eRet;
 
-    if (! ADMW1001_CHANNEL_IS_VIRTUAL(eChannelId)) {
         eRet = admw1001_SetChannelCount(hDevice, eChannelId,
                                         pChannelConfig->enableChannel ?
                                         pChannelConfig->measurementsPerCycle : 0);
@@ -2184,9 +2001,6 @@
                 case ADMW1001_CH_ID_DIG_I2C_1:
                     eRet = admw_SetI2cChannelConfig(hDevice, eChannelId, pChannelConfig);
                     break;
-                case ADMW1001_CH_ID_DIG_SPI_0:
-                    eRet = admw_SetSpiChannelConfig(hDevice, eChannelId, pChannelConfig);
-                    break;
                 default:
                     ADMW_LOG_ERROR("Invalid channel ID %d specified", eChannelId);
                     eRet = ADMW_INVALID_PARAM;
@@ -2210,7 +2024,6 @@
                 return eRet;
             }
         }
-    }
 
     if (pChannelConfig->enableChannel) {
         /* Threshold limits can be configured individually for virtual channels */
@@ -2329,10 +2142,6 @@
     unsigned *pLength)
 {
     switch (pDesc->geometry) {
-        case ADMW1001_LUT_GEOMETRY_COEFFS:
-            if (pDesc->equation == ADMW1001_LUT_EQUATION_BIVARIATE_POLYN)
-                *pLength = ADMW1001_LUT_COEFF_LIST_SIZE(pData->coeffList);
-            break;
         case ADMW1001_LUT_GEOMETRY_NES_1D:
             *pLength = ADMW1001_LUT_1D_NES_SIZE(pData->lut1dNes);
             break;