Vybhav Kadaba
Mbed FW update
Diff: src/admw_1001.c
- Revision:
- 23:bb685f35b08b
- Parent:
- 18:cbf514cce921
- Child:
- 32:52445bef314d
--- a/src/admw_1001.c Thu Sep 26 05:56:58 2019 +0000
+++ b/src/admw_1001.c Thu Sep 26 06:15:39 2019 +0000
@@ -184,12 +184,11 @@
#define ADMW1001_CHANNEL_IS_VIRTUAL(c) \
((c) == ADMW1001_CH_ID_DIG_SPI_1 || (c) == ADMW1001_CH_ID_DIG_SPI_2)
-typedef struct
-{
+typedef struct {
unsigned nDeviceIndex;
ADMW_SPI_HANDLE hSpi;
ADMW_GPIO_HANDLE hGpio;
-
+
} ADMW_DEVICE_CONTEXT;
static ADMW_DEVICE_CONTEXT gDeviceCtx[ADMW_PLATFORM_MAX_DEVICES];
@@ -251,13 +250,10 @@
{
ADMW_DEVICE_CONTEXT *pCtx = hDevice;
- if (callbackFunction)
- {
+ if (callbackFunction) {
return admw_GpioIrqEnable(pCtx->hGpio, ePinId, callbackFunction,
- pCallbackParam);
- }
- else
- {
+ pCallbackParam);
+ } else {
return admw_GpioIrqDisable(pCtx->hGpio, ePinId);
}
}
@@ -271,7 +267,7 @@
* - #ADMW_SUCCESS Call completed successfully.
* - #ADMW_FAILURE If reseet faisl
*
- * @details Toggle reset pin of the ADMW device low for a
+ * @details Toggle reset pin of the ADMW device low for a
* minimum of 4 usec.
*
*/
@@ -327,8 +323,7 @@
pStatus->deviceStatus |= ADMW_DEVICE_STATUS_DATAREADY;
if (statusReg.FIFO_Error)
pStatus->deviceStatus |= ADMW_DEVICE_STATUS_FIFO_ERROR;
- if (statusReg.Alert_Active)
- {
+ if (statusReg.Alert_Active) {
pStatus->deviceStatus |= ADMW_DEVICE_STATUS_ALERT;
ADMW_CORE_Alert_Code_t alertCodeReg;
@@ -339,10 +334,8 @@
READ_REG_U16(hDevice, channelAlertStatusReg.VALUE16,
CORE_CHANNEL_ALERT_STATUS);
- for (unsigned i = 0; i < ADMW1001_MAX_CHANNELS; i++)
- {
- if (channelAlertStatusReg.VALUE16 & (1 << i))
- {
+ for (unsigned i = 0; i < ADMW1001_MAX_CHANNELS; i++) {
+ if (channelAlertStatusReg.VALUE16 & (1 << i)) {
ADMW_CORE_Alert_Code_Ch_t channelAlertCodeReg;
READ_REG_U16(hDevice, channelAlertCodeReg.VALUE16, CORE_ALERT_CODE_CHn(i));
pStatus->channelAlertCodes[i] = channelAlertCodeReg.Alert_Code_Ch;
@@ -386,8 +379,7 @@
pStatus->deviceStatus |= ADMW_DEVICE_STATUS_LUT_ERROR;
}
- if (statusReg.Error)
- {
+ if (statusReg.Error) {
pStatus->deviceStatus |= ADMW_DEVICE_STATUS_ERROR;
ADMW_CORE_Error_Code_t errorCodeReg;
@@ -405,8 +397,7 @@
pStatus->diagnosticsStatus |= ADMW_DIAGNOSTICS_STATUS_CALIBRATION_ERROR;
}
- if (statusReg.Alert_Active || statusReg.Error)
- {
+ if (statusReg.Alert_Active || statusReg.Error) {
ADMW_CORE_Debug_Code_t debugCodeReg;
READ_REG_U32(hDevice, debugCodeReg.VALUE32, CORE_DEBUG_CODE);
pStatus->debugCode = debugCodeReg.Debug_Code;
@@ -446,8 +437,7 @@
* 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 != ENUM_CORE_COMMAND_NOP)
- {
+ if (command != ENUM_CORE_COMMAND_NOP) {
eRet = admw_GetCommandRunningState(hDevice, &bCommandRunning);
if (eRet)
return eRet;
@@ -459,8 +449,7 @@
commandReg.Special_Command = command;
WRITE_REG_U8(hDevice, commandReg.VALUE8, CORE_COMMAND);
- if (bWaitForCompletion)
- {
+ if (bWaitForCompletion) {
do {
/* Allow a minimum 50usec delay for status update before checking */
admw_TimeDelayUsec(50);
@@ -506,16 +495,15 @@
ADMW_DEVICE_HANDLE const hDevice,
ADMW_MEASUREMENT_MODE const eMeasurementMode)
{
- switch (eMeasurementMode)
- {
- 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);
- default:
- ADMW_LOG_ERROR("Invalid measurement mode %d specified",
- eMeasurementMode);
- return ADMW_INVALID_PARAM;
+ switch (eMeasurementMode) {
+ 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);
+ default:
+ ADMW_LOG_ERROR("Invalid measurement mode %d specified",
+ eMeasurementMode);
+ return ADMW_INVALID_PARAM;
}
}
@@ -529,13 +517,12 @@
ADMW_DEVICE_HANDLE const hDevice,
ADMW_USER_CONFIG_SLOT const eSlotId)
{
- switch (eSlotId)
- {
+ switch (eSlotId) {
case ADMW_FLASH_CONFIG_1:
return executeCommand(hDevice, CORE_COMMAND_SAVE_CONFIG_1, true);
default:
ADMW_LOG_ERROR("Invalid user config target slot %d specified",
- eSlotId);
+ eSlotId);
return ADMW_INVALID_PARAM;
}
}
@@ -548,13 +535,12 @@
ADMW_DEVICE_HANDLE const hDevice,
ADMW_USER_CONFIG_SLOT const eSlotId)
{
- switch (eSlotId)
- {
+ switch (eSlotId) {
case ADMW_FLASH_CONFIG_1:
return executeCommand(hDevice, CORE_COMMAND_LOAD_CONFIG_1, true);
default:
ADMW_LOG_ERROR("Invalid user config source slot %d specified",
- eSlotId);
+ eSlotId);
return ADMW_INVALID_PARAM;
}
}
@@ -605,7 +591,7 @@
ADMW1001_Sensor_Result_t sensorResult;
ADMW_DEVICE_CONTEXT *pCtx = hDevice;
uint16_t command = ADMW1001_HOST_COMMS_READ_CMD |
- (REG_CORE_DATA_FIFO & ADMW1001_HOST_COMMS_ADR_MASK);
+ (REG_CORE_DATA_FIFO & ADMW1001_HOST_COMMS_ADR_MASK);
uint8_t commandData[2] = {
command >> 8,
command & 0xFF
@@ -616,9 +602,8 @@
do {
eRet = admw_SpiTransfer(pCtx->hSpi, commandData, commandResponse,
- sizeof(command), false);
- if (eRet)
- {
+ sizeof(command), false);
+ if (eRet) {
ADMW_LOG_ERROR("Failed to send read command for FIFO register");
return eRet;
}
@@ -626,8 +611,7 @@
} while ((commandResponse[0] != ADMW1001_HOST_COMMS_CMD_RESP_0) ||
(commandResponse[1] != ADMW1001_HOST_COMMS_CMD_RESP_1));
- for (unsigned i = 0; i < nRequested; i++)
- {
+ for (unsigned i = 0; i < nRequested; i++) {
bool bHoldCs = true;
/* Keep the CS signal asserted for all but the last sample */
@@ -637,15 +621,13 @@
getDataCnt++;
eRet = admw_SpiTransfer(pCtx->hSpi, NULL, &sensorResult,
- nBytesPerSample, bHoldCs);
- if (eRet)
- {
+ nBytesPerSample, bHoldCs);
+ if (eRet) {
ADMW_LOG_ERROR("Failed to read data from FIFO register");
return eRet;
}
- if (! sensorResult.Ch_Valid)
- {
+ if (! sensorResult.Ch_Valid) {
/*
* Reading an invalid sample indicates that there are no
* more samples available or we've lost sync with the device.
@@ -705,7 +687,7 @@
ADMW_RESULT eRet;
ADMW_DEVICE_CONTEXT *pCtx = hDevice;
uint16_t command = ADMW1001_HOST_COMMS_WRITE_CMD |
- (nAddress & ADMW1001_HOST_COMMS_ADR_MASK);
+ (nAddress & ADMW1001_HOST_COMMS_ADR_MASK);
uint8_t commandData[2] = {
command >> 8,
command & 0xFF
@@ -714,11 +696,10 @@
do {
eRet = admw_SpiTransfer(pCtx->hSpi, commandData, commandResponse,
- sizeof(command), false);
- if (eRet)
- {
+ sizeof(command), false);
+ if (eRet) {
ADMW_LOG_ERROR("Failed to send write command for register %u",
- nAddress);
+ nAddress);
return eRet;
}
@@ -727,10 +708,9 @@
(commandResponse[1] != ADMW1001_HOST_COMMS_CMD_RESP_1));
eRet = admw_SpiTransfer(pCtx->hSpi, pData, NULL, nLength, false);
- if (eRet)
- {
+ if (eRet) {
ADMW_LOG_ERROR("Failed to write data (%dB) to register %u",
- nLength, nAddress);
+ nLength, nAddress);
return eRet;
}
@@ -748,7 +728,7 @@
ADMW_RESULT eRet;
ADMW_DEVICE_CONTEXT *pCtx = hDevice;
uint16_t command = ADMW1001_HOST_COMMS_DEBUG_WRITE_CMD |
- (nAddress & ADMW1001_HOST_COMMS_ADR_MASK);
+ (nAddress & ADMW1001_HOST_COMMS_ADR_MASK);
uint8_t commandData[2] = {
command >> 8,
command & 0xFF
@@ -757,11 +737,10 @@
do {
eRet = admw_SpiTransfer(pCtx->hSpi, commandData, commandResponse,
- sizeof(command), false);
- if (eRet)
- {
+ sizeof(command), false);
+ if (eRet) {
ADMW_LOG_ERROR("Failed to send write command for register %u",
- nAddress);
+ nAddress);
return eRet;
}
@@ -770,10 +749,9 @@
(commandResponse[1] != ADMW1001_HOST_COMMS_CMD_RESP_1));
eRet = admw_SpiTransfer(pCtx->hSpi, pData, NULL, nLength, false);
- if (eRet)
- {
+ if (eRet) {
ADMW_LOG_ERROR("Failed to write data (%dB) to register %u",
- nLength, nAddress);
+ nLength, nAddress);
return eRet;
}
@@ -790,7 +768,7 @@
ADMW_RESULT eRet;
ADMW_DEVICE_CONTEXT *pCtx = hDevice;
uint16_t command = ADMW1001_HOST_COMMS_READ_CMD |
- (nAddress & ADMW1001_HOST_COMMS_ADR_MASK);
+ (nAddress & ADMW1001_HOST_COMMS_ADR_MASK);
uint8_t commandData[2] = {
command >> 8,
command & 0xFF
@@ -799,11 +777,10 @@
do {
eRet = admw_SpiTransfer(pCtx->hSpi, commandData, commandResponse,
- sizeof(command), false);
- if (eRet)
- {
+ sizeof(command), false);
+ if (eRet) {
ADMW_LOG_ERROR("Failed to send read command for register %u",
- nAddress);
+ nAddress);
return eRet;
}
@@ -812,10 +789,9 @@
(commandResponse[1] != ADMW1001_HOST_COMMS_CMD_RESP_1));
eRet = admw_SpiTransfer(pCtx->hSpi, NULL, pData, nLength, false);
- if (eRet)
- {
+ if (eRet) {
ADMW_LOG_ERROR("Failed to read data (%uB) from register %u",
- nLength, nAddress);
+ nLength, nAddress);
return eRet;
}
@@ -833,7 +809,7 @@
ADMW_RESULT eRet;
ADMW_DEVICE_CONTEXT *pCtx = hDevice;
uint16_t command = ADMW1001_HOST_COMMS_DEBUG_READ_CMD |
- (nAddress & ADMW1001_HOST_COMMS_ADR_MASK);
+ (nAddress & ADMW1001_HOST_COMMS_ADR_MASK);
uint8_t commandData[2] = {
command >> 8,
command & 0xFF
@@ -842,11 +818,10 @@
do {
eRet = admw_SpiTransfer(pCtx->hSpi, commandData, commandResponse,
- sizeof(command), false);
- if (eRet)
- {
+ sizeof(command), false);
+ if (eRet) {
ADMW_LOG_ERROR("Failed to send read command for register %u",
- nAddress);
+ nAddress);
return eRet;
}
@@ -855,10 +830,9 @@
(commandResponse[1] != ADMW1001_HOST_COMMS_CMD_RESP_1));
eRet = admw_SpiTransfer(pCtx->hSpi, NULL, pData, nLength, false);
- if (eRet)
- {
+ if (eRet) {
ADMW_LOG_ERROR("Failed to read data (%uB) from register %u",
- nLength, nAddress);
+ nLength, nAddress);
return eRet;
}
@@ -899,85 +873,71 @@
else
*peOperatingMode = ADMW1001_OPERATING_MODE_CONTINUOUS;
- if (eMeasurementMode == ADMW_MEASUREMENT_MODE_OMIT_RAW)
- {
+ if (eMeasurementMode == ADMW_MEASUREMENT_MODE_OMIT_RAW) {
*pnBytesPerSample = 5;
- }
- else
- {
+ } else {
*pnBytesPerSample = 8;
}
-
+
for (ADMW1001_CH_ID chId = ADMW1001_CH_ID_ANLG_1_UNIVERSAL;
- chId < ADMW1001_MAX_CHANNELS;
- chId++)
- {
+ chId < ADMW1001_MAX_CHANNELS;
+ chId++) {
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)
- {
+
+ if (channelCountReg.Channel_Enable && !sensorDetailsReg.Do_Not_Publish) {
ADMW_CORE_Sensor_Type_t sensorTypeReg;
unsigned nActualChannels = 1;
-
+
READ_REG_U16(hDevice, sensorTypeReg.VALUE16, CORE_SENSOR_TYPEn(chId));
-
- 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 (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 ((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;
}
}
-
+
nChannelsEnabled += nActualChannels;
-
+
nSamplesPerCycle += nActualChannels *
(channelCountReg.Channel_Count + 1);
}
}
-
- if (nChannelsEnabled == 0)
- {
+
+ if (nChannelsEnabled == 0) {
*pnSamplesPerDataready = 0;
*pnSamplesPerCycle = 0;
return ADMW_SUCCESS;
}
-
+
*pnSamplesPerCycle = nSamplesPerCycle;
-
- if (modeReg.Drdy_Mode == CORE_MODE_DRDY_PER_CONVERSION)
- {
+
+ if (modeReg.Drdy_Mode == CORE_MODE_DRDY_PER_CONVERSION) {
*pnSamplesPerDataready = 1;
- }
- else
- {
+ } else {
*pnSamplesPerDataready = nSamplesPerCycle;
}
-
- if (modeReg.Drdy_Mode == CORE_MODE_DRDY_PER_CONVERSION)
- {
+
+ if (modeReg.Drdy_Mode == CORE_MODE_DRDY_PER_CONVERSION) {
*peDataReadyMode = ADMW1001_DATAREADY_PER_CONVERSION;
- }
- else
- {
+ } else {
*peDataReadyMode = ADMW1001_DATAREADY_PER_CYCLE;
}
-
+
return ADMW_SUCCESS;
}
@@ -991,7 +951,7 @@
READ_REG_U8(hDevice, productIdLoReg.VALUE8, SPI_PRODUCT_ID_L);
READ_REG_U8(hDevice, productIdHiReg.VALUE8, SPI_PRODUCT_ID_H);
- *pProductId = (ADMW_PRODUCT_ID)((productIdHiReg.VALUE8 << 8) |
+ *pProductId = (ADMW_PRODUCT_ID)((productIdHiReg.VALUE8 << 8) |
productIdLoReg.VALUE8);
return ADMW_SUCCESS;
}
@@ -1002,16 +962,11 @@
{
ADMW_CORE_Power_Config_t powerConfigReg;
- if (powerMode == ADMW1001_POWER_MODE_HIBERNATION)
- {
+ if (powerMode == ADMW1001_POWER_MODE_HIBERNATION) {
powerConfigReg.Power_Mode_MCU = CORE_POWER_CONFIG_HIBERNATION;
- }
- else if (powerMode == ADMW1001_POWER_MODE_ACTIVE)
- {
+ } else if (powerMode == ADMW1001_POWER_MODE_ACTIVE) {
powerConfigReg.Power_Mode_MCU = CORE_POWER_CONFIG_ACTIVE_MODE;
- }
- else
- {
+ } else {
ADMW_LOG_ERROR("Invalid power mode %d specified", powerMode);
return ADMW_INVALID_PARAM;
}
@@ -1028,8 +983,7 @@
ADMW_RESULT eRet;
eRet = admw_SetPowerMode(hDevice, pPowerConfig->powerMode);
- if (eRet != ADMW_SUCCESS)
- {
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set power mode");
return eRet;
}
@@ -1046,31 +1000,21 @@
modeReg.VALUE8 = REG_RESET_VAL(CORE_MODE);
- if (eOperatingMode == ADMW1001_OPERATING_MODE_SINGLECYCLE)
- {
+ if (eOperatingMode == ADMW1001_OPERATING_MODE_SINGLECYCLE) {
modeReg.Conversion_Mode = CORE_MODE_SINGLECYCLE;
- }
- else if (eOperatingMode == ADMW1001_OPERATING_MODE_CONTINUOUS)
- {
+ } else if (eOperatingMode == ADMW1001_OPERATING_MODE_CONTINUOUS) {
modeReg.Conversion_Mode = CORE_MODE_CONTINUOUS;
- }
- else
- {
+ } else {
ADMW_LOG_ERROR("Invalid operating mode %d specified",
- eOperatingMode);
+ eOperatingMode);
return ADMW_INVALID_PARAM;
}
- if (eDataReadyMode == ADMW1001_DATAREADY_PER_CONVERSION)
- {
+ if (eDataReadyMode == ADMW1001_DATAREADY_PER_CONVERSION) {
modeReg.Drdy_Mode = CORE_MODE_DRDY_PER_CONVERSION;
- }
- else if (eDataReadyMode == ADMW1001_DATAREADY_PER_CYCLE)
- {
+ } else if (eDataReadyMode == ADMW1001_DATAREADY_PER_CYCLE) {
modeReg.Drdy_Mode = CORE_MODE_DRDY_PER_CYCLE;
- }
- else
- {
+ } else {
ADMW_LOG_ERROR("Invalid data-ready mode %d specified", eDataReadyMode);
return ADMW_INVALID_PARAM;
}
@@ -1088,19 +1032,15 @@
cycleControlReg.VALUE16 = REG_RESET_VAL(CORE_CYCLE_CONTROL);
- if (nCycleInterval < (1000 * (1 << 12)))
- {
+ if (nCycleInterval < (1000 * (1 << 12))) {
cycleControlReg.Cycle_Time_Units = CORE_CYCLE_CONTROL_MILLISECONDS;
nCycleInterval /= 1000;
- }
- else
- {
+ } else {
cycleControlReg.Cycle_Time_Units = CORE_CYCLE_CONTROL_SECONDS;
nCycleInterval /= 1000000;
}
- if (vBiasEnable == true)
- {
+ if (vBiasEnable == true) {
cycleControlReg.Vbias = 1;
}
CHECK_REG_FIELD_VAL(CORE_CYCLE_CONTROL_CYCLE_TIME, nCycleInterval);
@@ -1129,28 +1069,24 @@
eRet = admw_SetMode(hDevice,
pMeasConfig->operatingMode,
pMeasConfig->dataReadyMode);
- if (eRet != ADMW_SUCCESS)
- {
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set operating mode");
return eRet;
}
eRet = admw_SetCycleControl(hDevice, pMeasConfig->cycleInterval,
pMeasConfig->vBiasEnable);
- if (eRet != ADMW_SUCCESS)
- {
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set cycle control");
return eRet;
}
- if(pMeasConfig->externalRef1Value>0)
- {
+ if(pMeasConfig->externalRef1Value>0) {
eRet = admw_SetExternalReferenceValues(hDevice,
pMeasConfig->externalRef1Value);
}
- if (eRet != ADMW_SUCCESS)
- {
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set external reference values");
return eRet;
}
@@ -1176,24 +1112,23 @@
else
diagnosticsControlReg.Diag_Meas_En = 1;
- switch (pDiagnosticsConfig->osdFrequency)
- {
- 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_100_CYCLES;
- break;
- case ADMW1001_OPEN_SENSOR_DIAGNOSTICS_PER_1000_CYCLES:
- diagnosticsControlReg.Diag_OSD_Freq = CORE_DIAGNOSTICS_CONTROL_OCD_PER_1000_CYCLES;
- break;
- default:
- ADMW_LOG_ERROR("Invalid open-sensor diagnostic frequency %d specified",
- pDiagnosticsConfig->osdFrequency);
- return ADMW_INVALID_PARAM;
+ switch (pDiagnosticsConfig->osdFrequency) {
+ 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_100_CYCLES;
+ break;
+ case ADMW1001_OPEN_SENSOR_DIAGNOSTICS_PER_1000_CYCLES:
+ diagnosticsControlReg.Diag_OSD_Freq = CORE_DIAGNOSTICS_CONTROL_OCD_PER_1000_CYCLES;
+ break;
+ default:
+ ADMW_LOG_ERROR("Invalid open-sensor diagnostic frequency %d specified",
+ pDiagnosticsConfig->osdFrequency);
+ return ADMW_INVALID_PARAM;
}
WRITE_REG_U16(hDevice, diagnosticsControlReg.VALUE16, CORE_DIAGNOSTICS_CONTROL);
@@ -1210,8 +1145,7 @@
channelCountReg.VALUE8 = REG_RESET_VAL(CORE_CHANNEL_COUNTn);
- if (nMeasurementsPerCycle > 0)
- {
+ if (nMeasurementsPerCycle > 0) {
nMeasurementsPerCycle -= 1;
CHECK_REG_FIELD_VAL(CORE_CHANNEL_COUNT_CHANNEL_COUNT,
@@ -1219,9 +1153,7 @@
channelCountReg.Channel_Enable = 1;
channelCountReg.Channel_Count = nMeasurementsPerCycle;
- }
- else
- {
+ } else {
channelCountReg.Channel_Enable = 0;
}
@@ -1275,8 +1207,7 @@
sensorTypeReg.VALUE16 = REG_RESET_VAL(CORE_SENSOR_TYPEn);
/* Ensure that the sensor type is valid for this channel */
- switch(sensorType)
- {
+ switch(sensorType) {
case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT100:
case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT1000:
case ADMW1001_ADC_SENSOR_RTD_3WIRE_1:
@@ -1314,8 +1245,7 @@
case ADMW1001_ADC_SENSOR_THERMISTOR_3:
case ADMW1001_ADC_SENSOR_THERMISTOR_4:
if (! (ADMW1001_CHANNEL_IS_ADC_SENSOR(eChannelId) ||
- ADMW1001_CHANNEL_IS_ADC_CJC(eChannelId)))
- {
+ ADMW1001_CHANNEL_IS_ADC_CJC(eChannelId))) {
ADMW_LOG_ERROR(
"Invalid ADC sensor type %d specified for channel %d",
sensorType, eChannelId);
@@ -1334,8 +1264,7 @@
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))
- {
+ if (! ADMW1001_CHANNEL_IS_ADC_VOLTAGE(eChannelId)) {
ADMW_LOG_ERROR(
"Invalid ADC sensor type %d specified for channel %d",
sensorType, eChannelId);
@@ -1346,8 +1275,7 @@
case ADMW1001_ADC_SENSOR_CURRENT_PRESSURE_A:
case ADMW1001_ADC_SENSOR_CURRENT_PRESSURE_1:
case ADMW1001_ADC_SENSOR_CURRENT_PRESSURE_2:
- if (! ADMW1001_CHANNEL_IS_ADC_CURRENT(eChannelId))
- {
+ if (! ADMW1001_CHANNEL_IS_ADC_CURRENT(eChannelId)) {
ADMW_LOG_ERROR(
"Invalid ADC sensor type %d specified for channel %d",
sensorType, eChannelId);
@@ -1356,7 +1284,7 @@
break;
default:
ADMW_LOG_ERROR("Invalid/unsupported ADC sensor type %d specified",
- sensorType);
+ sensorType);
return ADMW_INVALID_PARAM;
}
@@ -1389,8 +1317,7 @@
sensorDetailsReg.VALUE32 = REG_RESET_VAL(CORE_SENSOR_DETAILSn);
- switch(pChannelConfig->measurementUnit)
- {
+ switch(pChannelConfig->measurementUnit) {
case ADMW1001_MEASUREMENT_UNIT_FAHRENHEIT:
sensorDetailsReg.Measurement_Units = CORE_SENSOR_DETAILS_UNITS_DEGF;
break;
@@ -1406,19 +1333,15 @@
return ADMW_INVALID_PARAM;
}
- if (pChannelConfig->compensationChannel == ADMW1001_CH_ID_NONE)
- {
+ if (pChannelConfig->compensationChannel == ADMW1001_CH_ID_NONE) {
sensorDetailsReg.Compensation_Disable = 1;
sensorDetailsReg.Compensation_Channel = 0;
- }
- else
- {
+ } else {
sensorDetailsReg.Compensation_Disable = 0;
sensorDetailsReg.Compensation_Channel = pChannelConfig->compensationChannel;
}
- switch(refType)
- {
+ switch(refType) {
case ADMW1001_ADC_REFERENCE_VOLTAGE_INTERNAL:
sensorDetailsReg.Reference_Select = CORE_SENSOR_DETAILS_REF_VINT;
break;
@@ -1432,9 +1355,8 @@
ADMW_LOG_ERROR("Invalid ADC reference type %d specified", refType);
return ADMW_INVALID_PARAM;
}
-
- switch(pAdcChannelConfig->gain)
- {
+
+ switch(pAdcChannelConfig->gain) {
case ADMW1001_ADC_GAIN_1X:
sensorDetailsReg.PGA_Gain = CORE_SENSOR_DETAILS_PGA_GAIN_1;
break;
@@ -1461,12 +1383,11 @@
break;
default:
ADMW_LOG_ERROR("Invalid ADC gain %d specified",
- pAdcChannelConfig->gain);
+ pAdcChannelConfig->gain);
return ADMW_INVALID_PARAM;
}
- switch(pAdcChannelConfig->rtdCurve)
- {
+ switch(pAdcChannelConfig->rtdCurve) {
case ADMW1001_ADC_RTD_CURVE_EUROPEAN:
sensorDetailsReg.RTD_Curve = CORE_SENSOR_DETAILS_EUROPEAN_CURVE;
break;
@@ -1481,21 +1402,17 @@
break;
default:
ADMW_LOG_ERROR("Invalid RTD Curve %d specified",
- pAdcChannelConfig->rtdCurve);
+ pAdcChannelConfig->rtdCurve);
return ADMW_INVALID_PARAM;
}
- if (pChannelConfig->disablePublishing)
- {
+ if (pChannelConfig->disablePublishing) {
sensorDetailsReg.Do_Not_Publish = 1;
- }
- else
- {
+ } else {
sensorDetailsReg.Do_Not_Publish = 0;
}
-
- switch (pChannelConfig->lutSelect)
- {
+
+ switch (pChannelConfig->lutSelect) {
case ADMW1001_LUT_DEFAULT:
case ADMW1001_LUT_UNITY:
case ADMW1001_LUT_CUSTOM:
@@ -1503,10 +1420,10 @@
break;
default:
ADMW_LOG_ERROR("Invalid LUT selection %d specified",
- pChannelConfig->lutSelect);
- return ADMW_INVALID_PARAM;
+ pChannelConfig->lutSelect);
+ return ADMW_INVALID_PARAM;
}
-
+
WRITE_REG_U32(hDevice, sensorDetailsReg.VALUE32, CORE_SENSOR_DETAILSn(eChannelId));
return ADMW_SUCCESS;
@@ -1520,45 +1437,39 @@
ADMW_CORE_Measurement_Setup_t MeasSetupReg;
MeasSetupReg.VALUE32 = REG_RESET_VAL(CORE_MEASUREMENT_SETUPn);
- if (pFilterConfig->type == ADMW1001_ADC_FILTER_SINC4)
- {
+ if (pFilterConfig->type == ADMW1001_ADC_FILTER_SINC4) {
MeasSetupReg.ADC_Filter_Type = CORE_MEASUREMENT_SETUP_ENABLE_SINC4;
MeasSetupReg.ADC_SF = pFilterConfig->sf;
- }
- else if (pFilterConfig->type == ADMW1001_ADC_FILTER_SINC3)
- {
+ } else if (pFilterConfig->type == ADMW1001_ADC_FILTER_SINC3) {
MeasSetupReg.ADC_Filter_Type = CORE_MEASUREMENT_SETUP_ENABLE_SINC3;
- MeasSetupReg.ADC_SF = pFilterConfig->sf;
- }
- else
- {
+ MeasSetupReg.ADC_SF = pFilterConfig->sf;
+ } else {
ADMW_LOG_ERROR("Invalid ADC filter type %d specified",
- pFilterConfig->type);
+ pFilterConfig->type);
return ADMW_INVALID_PARAM;
}
-
+
/* chop mod ecan be 0 (none), 1 (HW, 2 (SW, 3 (HW+SW). */
MeasSetupReg.Chop_Mode = pFilterConfig->chopMode;
-
+
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;
+
+ 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;
@@ -1587,44 +1498,43 @@
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
- {
+ else {
ADMW_LOG_ERROR("Invalid ADC excitation current %d specified",
pCurrentConfig->outputLevel);
return ADMW_INVALID_PARAM;
}
-
+
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;
+ 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;
}
WRITE_REG_U16(hDevice, channelExcitationReg.VALUE16, CORE_CHANNEL_EXCITATIONn(eChannelId));
@@ -1642,38 +1552,34 @@
&pChannelConfig->adcChannelConfig;
eRet = admw_SetChannelAdcSensorType(hDevice, eChannelId,
- pAdcChannelConfig->sensor);
- if (eRet != ADMW_SUCCESS)
- {
+ pAdcChannelConfig->sensor);
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set ADC sensor type for channel %d",
- eChannelId);
+ eChannelId);
return eRet;
}
eRet = admw_SetChannelAdcSensorDetails(hDevice, eChannelId,
- pChannelConfig);
- if (eRet != ADMW_SUCCESS)
- {
+ pChannelConfig);
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set ADC sensor details for channel %d",
- eChannelId);
+ eChannelId);
return eRet;
}
eRet = admw_SetChannelAdcFilter(hDevice, eChannelId,
- &pAdcChannelConfig->filter);
- if (eRet != ADMW_SUCCESS)
- {
+ &pAdcChannelConfig->filter);
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set ADC filter for channel %d",
- eChannelId);
+ eChannelId);
return eRet;
}
eRet = admw_SetChannelAdcCurrentConfig(hDevice, eChannelId,
- &pAdcChannelConfig->current);
- if (eRet != ADMW_SUCCESS)
- {
+ &pAdcChannelConfig->current);
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set ADC current for channel %d",
- eChannelId);
+ eChannelId);
return eRet;
}
@@ -1689,23 +1595,17 @@
sensorDetailsReg.VALUE32 = REG_RESET_VAL(CORE_SENSOR_DETAILSn);
- if (pChannelConfig->compensationChannel == ADMW1001_CH_ID_NONE)
- {
+ if (pChannelConfig->compensationChannel == ADMW1001_CH_ID_NONE) {
sensorDetailsReg.Compensation_Disable = 1;
sensorDetailsReg.Compensation_Channel = 0;
- }
- else
- {
+ } else {
ADMW_LOG_ERROR("Invalid compensation channel specified for digital sensor");
return ADMW_INVALID_PARAM;
}
- if (pChannelConfig->measurementUnit == ADMW1001_MEASUREMENT_UNIT_UNSPECIFIED)
- {
+ if (pChannelConfig->measurementUnit == ADMW1001_MEASUREMENT_UNIT_UNSPECIFIED) {
sensorDetailsReg.Measurement_Units = CORE_SENSOR_DETAILS_UNITS_UNSPECIFIED;
- }
- else
- {
+ } else {
ADMW_LOG_ERROR("Invalid measurement unit specified for digital channel");
return ADMW_INVALID_PARAM;
}
@@ -1745,8 +1645,7 @@
* NOTE - the fall-through cases in the switch statement below are
* intentional.
*/
- switch (pConfigCommand->commandLength)
- {
+ switch (pConfigCommand->commandLength) {
case 7:
WRITE_REG_U8(hDevice, pConfigCommand->command[6],
CORE_DIGITAL_SENSOR_COMMAND7n(eChannelId));
@@ -1773,8 +1672,7 @@
break;
};
- switch (pDataRequestCommand->commandLength)
- {
+ switch (pDataRequestCommand->commandLength) {
case 7:
WRITE_REG_U8(hDevice, pDataRequestCommand->command[6],
CORE_DIGITAL_SENSOR_READ_CMD7n(eChannelId));
@@ -1813,15 +1711,12 @@
sensorConfigReg.VALUE16 = REG_RESET_VAL(CORE_DIGITAL_SENSOR_CONFIGn);
- if (pDataFormat->coding != ADMW1001_DIGITAL_SENSOR_DATA_CODING_NONE)
- {
- if (pDataFormat->frameLength == 0)
- {
+ if (pDataFormat->coding != ADMW1001_DIGITAL_SENSOR_DATA_CODING_NONE) {
+ if (pDataFormat->frameLength == 0) {
ADMW_LOG_ERROR("Invalid frame length specified for digital sensor data format");
return ADMW_INVALID_PARAM;
}
- if (pDataFormat->numDataBits == 0)
- {
+ if (pDataFormat->numDataBits == 0) {
ADMW_LOG_ERROR("Invalid frame length specified for digital sensor data format");
return ADMW_INVALID_PARAM;
}
@@ -1839,24 +1734,21 @@
sensorConfigReg.Digital_Sensor_Left_Aligned = pDataFormat->leftJustified ? 1 : 0;
sensorConfigReg.Digital_Sensor_Little_Endian = pDataFormat->littleEndian ? 1 : 0;
- switch (pDataFormat->coding)
- {
- case ADMW1001_DIGITAL_SENSOR_DATA_CODING_UNIPOLAR:
- sensorConfigReg.Digital_Sensor_Coding = CORE_DIGITAL_SENSOR_CONFIG_CODING_UNIPOLAR;
- break;
- case ADMW1001_DIGITAL_SENSOR_DATA_CODING_TWOS_COMPLEMENT:
- sensorConfigReg.Digital_Sensor_Coding = CORE_DIGITAL_SENSOR_CONFIG_CODING_TWOS_COMPL;
- break;
- case ADMW1001_DIGITAL_SENSOR_DATA_CODING_OFFSET_BINARY:
- sensorConfigReg.Digital_Sensor_Coding = CORE_DIGITAL_SENSOR_CONFIG_CODING_OFFSET_BINARY;
- break;
- default:
- ADMW_LOG_ERROR("Invalid coding specified for digital sensor data format");
- return ADMW_INVALID_PARAM;
+ switch (pDataFormat->coding) {
+ case ADMW1001_DIGITAL_SENSOR_DATA_CODING_UNIPOLAR:
+ sensorConfigReg.Digital_Sensor_Coding = CORE_DIGITAL_SENSOR_CONFIG_CODING_UNIPOLAR;
+ break;
+ case ADMW1001_DIGITAL_SENSOR_DATA_CODING_TWOS_COMPLEMENT:
+ sensorConfigReg.Digital_Sensor_Coding = CORE_DIGITAL_SENSOR_CONFIG_CODING_TWOS_COMPL;
+ break;
+ case ADMW1001_DIGITAL_SENSOR_DATA_CODING_OFFSET_BINARY:
+ sensorConfigReg.Digital_Sensor_Coding = CORE_DIGITAL_SENSOR_CONFIG_CODING_OFFSET_BINARY;
+ break;
+ default:
+ ADMW_LOG_ERROR("Invalid coding specified for digital sensor data format");
+ return ADMW_INVALID_PARAM;
}
- }
- else
- {
+ } else {
sensorConfigReg.Digital_Sensor_Coding = CORE_DIGITAL_SENSOR_CONFIG_CODING_NONE;
}
@@ -1868,9 +1760,9 @@
}
static ADMW_RESULT admw_SetDigitalCalibrationParam(
- ADMW_DEVICE_HANDLE hDevice,
- ADMW1001_CH_ID eChannelId,
- ADMW1001_DIGITAL_CALIBRATION_COMMAND *pCalibrationParam)
+ ADMW_DEVICE_HANDLE hDevice,
+ ADMW1001_CH_ID eChannelId,
+ ADMW1001_DIGITAL_CALIBRATION_COMMAND *pCalibrationParam)
{
ADMW_CORE_Calibration_Parameter_t calibrationParamReg;
@@ -1882,7 +1774,7 @@
calibrationParamReg.Calibration_Parameter_Enable = 1;
CHECK_REG_FIELD_VAL(CORE_CALIBRATION_PARAMETER_CALIBRATION_PARAMETER,
- pCalibrationParam->calibrationParam);
+ pCalibrationParam->calibrationParam);
calibrationParamReg.Calibration_Parameter = pCalibrationParam->calibrationParam;
@@ -1902,8 +1794,7 @@
sensorTypeReg.VALUE16 = REG_RESET_VAL(CORE_SENSOR_TYPEn);
/* Ensure that the sensor type is valid for this channel */
- switch(sensorType)
- {
+ switch(sensorType) {
case ADMW1001_I2C_SENSOR_HUMIDITY_A:
case ADMW1001_I2C_SENSOR_HUMIDITY_B:
sensorTypeReg.Sensor_Type = sensorType;
@@ -1938,106 +1829,88 @@
digitalSensorComms.VALUE16 = REG_RESET_VAL(CORE_DIGITAL_SENSOR_COMMSn);
- if(pDigitalComms->useCustomCommsConfig)
- {
+ if(pDigitalComms->useCustomCommsConfig) {
digitalSensorComms.Digital_Sensor_Comms_En = 1;
- if(pDigitalComms->i2cClockSpeed == ADMW1001_DIGITAL_SENSOR_COMMS_I2C_CLOCK_SPEED_100K)
- {
+ if(pDigitalComms->i2cClockSpeed == ADMW1001_DIGITAL_SENSOR_COMMS_I2C_CLOCK_SPEED_100K) {
digitalSensorComms.I2C_Clock = CORE_DIGITAL_SENSOR_COMMS_I2C_100K;
- }
- else if(pDigitalComms->i2cClockSpeed == ADMW1001_DIGITAL_SENSOR_COMMS_I2C_CLOCK_SPEED_400K)
- {
+ } else if(pDigitalComms->i2cClockSpeed == ADMW1001_DIGITAL_SENSOR_COMMS_I2C_CLOCK_SPEED_400K) {
digitalSensorComms.I2C_Clock = CORE_DIGITAL_SENSOR_COMMS_I2C_400K;
- }
- else
- {
+ } else {
ADMW_LOG_ERROR("Invalid I2C clock speed %d specified",
- pDigitalComms->i2cClockSpeed);
+ pDigitalComms->i2cClockSpeed);
return ADMW_INVALID_PARAM;
}
- if(pDigitalComms->spiMode == ADMW1001_DIGITAL_SENSOR_COMMS_SPI_MODE_0)
- {
+ 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)
- {
+ } 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)
- {
+ } 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)
- {
+ } else if(pDigitalComms->spiMode == ADMW1001_DIGITAL_SENSOR_COMMS_SPI_MODE_3) {
digitalSensorComms.SPI_Mode = CORE_DIGITAL_SENSOR_COMMS_SPI_MODE_3;
- }
- else
- {
+ } else {
ADMW_LOG_ERROR("Invalid SPI mode %d specified",
- pDigitalComms->spiMode);
+ 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;
+ 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;
}
- }
- else
- {
+ } else {
digitalSensorComms.Digital_Sensor_Comms_En = 0;
}
@@ -2056,66 +1929,59 @@
&pChannelConfig->i2cChannelConfig;
eRet = admw_SetChannelI2cSensorType(hDevice, eChannelId,
- pI2cChannelConfig->sensor);
- if (eRet != ADMW_SUCCESS)
- {
+ pI2cChannelConfig->sensor);
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set I2C sensor type for channel %d",
- eChannelId);
+ eChannelId);
return eRet;
}
eRet = admw_SetChannelI2cSensorAddress(hDevice, eChannelId,
- pI2cChannelConfig->deviceAddress);
- if (eRet != ADMW_SUCCESS)
- {
+ pI2cChannelConfig->deviceAddress);
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set I2C sensor address for channel %d",
- eChannelId);
+ eChannelId);
return eRet;
}
eRet = admw_SetChannelDigitalSensorDetails(hDevice, eChannelId,
- pChannelConfig);
- if (eRet != ADMW_SUCCESS)
- {
+ pChannelConfig);
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set I2C sensor details for channel %d",
- eChannelId);
+ eChannelId);
return eRet;
}
eRet = admw_SetDigitalSensorCommands(hDevice, eChannelId,
- &pI2cChannelConfig->configurationCommand,
- &pI2cChannelConfig->dataRequestCommand);
- if (eRet != ADMW_SUCCESS)
- {
+ &pI2cChannelConfig->configurationCommand,
+ &pI2cChannelConfig->dataRequestCommand);
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set I2C sensor commands for channel %d",
- eChannelId);
+ eChannelId);
return eRet;
}
eRet = admw_SetDigitalSensorFormat(hDevice, eChannelId,
- &pI2cChannelConfig->dataFormat);
- if (eRet != ADMW_SUCCESS)
- {
+ &pI2cChannelConfig->dataFormat);
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set I2C sensor data format for channel %d",
- eChannelId);
+ eChannelId);
return eRet;
}
eRet = admw_SetDigitalCalibrationParam(hDevice, eChannelId,
- &pI2cChannelConfig->digitalCalibrationParam);
- if (eRet != ADMW_SUCCESS)
- {
+ &pI2cChannelConfig->digitalCalibrationParam);
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set I2C digital calibration param for channel %d",
- eChannelId);
+ eChannelId);
return eRet;
}
eRet = admw_SetDigitalChannelComms(hDevice, eChannelId,
- &pI2cChannelConfig->configureComms);
- if (eRet != ADMW_SUCCESS)
- {
+ &pI2cChannelConfig->configureComms);
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set I2C comms for channel %d",
- eChannelId);
+ eChannelId);
return eRet;
}
@@ -2132,17 +1998,16 @@
sensorTypeReg.VALUE16 = REG_RESET_VAL(CORE_SENSOR_TYPEn);
/* Ensure that the sensor type is valid for this channel */
- switch(sensorType)
- {
- case ADMW1001_SPI_SENSOR_PRESSURE_A:
- case ADMW1001_SPI_SENSOR_ACCELEROMETER_A:
- case ADMW1001_SPI_SENSOR_ACCELEROMETER_B:
-
- sensorTypeReg.Sensor_Type = sensorType;
- break;
- default:
- ADMW_LOG_ERROR("Unsupported SPI sensor type %d specified", sensorType);
- return ADMW_INVALID_PARAM;
+ switch(sensorType) {
+ case ADMW1001_SPI_SENSOR_PRESSURE_A:
+ case ADMW1001_SPI_SENSOR_ACCELEROMETER_A:
+ case ADMW1001_SPI_SENSOR_ACCELEROMETER_B:
+
+ sensorTypeReg.Sensor_Type = sensorType;
+ break;
+ default:
+ ADMW_LOG_ERROR("Unsupported SPI sensor type %d specified", sensorType);
+ return ADMW_INVALID_PARAM;
}
WRITE_REG_U16(hDevice, sensorTypeReg.VALUE16, CORE_SENSOR_TYPEn(eChannelId));
@@ -2160,57 +2025,51 @@
&pChannelConfig->spiChannelConfig;
eRet = admw_SetChannelSpiSensorType(hDevice, eChannelId,
- pSpiChannelConfig->sensor);
- if (eRet != ADMW_SUCCESS)
- {
+ pSpiChannelConfig->sensor);
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set SPI sensor type for channel %d",
- eChannelId);
+ eChannelId);
return eRet;
}
eRet = admw_SetChannelDigitalSensorDetails(hDevice, eChannelId,
- pChannelConfig);
- if (eRet != ADMW_SUCCESS)
- {
+ pChannelConfig);
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set SPI sensor details for channel %d",
- eChannelId);
+ eChannelId);
return eRet;
}
eRet = admw_SetDigitalSensorCommands(hDevice, eChannelId,
- &pSpiChannelConfig->configurationCommand,
- &pSpiChannelConfig->dataRequestCommand);
- if (eRet != ADMW_SUCCESS)
- {
+ &pSpiChannelConfig->configurationCommand,
+ &pSpiChannelConfig->dataRequestCommand);
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set SPI sensor commands for channel %d",
- eChannelId);
+ eChannelId);
return eRet;
}
eRet = admw_SetDigitalSensorFormat(hDevice, eChannelId,
- &pSpiChannelConfig->dataFormat);
- if (eRet != ADMW_SUCCESS)
- {
+ &pSpiChannelConfig->dataFormat);
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set SPI sensor data format for channel %d",
- eChannelId);
+ eChannelId);
return eRet;
}
eRet = admw_SetDigitalCalibrationParam(hDevice, eChannelId,
- &pSpiChannelConfig->digitalCalibrationParam);
- if (eRet != ADMW_SUCCESS)
- {
+ &pSpiChannelConfig->digitalCalibrationParam);
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set SPI digital calibration param for channel %d",
- eChannelId);
+ eChannelId);
return eRet;
}
eRet = admw_SetDigitalChannelComms(hDevice, eChannelId,
- &pSpiChannelConfig->configureComms);
- if (eRet != ADMW_SUCCESS)
- {
+ &pSpiChannelConfig->configureComms);
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set SPI comms for channel %d",
- eChannelId);
+ eChannelId);
return eRet;
}
@@ -2227,13 +2086,10 @@
* If the low/high limits are *both* set to 0 in memory, or NaNs, assume
* that they are unset, or not required, and use infinity defaults instead
*/
- if (fHighThresholdLimit == 0.0f && fLowThresholdLimit == 0.0f)
- {
+ if (fHighThresholdLimit == 0.0f && fLowThresholdLimit == 0.0f) {
fHighThresholdLimit = INFINITY;
fLowThresholdLimit = -INFINITY;
- }
- else
- {
+ } else {
if (isnan(fHighThresholdLimit))
fHighThresholdLimit = INFINITY;
if (isnan(fLowThresholdLimit))
@@ -2286,17 +2142,12 @@
{
ADMW_CORE_Settling_Time_t settlingTimeReg;
- if (nSettlingTime < (1 << 12))
- {
+ if (nSettlingTime < (1 << 12)) {
settlingTimeReg.Settling_Time_Units = CORE_SETTLING_TIME_MICROSECONDS;
- }
- else if (nSettlingTime < (1000 * (1 << 12)))
- {
+ } else if (nSettlingTime < (1000 * (1 << 12))) {
settlingTimeReg.Settling_Time_Units = CORE_SETTLING_TIME_MILLISECONDS;
nSettlingTime /= 1000;
- }
- else
- {
+ } else {
settlingTimeReg.Settling_Time_Units = CORE_SETTLING_TIME_SECONDS;
nSettlingTime /= 1000000;
}
@@ -2316,101 +2167,90 @@
{
ADMW_RESULT eRet;
- if (! ADMW1001_CHANNEL_IS_VIRTUAL(eChannelId))
- {
+ if (! ADMW1001_CHANNEL_IS_VIRTUAL(eChannelId)) {
eRet = admw1001_SetChannelCount(hDevice, eChannelId,
- pChannelConfig->enableChannel ?
- pChannelConfig->measurementsPerCycle : 0);
- if (eRet != ADMW_SUCCESS)
- {
+ pChannelConfig->enableChannel ?
+ pChannelConfig->measurementsPerCycle : 0);
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set measurement count for channel %d",
- eChannelId);
+ eChannelId);
return eRet;
}
eRet = admw1001_SetChannelOptions(hDevice, eChannelId,
- pChannelConfig->priority);
- if (eRet != ADMW_SUCCESS)
- {
+ pChannelConfig->priority);
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set priority for channel %d",
- eChannelId);
+ eChannelId);
return eRet;
}
/* If the channel is not enabled, we can skip the following steps */
- if (pChannelConfig->enableChannel)
- {
+ if (pChannelConfig->enableChannel) {
eRet = admw1001_SetChannelSkipCount(hDevice, eChannelId,
- pChannelConfig->cycleSkipCount);
- if (eRet != ADMW_SUCCESS)
- {
+ pChannelConfig->cycleSkipCount);
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set cycle skip count for channel %d",
- eChannelId);
+ eChannelId);
return eRet;
}
- switch (eChannelId)
- {
- case ADMW1001_CH_ID_ANLG_1_UNIVERSAL:
- case ADMW1001_CH_ID_ANLG_2_UNIVERSAL:
- case ADMW1001_CH_ID_ANLG_1_DIFFERENTIAL:
- case ADMW1001_CH_ID_ANLG_2_DIFFERENTIAL:
- eRet = admw_SetAdcChannelConfig(hDevice, eChannelId, pChannelConfig);
- break;
- case ADMW1001_CH_ID_DIG_I2C_0:
- 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);
- return ADMW_INVALID_PARAM;
+ switch (eChannelId) {
+ case ADMW1001_CH_ID_ANLG_1_UNIVERSAL:
+ case ADMW1001_CH_ID_ANLG_2_UNIVERSAL:
+ case ADMW1001_CH_ID_ANLG_1_DIFFERENTIAL:
+ case ADMW1001_CH_ID_ANLG_2_DIFFERENTIAL:
+ eRet = admw_SetAdcChannelConfig(hDevice, eChannelId, pChannelConfig);
+ break;
+ case ADMW1001_CH_ID_DIG_I2C_0:
+ 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);
+ return ADMW_INVALID_PARAM;
}
eRet = admw1001_SetChannelSettlingTime(hDevice, eChannelId,
- pChannelConfig->extraSettlingTime);
- if (eRet != ADMW_SUCCESS)
- {
+ pChannelConfig->extraSettlingTime);
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set settling time for channel %d",
- eChannelId);
+ eChannelId);
return eRet;
}
}
}
- if (pChannelConfig->enableChannel)
- {
+ if (pChannelConfig->enableChannel) {
/* Threshold limits can be configured individually for virtual channels */
eRet = admw1001_SetChannelThresholdLimits(hDevice, eChannelId,
- pChannelConfig->highThreshold,
- pChannelConfig->lowThreshold);
- if (eRet != ADMW_SUCCESS)
- {
+ pChannelConfig->highThreshold,
+ pChannelConfig->lowThreshold);
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set threshold limits for channel %d",
- eChannelId);
+ eChannelId);
return eRet;
}
/* Offset and gain can be configured individually for virtual channels */
eRet = admw1001_SetOffsetGain(hDevice, eChannelId,
- pChannelConfig->offsetAdjustment,
- pChannelConfig->gainAdjustment);
- if (eRet != ADMW_SUCCESS)
- {
+ pChannelConfig->offsetAdjustment,
+ pChannelConfig->gainAdjustment);
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set offset/gain for channel %d",
- eChannelId);
+ eChannelId);
return eRet;
}
/* Set sensor specific parameter */
eRet = admw1001_SetSensorParameter(hDevice, eChannelId,
- pChannelConfig->sensorParameter);
- if (eRet != ADMW_SUCCESS)
- {
+ pChannelConfig->sensorParameter);
+ if (eRet != ADMW_SUCCESS) {
ADMW_LOG_ERROR("Failed to set sensor parameter for channel %d",
- eChannelId);
+ eChannelId);
return eRet;
}
}
@@ -2426,31 +2266,27 @@
ADMW_PRODUCT_ID productId;
ADMW_RESULT eRet;
- if (pConfig->productId != ADMW_PRODUCT_ID_ADMW1001)
- {
+ if (pConfig->productId != ADMW_PRODUCT_ID_ADMW1001) {
ADMW_LOG_ERROR("Configuration Product ID (0x%X) is not supported (0x%0X)",
- pConfig->productId, ADMW_PRODUCT_ID_ADMW1001);
+ 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);
+
+ 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)
- {
+ if (eRet) {
ADMW_LOG_ERROR("Failed to read device Product ID register");
return eRet;
}
- if (pConfig->productId != productId)
- {
+ if (pConfig->productId != productId) {
ADMW_LOG_ERROR("Configuration Product ID (0x%X) does not match device (0x%0X)",
pConfig->productId, productId);
return ADMW_INVALID_PARAM;
@@ -2459,34 +2295,29 @@
pDeviceConfig = &pConfig->admw1001;
eRet = admw1001_SetPowerConfig(hDevice, &pDeviceConfig->power);
- if (eRet)
- {
+ if (eRet) {
ADMW_LOG_ERROR("Failed to set power configuration");
return eRet;
}
eRet = admw1001_SetMeasurementConfig(hDevice, &pDeviceConfig->measurement);
- if (eRet)
- {
+ if (eRet) {
ADMW_LOG_ERROR("Failed to set measurement configuration");
return eRet;
}
eRet = admw1001_SetDiagnosticsConfig(hDevice, &pDeviceConfig->diagnostics);
- if (eRet)
- {
+ if (eRet) {
ADMW_LOG_ERROR("Failed to set diagnostics configuration");
return eRet;
}
for (ADMW1001_CH_ID id = ADMW1001_CH_ID_ANLG_1_UNIVERSAL;
- id < ADMW1001_MAX_CHANNELS;
- id++)
- {
+ id < ADMW1001_MAX_CHANNELS;
+ id++) {
eRet = admw1001_SetChannelConfig(hDevice, id,
- &pDeviceConfig->channels[id]);
- if (eRet)
- {
+ &pDeviceConfig->channels[id]);
+ if (eRet) {
ADMW_LOG_ERROR("Failed to set channel %d configuration", id);
return eRet;
}
@@ -2503,69 +2334,63 @@
ADMW1001_LUT_TABLE *pLutTable = pLutData->tables;
unsigned actualLength = 0;
- if (pLutData->header.signature != ADMW_LUT_SIGNATURE)
- {
+ if (pLutData->header.signature != ADMW_LUT_SIGNATURE) {
ADMW_LOG_ERROR("LUT signature incorrect (expected 0x%X, actual 0x%X)",
- ADMW_LUT_SIGNATURE, pLutHeader->signature);
+ ADMW_LUT_SIGNATURE, pLutHeader->signature);
return ADMW_INVALID_SIGNATURE;
}
- for (unsigned i = 0; i < pLutHeader->numTables; i++)
- {
+ for (unsigned i = 0; i < pLutHeader->numTables; i++) {
ADMW1001_LUT_DESCRIPTOR *pDesc = &pLutTable->descriptor;
ADMW1001_LUT_TABLE_DATA *pData = &pLutTable->data;
unsigned short calculatedCrc;
- switch (pDesc->geometry)
- {
- case ADMW1001_LUT_GEOMETRY_COEFFS:
- switch (pDesc->equation)
- {
- case ADMW1001_LUT_EQUATION_POLYN:
- case ADMW1001_LUT_EQUATION_POLYNEXP:
- case ADMW1001_LUT_EQUATION_QUADRATIC:
- case ADMW1001_LUT_EQUATION_STEINHART:
- case ADMW1001_LUT_EQUATION_LOGARITHMIC:
- case ADMW1001_LUT_EQUATION_BIVARIATE_POLYN:
+ switch (pDesc->geometry) {
+ case ADMW1001_LUT_GEOMETRY_COEFFS:
+ switch (pDesc->equation) {
+ case ADMW1001_LUT_EQUATION_POLYN:
+ case ADMW1001_LUT_EQUATION_POLYNEXP:
+ case ADMW1001_LUT_EQUATION_QUADRATIC:
+ case ADMW1001_LUT_EQUATION_STEINHART:
+ case ADMW1001_LUT_EQUATION_LOGARITHMIC:
+ case ADMW1001_LUT_EQUATION_BIVARIATE_POLYN:
+ break;
+ default:
+ ADMW_LOG_ERROR("Invalid equation %u specified for LUT table %u",
+ pDesc->equation, i);
+ return ADMW_INVALID_PARAM;
+ }
break;
- default:
+ 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);
+ pDesc->equation, i);
return ADMW_INVALID_PARAM;
}
- 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",
- pDesc->geometry, i);
- return ADMW_INVALID_PARAM;
+ break;
+ default:
+ ADMW_LOG_ERROR("Invalid geometry %u specified for LUT table %u",
+ pDesc->geometry, i);
+ return ADMW_INVALID_PARAM;
}
- switch (pDesc->dataType)
- {
- case ADMW1001_LUT_DATA_TYPE_FLOAT32:
- case ADMW1001_LUT_DATA_TYPE_FLOAT64:
- break;
- default:
- ADMW_LOG_ERROR("Invalid vector format %u specified for LUT table %u",
- pDesc->dataType, i);
- return ADMW_INVALID_PARAM;
+ switch (pDesc->dataType) {
+ case ADMW1001_LUT_DATA_TYPE_FLOAT32:
+ case ADMW1001_LUT_DATA_TYPE_FLOAT64:
+ break;
+ default:
+ ADMW_LOG_ERROR("Invalid vector format %u specified for LUT table %u",
+ pDesc->dataType, i);
+ return ADMW_INVALID_PARAM;
}
calculatedCrc = admw_crc16_ccitt(pData, pDesc->length);
- if (calculatedCrc != pDesc->crc16)
- {
+ if (calculatedCrc != pDesc->crc16) {
ADMW_LOG_ERROR("CRC validation failed on LUT table %u (expected 0x%04X, actual 0x%04X)",
- i, pDesc->crc16, calculatedCrc);
+ i, pDesc->crc16, calculatedCrc);
return ADMW_CRC_ERROR;
}
@@ -2575,17 +2400,15 @@
pLutTable = (ADMW1001_LUT_TABLE *)((uint8_t *)pLutTable + sizeof(*pDesc) + pDesc->length);
}
- if (actualLength != pLutHeader->totalLength)
- {
+ if (actualLength != pLutHeader->totalLength) {
ADMW_LOG_ERROR("LUT table length mismatch (expected %u, actual %u)",
- pLutHeader->totalLength, actualLength);
+ pLutHeader->totalLength, actualLength);
return ADMW_WRONG_SIZE;
}
- if (sizeof(*pLutHeader) + pLutHeader->totalLength > ADMW_LUT_MAX_SIZE)
- {
+ if (sizeof(*pLutHeader) + pLutHeader->totalLength > ADMW_LUT_MAX_SIZE) {
ADMW_LOG_ERROR("Maximum LUT table length (%u bytes) exceeded",
- ADMW_LUT_MAX_SIZE);
+ ADMW_LUT_MAX_SIZE);
return ADMW_WRONG_SIZE;
}
@@ -2602,7 +2425,7 @@
ADMW1001_LUT_RAW * const pLutData)
{
return admw1001_SetLutData(hDevice,
- (ADMW1001_LUT *)pLutData);
+ (ADMW1001_LUT *)pLutData);
}
static ADMW_RESULT getLutTableSize(
@@ -2610,30 +2433,29 @@
ADMW1001_LUT_TABLE_DATA * const pData,
unsigned *pLength)
{
- 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);
- return ADMW_INVALID_PARAM;
+ 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);
+ return ADMW_INVALID_PARAM;
}
return ADMW_SUCCESS;
@@ -2649,8 +2471,7 @@
ADMW1001_LUT_HEADER *pHdr = &pLutBuffer->header;
uint8_t *pLutTableData = (uint8_t *)pLutBuffer + sizeof(*pHdr);
- if (sizeof(*pHdr) > nLutBufferSize)
- {
+ if (sizeof(*pHdr) > nLutBufferSize) {
ADMW_LOG_ERROR("Insufficient LUT buffer size provided");
return ADMW_INVALID_PARAM;
}
@@ -2666,8 +2487,7 @@
* Walk through the list of table pointers provided, appending the table
* descriptor+data from each one to the provided LUT buffer
*/
- for (unsigned i = 0; i < nNumTables; i++)
- {
+ for (unsigned i = 0; i < nNumTables; i++) {
ADMW1001_LUT_DESCRIPTOR * const pDesc = ppDesc[i];
ADMW1001_LUT_TABLE_DATA * const pData = ppData[i];
ADMW_RESULT res;
@@ -2682,8 +2502,7 @@
pDesc->length = dataLength;
pDesc->crc16 = admw_crc16_ccitt(pData, dataLength);
- if ((sizeof(*pHdr) + pHdr->totalLength + sizeof(*pDesc) + dataLength) > nLutBufferSize)
- {
+ if ((sizeof(*pHdr) + pHdr->totalLength + sizeof(*pDesc) + dataLength) > nLutBufferSize) {
ADMW_LOG_ERROR("Insufficient LUT buffer size provided");
return ADMW_INVALID_PARAM;
}
@@ -2706,21 +2525,18 @@
char nData[ADMW_VERSION_REG_VAL_SIZE]; //4 Bytes of version register data
ADMW_RESULT res;
res=admw1001_ReadRegister(hDevice,nAddress,nData,sizeof(nData));
- if(res != ADMW_SUCCESS)
- {
+ if(res != ADMW_SUCCESS) {
//if reading version register failed, sending 00.00.0000 as ADMW1001 firmware version
//strcat(nData, ADMW1001_FIRMWARE_VERSION_DEFAULT);
ADMW_LOG_INFO("Firmware Version Id is %X.%X",nData[2],nData[0]);
- }
- else
- {
+ } 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",nData[2],nData[0]);
}
return ADMW_SUCCESS;
-}
-
+}
+
ADMW_RESULT admw1001_getFirmwareStatus(
ADMW_DEVICE_HANDLE const hDevice,
bool * const bFirmwareStatus)
@@ -2749,78 +2565,74 @@
DataBuffer[9] = 0x00; //Address
DataBuffer[10] = 0x53;
- DataBuffer[11] = 0x00;
+ DataBuffer[11] = 0x00;
DataBuffer[12] = 0x00;
DataBuffer[13] = 0x00; //Checksum
nSize = SFL_READ_STATUS_HDR_SIZE;
- do
- {
+ do {
// Get the SFL command irq pin to check if SFL is ready to receive commands
// Status pin is not checked since SFL is just booted, there should not be any issue with SFL
eRet = admw_GetGpioState( hDevice, ADMW_GPIO_PIN_DATAREADY, &bitCommand );
if( eRet != ADMW_SUCCESS) {
- return eRet;
+ return eRet;
}
// Command IRQ pin should be low and Status IRQ pin should be high for SFL to be in good state and ready to recieve commands
- // pinreg == '0x00' - Error occured in SFL
+ // pinreg == '0x00' - Error occured in SFL
// pinreg == '0x01' - SFL is ready to recieve commands
// pinreg == '0x02' - Error occured in handling any commands in SFL
// pinreg == '0x03' - SFL not booted
pinreg = (bitCommand);
-
- }while(pinreg != 0x0u);
+
+ } while(pinreg != 0x0u);
eRet = admw_SpiTransfer(pCtx->hSpi, DataBuffer, NULL,
- nSize, false);
- if (eRet)
- {
+ nSize, false);
+ if (eRet) {
return eRet;
}
//wait for command irq line to go low after sending read status header
wait_ms( 100 );
- do
- {
+ do {
// Get the SFL command irq pin to check if SFL is ready to receive commands
- // Status pin is not checked since SFL is just booted, there should not be any issue with SFL
+ // Status pin is not checked since SFL is just booted, there should not be any issue with SFL
eRet = admw_GetGpioState( hDevice, ADMW_GPIO_PIN_DATAREADY, &bitCommand );
if( eRet != ADMW_SUCCESS) {
- return eRet;
+ return eRet;
}
-
+
// Command IRQ pin should be low and Status IRQ pin should be high for SFL to be in good state and ready to recieve commands
- // pinreg == '0x00' - Error occured in SFL
+ // pinreg == '0x00' - Error occured in SFL
// pinreg == '0x01' - SFL is ready to recieve commands
// pinreg == '0x02' - Error occured in handling any commands in SFL
// pinreg == '0x03' - SFL not booted
-
+
pinreg = (bitCommand);
- }while(pinreg != 0x0u);
+ } while(pinreg != 0x0u);
nSize = SFL_READ_STATUS_RESPONSE_SIZE;
eRet = admw_SpiReceive(pCtx->hSpi, NULL, DataBuffer,
- nSize, false);
-
- if (eRet)
- {
+ nSize, false);
+
+ if (eRet) {
return eRet;
}
//Verifying the application version from the response to check if firmware is present or not
- /*
+ /*
Flash Memory description
______________
| Secure | 0x0000 0000
| Flashloader |
|______________| 0x0000 3BFF
- | Security |------------------
+ | Security |------------------
| Page | 0x0000 3C00
| |
|______________| 0x0000 3FFF
@@ -2840,29 +2652,26 @@
Application version is stored in the App Info Page, the app version is updated in this region everytime the new application firmware is downloaded.
Here we verify if Application version is present in the Read Status response
If the app version bytes value is 0xFFFFFFFF then there is no firmware else there exist a firmware
-
+
Read Status Response:
____________________________________________________________________________________________________________________________________
| | | | | |
|uint16_t nFlashLoaderVersion | uint16_t nStatus | uint32_t nApplicationVersion | uint32_t nApplicationHash[8] | uint16_t nChecksum |
|_____________________________|__________________|______________________________|______________________________|_____________________|
-
+
*/
if( ((DataBuffer[4] == 0xFF) &&
- (DataBuffer[5] == 0xFF) &&
- (DataBuffer[6] == 0xFF) &&
- (DataBuffer[7] == 0xFF)) ||
- ((DataBuffer[4] == 0x00) &&
- (DataBuffer[5] == 0x00) &&
- (DataBuffer[6] == 0x00) &&
- (DataBuffer[7] == 0x00)))
- {
- *bFirmwareStatus = false;
- }
- else
- {
- *bFirmwareStatus = true;
+ (DataBuffer[5] == 0xFF) &&
+ (DataBuffer[6] == 0xFF) &&
+ (DataBuffer[7] == 0xFF)) ||
+ ((DataBuffer[4] == 0x00) &&
+ (DataBuffer[5] == 0x00) &&
+ (DataBuffer[6] == 0x00) &&
+ (DataBuffer[7] == 0x00))) {
+ *bFirmwareStatus = false;
+ } else {
+ *bFirmwareStatus = true;
}
return eRet;