Ross O'Halloran
/
AdiSense1000_SmartBabySeat
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.
Fork of
AdiSense1000_SmartBabySeat
by 
SDMP_IOT
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)
{