Jake Greaves
/
AdiSense1000_V21
Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Diff: src/adi_sense_1000.c
- Branch:
- v2.0
- Revision:
- 29:57edca10d78c
- Parent:
- 27:567abf893938
- Child:
- 30:119ff4f3aef6
--- a/src/adi_sense_1000.c Mon Mar 26 20:28:05 2018 +0100
+++ b/src/adi_sense_1000.c Tue May 22 13:45:24 2018 +0100
@@ -226,7 +226,7 @@
pCtx = &gDeviceCtx[nDeviceIndex];
pCtx->nDeviceIndex = nDeviceIndex;
- eRet = adi_sense_LogOpen();
+ eRet = adi_sense_LogOpen(&pConnectionInfo->log);
if (eRet != ADI_SENSE_SUCCESS)
return eRet;
@@ -323,6 +323,9 @@
ADI_ADISENSE_CORE_Status_t statusReg;
READ_REG_U8(hDevice, statusReg.VALUE8, CORE_STATUS);
+ ADI_ADISENSE_CORE_Alert_Status_2_t alert2Reg;
+ READ_REG_U16(hDevice, alert2Reg.VALUE16, CORE_ALERT_STATUS_2);
+
memset(pStatus, 0, sizeof(*pStatus));
if (!statusReg.Cmd_Running) /* Active-low, so invert it */
@@ -331,6 +334,8 @@
pStatus->deviceStatus |= ADI_SENSE_DEVICE_STATUS_DATAREADY;
if (statusReg.FIFO_Error)
pStatus->deviceStatus |= ADI_SENSE_DEVICE_STATUS_FIFO_ERROR;
+ if (alert2Reg.Ext_Flash_Error)
+ pStatus->deviceStatus |= ADI_SENSE_DEVICE_STATUS_EXT_FLASH_ERROR;
if (statusReg.Alert_Active)
{
pStatus->deviceStatus |= ADI_SENSE_DEVICE_STATUS_ALERT;
@@ -377,10 +382,6 @@
pStatus->channelAlerts[i] |= ADI_SENSE_CHANNEL_ALERT_SENSOR_NOT_READY;
if (alertDetailReg.Comp_Not_Ready)
pStatus->channelAlerts[i] |= ADI_SENSE_CHANNEL_ALERT_COMP_NOT_READY;
- if (alertDetailReg.Under_Voltage)
- pStatus->channelAlerts[i] |= ADI_SENSE_CHANNEL_ALERT_UNDER_VOLTAGE;
- if (alertDetailReg.Over_Voltage)
- pStatus->channelAlerts[i] |= ADI_SENSE_CHANNEL_ALERT_OVER_VOLTAGE;
if (alertDetailReg.Correction_UnderRange)
pStatus->channelAlerts[i] |= ADI_SENSE_CHANNEL_ALERT_LUT_UNDER_RANGE;
if (alertDetailReg.Correction_OverRange)
@@ -388,8 +389,6 @@
}
}
- ADI_ADISENSE_CORE_Alert_Status_2_t alert2Reg;
- READ_REG_U16(hDevice, alert2Reg.VALUE16, CORE_ALERT_STATUS_2);
if (alert2Reg.Configuration_Error)
pStatus->deviceStatus |= ADI_SENSE_DEVICE_STATUS_CONFIG_ERROR;
if (alert2Reg.LUT_Error)
@@ -415,14 +414,6 @@
pStatus->diagnosticsStatus |= ADI_SENSE_DIAGNOSTICS_STATUS_SUPPLY_MONITOR_ERROR;
if (diagStatusReg.Diag_Supply_Cap_Error)
pStatus->diagnosticsStatus |= ADI_SENSE_DIAGNOSTICS_STATUS_SUPPLY_CAP_ERROR;
- if (diagStatusReg.Diag_Ainm_UV_Error)
- pStatus->diagnosticsStatus |= ADI_SENSE_DIAGNOSTICS_STATUS_AINM_UV_ERROR;
- if (diagStatusReg.Diag_Ainm_OV_Error)
- pStatus->diagnosticsStatus |= ADI_SENSE_DIAGNOSTICS_STATUS_AINM_OV_ERROR;
- if (diagStatusReg.Diag_Ainp_UV_Error)
- pStatus->diagnosticsStatus |= ADI_SENSE_DIAGNOSTICS_STATUS_AINP_UV_ERROR;
- if (diagStatusReg.Diag_Ainp_OV_Error)
- pStatus->diagnosticsStatus |= ADI_SENSE_DIAGNOSTICS_STATUS_AINP_OV_ERROR;
if (diagStatusReg.Diag_Conversion_Error)
pStatus->diagnosticsStatus |= ADI_SENSE_DIAGNOSTICS_STATUS_CONVERSION_ERROR;
if (diagStatusReg.Diag_Calibration_Error)
@@ -491,6 +482,13 @@
return ADI_SENSE_SUCCESS;
}
+ADI_SENSE_RESULT adi_sense_Shutdown(
+ ADI_SENSE_DEVICE_HANDLE const hDevice)
+{
+ return executeCommand(hDevice, ADISENSE_CORE_COMMAND_POWER_DOWN, false);
+}
+
+
ADI_SENSE_RESULT adi_sense_ApplyConfigUpdates(
ADI_SENSE_DEVICE_HANDLE const hDevice)
{
@@ -535,13 +533,29 @@
/*
* Store the configuration settings to persistent memory on the device.
+ * The settings can be saved to 4 different flash memory areas (slots).
* No other command must be running when this is called.
* Do not power down the device while this command is running.
*/
ADI_SENSE_RESULT adi_sense_SaveConfig(
- ADI_SENSE_DEVICE_HANDLE const hDevice)
+ ADI_SENSE_DEVICE_HANDLE const hDevice,
+ ADI_SENSE_USER_CONFIG_SLOT const eSlotId)
{
- return executeCommand(hDevice, ADISENSE_CORE_COMMAND_SAVE_CONFIG_1, true);
+ switch (eSlotId)
+ {
+ case ADI_SENSE_FLASH_CONFIG_1:
+ return executeCommand(hDevice, ADISENSE_CORE_COMMAND_SAVE_CONFIG_1, true);
+ case ADI_SENSE_FLASH_CONFIG_2:
+ return executeCommand(hDevice, ADISENSE_CORE_COMMAND_SAVE_CONFIG_2, true);
+ case ADI_SENSE_FLASH_CONFIG_3:
+ return executeCommand(hDevice, ADISENSE_CORE_COMMAND_SAVE_CONFIG_3, true);
+ case ADI_SENSE_FLASH_CONFIG_4:
+ return executeCommand(hDevice, ADISENSE_CORE_COMMAND_SAVE_CONFIG_4, true);
+ default:
+ ADI_SENSE_LOG_ERROR("Invalid user config target slot %d specified",
+ eSlotId);
+ return ADI_SENSE_INVALID_PARAM;
+ }
}
/*
@@ -549,12 +563,147 @@
* No other command must be running when this is called.
*/
ADI_SENSE_RESULT adi_sense_RestoreConfig(
+ ADI_SENSE_DEVICE_HANDLE const hDevice,
+ ADI_SENSE_USER_CONFIG_SLOT const eSlotId)
+{
+ switch (eSlotId)
+ {
+ case ADI_SENSE_FLASH_CONFIG_1:
+ return executeCommand(hDevice, ADISENSE_CORE_COMMAND_LOAD_CONFIG_1, true);
+ case ADI_SENSE_FLASH_CONFIG_2:
+ return executeCommand(hDevice, ADISENSE_CORE_COMMAND_LOAD_CONFIG_2, true);
+ case ADI_SENSE_FLASH_CONFIG_3:
+ return executeCommand(hDevice, ADISENSE_CORE_COMMAND_LOAD_CONFIG_3, true);
+ case ADI_SENSE_FLASH_CONFIG_4:
+ return executeCommand(hDevice, ADISENSE_CORE_COMMAND_LOAD_CONFIG_4, true);
+ default:
+ ADI_SENSE_LOG_ERROR("Invalid user config source slot %d specified",
+ eSlotId);
+ return ADI_SENSE_INVALID_PARAM;
+ }
+}
+
+/*
+ * Erase the entire external flash memory.
+ * No other command must be running when this is called.
+ */
+ADI_SENSE_RESULT adi_sense_EraseExternalFlash(
ADI_SENSE_DEVICE_HANDLE const hDevice)
{
- return executeCommand(hDevice, ADISENSE_CORE_COMMAND_LOAD_CONFIG_1, true);
+ return executeCommand(hDevice, ADISENSE_CORE_COMMAND_ERASE_EXTERNAL_FLASH, true);
+}
+
+/*
+ * Read the number of samples stored in external flash memory.
+ * No other command must be running when this is called.
+ */
+ADI_SENSE_RESULT adi_sense_GetExternalFlashSampleCount(
+ ADI_SENSE_DEVICE_HANDLE const hDevice,
+ uint32_t * nSampleCount)
+{
+ ADI_ADISENSE_CORE_Ext_Flash_Sample_Count_t nCount;
+
+ READ_REG_U32(hDevice, nCount.VALUE32, CORE_EXT_FLASH_SAMPLE_COUNT);
+
+ *nSampleCount = nCount.VALUE32;
+
+ return ADI_SENSE_SUCCESS;
+}
+
+// DEBUG - TO BE DELETED
+ADI_SENSE_RESULT adi_sense_SetExternalFlashIndex(
+ ADI_SENSE_DEVICE_HANDLE const hDevice,
+ uint32_t nStartIndex)
+{
+ WRITE_REG_U32(hDevice, nStartIndex, CORE_EXT_FLASH_INDEX);
+
+ return ADI_SENSE_SUCCESS;
}
/*
+ * Read a set of data samples stored in the device external flash memory.
+ * This may be called at any time.
+ */
+ADI_SENSE_RESULT adi_sense_GetExternalFlashData(
+ ADI_SENSE_DEVICE_HANDLE const hDevice,
+ ADI_SENSE_DATA_SAMPLE * const pSamples,
+ uint32_t const nStartIndex,
+ uint32_t const nRequested,
+ uint32_t * const pnReturned)
+{
+ ADI_SENSE_DEVICE_CONTEXT *pCtx = hDevice;
+ uint16_t command = ADI_SENSE_1000_HOST_COMMS_READ_CMD |
+ (REG_ADISENSE_CORE_EXT_FLASH_DATA & ADI_SENSE_1000_HOST_COMMS_ADR_MASK);
+ uint8_t commandData[2] = {
+ command >> 8,
+ command & 0xFF
+ };
+ uint8_t commandResponse[2];
+ unsigned nValidSamples = 0;
+ ADI_SENSE_RESULT eRet = ADI_SENSE_SUCCESS;
+
+ /* Setup initial sample */
+ WRITE_REG_U32(hDevice, nStartIndex, CORE_EXT_FLASH_INDEX);
+
+ /* Send flash read command */
+ do {
+ eRet = adi_sense_SpiTransfer(pCtx->hSpi, commandData, commandResponse,
+ sizeof(command), false);
+ if (eRet)
+ {
+ ADI_SENSE_LOG_ERROR("Failed to send read command for external flash");
+ return eRet;
+ }
+
+ adi_sense_TimeDelayUsec(ADI_SENSE_1000_HOST_COMMS_XFER_DELAY);
+ } while ((commandResponse[0] != ADI_SENSE_1000_HOST_COMMS_CMD_RESP_0) ||
+ (commandResponse[1] != ADI_SENSE_1000_HOST_COMMS_CMD_RESP_1));
+
+ /* Read samples from external flash memory */
+ for (unsigned i = 0; i < nRequested; i++)
+ {
+ ADI_SENSE_1000_Sensor_Result_t sensorResult;
+ bool_t bHoldCs = true;
+
+ /* Keep the CS signal asserted for all but the last sample */
+ if ((i + 1) == nRequested)
+ bHoldCs = false;
+
+ eRet = adi_sense_SpiTransfer(pCtx->hSpi, NULL, (uint8_t *) (&sensorResult),
+ 8, bHoldCs);
+ if (eRet)
+ {
+ ADI_SENSE_LOG_ERROR("Failed to read data from external flash");
+ return eRet;
+ }
+
+ ADI_SENSE_DATA_SAMPLE *pSample = &pSamples[nValidSamples];
+
+ pSample->status = (ADI_SENSE_DEVICE_STATUS_FLAGS)0;
+ if (sensorResult.Ch_Error)
+ pSample->status |= ADI_SENSE_DEVICE_STATUS_ERROR;
+ if (sensorResult.Ch_Alert)
+ pSample->status |= ADI_SENSE_DEVICE_STATUS_ALERT;
+
+ if (sensorResult.Ch_Raw)
+ pSample->rawValue = sensorResult.Raw_Sample;
+ else
+ pSample->rawValue = 0;
+
+ pSample->channelId = sensorResult.Channel_ID;
+ pSample->processedValue = sensorResult.Sensor_Result;
+
+ nValidSamples++;
+ }
+ *pnReturned = nValidSamples;
+
+ adi_sense_TimeDelayUsec(ADI_SENSE_1000_HOST_COMMS_XFER_DELAY);
+
+ return eRet;
+}
+
+
+/*
* Store the LUT data to persistent memory on the device.
* No other command must be running when this is called.
* Do not power down the device while this command is running.
@@ -608,6 +757,17 @@
}
/*
+ * Run digital calibration routines on the device.
+ * Calibration is executed according to the current applied settings.
+ * No other command must be running when this is called.
+ */
+ADI_SENSE_RESULT adi_sense_RunDigitalCalibration(
+ ADI_SENSE_DEVICE_HANDLE const hDevice)
+{
+ return executeCommand(hDevice, ADISENSE_CORE_COMMAND_CALIBRATE_DIGITAL, true);
+}
+
+/*
* Read a set of data samples from the device.
* This may be called at any time.
*/
@@ -638,7 +798,6 @@
ADI_SENSE_LOG_ERROR("Failed to send read command for FIFO register");
return eRet;
}
-
adi_sense_TimeDelayUsec(ADI_SENSE_1000_HOST_COMMS_XFER_DELAY);
} while ((commandResponse[0] != ADI_SENSE_1000_HOST_COMMS_CMD_RESP_0) ||
(commandResponse[1] != ADI_SENSE_1000_HOST_COMMS_CMD_RESP_1));
@@ -915,10 +1074,10 @@
/* 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 ==
- ADISENSE_CORE_SENSOR_TYPE_SENSOR_SPI_ACCELEROMETER_1) ||
- (sensorTypeReg.Sensor_Type ==
- ADISENSE_CORE_SENSOR_TYPE_SENSOR_SPI_ACCELEROMETER_2))
+ if ((sensorTypeReg.Sensor_Type >=
+ ADISENSE_CORE_SENSOR_TYPE_SENSOR_SPI_ACCELEROMETER_A_DEF_L1) &&
+ (sensorTypeReg.Sensor_Type <=
+ ADISENSE_CORE_SENSOR_TYPE_SENSOR_SPI_ACCELEROMETER_B_ADV_L2))
nActualChannels += 2;
}
@@ -1046,7 +1205,9 @@
static ADI_SENSE_RESULT adi_sense_SetMode(
ADI_SENSE_DEVICE_HANDLE hDevice,
ADI_SENSE_1000_OPERATING_MODE eOperatingMode,
- ADI_SENSE_1000_DATAREADY_MODE eDataReadyMode)
+ ADI_SENSE_1000_DATAREADY_MODE eDataReadyMode,
+ ADI_SENSE_1000_CALIBRATION_MODE eCalibrationMode,
+ bool bEnableExtFlash)
{
ADI_ADISENSE_CORE_Mode_t modeReg;
@@ -1099,6 +1260,25 @@
return ADI_SENSE_INVALID_PARAM;
}
+ if (eCalibrationMode == ADI_SENSE_1000_NO_CALIBRATION)
+ {
+ modeReg.Calibration_Method = ADISENSE_CORE_MODE_NO_CAL;
+ }
+ else if (eCalibrationMode == ADI_SENSE_1000_DO_CALIBRATION)
+ {
+ modeReg.Calibration_Method = ADISENSE_CORE_MODE_DO_CAL;
+ }
+ else
+ {
+ ADI_SENSE_LOG_ERROR("Invalid calibration mode %d specified",
+ eCalibrationMode);
+ return ADI_SENSE_INVALID_PARAM;
+ }
+
+ modeReg.Ext_Flash_Store = (bEnableExtFlash ?
+ ADISENSE_CORE_MODE_EXT_FLASH_USED :
+ ADISENSE_CORE_MODE_EXT_FLASH_NOT_USED);
+
WRITE_REG_U8(hDevice, modeReg.VALUE8, CORE_MODE);
return ADI_SENSE_SUCCESS;
@@ -1185,7 +1365,9 @@
eRet = adi_sense_SetMode(hDevice,
pMeasConfig->operatingMode,
- pMeasConfig->dataReadyMode);
+ pMeasConfig->dataReadyMode,
+ pMeasConfig->calibrationMode,
+ pMeasConfig->enableExternalFlash);
if (eRet != ADI_SENSE_SUCCESS)
{
ADI_SENSE_LOG_ERROR("Failed to set operating mode");
@@ -1511,20 +1693,14 @@
case ADI_SENSE_1000_ADC_SENSOR_BRIDGE_6WIRE_2_ADV_L2:
case ADI_SENSE_1000_ADC_SENSOR_BRIDGE_6WIRE_3_ADV_L2:
case ADI_SENSE_1000_ADC_SENSOR_BRIDGE_6WIRE_4_ADV_L2:
- case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_A_10K_DEF_L1:
- case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_B_10K_DEF_L1:
- case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_1_DEF_L2:
- case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_2_DEF_L2:
- case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_3_DEF_L2:
- case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_4_DEF_L2:
- case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_A_10K_ADV_L1:
- case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_B_10K_ADV_L1:
- case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_1_ADV_L2:
- case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_2_ADV_L2:
- case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_3_ADV_L2:
- case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_4_ADV_L2:
case ADI_SENSE_1000_ADC_SENSOR_MICROPHONE_A_DEF_L1:
case ADI_SENSE_1000_ADC_SENSOR_MICROPHONE_B_DEF_L1:
+ case ADI_SENSE_1000_ADC_SENSOR_MICROPHONE_1_DEF_L2:
+ case ADI_SENSE_1000_ADC_SENSOR_MICROPHONE_2_DEF_L2:
+ case ADI_SENSE_1000_ADC_SENSOR_MICROPHONE_A_ADV_L1:
+ case ADI_SENSE_1000_ADC_SENSOR_MICROPHONE_B_ADV_L1:
+ case ADI_SENSE_1000_ADC_SENSOR_MICROPHONE_1_ADV_L2:
+ case ADI_SENSE_1000_ADC_SENSOR_MICROPHONE_2_ADV_L2:
if (! ADI_SENSE_1000_CHANNEL_IS_ADC_SENSOR(eChannelId))
{
ADI_SENSE_LOG_ERROR(
@@ -1553,6 +1729,18 @@
case ADI_SENSE_1000_ADC_SENSOR_DIODE_3C_TYPEA_ADV_L1:
case ADI_SENSE_1000_ADC_SENSOR_DIODE_2C_1_ADV_L2:
case ADI_SENSE_1000_ADC_SENSOR_DIODE_3C_1_ADV_L2:
+ case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_A_10K_DEF_L1:
+ case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_B_10K_DEF_L1:
+ case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_1_DEF_L2:
+ case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_2_DEF_L2:
+ case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_3_DEF_L2:
+ case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_4_DEF_L2:
+ case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_A_10K_ADV_L1:
+ case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_B_10K_ADV_L1:
+ case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_1_ADV_L2:
+ case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_2_ADV_L2:
+ case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_3_ADV_L2:
+ case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_4_ADV_L2:
if (! (ADI_SENSE_1000_CHANNEL_IS_ADC_SENSOR(eChannelId) ||
ADI_SENSE_1000_CHANNEL_IS_ADC_CJC(eChannelId)))
{
@@ -1563,10 +1751,14 @@
}
break;
case ADI_SENSE_1000_ADC_SENSOR_VOLTAGE:
- case ADI_SENSE_1000_ADC_SENSOR_VOLTAGE_PRESSURE_HONEYWELL_TRUSTABILITY:
- case ADI_SENSE_1000_ADC_SENSOR_VOLTAGE_PRESSURE_AMPHENOL_NPA300X:
+ case ADI_SENSE_1000_ADC_SENSOR_VOLTAGE_PRESSURE_A_DEF_L1:
+ case ADI_SENSE_1000_ADC_SENSOR_VOLTAGE_PRESSURE_B_DEF_L1:
case ADI_SENSE_1000_ADC_SENSOR_VOLTAGE_PRESSURE_1_DEF_L2:
case ADI_SENSE_1000_ADC_SENSOR_VOLTAGE_PRESSURE_2_DEF_L2:
+ case ADI_SENSE_1000_ADC_SENSOR_VOLTAGE_PRESSURE_A_ADV_L1:
+ case ADI_SENSE_1000_ADC_SENSOR_VOLTAGE_PRESSURE_B_ADV_L1:
+ case ADI_SENSE_1000_ADC_SENSOR_VOLTAGE_PRESSURE_1_ADV_L2:
+ case ADI_SENSE_1000_ADC_SENSOR_VOLTAGE_PRESSURE_2_ADV_L2:
if (! ADI_SENSE_1000_CHANNEL_IS_ADC_VOLTAGE(eChannelId))
{
ADI_SENSE_LOG_ERROR(
@@ -1576,9 +1768,12 @@
}
break;
case ADI_SENSE_1000_ADC_SENSOR_CURRENT:
- case ADI_SENSE_1000_ADC_SENSOR_CURRENT_PRESSURE_HONEYWELL_PX2:
+ case ADI_SENSE_1000_ADC_SENSOR_CURRENT_PRESSURE_A_DEF_L1:
case ADI_SENSE_1000_ADC_SENSOR_CURRENT_PRESSURE_1_DEF_L2:
case ADI_SENSE_1000_ADC_SENSOR_CURRENT_PRESSURE_2_DEF_L2:
+ case ADI_SENSE_1000_ADC_SENSOR_CURRENT_PRESSURE_A_ADV_L1:
+ case ADI_SENSE_1000_ADC_SENSOR_CURRENT_PRESSURE_1_ADV_L2:
+ case ADI_SENSE_1000_ADC_SENSOR_CURRENT_PRESSURE_2_ADV_L2:
if (! ADI_SENSE_1000_CHANNEL_IS_ADC_CURRENT(eChannelId))
{
ADI_SENSE_LOG_ERROR(
@@ -1629,16 +1824,27 @@
sensorDetailsReg.Measurement_Units = ADISENSE_CORE_SENSOR_DETAILS_UNITS_DEGF;
break;
case ADI_SENSE_1000_MEASUREMENT_UNIT_CELSIUS:
- case ADI_SENSE_1000_MEASUREMENT_UNIT_DEFAULT:
sensorDetailsReg.Measurement_Units = ADISENSE_CORE_SENSOR_DETAILS_UNITS_DEGC;
break;
+ case ADI_SENSE_1000_MEASUREMENT_UNIT_UNSPECIFIED:
+ sensorDetailsReg.Measurement_Units = ADISENSE_CORE_SENSOR_DETAILS_UNITS_UNSPECIFIED;
+ break;
default:
ADI_SENSE_LOG_ERROR("Invalid measurement unit %d specified",
pChannelConfig->measurementUnit);
return ADI_SENSE_INVALID_PARAM;
}
- sensorDetailsReg.Compensation_Channel = pChannelConfig->compensationChannel;
+ if (pChannelConfig->compensationChannel == ADI_SENSE_1000_CHANNEL_ID_NONE)
+ {
+ sensorDetailsReg.Compensation_Disable = 1;
+ sensorDetailsReg.Compensation_Channel = 0;
+ }
+ else
+ {
+ sensorDetailsReg.Compensation_Disable = 0;
+ sensorDetailsReg.Compensation_Channel = pChannelConfig->compensationChannel;
+ }
switch(pRefConfig->type)
{
@@ -1722,6 +1928,11 @@
else
sensorDetailsReg.Do_Not_Publish = 0;
+ if (pChannelConfig->enableUnityLut)
+ sensorDetailsReg.Unity_LUT_Select = 1;
+ else
+ sensorDetailsReg.Unity_LUT_Select = 0;
+
WRITE_REG_U32(hDevice, sensorDetailsReg.VALUE32, CORE_SENSOR_DETAILSn(eChannelId));
return ADI_SENSE_SUCCESS;
@@ -1858,6 +2069,53 @@
return ADI_SENSE_SUCCESS;
}
+static ADI_SENSE_RESULT adi_sense_SetChannelDigitalSensorDetails(
+ ADI_SENSE_DEVICE_HANDLE hDevice,
+ ADI_SENSE_1000_CHANNEL_ID eChannelId,
+ ADI_SENSE_1000_CHANNEL_CONFIG *pChannelConfig)
+{
+ ADI_ADISENSE_CORE_Sensor_Details_t sensorDetailsReg;
+
+ sensorDetailsReg.VALUE32 = REG_RESET_VAL(CORE_SENSOR_DETAILSn);
+
+ if (pChannelConfig->compensationChannel == ADI_SENSE_1000_CHANNEL_ID_NONE)
+ {
+ sensorDetailsReg.Compensation_Disable = 1;
+ sensorDetailsReg.Compensation_Channel = 0;
+ }
+ else
+ {
+ ADI_SENSE_LOG_ERROR("Invalid compensation channel specified for digital sensor");
+ return ADI_SENSE_INVALID_PARAM;
+ }
+
+ if (pChannelConfig->measurementUnit == ADI_SENSE_1000_MEASUREMENT_UNIT_UNSPECIFIED)
+ {
+ sensorDetailsReg.Measurement_Units = ADISENSE_CORE_SENSOR_DETAILS_UNITS_UNSPECIFIED;
+ }
+ else
+ {
+ ADI_SENSE_LOG_ERROR("Invalid measurement unit specified for digital channel");
+ return ADI_SENSE_INVALID_PARAM;
+ }
+
+ if (pChannelConfig->disablePublishing)
+ sensorDetailsReg.Do_Not_Publish = 1;
+ else
+ sensorDetailsReg.Do_Not_Publish = 0;
+
+ if (pChannelConfig->enableUnityLut)
+ sensorDetailsReg.Unity_LUT_Select = 1;
+ else
+ sensorDetailsReg.Unity_LUT_Select = 0;
+
+ sensorDetailsReg.Vbias = 0;
+ sensorDetailsReg.Reference_Buffer_Disable = 1;
+
+ WRITE_REG_U32(hDevice, sensorDetailsReg.VALUE32, CORE_SENSOR_DETAILSn(eChannelId));
+
+ return ADI_SENSE_SUCCESS;
+}
static ADI_SENSE_RESULT adi_sense_SetDigitalSensorCommands(
ADI_SENSE_DEVICE_HANDLE hDevice,
@@ -2005,6 +2263,10 @@
return ADI_SENSE_INVALID_PARAM;
}
}
+ else
+ {
+ sensorConfigReg.Digital_Sensor_Coding = ADISENSE_CORE_DIGITAL_SENSOR_CONFIG_CODING_NONE;
+ }
WRITE_REG_U16(hDevice, sensorConfigReg.VALUE16,
CORE_DIGITAL_SENSOR_CONFIGn(eChannelId));
@@ -2013,6 +2275,31 @@
return ADI_SENSE_SUCCESS;
}
+static ADI_SENSE_RESULT adi_sense_SetDigitalCalibrationParam(
+ ADI_SENSE_DEVICE_HANDLE hDevice,
+ ADI_SENSE_1000_CHANNEL_ID eChannelId,
+ ADI_SENSE_1000_DIGITAL_CALIBRATION_COMMAND *pCalibrationParam)
+{
+ ADI_ADISENSE_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 ADI_SENSE_SUCCESS;
+}
+
static ADI_SENSE_RESULT adi_sense_SetChannelI2cSensorType(
ADI_SENSE_DEVICE_HANDLE hDevice,
ADI_SENSE_1000_CHANNEL_ID eChannelId,
@@ -2025,14 +2312,19 @@
/* Ensure that the sensor type is valid for this channel */
switch(sensorType)
{
- case ADI_SENSE_1000_I2C_SENSOR_HUMIDITY_HONEYWELL_HUMIDICON:
- sensorTypeReg.Sensor_Type = ADISENSE_CORE_SENSOR_TYPE_SENSOR_I2C_HUMIDITY_HONEYWELL_HUMIDICON;
- break;
- case ADI_SENSE_1000_I2C_SENSOR_HUMIDITY_SENSIRION_SHT3X:
- sensorTypeReg.Sensor_Type = ADISENSE_CORE_SENSOR_TYPE_SENSOR_I2C_HUMIDITY_SENSIRION_SHT3X;
- break;
- case ADI_SENSE_1000_I2C_SENSOR_LIGHT_ONSEMI_NOA1305:
- sensorTypeReg.Sensor_Type = ADISENSE_CORE_SENSOR_TYPE_SENSOR_I2C_AMBIENTLIGHT_1;
+ case ADI_SENSE_1000_I2C_SENSOR_HUMIDITY_A_DEF_L1:
+ case ADI_SENSE_1000_I2C_SENSOR_HUMIDITY_B_DEF_L1:
+ case ADI_SENSE_1000_I2C_SENSOR_HUMIDITY_A_DEF_L2:
+ case ADI_SENSE_1000_I2C_SENSOR_HUMIDITY_B_DEF_L2:
+ case ADI_SENSE_1000_I2C_SENSOR_HUMIDITY_A_ADV_L1:
+ case ADI_SENSE_1000_I2C_SENSOR_HUMIDITY_B_ADV_L1:
+ case ADI_SENSE_1000_I2C_SENSOR_HUMIDITY_A_ADV_L2:
+ case ADI_SENSE_1000_I2C_SENSOR_HUMIDITY_B_ADV_L2:
+ case ADI_SENSE_1000_I2C_SENSOR_AMBIENTLIGHT_A_DEF_L1:
+ case ADI_SENSE_1000_I2C_SENSOR_AMBIENTLIGHT_A_DEF_L2:
+ case ADI_SENSE_1000_I2C_SENSOR_AMBIENTLIGHT_A_ADV_L1:
+ case ADI_SENSE_1000_I2C_SENSOR_AMBIENTLIGHT_A_ADV_L2:
+ sensorTypeReg.Sensor_Type = sensorType;
break;
default:
ADI_SENSE_LOG_ERROR("Unsupported I2C sensor type %d specified", sensorType);
@@ -2055,12 +2347,198 @@
return ADI_SENSE_SUCCESS;
}
+static ADI_SENSE_RESULT adi_sense_SetDigitalChannelComms(
+ ADI_SENSE_DEVICE_HANDLE hDevice,
+ ADI_SENSE_1000_CHANNEL_ID eChannelId,
+ ADI_SENSE_1000_DIGITAL_SENSOR_COMMS *pDigitalComms)
+{
+ ADI_ADISENSE_CORE_Digital_Sensor_Comms_t digitalSensorComms;
+
+ digitalSensorComms.VALUE16 = REG_RESET_VAL(CORE_DIGITAL_SENSOR_COMMSn);
+
+ if(pDigitalComms->useCustomCommsConfig)
+ {
+ digitalSensorComms.Digital_Sensor_Comms_En = 1;
+
+ if(pDigitalComms->i2cClockSpeed == ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_I2C_CLOCK_SPEED_100K)
+ {
+ digitalSensorComms.I2C_Clock = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_I2C_100K;
+ }
+ else if(pDigitalComms->i2cClockSpeed == ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_I2C_CLOCK_SPEED_400K)
+ {
+ digitalSensorComms.I2C_Clock = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_I2C_400K;
+ }
+ else
+ {
+ ADI_SENSE_LOG_ERROR("Invalid I2C clock speed %d specified",
+ pDigitalComms->i2cClockSpeed);
+ return ADI_SENSE_INVALID_PARAM;
+ }
+
+ if(pDigitalComms->spiMode == ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_SPI_MODE_0)
+ {
+ digitalSensorComms.SPI_Mode = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_SPI_MODE_0;
+ }
+ else if(pDigitalComms->spiMode == ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_SPI_MODE_1)
+ {
+ digitalSensorComms.SPI_Mode = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_SPI_MODE_1;
+ }
+ else if(pDigitalComms->spiMode == ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_SPI_MODE_2)
+ {
+ digitalSensorComms.SPI_Mode = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_SPI_MODE_2;
+ }
+ else if(pDigitalComms->spiMode == ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_SPI_MODE_3)
+ {
+ digitalSensorComms.SPI_Mode = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_SPI_MODE_3;
+ }
+ else
+ {
+ ADI_SENSE_LOG_ERROR("Invalid SPI mode %d specified",
+ pDigitalComms->spiMode);
+ return ADI_SENSE_INVALID_PARAM;
+ }
+
+ switch (pDigitalComms->spiClock)
+ {
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_SPI_CLOCK_13MHZ:
+ digitalSensorComms.SPI_Clock = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_SPI_13MHZ;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_SPI_CLOCK_6_5MHZ:
+ digitalSensorComms.SPI_Clock = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_SPI_6_5MHZ;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_SPI_CLOCK_3_25MHZ:
+ digitalSensorComms.SPI_Clock = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_SPI_3_25MHZ;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_SPI_CLOCK_1_625MHZ:
+ digitalSensorComms.SPI_Clock = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_SPI_1_625MHZ;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_SPI_CLOCK_812KHZ:
+ digitalSensorComms.SPI_Clock = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_SPI_812KHZ;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_SPI_CLOCK_406KHZ:
+ digitalSensorComms.SPI_Clock = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_SPI_406KHZ;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_SPI_CLOCK_203KHZ:
+ digitalSensorComms.SPI_Clock = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_SPI_203KHZ;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_SPI_CLOCK_101KHZ:
+ digitalSensorComms.SPI_Clock = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_SPI_101KHZ;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_SPI_CLOCK_50KHZ:
+ digitalSensorComms.SPI_Clock = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_SPI_50KHZ;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_SPI_CLOCK_25KHZ:
+ digitalSensorComms.SPI_Clock = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_SPI_25KHZ;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_SPI_CLOCK_12KHZ:
+ digitalSensorComms.SPI_Clock = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_SPI_12KHZ;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_SPI_CLOCK_6KHZ:
+ digitalSensorComms.SPI_Clock = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_SPI_6KHZ;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_SPI_CLOCK_3KHZ:
+ digitalSensorComms.SPI_Clock = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_SPI_3KHZ;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_SPI_CLOCK_1_5KHZ:
+ digitalSensorComms.SPI_Clock = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_SPI_1_5KHZ;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_SPI_CLOCK_793HZ:
+ digitalSensorComms.SPI_Clock = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_SPI_793HZ;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_SPI_CLOCK_396HZ:
+ digitalSensorComms.SPI_Clock = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_SPI_396HZ;
+ break;
+ default:
+ ADI_SENSE_LOG_ERROR("Invalid SPI clock %d specified",
+ pDigitalComms->spiClock);
+ return ADI_SENSE_INVALID_PARAM;
+ }
+
+ switch (pDigitalComms->uartLineConfig)
+ {
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_UART_LINE_CONFIG_8N1:
+ digitalSensorComms.Uart_Mode = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_LINECONTROL_8N1;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_UART_LINE_CONFIG_8N2:
+ digitalSensorComms.Uart_Mode = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_LINECONTROL_8N2;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_UART_LINE_CONFIG_8N3:
+ digitalSensorComms.Uart_Mode = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_LINECONTROL_8N3;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_UART_LINE_CONFIG_8E1:
+ digitalSensorComms.Uart_Mode = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_LINECONTROL_8E1;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_UART_LINE_CONFIG_8E2:
+ digitalSensorComms.Uart_Mode = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_LINECONTROL_8E2;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_UART_LINE_CONFIG_8E3:
+ digitalSensorComms.Uart_Mode = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_LINECONTROL_8E3;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_UART_LINE_CONFIG_8O1:
+ digitalSensorComms.Uart_Mode = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_LINECONTROL_8O1;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_UART_LINE_CONFIG_8O2:
+ digitalSensorComms.Uart_Mode = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_LINECONTROL_8O2;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_UART_LINE_CONFIG_8O3:
+ digitalSensorComms.Uart_Mode = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_LINECONTROL_8O3;
+ break;
+ default:
+ ADI_SENSE_LOG_ERROR("Invalid UART mode %d specified",
+ pDigitalComms->uartLineConfig);
+ return ADI_SENSE_INVALID_PARAM;
+ }
+
+ switch (pDigitalComms->uartBaudRate)
+ {
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_UART_BAUD_RATE_115200:
+ digitalSensorComms.Uart_Baud = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_UART_115200;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_UART_BAUD_RATE_57600:
+ digitalSensorComms.Uart_Baud = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_UART_57600;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_UART_BAUD_RATE_38400:
+ digitalSensorComms.Uart_Baud = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_UART_38400;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_UART_BAUD_RATE_19200:
+ digitalSensorComms.Uart_Baud = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_UART_19200;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_UART_BAUD_RATE_9600:
+ digitalSensorComms.Uart_Baud = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_UART_9600;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_UART_BAUD_RATE_4800:
+ digitalSensorComms.Uart_Baud = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_UART_4800;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_UART_BAUD_RATE_2400:
+ digitalSensorComms.Uart_Baud = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_UART_2400;
+ break;
+ case ADI_SENSE_1000_DIGITAL_SENSOR_COMMS_UART_BAUD_RATE_1200:
+ digitalSensorComms.Uart_Baud = ADISENSE_CORE_DIGITAL_SENSOR_COMMS_UART_1200;
+ break;
+ default:
+ ADI_SENSE_LOG_ERROR("Invalid UART baud rate %d specified",
+ pDigitalComms->uartBaudRate);
+ return ADI_SENSE_INVALID_PARAM;
+ }
+ }
+ else
+ {
+ digitalSensorComms.Digital_Sensor_Comms_En = 0;
+ }
+
+ WRITE_REG_U16(hDevice, digitalSensorComms.VALUE16, CORE_DIGITAL_SENSOR_COMMSn(eChannelId));
+
+ return ADI_SENSE_SUCCESS;
+}
+
ADI_SENSE_RESULT adi_sense_SetI2cChannelConfig(
ADI_SENSE_DEVICE_HANDLE hDevice,
ADI_SENSE_1000_CHANNEL_ID eChannelId,
- ADI_SENSE_1000_I2C_CHANNEL_CONFIG *pI2cChannelConfig)
+ ADI_SENSE_1000_CHANNEL_CONFIG *pChannelConfig)
{
ADI_SENSE_RESULT eRet;
+ ADI_SENSE_1000_I2C_CHANNEL_CONFIG *pI2cChannelConfig =
+ &pChannelConfig->i2cChannelConfig;
eRet = adi_sense_SetChannelI2cSensorType(hDevice, eChannelId,
pI2cChannelConfig->sensor);
@@ -2080,6 +2558,15 @@
return eRet;
}
+ eRet = adi_sense_SetChannelDigitalSensorDetails(hDevice, eChannelId,
+ pChannelConfig);
+ if (eRet != ADI_SENSE_SUCCESS)
+ {
+ ADI_SENSE_LOG_ERROR("Failed to set I2C sensor details for channel %d",
+ eChannelId);
+ return eRet;
+ }
+
eRet = adi_sense_SetDigitalSensorCommands(hDevice, eChannelId,
&pI2cChannelConfig->configurationCommand,
&pI2cChannelConfig->dataRequestCommand);
@@ -2099,6 +2586,24 @@
return eRet;
}
+ eRet = adi_sense_SetDigitalCalibrationParam(hDevice, eChannelId,
+ &pI2cChannelConfig->digitalCalibrationParam);
+ if (eRet != ADI_SENSE_SUCCESS)
+ {
+ ADI_SENSE_LOG_ERROR("Failed to set I2C digital calibration param for channel %d",
+ eChannelId);
+ return eRet;
+ }
+
+ eRet = adi_sense_SetDigitalChannelComms(hDevice, eChannelId,
+ &pI2cChannelConfig->configureComms);
+ if (eRet != ADI_SENSE_SUCCESS)
+ {
+ ADI_SENSE_LOG_ERROR("Failed to set I2C comms for channel %d",
+ eChannelId);
+ return eRet;
+ }
+
return ADI_SENSE_SUCCESS;
}
@@ -2114,14 +2619,19 @@
/* Ensure that the sensor type is valid for this channel */
switch(sensorType)
{
- case ADI_SENSE_1000_SPI_SENSOR_PRESSURE_HONEYWELL_TRUSTABILITY:
- sensorTypeReg.Sensor_Type = ADISENSE_CORE_SENSOR_TYPE_SENSOR_SPI_PRESSURE_HONEYWELL_TRUSTABILITY;
- break;
- case ADI_SENSE_1000_SPI_SENSOR_ACCELEROMETER_ADI_ADXL362:
- sensorTypeReg.Sensor_Type = ADISENSE_CORE_SENSOR_TYPE_SENSOR_SPI_ACCELEROMETER_1;
- break;
- case ADI_SENSE_1000_SPI_SENSOR_ACCELEROMETER_ADI_ADXL355:
- sensorTypeReg.Sensor_Type = ADISENSE_CORE_SENSOR_TYPE_SENSOR_SPI_ACCELEROMETER_2;
+ case ADI_SENSE_1000_SPI_SENSOR_PRESSURE_A_DEF_L1:
+ case ADI_SENSE_1000_SPI_SENSOR_PRESSURE_A_DEF_L2:
+ case ADI_SENSE_1000_SPI_SENSOR_PRESSURE_A_ADV_L1:
+ case ADI_SENSE_1000_SPI_SENSOR_PRESSURE_A_ADV_L2:
+ case ADI_SENSE_1000_SPI_SENSOR_ACCELEROMETER_A_DEF_L1:
+ case ADI_SENSE_1000_SPI_SENSOR_ACCELEROMETER_B_DEF_L1:
+ case ADI_SENSE_1000_SPI_SENSOR_ACCELEROMETER_A_DEF_L2:
+ case ADI_SENSE_1000_SPI_SENSOR_ACCELEROMETER_B_DEF_L2:
+ case ADI_SENSE_1000_SPI_SENSOR_ACCELEROMETER_A_ADV_L1:
+ case ADI_SENSE_1000_SPI_SENSOR_ACCELEROMETER_B_ADV_L1:
+ case ADI_SENSE_1000_SPI_SENSOR_ACCELEROMETER_A_ADV_L2:
+ case ADI_SENSE_1000_SPI_SENSOR_ACCELEROMETER_B_ADV_L2:
+ sensorTypeReg.Sensor_Type = sensorType;
break;
default:
ADI_SENSE_LOG_ERROR("Unsupported SPI sensor type %d specified", sensorType);
@@ -2136,9 +2646,11 @@
ADI_SENSE_RESULT adi_sense_SetSpiChannelConfig(
ADI_SENSE_DEVICE_HANDLE hDevice,
ADI_SENSE_1000_CHANNEL_ID eChannelId,
- ADI_SENSE_1000_SPI_CHANNEL_CONFIG *pSpiChannelConfig)
+ ADI_SENSE_1000_CHANNEL_CONFIG *pChannelConfig)
{
ADI_SENSE_RESULT eRet;
+ ADI_SENSE_1000_SPI_CHANNEL_CONFIG *pSpiChannelConfig =
+ &pChannelConfig->spiChannelConfig;
eRet = adi_sense_SetChannelSpiSensorType(hDevice, eChannelId,
pSpiChannelConfig->sensor);
@@ -2149,6 +2661,15 @@
return eRet;
}
+ eRet = adi_sense_SetChannelDigitalSensorDetails(hDevice, eChannelId,
+ pChannelConfig);
+ if (eRet != ADI_SENSE_SUCCESS)
+ {
+ ADI_SENSE_LOG_ERROR("Failed to set SPI sensor details for channel %d",
+ eChannelId);
+ return eRet;
+ }
+
eRet = adi_sense_SetDigitalSensorCommands(hDevice, eChannelId,
&pSpiChannelConfig->configurationCommand,
&pSpiChannelConfig->dataRequestCommand);
@@ -2168,6 +2689,105 @@
return eRet;
}
+ eRet = adi_sense_SetDigitalCalibrationParam(hDevice, eChannelId,
+ &pSpiChannelConfig->digitalCalibrationParam);
+ if (eRet != ADI_SENSE_SUCCESS)
+ {
+ ADI_SENSE_LOG_ERROR("Failed to set SPI digital calibration param for channel %d",
+ eChannelId);
+ return eRet;
+ }
+
+ eRet = adi_sense_SetDigitalChannelComms(hDevice, eChannelId,
+ &pSpiChannelConfig->configureComms);
+ if (eRet != ADI_SENSE_SUCCESS)
+ {
+ ADI_SENSE_LOG_ERROR("Failed to set SPI comms for channel %d",
+ eChannelId);
+ return eRet;
+ }
+
+ return ADI_SENSE_SUCCESS;
+}
+
+static ADI_SENSE_RESULT adi_sense_SetChannelUartSensorType(
+ ADI_SENSE_DEVICE_HANDLE hDevice,
+ ADI_SENSE_1000_CHANNEL_ID eChannelId,
+ ADI_SENSE_1000_UART_SENSOR_TYPE sensorType)
+{
+ ADI_ADISENSE_CORE_Sensor_Type_t sensorTypeReg;
+
+ sensorTypeReg.VALUE16 = REG_RESET_VAL(CORE_SENSOR_TYPEn);
+
+ /* Ensure that the sensor type is valid for this channel */
+ switch(sensorType)
+ {
+ case ADI_SENSE_1000_UART_SENSOR_UART_CO2_A_DEF_L1:
+ case ADI_SENSE_1000_UART_SENSOR_UART_CO2_B_DEF_L1:
+ case ADI_SENSE_1000_UART_SENSOR_UART_CO2_A_DEF_L2:
+ case ADI_SENSE_1000_UART_SENSOR_UART_CO2_B_DEF_L2:
+ case ADI_SENSE_1000_UART_SENSOR_UART_CO2_A_ADV_L1:
+ case ADI_SENSE_1000_UART_SENSOR_UART_CO2_B_ADV_L1:
+ case ADI_SENSE_1000_UART_SENSOR_UART_CO2_A_ADV_L2:
+ case ADI_SENSE_1000_UART_SENSOR_UART_CO2_B_ADV_L2:
+ sensorTypeReg.Sensor_Type = sensorType;
+ break;
+ default:
+ ADI_SENSE_LOG_ERROR("Unsupported UART sensor type %d specified", sensorType);
+ return ADI_SENSE_INVALID_PARAM;
+ }
+
+ WRITE_REG_U16(hDevice, sensorTypeReg.VALUE16, CORE_SENSOR_TYPEn(eChannelId));
+
+ return ADI_SENSE_SUCCESS;
+}
+
+ADI_SENSE_RESULT adi_sense_SetUartChannelConfig(
+ ADI_SENSE_DEVICE_HANDLE hDevice,
+ ADI_SENSE_1000_CHANNEL_ID eChannelId,
+ ADI_SENSE_1000_CHANNEL_CONFIG *pChannelConfig)
+{
+ ADI_SENSE_RESULT eRet;
+ ADI_SENSE_1000_UART_CHANNEL_CONFIG *pUartChannelConfig =
+ &pChannelConfig->uartChannelConfig;
+
+ eRet = adi_sense_SetChannelUartSensorType(hDevice, eChannelId,
+ pUartChannelConfig->sensor);
+ if (eRet != ADI_SENSE_SUCCESS)
+ {
+ ADI_SENSE_LOG_ERROR("Failed to set UART sensor type for channel %d",
+ eChannelId);
+ return eRet;
+ }
+
+ eRet = adi_sense_SetChannelDigitalSensorDetails(hDevice, eChannelId,
+ pChannelConfig);
+ if (eRet != ADI_SENSE_SUCCESS)
+ {
+ ADI_SENSE_LOG_ERROR("Failed to set UART sensor details for channel %d",
+ eChannelId);
+ return eRet;
+ }
+
+ eRet = adi_sense_SetDigitalCalibrationParam(hDevice, eChannelId,
+ &pUartChannelConfig->digitalCalibrationParam);
+ if (eRet != ADI_SENSE_SUCCESS)
+ {
+ ADI_SENSE_LOG_ERROR("Failed to set UART digital calibration param for channel %d",
+ eChannelId);
+ return eRet;
+ }
+
+ eRet = adi_sense_SetDigitalChannelComms(hDevice, eChannelId,
+ &pUartChannelConfig->configureComms);
+ if (eRet != ADI_SENSE_SUCCESS)
+ {
+ ADI_SENSE_LOG_ERROR("Failed to set UART comms for channel %d",
+ eChannelId);
+ return eRet;
+ }
+
+
return ADI_SENSE_SUCCESS;
}
@@ -2318,12 +2938,13 @@
break;
case ADI_SENSE_1000_CHANNEL_ID_I2C_0:
case ADI_SENSE_1000_CHANNEL_ID_I2C_1:
- eRet = adi_sense_SetI2cChannelConfig(hDevice, eChannelId,
- &pChannelConfig->i2cChannelConfig);
+ eRet = adi_sense_SetI2cChannelConfig(hDevice, eChannelId, pChannelConfig);
break;
case ADI_SENSE_1000_CHANNEL_ID_SPI_0:
- eRet = adi_sense_SetSpiChannelConfig(hDevice, eChannelId,
- &pChannelConfig->spiChannelConfig);
+ eRet = adi_sense_SetSpiChannelConfig(hDevice, eChannelId, pChannelConfig);
+ break;
+ case ADI_SENSE_1000_CHANNEL_ID_UART:
+ eRet = adi_sense_SetUartChannelConfig(hDevice, eChannelId, pChannelConfig);
break;
default:
ADI_SENSE_LOG_ERROR("Invalid channel ID %d specified", eChannelId);
@@ -2521,7 +3142,7 @@
return ADI_SENSE_INVALID_PARAM;
}
- calculatedCrc = crc16_ccitt(pData, pDesc->length);
+ calculatedCrc = adi_sense_crc16_ccitt(pData, pDesc->length);
if (calculatedCrc != pDesc->crc16)
{
ADI_SENSE_LOG_ERROR("CRC validation failed on LUT table %u (expected 0x%04X, actual 0x%04X)",
@@ -2640,7 +3261,7 @@
/* Fill in the table descriptor length and CRC fields */
pDesc->length = dataLength;
- pDesc->crc16 = crc16_ccitt(pData, dataLength);
+ pDesc->crc16 = adi_sense_crc16_ccitt(pData, dataLength);
if ((sizeof(*pHdr) + pHdr->totalLength + sizeof(*pDesc) + dataLength) > nLutBufferSize)
{