Rohan Gurav
/
Sean_AdiSense1000_V21
ADISense1000 Version 2.1 code base
Fork of AdiSense1000_V21 by
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) {