EV-PRO-MW1001_Development - added wait_us(31) in admw_spi.cpp to support hibe…

Users » Vkadaba » Code » EV-PRO-MW1001_Development

Vybhav Kadaba / Mbed OS EV-PRO-MW1001_Development

added wait_us(31) in admw_spi.cpp to support hibernation mode

src/admw_1001.c@18:cbf514cce921, 2019-08-20 (annotated)

Committer:: Vkadaba
Date:: Tue Aug 20 12:19:31 2019 +0000
Revision:: 18:cbf514cce921
Parent:: 17:2f0028880874
Child:: 23:bb685f35b08b

Added No excitation current config in host firmware

Who changed what in which revision?

User	Revision	Line number	New contents of line
ADIJake	0:85855ecd3257	1	/*
Vkadaba	8:2f2775c34640	2	Copyright 2019 (c) Analog Devices, Inc.
ADIJake	0:85855ecd3257	3
ADIJake	0:85855ecd3257	4	All rights reserved.
ADIJake	0:85855ecd3257	5
ADIJake	0:85855ecd3257	6	Redistribution and use in source and binary forms, with or without
ADIJake	0:85855ecd3257	7	modification, are permitted provided that the following conditions are met:
ADIJake	0:85855ecd3257	8	- Redistributions of source code must retain the above copyright
ADIJake	0:85855ecd3257	9	notice, this list of conditions and the following disclaimer.
ADIJake	0:85855ecd3257	10	- Redistributions in binary form must reproduce the above copyright
ADIJake	0:85855ecd3257	11	notice, this list of conditions and the following disclaimer in
ADIJake	0:85855ecd3257	12	the documentation and/or other materials provided with the
ADIJake	0:85855ecd3257	13	distribution.
ADIJake	0:85855ecd3257	14	- Neither the name of Analog Devices, Inc. nor the names of its
ADIJake	0:85855ecd3257	15	contributors may be used to endorse or promote products derived
ADIJake	0:85855ecd3257	16	from this software without specific prior written permission.
ADIJake	0:85855ecd3257	17	- The use of this software may or may not infringe the patent rights
ADIJake	0:85855ecd3257	18	of one or more patent holders. This license does not release you
ADIJake	0:85855ecd3257	19	from the requirement that you obtain separate licenses from these
ADIJake	0:85855ecd3257	20	patent holders to use this software.
ADIJake	0:85855ecd3257	21	- Use of the software either in source or binary form, must be run
ADIJake	0:85855ecd3257	22	on or directly connected to an Analog Devices Inc. component.
ADIJake	0:85855ecd3257	23
ADIJake	0:85855ecd3257	24	THIS SOFTWARE IS PROVIDED BY ANALOG DEVICES "AS IS" AND ANY EXPRESS OR
ADIJake	0:85855ecd3257	25	IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, NON-INFRINGEMENT,
ADIJake	0:85855ecd3257	26	MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
ADIJake	0:85855ecd3257	27	IN NO EVENT SHALL ANALOG DEVICES BE LIABLE FOR ANY DIRECT, INDIRECT,
ADIJake	0:85855ecd3257	28	INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
ADIJake	0:85855ecd3257	29	LIMITED TO, INTELLECTUAL PROPERTY RIGHTS, PROCUREMENT OF SUBSTITUTE GOODS OR
ADIJake	0:85855ecd3257	30	SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
ADIJake	0:85855ecd3257	31	CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
ADIJake	0:85855ecd3257	32	OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
ADIJake	0:85855ecd3257	33	OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
ADIJake	0:85855ecd3257	34	*/
ADIJake	0:85855ecd3257	35
ADIJake	0:85855ecd3257	36	/*!
ADIJake	0:85855ecd3257	37	******************************************************************************
ADIJake	0:85855ecd3257	38	* @file:
Vkadaba	8:2f2775c34640	39	* @brief: API implementation for ADMW1001
ADIJake	0:85855ecd3257	40	*-----------------------------------------------------------------------------
ADIJake	0:85855ecd3257	41	*/
ADIJake	0:85855ecd3257	42
ADIJake	0:85855ecd3257	43	#include <float.h>
ADIJake	0:85855ecd3257	44	#include <math.h>
ADIJake	0:85855ecd3257	45	#include <string.h>
ADIJake	0:85855ecd3257	46
Vkadaba	5:0728bde67bdb	47	#include "admw_platform.h"
Vkadaba	5:0728bde67bdb	48	#include "admw_api.h"
Vkadaba	5:0728bde67bdb	49	#include "admw1001/admw1001_api.h"
Vkadaba	5:0728bde67bdb	50
Vkadaba	5:0728bde67bdb	51	#include "admw1001/ADMW1001_REGISTERS_typedefs.h"
Vkadaba	5:0728bde67bdb	52	#include "admw1001/ADMW1001_REGISTERS.h"
Vkadaba	5:0728bde67bdb	53	#include "admw1001/admw1001_lut_data.h"
Vkadaba	5:0728bde67bdb	54	#include "admw1001/admw1001_host_comms.h"
ADIJake	0:85855ecd3257	55
ADIJake	0:85855ecd3257	56	#include "crc16.h"
Vkadaba	13:97cb32670539	57	#define VERSIONID_MAJOR 2
Vkadaba	13:97cb32670539	58	#define VERSIONID_MINOR 0
ADIJake	0:85855ecd3257	59
ADIJake	0:85855ecd3257	60	uint32_t getDataCnt = 0;
ADIJake	0:85855ecd3257	61
ADIJake	0:85855ecd3257	62	/*
ADIJake	0:85855ecd3257	63	* The following macros are used to encapsulate the register access code
ADIJake	0:85855ecd3257	64	* to improve readability in the functions further below in this file
ADIJake	0:85855ecd3257	65	*/
ADIJake	0:85855ecd3257	66	#define STRINGIFY(name) #name
ADIJake	0:85855ecd3257	67
ADIJake	0:85855ecd3257	68	/* Expand the full name of the reset value macro for the specified register */
Vkadaba	5:0728bde67bdb	69	#define REG_RESET_VAL(_name) REG_##_name##_RESET
ADIJake	0:85855ecd3257	70
ADIJake	0:85855ecd3257	71	/* Checks if a value is outside the bounds of the specified register field */
ADIJake	0:85855ecd3257	72	#define CHECK_REG_FIELD_VAL(_field, _val) \
ADIJake	0:85855ecd3257	73	do { \
Vkadaba	8:2f2775c34640	74	uint32_t _mask = BITM_##_field; \
Vkadaba	8:2f2775c34640	75	uint32_t _shift = BITP_##_field; \
ADIJake	0:85855ecd3257	76	if ((((_val) << _shift) & ~(_mask)) != 0) { \
Vkadaba	6:9d393a9677f4	77	ADMW_LOG_ERROR("Value 0x%08X invalid for register field %s",\
ADIJake	0:85855ecd3257	78	(uint32_t)(_val), \
Vkadaba	6:9d393a9677f4	79	STRINGIFY(ADMW_##_field)); \
Vkadaba	8:2f2775c34640	80	return ADMW_INVALID_PARAM; \
ADIJake	0:85855ecd3257	81	} \
ADIJake	0:85855ecd3257	82	} while(false)
ADIJake	0:85855ecd3257	83
ADIJake	0:85855ecd3257	84	/*
ADIJake	0:85855ecd3257	85	* Encapsulates the write to a specified register
ADIJake	0:85855ecd3257	86	* NOTE - this will cause the calling function to return on error
ADIJake	0:85855ecd3257	87	*/
ADIJake	0:85855ecd3257	88	#define WRITE_REG(_hdev, _val, _name, _type) \
ADIJake	0:85855ecd3257	89	do { \
Vkadaba	8:2f2775c34640	90	ADMW_RESULT _res; \
ADIJake	0:85855ecd3257	91	_type _regval = _val; \
Vkadaba	8:2f2775c34640	92	_res = admw1001_WriteRegister((_hdev), \
Vkadaba	8:2f2775c34640	93	REG_##_name, \
ADIJake	0:85855ecd3257	94	&_regval, sizeof(_regval)); \
Vkadaba	8:2f2775c34640	95	if (_res != ADMW_SUCCESS) \
ADIJake	0:85855ecd3257	96	return _res; \
ADIJake	0:85855ecd3257	97	} while(false)
ADIJake	0:85855ecd3257	98
ADIJake	0:85855ecd3257	99	/* Wrapper macro to write a value to a uint32_t register */
Vkadaba	8:2f2775c34640	100	#define WRITE_REG_U32(_hdev, _val, _name) \
ADIJake	0:85855ecd3257	101	WRITE_REG(_hdev, _val, _name, uint32_t)
ADIJake	0:85855ecd3257	102	/* Wrapper macro to write a value to a uint16_t register */
Vkadaba	8:2f2775c34640	103	#define WRITE_REG_U16(_hdev, _val, _name) \
ADIJake	0:85855ecd3257	104	WRITE_REG(_hdev, _val, _name, uint16_t)
ADIJake	0:85855ecd3257	105	/* Wrapper macro to write a value to a uint8_t register */
Vkadaba	8:2f2775c34640	106	#define WRITE_REG_U8(_hdev, _val, _name) \
ADIJake	0:85855ecd3257	107	WRITE_REG(_hdev, _val, _name, uint8_t)
ADIJake	0:85855ecd3257	108	/* Wrapper macro to write a value to a float32_t register */
Vkadaba	8:2f2775c34640	109	#define WRITE_REG_FLOAT(_hdev, _val, _name) \
ADIJake	0:85855ecd3257	110	WRITE_REG(_hdev, _val, _name, float32_t)
ADIJake	0:85855ecd3257	111
ADIJake	0:85855ecd3257	112	/*
ADIJake	0:85855ecd3257	113	* Encapsulates the read from a specified register
ADIJake	0:85855ecd3257	114	* NOTE - this will cause the calling function to return on error
ADIJake	0:85855ecd3257	115	*/
ADIJake	0:85855ecd3257	116	#define READ_REG(_hdev, _val, _name, _type) \
ADIJake	0:85855ecd3257	117	do { \
Vkadaba	8:2f2775c34640	118	ADMW_RESULT _res; \
ADIJake	0:85855ecd3257	119	_type _regval; \
Vkadaba	8:2f2775c34640	120	_res = admw1001_ReadRegister((_hdev), \
Vkadaba	8:2f2775c34640	121	REG_##_name, \
ADIJake	0:85855ecd3257	122	&_regval, sizeof(_regval)); \
Vkadaba	8:2f2775c34640	123	if (_res != ADMW_SUCCESS) \
ADIJake	0:85855ecd3257	124	return _res; \
ADIJake	0:85855ecd3257	125	_val = _regval; \
ADIJake	0:85855ecd3257	126	} while(false)
ADIJake	0:85855ecd3257	127
ADIJake	0:85855ecd3257	128	/* Wrapper macro to read a value from a uint32_t register */
Vkadaba	8:2f2775c34640	129	#define READ_REG_U32(_hdev, _val, _name) \
ADIJake	0:85855ecd3257	130	READ_REG(_hdev, _val, _name, uint32_t)
ADIJake	0:85855ecd3257	131	/* Wrapper macro to read a value from a uint16_t register */
Vkadaba	8:2f2775c34640	132	#define READ_REG_U16(_hdev, _val, _name) \
ADIJake	0:85855ecd3257	133	READ_REG(_hdev, _val, _name, uint16_t)
ADIJake	0:85855ecd3257	134	/* Wrapper macro to read a value from a uint8_t register */
Vkadaba	8:2f2775c34640	135	#define READ_REG_U8(_hdev, _val, _name) \
ADIJake	0:85855ecd3257	136	READ_REG(_hdev, _val, _name, uint8_t)
ADIJake	0:85855ecd3257	137	/* Wrapper macro to read a value from a float32_t register */
Vkadaba	8:2f2775c34640	138	#define READ_REG_FLOAT(_hdev, _val, _name) \
ADIJake	0:85855ecd3257	139	READ_REG(_hdev, _val, _name, float32_t)
ADIJake	0:85855ecd3257	140
ADIJake	0:85855ecd3257	141	/*
ADIJake	0:85855ecd3257	142	* Wrapper macro to write an array of values to a uint8_t register
ADIJake	0:85855ecd3257	143	* NOTE - this is intended only for writing to a keyhole data register
ADIJake	0:85855ecd3257	144	*/
Vkadaba	8:2f2775c34640	145	#define WRITE_REG_U8_ARRAY(_hdev, _arr, _len, _name) \
Vkadaba	6:9d393a9677f4	146	do { \
Vkadaba	8:2f2775c34640	147	ADMW_RESULT _res; \
Vkadaba	8:2f2775c34640	148	_res = admw1001_WriteRegister(_hdev, \
Vkadaba	8:2f2775c34640	149	REG_##_name, \
Vkadaba	6:9d393a9677f4	150	_arr, _len); \
Vkadaba	8:2f2775c34640	151	if (_res != ADMW_SUCCESS) \
Vkadaba	6:9d393a9677f4	152	return _res; \
ADIJake	0:85855ecd3257	153	} while(false)
ADIJake	0:85855ecd3257	154
ADIJake	0:85855ecd3257	155	/*
ADIJake	0:85855ecd3257	156	* Wrapper macro to read an array of values from a uint8_t register
ADIJake	0:85855ecd3257	157	* NOTE - this is intended only for reading from a keyhole data register
ADIJake	0:85855ecd3257	158	*/
Vkadaba	6:9d393a9677f4	159	#define READ_REG_U8_ARRAY(_hdev, _arr, _len, _name) \
Vkadaba	6:9d393a9677f4	160	do { \
Vkadaba	8:2f2775c34640	161	ADMW_RESULT _res; \
Vkadaba	8:2f2775c34640	162	_res = admw1001_ReadRegister((_hdev), \
Vkadaba	8:2f2775c34640	163	REG##_name, \
Vkadaba	6:9d393a9677f4	164	_arr, _len); \
Vkadaba	8:2f2775c34640	165	if (_res != ADMW_SUCCESS) \
Vkadaba	6:9d393a9677f4	166	return _res; \
ADIJake	0:85855ecd3257	167	} while(false)
ADIJake	0:85855ecd3257	168
Vkadaba	8:2f2775c34640	169	#define ADMW1001_CHANNEL_IS_ADC(c) \
Vkadaba	8:2f2775c34640	170	((c) >= ADMW1001_CH_ID_ANLG_1_UNIVERSAL && (c) <= ADMW1001_CH_ID_ANLG_2_DIFFERENTIAL)
Vkadaba	6:9d393a9677f4	171
Vkadaba	8:2f2775c34640	172	#define ADMW1001_CHANNEL_IS_ADC_CJC(c) \
Vkadaba	8:2f2775c34640	173	((c) >= ADMW1001_CH_ID_ANLG_1_UNIVERSAL && (c) <= ADMW1001_CH_ID_ANLG_2_UNIVERSAL)
Vkadaba	6:9d393a9677f4	174
Vkadaba	8:2f2775c34640	175	#define ADMW1001_CHANNEL_IS_ADC_SENSOR(c) \
Vkadaba	8:2f2775c34640	176	((c) >= ADMW1001_CH_ID_ANLG_1_UNIVERSAL && (c) <= ADMW1001_CH_ID_ANLG_2_UNIVERSAL)
Vkadaba	6:9d393a9677f4	177
Vkadaba	8:2f2775c34640	178	#define ADMW1001_CHANNEL_IS_ADC_VOLTAGE(c) \
Vkadaba	8:2f2775c34640	179	((c) == ADMW1001_CH_ID_ANLG_1_DIFFERENTIAL \|\| ADMW1001_CH_ID_ANLG_2_DIFFERENTIAL)
Vkadaba	6:9d393a9677f4	180
Vkadaba	8:2f2775c34640	181	#define ADMW1001_CHANNEL_IS_ADC_CURRENT(c) \
Vkadaba	8:2f2775c34640	182	((c) == ADMW1001_CH_ID_ANLG_1_UNIVERSAL \|\| (c) == ADMW1001_CH_ID_ANLG_2_UNIVERSAL)
Vkadaba	6:9d393a9677f4	183
Vkadaba	8:2f2775c34640	184	#define ADMW1001_CHANNEL_IS_VIRTUAL(c) \
Vkadaba	8:2f2775c34640	185	((c) == ADMW1001_CH_ID_DIG_SPI_1 \|\| (c) == ADMW1001_CH_ID_DIG_SPI_2)
ADIJake	0:85855ecd3257	186
ADIJake	0:85855ecd3257	187	typedef struct
ADIJake	0:85855ecd3257	188	{
ADIJake	0:85855ecd3257	189	unsigned nDeviceIndex;
Vkadaba	5:0728bde67bdb	190	ADMW_SPI_HANDLE hSpi;
Vkadaba	5:0728bde67bdb	191	ADMW_GPIO_HANDLE hGpio;
Vkadaba	8:2f2775c34640	192
Vkadaba	8:2f2775c34640	193	} ADMW_DEVICE_CONTEXT;
Vkadaba	5:0728bde67bdb	194
Vkadaba	5:0728bde67bdb	195	static ADMW_DEVICE_CONTEXT gDeviceCtx[ADMW_PLATFORM_MAX_DEVICES];
ADIJake	0:85855ecd3257	196
ADIJake	0:85855ecd3257	197	/*
Vkadaba	5:0728bde67bdb	198	* Open an ADMW device instance.
ADIJake	0:85855ecd3257	199	*/
Vkadaba	5:0728bde67bdb	200	ADMW_RESULT admw_Open(
Vkadaba	8:2f2775c34640	201	unsigned const nDeviceIndex,
Vkadaba	5:0728bde67bdb	202	ADMW_CONNECTION * const pConnectionInfo,
Vkadaba	5:0728bde67bdb	203	ADMW_DEVICE_HANDLE * const phDevice)
ADIJake	0:85855ecd3257	204	{
Vkadaba	5:0728bde67bdb	205	ADMW_DEVICE_CONTEXT *pCtx;
Vkadaba	5:0728bde67bdb	206	ADMW_RESULT eRet;
Vkadaba	5:0728bde67bdb	207
Vkadaba	5:0728bde67bdb	208	if (nDeviceIndex >= ADMW_PLATFORM_MAX_DEVICES)
Vkadaba	5:0728bde67bdb	209	return ADMW_INVALID_DEVICE_NUM;
ADIJake	0:85855ecd3257	210
ADIJake	0:85855ecd3257	211	pCtx = &gDeviceCtx[nDeviceIndex];
ADIJake	0:85855ecd3257	212	pCtx->nDeviceIndex = nDeviceIndex;
ADIJake	0:85855ecd3257	213
Vkadaba	5:0728bde67bdb	214	eRet = admw_LogOpen(&pConnectionInfo->log);
Vkadaba	5:0728bde67bdb	215	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	216	return eRet;
ADIJake	0:85855ecd3257	217
Vkadaba	5:0728bde67bdb	218	eRet = admw_GpioOpen(&pConnectionInfo->gpio, &pCtx->hGpio);
Vkadaba	5:0728bde67bdb	219	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	220	return eRet;
ADIJake	0:85855ecd3257	221
Vkadaba	5:0728bde67bdb	222	eRet = admw_SpiOpen(&pConnectionInfo->spi, &pCtx->hSpi);
Vkadaba	5:0728bde67bdb	223	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	224	return eRet;
ADIJake	0:85855ecd3257	225
ADIJake	0:85855ecd3257	226	*phDevice = pCtx;
Vkadaba	5:0728bde67bdb	227	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	228	}
ADIJake	0:85855ecd3257	229
ADIJake	0:85855ecd3257	230	/*
ADIJake	0:85855ecd3257	231	* Get the current state of the specified GPIO input signal.
ADIJake	0:85855ecd3257	232	*/
Vkadaba	5:0728bde67bdb	233	ADMW_RESULT admw_GetGpioState(
Vkadaba	5:0728bde67bdb	234	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	5:0728bde67bdb	235	ADMW_GPIO_PIN const ePinId,
ADIJake	0:85855ecd3257	236	bool * const pbAsserted)
ADIJake	0:85855ecd3257	237	{
Vkadaba	5:0728bde67bdb	238	ADMW_DEVICE_CONTEXT *pCtx = hDevice;
Vkadaba	5:0728bde67bdb	239
Vkadaba	5:0728bde67bdb	240	return admw_GpioGet(pCtx->hGpio, ePinId, pbAsserted);
ADIJake	0:85855ecd3257	241	}
ADIJake	0:85855ecd3257	242
ADIJake	0:85855ecd3257	243	/*
ADIJake	0:85855ecd3257	244	* Register an application-defined callback function for GPIO interrupts.
ADIJake	0:85855ecd3257	245	*/
Vkadaba	5:0728bde67bdb	246	ADMW_RESULT admw_RegisterGpioCallback(
Vkadaba	5:0728bde67bdb	247	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	5:0728bde67bdb	248	ADMW_GPIO_PIN const ePinId,
Vkadaba	5:0728bde67bdb	249	ADMW_GPIO_CALLBACK const callbackFunction,
ADIJake	0:85855ecd3257	250	void * const pCallbackParam)
ADIJake	0:85855ecd3257	251	{
Vkadaba	5:0728bde67bdb	252	ADMW_DEVICE_CONTEXT *pCtx = hDevice;
ADIJake	0:85855ecd3257	253
ADIJake	0:85855ecd3257	254	if (callbackFunction)
ADIJake	0:85855ecd3257	255	{
Vkadaba	5:0728bde67bdb	256	return admw_GpioIrqEnable(pCtx->hGpio, ePinId, callbackFunction,
ADIJake	0:85855ecd3257	257	pCallbackParam);
ADIJake	0:85855ecd3257	258	}
ADIJake	0:85855ecd3257	259	else
ADIJake	0:85855ecd3257	260	{
Vkadaba	5:0728bde67bdb	261	return admw_GpioIrqDisable(pCtx->hGpio, ePinId);
ADIJake	0:85855ecd3257	262	}
ADIJake	0:85855ecd3257	263	}
ADIJake	0:85855ecd3257	264
Vkadaba	8:2f2775c34640	265	/*!
Vkadaba	8:2f2775c34640	266	* @brief Reset the specified ADMW device.
Vkadaba	8:2f2775c34640	267	*
Vkadaba	8:2f2775c34640	268	* @param[in] hDevice - handle of ADMW device to reset.
Vkadaba	8:2f2775c34640	269	*
Vkadaba	8:2f2775c34640	270	* @return Status
Vkadaba	8:2f2775c34640	271	* - #ADMW_SUCCESS Call completed successfully.
Vkadaba	8:2f2775c34640	272	* - #ADMW_FAILURE If reseet faisl
Vkadaba	8:2f2775c34640	273	*
Vkadaba	8:2f2775c34640	274	* @details Toggle reset pin of the ADMW device low for a
Vkadaba	8:2f2775c34640	275	* minimum of 4 usec.
Vkadaba	8:2f2775c34640	276	*
ADIJake	0:85855ecd3257	277	*/
Vkadaba	8:2f2775c34640	278	ADMW_RESULT admw_Reset(ADMW_DEVICE_HANDLE const hDevice)
ADIJake	0:85855ecd3257	279	{
Vkadaba	5:0728bde67bdb	280	ADMW_DEVICE_CONTEXT *pCtx = hDevice;
Vkadaba	5:0728bde67bdb	281	ADMW_RESULT eRet;
ADIJake	0:85855ecd3257	282
ADIJake	0:85855ecd3257	283	/* Pulse the Reset GPIO pin low for a minimum of 4 microseconds */
Vkadaba	5:0728bde67bdb	284	eRet = admw_GpioSet(pCtx->hGpio, ADMW_GPIO_PIN_RESET, false);
Vkadaba	5:0728bde67bdb	285	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	286	return eRet;
ADIJake	0:85855ecd3257	287
Vkadaba	5:0728bde67bdb	288	admw_TimeDelayUsec(4);
Vkadaba	5:0728bde67bdb	289
Vkadaba	5:0728bde67bdb	290	eRet = admw_GpioSet(pCtx->hGpio, ADMW_GPIO_PIN_RESET, true);
Vkadaba	5:0728bde67bdb	291	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	292	return eRet;
ADIJake	0:85855ecd3257	293
Vkadaba	5:0728bde67bdb	294	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	295	}
ADIJake	0:85855ecd3257	296
ADIJake	0:85855ecd3257	297	/*!
Vkadaba	8:2f2775c34640	298	* @brief Get general status of ADMW module.
ADIJake	0:85855ecd3257	299	*
ADIJake	0:85855ecd3257	300	* @param[in]
ADIJake	0:85855ecd3257	301	* @param[out] pStatus : Pointer to CORE Status struct.
ADIJake	0:85855ecd3257	302	*
ADIJake	0:85855ecd3257	303	* @return Status
Vkadaba	5:0728bde67bdb	304	* - #ADMW_SUCCESS Call completed successfully.
Vkadaba	5:0728bde67bdb	305	* - #ADMW_FAILURE If status register read fails.
ADIJake	0:85855ecd3257	306	*
Vkadaba	8:2f2775c34640	307	* @details Read the general status register for the ADMW
ADIJake	0:85855ecd3257	308	* module. Indicates Error, Alert conditions, data ready
ADIJake	0:85855ecd3257	309	* and command running.
ADIJake	0:85855ecd3257	310	*
ADIJake	0:85855ecd3257	311	*/
Vkadaba	5:0728bde67bdb	312	ADMW_RESULT admw_GetStatus(
Vkadaba	5:0728bde67bdb	313	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	5:0728bde67bdb	314	ADMW_STATUS * const pStatus)
ADIJake	0:85855ecd3257	315	{
Vkadaba	8:2f2775c34640	316	ADMW_CORE_Status_t statusReg;
ADIJake	0:85855ecd3257	317	READ_REG_U8(hDevice, statusReg.VALUE8, CORE_STATUS);
ADIJake	0:85855ecd3257	318
Vkadaba	8:2f2775c34640	319	ADMW_CORE_Alert_Status_2_t alert2Reg;
ADIJake	0:85855ecd3257	320	READ_REG_U16(hDevice, alert2Reg.VALUE16, CORE_ALERT_STATUS_2);
ADIJake	0:85855ecd3257	321
ADIJake	0:85855ecd3257	322	memset(pStatus, 0, sizeof(*pStatus));
ADIJake	0:85855ecd3257	323
ADIJake	0:85855ecd3257	324	if (!statusReg.Cmd_Running) /* Active-low, so invert it */
Vkadaba	5:0728bde67bdb	325	pStatus->deviceStatus \|= ADMW_DEVICE_STATUS_BUSY;
ADIJake	0:85855ecd3257	326	if (statusReg.Drdy)
Vkadaba	5:0728bde67bdb	327	pStatus->deviceStatus \|= ADMW_DEVICE_STATUS_DATAREADY;
ADIJake	0:85855ecd3257	328	if (statusReg.FIFO_Error)
Vkadaba	5:0728bde67bdb	329	pStatus->deviceStatus \|= ADMW_DEVICE_STATUS_FIFO_ERROR;
ADIJake	0:85855ecd3257	330	if (statusReg.Alert_Active)
ADIJake	0:85855ecd3257	331	{
Vkadaba	5:0728bde67bdb	332	pStatus->deviceStatus \|= ADMW_DEVICE_STATUS_ALERT;
Vkadaba	5:0728bde67bdb	333
Vkadaba	8:2f2775c34640	334	ADMW_CORE_Alert_Code_t alertCodeReg;
ADIJake	0:85855ecd3257	335	READ_REG_U16(hDevice, alertCodeReg.VALUE16, CORE_ALERT_CODE);
ADIJake	0:85855ecd3257	336	pStatus->alertCode = alertCodeReg.Alert_Code;
ADIJake	0:85855ecd3257	337
Vkadaba	8:2f2775c34640	338	ADMW_CORE_Channel_Alert_Status_t channelAlertStatusReg;
ADIJake	0:85855ecd3257	339	READ_REG_U16(hDevice, channelAlertStatusReg.VALUE16,
ADIJake	0:85855ecd3257	340	CORE_CHANNEL_ALERT_STATUS);
ADIJake	0:85855ecd3257	341
Vkadaba	5:0728bde67bdb	342	for (unsigned i = 0; i < ADMW1001_MAX_CHANNELS; i++)
ADIJake	0:85855ecd3257	343	{
ADIJake	0:85855ecd3257	344	if (channelAlertStatusReg.VALUE16 & (1 << i))
ADIJake	0:85855ecd3257	345	{
Vkadaba	8:2f2775c34640	346	ADMW_CORE_Alert_Code_Ch_t channelAlertCodeReg;
ADIJake	0:85855ecd3257	347	READ_REG_U16(hDevice, channelAlertCodeReg.VALUE16, CORE_ALERT_CODE_CHn(i));
ADIJake	0:85855ecd3257	348	pStatus->channelAlertCodes[i] = channelAlertCodeReg.Alert_Code_Ch;
ADIJake	0:85855ecd3257	349
Vkadaba	8:2f2775c34640	350	ADMW_CORE_Alert_Detail_Ch_t alertDetailReg;
ADIJake	0:85855ecd3257	351	READ_REG_U16(hDevice, alertDetailReg.VALUE16,
ADIJake	0:85855ecd3257	352	CORE_ALERT_DETAIL_CHn(i));
ADIJake	0:85855ecd3257	353
ADIJake	0:85855ecd3257	354	if (alertDetailReg.Time_Out)
Vkadaba	5:0728bde67bdb	355	pStatus->channelAlerts[i] \|= ADMW_CHANNEL_ALERT_TIMEOUT;
ADIJake	0:85855ecd3257	356	if (alertDetailReg.Under_Range)
Vkadaba	5:0728bde67bdb	357	pStatus->channelAlerts[i] \|= ADMW_CHANNEL_ALERT_UNDER_RANGE;
ADIJake	0:85855ecd3257	358	if (alertDetailReg.Over_Range)
Vkadaba	5:0728bde67bdb	359	pStatus->channelAlerts[i] \|= ADMW_CHANNEL_ALERT_OVER_RANGE;
ADIJake	0:85855ecd3257	360	if (alertDetailReg.Low_Limit)
Vkadaba	5:0728bde67bdb	361	pStatus->channelAlerts[i] \|= ADMW_CHANNEL_ALERT_LOW_LIMIT;
ADIJake	0:85855ecd3257	362	if (alertDetailReg.High_Limit)
Vkadaba	5:0728bde67bdb	363	pStatus->channelAlerts[i] \|= ADMW_CHANNEL_ALERT_HIGH_LIMIT;
ADIJake	0:85855ecd3257	364	if (alertDetailReg.Sensor_Open)
Vkadaba	5:0728bde67bdb	365	pStatus->channelAlerts[i] \|= ADMW_CHANNEL_ALERT_SENSOR_OPEN;
ADIJake	0:85855ecd3257	366	if (alertDetailReg.Ref_Detect)
Vkadaba	5:0728bde67bdb	367	pStatus->channelAlerts[i] \|= ADMW_CHANNEL_ALERT_REF_DETECT;
ADIJake	0:85855ecd3257	368	if (alertDetailReg.Config_Err)
Vkadaba	5:0728bde67bdb	369	pStatus->channelAlerts[i] \|= ADMW_CHANNEL_ALERT_CONFIG_ERR;
ADIJake	0:85855ecd3257	370	if (alertDetailReg.LUT_Error_Ch)
Vkadaba	5:0728bde67bdb	371	pStatus->channelAlerts[i] \|= ADMW_CHANNEL_ALERT_LUT_ERR;
ADIJake	0:85855ecd3257	372	if (alertDetailReg.Sensor_Not_Ready)
Vkadaba	5:0728bde67bdb	373	pStatus->channelAlerts[i] \|= ADMW_CHANNEL_ALERT_SENSOR_NOT_READY;
ADIJake	0:85855ecd3257	374	if (alertDetailReg.Comp_Not_Ready)
Vkadaba	5:0728bde67bdb	375	pStatus->channelAlerts[i] \|= ADMW_CHANNEL_ALERT_COMP_NOT_READY;
ADIJake	0:85855ecd3257	376	if (alertDetailReg.Correction_UnderRange)
Vkadaba	5:0728bde67bdb	377	pStatus->channelAlerts[i] \|= ADMW_CHANNEL_ALERT_LUT_UNDER_RANGE;
ADIJake	0:85855ecd3257	378	if (alertDetailReg.Correction_OverRange)
Vkadaba	5:0728bde67bdb	379	pStatus->channelAlerts[i] \|= ADMW_CHANNEL_ALERT_LUT_OVER_RANGE;
ADIJake	0:85855ecd3257	380	}
ADIJake	0:85855ecd3257	381	}
ADIJake	0:85855ecd3257	382
ADIJake	0:85855ecd3257	383	if (alert2Reg.Configuration_Error)
Vkadaba	5:0728bde67bdb	384	pStatus->deviceStatus \|= ADMW_DEVICE_STATUS_CONFIG_ERROR;
ADIJake	0:85855ecd3257	385	if (alert2Reg.LUT_Error)
Vkadaba	5:0728bde67bdb	386	pStatus->deviceStatus \|= ADMW_DEVICE_STATUS_LUT_ERROR;
ADIJake	0:85855ecd3257	387	}
ADIJake	0:85855ecd3257	388
ADIJake	0:85855ecd3257	389	if (statusReg.Error)
ADIJake	0:85855ecd3257	390	{
Vkadaba	5:0728bde67bdb	391	pStatus->deviceStatus \|= ADMW_DEVICE_STATUS_ERROR;
Vkadaba	5:0728bde67bdb	392
Vkadaba	8:2f2775c34640	393	ADMW_CORE_Error_Code_t errorCodeReg;
ADIJake	0:85855ecd3257	394	READ_REG_U16(hDevice, errorCodeReg.VALUE16, CORE_ERROR_CODE);
ADIJake	0:85855ecd3257	395	pStatus->errorCode = errorCodeReg.Error_Code;
ADIJake	0:85855ecd3257	396
Vkadaba	8:2f2775c34640	397	ADMW_CORE_Diagnostics_Status_t diagStatusReg;
ADIJake	0:85855ecd3257	398	READ_REG_U16(hDevice, diagStatusReg.VALUE16, CORE_DIAGNOSTICS_STATUS);
ADIJake	0:85855ecd3257	399
ADIJake	0:85855ecd3257	400	if (diagStatusReg.Diag_Checksum_Error)
Vkadaba	5:0728bde67bdb	401	pStatus->diagnosticsStatus \|= ADMW_DIAGNOSTICS_STATUS_CHECKSUM_ERROR;
ADIJake	0:85855ecd3257	402	if (diagStatusReg.Diag_Conversion_Error)
Vkadaba	5:0728bde67bdb	403	pStatus->diagnosticsStatus \|= ADMW_DIAGNOSTICS_STATUS_CONVERSION_ERROR;
ADIJake	0:85855ecd3257	404	if (diagStatusReg.Diag_Calibration_Error)
Vkadaba	5:0728bde67bdb	405	pStatus->diagnosticsStatus \|= ADMW_DIAGNOSTICS_STATUS_CALIBRATION_ERROR;
ADIJake	0:85855ecd3257	406	}
ADIJake	0:85855ecd3257	407
ADIJake	0:85855ecd3257	408	if (statusReg.Alert_Active \|\| statusReg.Error)
ADIJake	0:85855ecd3257	409	{
Vkadaba	8:2f2775c34640	410	ADMW_CORE_Debug_Code_t debugCodeReg;
ADIJake	0:85855ecd3257	411	READ_REG_U32(hDevice, debugCodeReg.VALUE32, CORE_DEBUG_CODE);
ADIJake	0:85855ecd3257	412	pStatus->debugCode = debugCodeReg.Debug_Code;
ADIJake	0:85855ecd3257	413	}
ADIJake	0:85855ecd3257	414
Vkadaba	5:0728bde67bdb	415	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	416	}
ADIJake	0:85855ecd3257	417
Vkadaba	5:0728bde67bdb	418	ADMW_RESULT admw_GetCommandRunningState(
Vkadaba	5:0728bde67bdb	419	ADMW_DEVICE_HANDLE hDevice,
ADIJake	0:85855ecd3257	420	bool *pbCommandRunning)
ADIJake	0:85855ecd3257	421	{
Vkadaba	8:2f2775c34640	422	ADMW_CORE_Status_t statusReg;
ADIJake	0:85855ecd3257	423
ADIJake	0:85855ecd3257	424	READ_REG_U8(hDevice, statusReg.VALUE8, CORE_STATUS);
ADIJake	0:85855ecd3257	425
ADIJake	0:85855ecd3257	426	/* We should never normally see 0xFF here if the module is operational */
ADIJake	0:85855ecd3257	427	if (statusReg.VALUE8 == 0xFF)
Vkadaba	5:0728bde67bdb	428	return ADMW_ERR_NOT_INITIALIZED;
ADIJake	0:85855ecd3257	429
ADIJake	0:85855ecd3257	430	pbCommandRunning = !statusReg.Cmd_Running; / Active-low, so invert it */
ADIJake	0:85855ecd3257	431
Vkadaba	5:0728bde67bdb	432	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	433	}
ADIJake	0:85855ecd3257	434
Vkadaba	5:0728bde67bdb	435	static ADMW_RESULT executeCommand(
Vkadaba	5:0728bde67bdb	436	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	8:2f2775c34640	437	ADMW_CORE_Command_Special_Command const command,
ADIJake	0:85855ecd3257	438	bool const bWaitForCompletion)
ADIJake	0:85855ecd3257	439	{
Vkadaba	8:2f2775c34640	440	ADMW_CORE_Command_t commandReg;
ADIJake	0:85855ecd3257	441	bool bCommandRunning;
Vkadaba	5:0728bde67bdb	442	ADMW_RESULT eRet;
ADIJake	0:85855ecd3257	443
ADIJake	0:85855ecd3257	444	/*
ADIJake	0:85855ecd3257	445	* Don't allow another command to be issued if one is already running, but
Vkadaba	6:9d393a9677f4	446	* make an exception for ENUM_CORE_COMMAND_NOP which can be used to
ADIJake	0:85855ecd3257	447	* request a running command to be stopped (e.g. continuous measurement)
ADIJake	0:85855ecd3257	448	*/
Vkadaba	6:9d393a9677f4	449	if (command != ENUM_CORE_COMMAND_NOP)
ADIJake	0:85855ecd3257	450	{
Vkadaba	5:0728bde67bdb	451	eRet = admw_GetCommandRunningState(hDevice, &bCommandRunning);
ADIJake	0:85855ecd3257	452	if (eRet)
ADIJake	0:85855ecd3257	453	return eRet;
ADIJake	0:85855ecd3257	454
ADIJake	0:85855ecd3257	455	if (bCommandRunning)
Vkadaba	5:0728bde67bdb	456	return ADMW_IN_USE;
ADIJake	0:85855ecd3257	457	}
ADIJake	0:85855ecd3257	458
ADIJake	0:85855ecd3257	459	commandReg.Special_Command = command;
ADIJake	0:85855ecd3257	460	WRITE_REG_U8(hDevice, commandReg.VALUE8, CORE_COMMAND);
ADIJake	0:85855ecd3257	461
ADIJake	0:85855ecd3257	462	if (bWaitForCompletion)
ADIJake	0:85855ecd3257	463	{
ADIJake	0:85855ecd3257	464	do {
ADIJake	0:85855ecd3257	465	/* Allow a minimum 50usec delay for status update before checking */
Vkadaba	5:0728bde67bdb	466	admw_TimeDelayUsec(50);
Vkadaba	5:0728bde67bdb	467
Vkadaba	5:0728bde67bdb	468	eRet = admw_GetCommandRunningState(hDevice, &bCommandRunning);
ADIJake	0:85855ecd3257	469	if (eRet)
ADIJake	0:85855ecd3257	470	return eRet;
ADIJake	0:85855ecd3257	471	} while (bCommandRunning);
ADIJake	0:85855ecd3257	472	}
ADIJake	0:85855ecd3257	473
Vkadaba	5:0728bde67bdb	474	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	475	}
ADIJake	0:85855ecd3257	476
Vkadaba	5:0728bde67bdb	477	ADMW_RESULT admw_Shutdown(
Vkadaba	5:0728bde67bdb	478	ADMW_DEVICE_HANDLE const hDevice)
ADIJake	0:85855ecd3257	479	{
Vkadaba	5:0728bde67bdb	480	return executeCommand(hDevice, CORE_COMMAND_POWER_DOWN, false);
ADIJake	0:85855ecd3257	481	}
ADIJake	0:85855ecd3257	482
ADIJake	0:85855ecd3257	483
Vkadaba	5:0728bde67bdb	484	ADMW_RESULT admw_ApplyConfigUpdates(
Vkadaba	5:0728bde67bdb	485	ADMW_DEVICE_HANDLE const hDevice)
ADIJake	0:85855ecd3257	486	{
Vkadaba	5:0728bde67bdb	487	return executeCommand(hDevice, CORE_COMMAND_LATCH_CONFIG, true);
ADIJake	0:85855ecd3257	488	}
ADIJake	0:85855ecd3257	489
ADIJake	0:85855ecd3257	490	/*!
ADIJake	0:85855ecd3257	491	* @brief Start a measurement cycle.
ADIJake	0:85855ecd3257	492	*
ADIJake	0:85855ecd3257	493	* @param[out]
ADIJake	0:85855ecd3257	494	*
ADIJake	0:85855ecd3257	495	* @return Status
Vkadaba	5:0728bde67bdb	496	* - #ADMW_SUCCESS Call completed successfully.
Vkadaba	5:0728bde67bdb	497	* - #ADMW_FAILURE
ADIJake	0:85855ecd3257	498	*
ADIJake	0:85855ecd3257	499	* @details Sends the latch config command. Configuration for channels in
ADIJake	0:85855ecd3257	500	* conversion cycle should be completed before this function.
ADIJake	0:85855ecd3257	501	* Channel enabled bit should be set before this function.
ADIJake	0:85855ecd3257	502	* Starts a conversion and configures the format of the sample.
ADIJake	0:85855ecd3257	503	*
ADIJake	0:85855ecd3257	504	*/
Vkadaba	5:0728bde67bdb	505	ADMW_RESULT admw_StartMeasurement(
Vkadaba	5:0728bde67bdb	506	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	5:0728bde67bdb	507	ADMW_MEASUREMENT_MODE const eMeasurementMode)
ADIJake	0:85855ecd3257	508	{
ADIJake	0:85855ecd3257	509	switch (eMeasurementMode)
ADIJake	0:85855ecd3257	510	{
Vkadaba	5:0728bde67bdb	511	case ADMW_MEASUREMENT_MODE_NORMAL:
Vkadaba	5:0728bde67bdb	512	return executeCommand(hDevice, CORE_COMMAND_CONVERT_WITH_RAW, false);
Vkadaba	5:0728bde67bdb	513	case ADMW_MEASUREMENT_MODE_OMIT_RAW:
Vkadaba	5:0728bde67bdb	514	return executeCommand(hDevice, CORE_COMMAND_CONVERT, false);
ADIJake	0:85855ecd3257	515	default:
Vkadaba	5:0728bde67bdb	516	ADMW_LOG_ERROR("Invalid measurement mode %d specified",
ADIJake	0:85855ecd3257	517	eMeasurementMode);
Vkadaba	5:0728bde67bdb	518	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	519	}
ADIJake	0:85855ecd3257	520	}
ADIJake	0:85855ecd3257	521
ADIJake	0:85855ecd3257	522	/*
ADIJake	0:85855ecd3257	523	* Store the configuration settings to persistent memory on the device.
ADIJake	0:85855ecd3257	524	* The settings can be saved to 4 different flash memory areas (slots).
ADIJake	0:85855ecd3257	525	* No other command must be running when this is called.
ADIJake	0:85855ecd3257	526	* Do not power down the device while this command is running.
ADIJake	0:85855ecd3257	527	*/
Vkadaba	5:0728bde67bdb	528	ADMW_RESULT admw_SaveConfig(
Vkadaba	5:0728bde67bdb	529	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	5:0728bde67bdb	530	ADMW_USER_CONFIG_SLOT const eSlotId)
ADIJake	0:85855ecd3257	531	{
ADIJake	0:85855ecd3257	532	switch (eSlotId)
ADIJake	0:85855ecd3257	533	{
Vkadaba	5:0728bde67bdb	534	case ADMW_FLASH_CONFIG_1:
Vkadaba	5:0728bde67bdb	535	return executeCommand(hDevice, CORE_COMMAND_SAVE_CONFIG_1, true);
ADIJake	0:85855ecd3257	536	default:
Vkadaba	5:0728bde67bdb	537	ADMW_LOG_ERROR("Invalid user config target slot %d specified",
ADIJake	0:85855ecd3257	538	eSlotId);
Vkadaba	5:0728bde67bdb	539	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	540	}
ADIJake	0:85855ecd3257	541	}
ADIJake	0:85855ecd3257	542
ADIJake	0:85855ecd3257	543	/*
ADIJake	0:85855ecd3257	544	* Restore the configuration settings from persistent memory on the device.
ADIJake	0:85855ecd3257	545	* No other command must be running when this is called.
ADIJake	0:85855ecd3257	546	*/
Vkadaba	5:0728bde67bdb	547	ADMW_RESULT admw_RestoreConfig(
Vkadaba	5:0728bde67bdb	548	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	5:0728bde67bdb	549	ADMW_USER_CONFIG_SLOT const eSlotId)
ADIJake	0:85855ecd3257	550	{
ADIJake	0:85855ecd3257	551	switch (eSlotId)
ADIJake	0:85855ecd3257	552	{
Vkadaba	5:0728bde67bdb	553	case ADMW_FLASH_CONFIG_1:
Vkadaba	5:0728bde67bdb	554	return executeCommand(hDevice, CORE_COMMAND_LOAD_CONFIG_1, true);
ADIJake	0:85855ecd3257	555	default:
Vkadaba	5:0728bde67bdb	556	ADMW_LOG_ERROR("Invalid user config source slot %d specified",
ADIJake	0:85855ecd3257	557	eSlotId);
Vkadaba	5:0728bde67bdb	558	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	559	}
ADIJake	0:85855ecd3257	560	}
ADIJake	0:85855ecd3257	561
ADIJake	0:85855ecd3257	562	/*
ADIJake	0:85855ecd3257	563	* Store the LUT data to persistent memory on the device.
ADIJake	0:85855ecd3257	564	* No other command must be running when this is called.
ADIJake	0:85855ecd3257	565	* Do not power down the device while this command is running.
ADIJake	0:85855ecd3257	566	*/
Vkadaba	5:0728bde67bdb	567	ADMW_RESULT admw_SaveLutData(
Vkadaba	5:0728bde67bdb	568	ADMW_DEVICE_HANDLE const hDevice)
ADIJake	0:85855ecd3257	569	{
Vkadaba	5:0728bde67bdb	570	return executeCommand(hDevice, CORE_COMMAND_SAVE_LUT, true);
ADIJake	0:85855ecd3257	571	}
ADIJake	0:85855ecd3257	572
ADIJake	0:85855ecd3257	573	/*
ADIJake	0:85855ecd3257	574	* Restore the LUT data from persistent memory on the device.
ADIJake	0:85855ecd3257	575	* No other command must be running when this is called.
ADIJake	0:85855ecd3257	576	*/
Vkadaba	5:0728bde67bdb	577	ADMW_RESULT admw_RestoreLutData(
Vkadaba	5:0728bde67bdb	578	ADMW_DEVICE_HANDLE const hDevice)
ADIJake	0:85855ecd3257	579	{
Vkadaba	5:0728bde67bdb	580	return executeCommand(hDevice, CORE_COMMAND_LOAD_LUT, true);
ADIJake	0:85855ecd3257	581	}
ADIJake	0:85855ecd3257	582
ADIJake	0:85855ecd3257	583	/*
ADIJake	0:85855ecd3257	584	* Stop the measurement cycles on the device.
ADIJake	0:85855ecd3257	585	* To be used only if a measurement command is currently running.
ADIJake	0:85855ecd3257	586	*/
Vkadaba	5:0728bde67bdb	587	ADMW_RESULT admw_StopMeasurement(
Vkadaba	5:0728bde67bdb	588	ADMW_DEVICE_HANDLE const hDevice)
ADIJake	0:85855ecd3257	589	{
Vkadaba	5:0728bde67bdb	590	return executeCommand(hDevice, CORE_COMMAND_NOP, true);
ADIJake	0:85855ecd3257	591	}
ADIJake	0:85855ecd3257	592
ADIJake	0:85855ecd3257	593	/*
ADIJake	0:85855ecd3257	594	* Read a set of data samples from the device.
ADIJake	0:85855ecd3257	595	* This may be called at any time.
ADIJake	0:85855ecd3257	596	*/
Vkadaba	5:0728bde67bdb	597	ADMW_RESULT admw_GetData(
Vkadaba	5:0728bde67bdb	598	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	5:0728bde67bdb	599	ADMW_MEASUREMENT_MODE const eMeasurementMode,
Vkadaba	5:0728bde67bdb	600	ADMW_DATA_SAMPLE * const pSamples,
ADIJake	0:85855ecd3257	601	uint8_t const nBytesPerSample,
ADIJake	0:85855ecd3257	602	uint32_t const nRequested,
ADIJake	0:85855ecd3257	603	uint32_t * const pnReturned)
ADIJake	0:85855ecd3257	604	{
Vkadaba	5:0728bde67bdb	605	ADMW1001_Sensor_Result_t sensorResult;
Vkadaba	5:0728bde67bdb	606	ADMW_DEVICE_CONTEXT *pCtx = hDevice;
Vkadaba	5:0728bde67bdb	607	uint16_t command = ADMW1001_HOST_COMMS_READ_CMD \|
Vkadaba	5:0728bde67bdb	608	(REG_CORE_DATA_FIFO & ADMW1001_HOST_COMMS_ADR_MASK);
ADIJake	0:85855ecd3257	609	uint8_t commandData[2] = {
ADIJake	0:85855ecd3257	610	command >> 8,
ADIJake	0:85855ecd3257	611	command & 0xFF
ADIJake	0:85855ecd3257	612	};
ADIJake	0:85855ecd3257	613	uint8_t commandResponse[2];
ADIJake	0:85855ecd3257	614	unsigned nValidSamples = 0;
Vkadaba	5:0728bde67bdb	615	ADMW_RESULT eRet = ADMW_SUCCESS;
ADIJake	0:85855ecd3257	616
ADIJake	0:85855ecd3257	617	do {
Vkadaba	5:0728bde67bdb	618	eRet = admw_SpiTransfer(pCtx->hSpi, commandData, commandResponse,
ADIJake	0:85855ecd3257	619	sizeof(command), false);
ADIJake	0:85855ecd3257	620	if (eRet)
ADIJake	0:85855ecd3257	621	{
Vkadaba	5:0728bde67bdb	622	ADMW_LOG_ERROR("Failed to send read command for FIFO register");
ADIJake	0:85855ecd3257	623	return eRet;
ADIJake	0:85855ecd3257	624	}
Vkadaba	5:0728bde67bdb	625	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
Vkadaba	5:0728bde67bdb	626	} while ((commandResponse[0] != ADMW1001_HOST_COMMS_CMD_RESP_0) \|\|
Vkadaba	5:0728bde67bdb	627	(commandResponse[1] != ADMW1001_HOST_COMMS_CMD_RESP_1));
ADIJake	0:85855ecd3257	628
ADIJake	0:85855ecd3257	629	for (unsigned i = 0; i < nRequested; i++)
ADIJake	0:85855ecd3257	630	{
ADIJake	0:85855ecd3257	631	bool bHoldCs = true;
ADIJake	0:85855ecd3257	632
ADIJake	0:85855ecd3257	633	/* Keep the CS signal asserted for all but the last sample */
ADIJake	0:85855ecd3257	634	if ((i + 1) == nRequested)
ADIJake	0:85855ecd3257	635	bHoldCs = false;
ADIJake	0:85855ecd3257	636
ADIJake	0:85855ecd3257	637	getDataCnt++;
ADIJake	0:85855ecd3257	638
Vkadaba	5:0728bde67bdb	639	eRet = admw_SpiTransfer(pCtx->hSpi, NULL, &sensorResult,
ADIJake	0:85855ecd3257	640	nBytesPerSample, bHoldCs);
ADIJake	0:85855ecd3257	641	if (eRet)
ADIJake	0:85855ecd3257	642	{
Vkadaba	5:0728bde67bdb	643	ADMW_LOG_ERROR("Failed to read data from FIFO register");
ADIJake	0:85855ecd3257	644	return eRet;
ADIJake	0:85855ecd3257	645	}
ADIJake	0:85855ecd3257	646
ADIJake	0:85855ecd3257	647	if (! sensorResult.Ch_Valid)
ADIJake	0:85855ecd3257	648	{
ADIJake	0:85855ecd3257	649	/*
ADIJake	0:85855ecd3257	650	* Reading an invalid sample indicates that there are no
ADIJake	0:85855ecd3257	651	* more samples available or we've lost sync with the device.
ADIJake	0:85855ecd3257	652	* In the latter case, it might be recoverable, but return here
ADIJake	0:85855ecd3257	653	* to let the application check the device status and decide itself.
ADIJake	0:85855ecd3257	654	*/
Vkadaba	5:0728bde67bdb	655	eRet = ADMW_INCOMPLETE;
ADIJake	0:85855ecd3257	656	break;
ADIJake	0:85855ecd3257	657	}
ADIJake	0:85855ecd3257	658
Vkadaba	5:0728bde67bdb	659	ADMW_DATA_SAMPLE *pSample = &pSamples[nValidSamples];
Vkadaba	5:0728bde67bdb	660
Vkadaba	5:0728bde67bdb	661	pSample->status = (ADMW_DEVICE_STATUS_FLAGS)0;
ADIJake	0:85855ecd3257	662	if (sensorResult.Ch_Error)
Vkadaba	5:0728bde67bdb	663	pSample->status \|= ADMW_DEVICE_STATUS_ERROR;
ADIJake	0:85855ecd3257	664	if (sensorResult.Ch_Alert)
Vkadaba	5:0728bde67bdb	665	pSample->status \|= ADMW_DEVICE_STATUS_ALERT;
ADIJake	0:85855ecd3257	666
ADIJake	0:85855ecd3257	667	if (sensorResult.Ch_Raw)
ADIJake	0:85855ecd3257	668	pSample->rawValue = sensorResult.Raw_Sample;
ADIJake	0:85855ecd3257	669	else
ADIJake	0:85855ecd3257	670	pSample->rawValue = 0;
ADIJake	0:85855ecd3257	671
ADIJake	0:85855ecd3257	672	pSample->channelId = sensorResult.Channel_ID;
ADIJake	0:85855ecd3257	673	pSample->processedValue = sensorResult.Sensor_Result;
ADIJake	0:85855ecd3257	674
ADIJake	0:85855ecd3257	675	nValidSamples++;
ADIJake	0:85855ecd3257	676
Vkadaba	5:0728bde67bdb	677	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
ADIJake	0:85855ecd3257	678	}
ADIJake	0:85855ecd3257	679	*pnReturned = nValidSamples;
ADIJake	0:85855ecd3257	680
ADIJake	0:85855ecd3257	681	return eRet;
ADIJake	0:85855ecd3257	682	}
ADIJake	0:85855ecd3257	683
ADIJake	0:85855ecd3257	684	/*
Vkadaba	5:0728bde67bdb	685	* Close the given ADMW device.
ADIJake	0:85855ecd3257	686	*/
Vkadaba	5:0728bde67bdb	687	ADMW_RESULT admw_Close(
Vkadaba	5:0728bde67bdb	688	ADMW_DEVICE_HANDLE const hDevice)
ADIJake	0:85855ecd3257	689	{
Vkadaba	5:0728bde67bdb	690	ADMW_DEVICE_CONTEXT *pCtx = hDevice;
Vkadaba	5:0728bde67bdb	691
Vkadaba	5:0728bde67bdb	692	admw_GpioClose(pCtx->hGpio);
Vkadaba	5:0728bde67bdb	693	admw_SpiClose(pCtx->hSpi);
Vkadaba	5:0728bde67bdb	694	admw_LogClose();
Vkadaba	5:0728bde67bdb	695
Vkadaba	5:0728bde67bdb	696	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	697	}
ADIJake	0:85855ecd3257	698
Vkadaba	5:0728bde67bdb	699	ADMW_RESULT admw1001_WriteRegister(
Vkadaba	5:0728bde67bdb	700	ADMW_DEVICE_HANDLE hDevice,
ADIJake	0:85855ecd3257	701	uint16_t nAddress,
ADIJake	0:85855ecd3257	702	void *pData,
ADIJake	0:85855ecd3257	703	unsigned nLength)
ADIJake	0:85855ecd3257	704	{
Vkadaba	5:0728bde67bdb	705	ADMW_RESULT eRet;
Vkadaba	5:0728bde67bdb	706	ADMW_DEVICE_CONTEXT *pCtx = hDevice;
Vkadaba	5:0728bde67bdb	707	uint16_t command = ADMW1001_HOST_COMMS_WRITE_CMD \|
Vkadaba	5:0728bde67bdb	708	(nAddress & ADMW1001_HOST_COMMS_ADR_MASK);
ADIJake	0:85855ecd3257	709	uint8_t commandData[2] = {
ADIJake	0:85855ecd3257	710	command >> 8,
ADIJake	0:85855ecd3257	711	command & 0xFF
ADIJake	0:85855ecd3257	712	};
ADIJake	0:85855ecd3257	713	uint8_t commandResponse[2];
ADIJake	0:85855ecd3257	714
ADIJake	0:85855ecd3257	715	do {
Vkadaba	5:0728bde67bdb	716	eRet = admw_SpiTransfer(pCtx->hSpi, commandData, commandResponse,
ADIJake	0:85855ecd3257	717	sizeof(command), false);
ADIJake	0:85855ecd3257	718	if (eRet)
ADIJake	0:85855ecd3257	719	{
Vkadaba	5:0728bde67bdb	720	ADMW_LOG_ERROR("Failed to send write command for register %u",
ADIJake	0:85855ecd3257	721	nAddress);
ADIJake	0:85855ecd3257	722	return eRet;
ADIJake	0:85855ecd3257	723	}
ADIJake	0:85855ecd3257	724
Vkadaba	5:0728bde67bdb	725	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
Vkadaba	5:0728bde67bdb	726	} while ((commandResponse[0] != ADMW1001_HOST_COMMS_CMD_RESP_0) \|\|
Vkadaba	5:0728bde67bdb	727	(commandResponse[1] != ADMW1001_HOST_COMMS_CMD_RESP_1));
Vkadaba	5:0728bde67bdb	728
Vkadaba	5:0728bde67bdb	729	eRet = admw_SpiTransfer(pCtx->hSpi, pData, NULL, nLength, false);
ADIJake	0:85855ecd3257	730	if (eRet)
ADIJake	0:85855ecd3257	731	{
Vkadaba	5:0728bde67bdb	732	ADMW_LOG_ERROR("Failed to write data (%dB) to register %u",
ADIJake	0:85855ecd3257	733	nLength, nAddress);
ADIJake	0:85855ecd3257	734	return eRet;
ADIJake	0:85855ecd3257	735	}
ADIJake	0:85855ecd3257	736
Vkadaba	5:0728bde67bdb	737	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
Vkadaba	5:0728bde67bdb	738
Vkadaba	5:0728bde67bdb	739	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	740	}
ADIJake	0:85855ecd3257	741
Vkadaba	6:9d393a9677f4	742	ADMW_RESULT admw1001_Write_Debug_Register(
Vkadaba	6:9d393a9677f4	743	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	6:9d393a9677f4	744	uint16_t nAddress,
Vkadaba	6:9d393a9677f4	745	void *pData,
Vkadaba	6:9d393a9677f4	746	unsigned nLength)
Vkadaba	6:9d393a9677f4	747	{
Vkadaba	6:9d393a9677f4	748	ADMW_RESULT eRet;
Vkadaba	6:9d393a9677f4	749	ADMW_DEVICE_CONTEXT *pCtx = hDevice;
Vkadaba	6:9d393a9677f4	750	uint16_t command = ADMW1001_HOST_COMMS_DEBUG_WRITE_CMD \|
Vkadaba	6:9d393a9677f4	751	(nAddress & ADMW1001_HOST_COMMS_ADR_MASK);
Vkadaba	6:9d393a9677f4	752	uint8_t commandData[2] = {
Vkadaba	6:9d393a9677f4	753	command >> 8,
Vkadaba	6:9d393a9677f4	754	command & 0xFF
Vkadaba	6:9d393a9677f4	755	};
Vkadaba	6:9d393a9677f4	756	uint8_t commandResponse[2];
Vkadaba	6:9d393a9677f4	757
Vkadaba	6:9d393a9677f4	758	do {
Vkadaba	6:9d393a9677f4	759	eRet = admw_SpiTransfer(pCtx->hSpi, commandData, commandResponse,
Vkadaba	6:9d393a9677f4	760	sizeof(command), false);
Vkadaba	6:9d393a9677f4	761	if (eRet)
Vkadaba	6:9d393a9677f4	762	{
Vkadaba	6:9d393a9677f4	763	ADMW_LOG_ERROR("Failed to send write command for register %u",
Vkadaba	6:9d393a9677f4	764	nAddress);
Vkadaba	6:9d393a9677f4	765	return eRet;
Vkadaba	6:9d393a9677f4	766	}
Vkadaba	6:9d393a9677f4	767
Vkadaba	6:9d393a9677f4	768	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
Vkadaba	6:9d393a9677f4	769	} while ((commandResponse[0] != ADMW1001_HOST_COMMS_CMD_RESP_0) \|\|
Vkadaba	6:9d393a9677f4	770	(commandResponse[1] != ADMW1001_HOST_COMMS_CMD_RESP_1));
Vkadaba	6:9d393a9677f4	771
Vkadaba	6:9d393a9677f4	772	eRet = admw_SpiTransfer(pCtx->hSpi, pData, NULL, nLength, false);
Vkadaba	6:9d393a9677f4	773	if (eRet)
Vkadaba	6:9d393a9677f4	774	{
Vkadaba	6:9d393a9677f4	775	ADMW_LOG_ERROR("Failed to write data (%dB) to register %u",
Vkadaba	6:9d393a9677f4	776	nLength, nAddress);
Vkadaba	6:9d393a9677f4	777	return eRet;
Vkadaba	6:9d393a9677f4	778	}
Vkadaba	6:9d393a9677f4	779
Vkadaba	6:9d393a9677f4	780	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
Vkadaba	6:9d393a9677f4	781
Vkadaba	6:9d393a9677f4	782	return ADMW_SUCCESS;
Vkadaba	6:9d393a9677f4	783	}
Vkadaba	5:0728bde67bdb	784	ADMW_RESULT admw1001_ReadRegister(
Vkadaba	5:0728bde67bdb	785	ADMW_DEVICE_HANDLE hDevice,
ADIJake	0:85855ecd3257	786	uint16_t nAddress,
ADIJake	0:85855ecd3257	787	void *pData,
ADIJake	0:85855ecd3257	788	unsigned nLength)
ADIJake	0:85855ecd3257	789	{
Vkadaba	5:0728bde67bdb	790	ADMW_RESULT eRet;
Vkadaba	5:0728bde67bdb	791	ADMW_DEVICE_CONTEXT *pCtx = hDevice;
Vkadaba	5:0728bde67bdb	792	uint16_t command = ADMW1001_HOST_COMMS_READ_CMD \|
Vkadaba	5:0728bde67bdb	793	(nAddress & ADMW1001_HOST_COMMS_ADR_MASK);
ADIJake	0:85855ecd3257	794	uint8_t commandData[2] = {
ADIJake	0:85855ecd3257	795	command >> 8,
ADIJake	0:85855ecd3257	796	command & 0xFF
ADIJake	0:85855ecd3257	797	};
ADIJake	0:85855ecd3257	798	uint8_t commandResponse[2];
ADIJake	0:85855ecd3257	799
ADIJake	0:85855ecd3257	800	do {
Vkadaba	5:0728bde67bdb	801	eRet = admw_SpiTransfer(pCtx->hSpi, commandData, commandResponse,
ADIJake	0:85855ecd3257	802	sizeof(command), false);
ADIJake	0:85855ecd3257	803	if (eRet)
ADIJake	0:85855ecd3257	804	{
Vkadaba	5:0728bde67bdb	805	ADMW_LOG_ERROR("Failed to send read command for register %u",
ADIJake	0:85855ecd3257	806	nAddress);
ADIJake	0:85855ecd3257	807	return eRet;
ADIJake	0:85855ecd3257	808	}
ADIJake	0:85855ecd3257	809
Vkadaba	5:0728bde67bdb	810	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
Vkadaba	5:0728bde67bdb	811	} while ((commandResponse[0] != ADMW1001_HOST_COMMS_CMD_RESP_0) \|\|
Vkadaba	5:0728bde67bdb	812	(commandResponse[1] != ADMW1001_HOST_COMMS_CMD_RESP_1));
Vkadaba	5:0728bde67bdb	813
Vkadaba	5:0728bde67bdb	814	eRet = admw_SpiTransfer(pCtx->hSpi, NULL, pData, nLength, false);
ADIJake	0:85855ecd3257	815	if (eRet)
ADIJake	0:85855ecd3257	816	{
Vkadaba	5:0728bde67bdb	817	ADMW_LOG_ERROR("Failed to read data (%uB) from register %u",
ADIJake	0:85855ecd3257	818	nLength, nAddress);
ADIJake	0:85855ecd3257	819	return eRet;
ADIJake	0:85855ecd3257	820	}
ADIJake	0:85855ecd3257	821
Vkadaba	5:0728bde67bdb	822	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
Vkadaba	5:0728bde67bdb	823
Vkadaba	5:0728bde67bdb	824	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	825	}
ADIJake	0:85855ecd3257	826
Vkadaba	6:9d393a9677f4	827	ADMW_RESULT admw1001_Read_Debug_Register(
Vkadaba	6:9d393a9677f4	828	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	6:9d393a9677f4	829	uint16_t nAddress,
Vkadaba	6:9d393a9677f4	830	void *pData,
Vkadaba	6:9d393a9677f4	831	unsigned nLength)
Vkadaba	6:9d393a9677f4	832	{
Vkadaba	6:9d393a9677f4	833	ADMW_RESULT eRet;
Vkadaba	6:9d393a9677f4	834	ADMW_DEVICE_CONTEXT *pCtx = hDevice;
Vkadaba	6:9d393a9677f4	835	uint16_t command = ADMW1001_HOST_COMMS_DEBUG_READ_CMD \|
Vkadaba	6:9d393a9677f4	836	(nAddress & ADMW1001_HOST_COMMS_ADR_MASK);
Vkadaba	6:9d393a9677f4	837	uint8_t commandData[2] = {
Vkadaba	6:9d393a9677f4	838	command >> 8,
Vkadaba	6:9d393a9677f4	839	command & 0xFF
Vkadaba	6:9d393a9677f4	840	};
Vkadaba	6:9d393a9677f4	841	uint8_t commandResponse[2];
Vkadaba	6:9d393a9677f4	842
Vkadaba	6:9d393a9677f4	843	do {
Vkadaba	6:9d393a9677f4	844	eRet = admw_SpiTransfer(pCtx->hSpi, commandData, commandResponse,
Vkadaba	6:9d393a9677f4	845	sizeof(command), false);
Vkadaba	6:9d393a9677f4	846	if (eRet)
Vkadaba	6:9d393a9677f4	847	{
Vkadaba	6:9d393a9677f4	848	ADMW_LOG_ERROR("Failed to send read command for register %u",
Vkadaba	6:9d393a9677f4	849	nAddress);
Vkadaba	6:9d393a9677f4	850	return eRet;
Vkadaba	6:9d393a9677f4	851	}
Vkadaba	6:9d393a9677f4	852
Vkadaba	6:9d393a9677f4	853	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
Vkadaba	6:9d393a9677f4	854	} while ((commandResponse[0] != ADMW1001_HOST_COMMS_CMD_RESP_0) \|\|
Vkadaba	6:9d393a9677f4	855	(commandResponse[1] != ADMW1001_HOST_COMMS_CMD_RESP_1));
Vkadaba	6:9d393a9677f4	856
Vkadaba	6:9d393a9677f4	857	eRet = admw_SpiTransfer(pCtx->hSpi, NULL, pData, nLength, false);
Vkadaba	6:9d393a9677f4	858	if (eRet)
Vkadaba	6:9d393a9677f4	859	{
Vkadaba	6:9d393a9677f4	860	ADMW_LOG_ERROR("Failed to read data (%uB) from register %u",
Vkadaba	6:9d393a9677f4	861	nLength, nAddress);
Vkadaba	6:9d393a9677f4	862	return eRet;
Vkadaba	6:9d393a9677f4	863	}
Vkadaba	6:9d393a9677f4	864
Vkadaba	6:9d393a9677f4	865	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
Vkadaba	6:9d393a9677f4	866
Vkadaba	6:9d393a9677f4	867	return ADMW_SUCCESS;
Vkadaba	6:9d393a9677f4	868	}
Vkadaba	5:0728bde67bdb	869	ADMW_RESULT admw_GetDeviceReadyState(
Vkadaba	5:0728bde67bdb	870	ADMW_DEVICE_HANDLE const hDevice,
ADIJake	0:85855ecd3257	871	bool * const bReady)
ADIJake	0:85855ecd3257	872	{
Vkadaba	5:0728bde67bdb	873	ADMW_SPI_Chip_Type_t chipTypeReg;
ADIJake	0:85855ecd3257	874
ADIJake	0:85855ecd3257	875	READ_REG_U8(hDevice, chipTypeReg.VALUE8, SPI_CHIP_TYPE);
ADIJake	0:85855ecd3257	876	/* If we read this register successfully, assume the device is ready */
Vkadaba	5:0728bde67bdb	877	*bReady = (chipTypeReg.VALUE8 == REG_SPI_CHIP_TYPE_RESET);
Vkadaba	5:0728bde67bdb	878
Vkadaba	5:0728bde67bdb	879	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	880	}
ADIJake	0:85855ecd3257	881
Vkadaba	5:0728bde67bdb	882	ADMW_RESULT admw1001_GetDataReadyModeInfo(
Vkadaba	8:2f2775c34640	883	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	8:2f2775c34640	884	ADMW_MEASUREMENT_MODE const eMeasurementMode,
Vkadaba	5:0728bde67bdb	885	ADMW1001_OPERATING_MODE * const peOperatingMode,
Vkadaba	5:0728bde67bdb	886	ADMW1001_DATAREADY_MODE * const peDataReadyMode,
Vkadaba	8:2f2775c34640	887	uint32_t * const pnSamplesPerDataready,
Vkadaba	8:2f2775c34640	888	uint32_t * const pnSamplesPerCycle,
Vkadaba	8:2f2775c34640	889	uint8_t * const pnBytesPerSample)
ADIJake	0:85855ecd3257	890	{
ADIJake	0:85855ecd3257	891	unsigned nChannelsEnabled = 0;
ADIJake	0:85855ecd3257	892	unsigned nSamplesPerCycle = 0;
ADIJake	0:85855ecd3257	893
Vkadaba	8:2f2775c34640	894	ADMW_CORE_Mode_t modeReg;
ADIJake	0:85855ecd3257	895	READ_REG_U8(hDevice, modeReg.VALUE8, CORE_MODE);
ADIJake	0:85855ecd3257	896
Vkadaba	6:9d393a9677f4	897	if (eMeasurementMode == (modeReg.Conversion_Mode == CORE_MODE_SINGLECYCLE))
Vkadaba	5:0728bde67bdb	898	*peOperatingMode = ADMW1001_OPERATING_MODE_SINGLECYCLE;
ADIJake	0:85855ecd3257	899	else
Vkadaba	5:0728bde67bdb	900	*peOperatingMode = ADMW1001_OPERATING_MODE_CONTINUOUS;
ADIJake	0:85855ecd3257	901
Vkadaba	6:9d393a9677f4	902	if (eMeasurementMode == ADMW_MEASUREMENT_MODE_OMIT_RAW)
ADIJake	0:85855ecd3257	903	{
Vkadaba	8:2f2775c34640	904	*pnBytesPerSample = 5;
ADIJake	0:85855ecd3257	905	}
ADIJake	0:85855ecd3257	906	else
ADIJake	0:85855ecd3257	907	{
Vkadaba	8:2f2775c34640	908	*pnBytesPerSample = 8;
Vkadaba	6:9d393a9677f4	909	}
Vkadaba	6:9d393a9677f4	910
Vkadaba	8:2f2775c34640	911	for (ADMW1001_CH_ID chId = ADMW1001_CH_ID_ANLG_1_UNIVERSAL;
Vkadaba	8:2f2775c34640	912	chId < ADMW1001_MAX_CHANNELS;
Vkadaba	8:2f2775c34640	913	chId++)
Vkadaba	6:9d393a9677f4	914	{
Vkadaba	8:2f2775c34640	915	ADMW_CORE_Sensor_Details_t sensorDetailsReg;
Vkadaba	8:2f2775c34640	916	ADMW_CORE_Channel_Count_t channelCountReg;
Vkadaba	8:2f2775c34640	917
Vkadaba	8:2f2775c34640	918	if (ADMW1001_CHANNEL_IS_VIRTUAL(chId))
Vkadaba	8:2f2775c34640	919	continue;
Vkadaba	8:2f2775c34640	920
Vkadaba	8:2f2775c34640	921	READ_REG_U8(hDevice, channelCountReg.VALUE8, CORE_CHANNEL_COUNTn(chId));
Vkadaba	8:2f2775c34640	922	READ_REG_U32(hDevice, sensorDetailsReg.VALUE32, CORE_SENSOR_DETAILSn(chId));
Vkadaba	8:2f2775c34640	923
Vkadaba	8:2f2775c34640	924	if (channelCountReg.Channel_Enable && !sensorDetailsReg.Do_Not_Publish)
Vkadaba	8:2f2775c34640	925	{
Vkadaba	8:2f2775c34640	926	ADMW_CORE_Sensor_Type_t sensorTypeReg;
Vkadaba	8:2f2775c34640	927	unsigned nActualChannels = 1;
Vkadaba	8:2f2775c34640	928
Vkadaba	8:2f2775c34640	929	READ_REG_U16(hDevice, sensorTypeReg.VALUE16, CORE_SENSOR_TYPEn(chId));
Vkadaba	8:2f2775c34640	930
Vkadaba	8:2f2775c34640	931	if (chId == ADMW1001_CH_ID_DIG_SPI_0)
Vkadaba	8:2f2775c34640	932	{
Vkadaba	8:2f2775c34640	933	/* Some sensors automatically generate samples on additional
Vkadaba	8:2f2775c34640	934	* "virtual" channels so these channels must be counted as
Vkadaba	8:2f2775c34640	935	* active when those sensors are selected and we use the count
Vkadaba	8:2f2775c34640	936	* from the corresponding "physical" channel
Vkadaba	8:2f2775c34640	937	*/
Vkadaba	8:2f2775c34640	938	if ((sensorTypeReg.Sensor_Type >=
Vkadaba	8:2f2775c34640	939	CORE_SENSOR_TYPE_SPI_ACCELEROMETER_A) &&
Vkadaba	8:2f2775c34640	940	(sensorTypeReg.Sensor_Type <=
Vkadaba	8:2f2775c34640	941	CORE_SENSOR_TYPE_SPI_ACCELEROMETER_B))
Vkadaba	8:2f2775c34640	942	{
Vkadaba	8:2f2775c34640	943	nActualChannels += 2;
Vkadaba	8:2f2775c34640	944	}
Vkadaba	8:2f2775c34640	945	}
Vkadaba	6:9d393a9677f4	946
Vkadaba	8:2f2775c34640	947	nChannelsEnabled += nActualChannels;
Vkadaba	8:2f2775c34640	948
Vkadaba	8:2f2775c34640	949	nSamplesPerCycle += nActualChannels *
Vkadaba	8:2f2775c34640	950	(channelCountReg.Channel_Count + 1);
ADIJake	0:85855ecd3257	951	}
Vkadaba	6:9d393a9677f4	952	}
Vkadaba	6:9d393a9677f4	953
Vkadaba	6:9d393a9677f4	954	if (nChannelsEnabled == 0)
Vkadaba	6:9d393a9677f4	955	{
Vkadaba	8:2f2775c34640	956	*pnSamplesPerDataready = 0;
Vkadaba	8:2f2775c34640	957	*pnSamplesPerCycle = 0;
Vkadaba	8:2f2775c34640	958	return ADMW_SUCCESS;
Vkadaba	6:9d393a9677f4	959	}
Vkadaba	6:9d393a9677f4	960
Vkadaba	6:9d393a9677f4	961	*pnSamplesPerCycle = nSamplesPerCycle;
Vkadaba	6:9d393a9677f4	962
Vkadaba	8:2f2775c34640	963	if (modeReg.Drdy_Mode == CORE_MODE_DRDY_PER_CONVERSION)
Vkadaba	6:9d393a9677f4	964	{
Vkadaba	8:2f2775c34640	965	*pnSamplesPerDataready = 1;
Vkadaba	6:9d393a9677f4	966	}
Vkadaba	6:9d393a9677f4	967	else
Vkadaba	6:9d393a9677f4	968	{
Vkadaba	8:2f2775c34640	969	*pnSamplesPerDataready = nSamplesPerCycle;
Vkadaba	6:9d393a9677f4	970	}
Vkadaba	8:2f2775c34640	971
Vkadaba	8:2f2775c34640	972	if (modeReg.Drdy_Mode == CORE_MODE_DRDY_PER_CONVERSION)
Vkadaba	8:2f2775c34640	973	{
Vkadaba	8:2f2775c34640	974	*peDataReadyMode = ADMW1001_DATAREADY_PER_CONVERSION;
Vkadaba	8:2f2775c34640	975	}
Vkadaba	6:9d393a9677f4	976	else
Vkadaba	6:9d393a9677f4	977	{
Vkadaba	8:2f2775c34640	978	*peDataReadyMode = ADMW1001_DATAREADY_PER_CYCLE;
ADIJake	0:85855ecd3257	979	}
Vkadaba	8:2f2775c34640	980
Vkadaba	5:0728bde67bdb	981	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	982	}
ADIJake	0:85855ecd3257	983
Vkadaba	5:0728bde67bdb	984	ADMW_RESULT admw_GetProductID(
Vkadaba	5:0728bde67bdb	985	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	5:0728bde67bdb	986	ADMW_PRODUCT_ID *pProductId)
ADIJake	0:85855ecd3257	987	{
Vkadaba	5:0728bde67bdb	988	ADMW_SPI_Product_ID_L_t productIdLoReg;
Vkadaba	5:0728bde67bdb	989	ADMW_SPI_Product_ID_H_t productIdHiReg;
ADIJake	0:85855ecd3257	990
ADIJake	0:85855ecd3257	991	READ_REG_U8(hDevice, productIdLoReg.VALUE8, SPI_PRODUCT_ID_L);
ADIJake	0:85855ecd3257	992	READ_REG_U8(hDevice, productIdHiReg.VALUE8, SPI_PRODUCT_ID_H);
ADIJake	0:85855ecd3257	993
Vkadaba	8:2f2775c34640	994	*pProductId = (ADMW_PRODUCT_ID)((productIdHiReg.VALUE8 << 8) \|
Vkadaba	8:2f2775c34640	995	productIdLoReg.VALUE8);
Vkadaba	5:0728bde67bdb	996	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	997	}
ADIJake	0:85855ecd3257	998
Vkadaba	5:0728bde67bdb	999	static ADMW_RESULT admw_SetPowerMode(
Vkadaba	5:0728bde67bdb	1000	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	5:0728bde67bdb	1001	ADMW1001_POWER_MODE powerMode)
ADIJake	0:85855ecd3257	1002	{
Vkadaba	8:2f2775c34640	1003	ADMW_CORE_Power_Config_t powerConfigReg;
Vkadaba	5:0728bde67bdb	1004
Vkadaba	6:9d393a9677f4	1005	if (powerMode == ADMW1001_POWER_MODE_HIBERNATION)
ADIJake	0:85855ecd3257	1006	{
Vkadaba	6:9d393a9677f4	1007	powerConfigReg.Power_Mode_MCU = CORE_POWER_CONFIG_HIBERNATION;
ADIJake	0:85855ecd3257	1008	}
Vkadaba	6:9d393a9677f4	1009	else if (powerMode == ADMW1001_POWER_MODE_ACTIVE)
ADIJake	0:85855ecd3257	1010	{
Vkadaba	6:9d393a9677f4	1011	powerConfigReg.Power_Mode_MCU = CORE_POWER_CONFIG_ACTIVE_MODE;
ADIJake	0:85855ecd3257	1012	}
ADIJake	0:85855ecd3257	1013	else
ADIJake	0:85855ecd3257	1014	{
Vkadaba	5:0728bde67bdb	1015	ADMW_LOG_ERROR("Invalid power mode %d specified", powerMode);
Vkadaba	5:0728bde67bdb	1016	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1017	}
ADIJake	0:85855ecd3257	1018
ADIJake	0:85855ecd3257	1019	WRITE_REG_U8(hDevice, powerConfigReg.VALUE8, CORE_POWER_CONFIG);
ADIJake	0:85855ecd3257	1020
Vkadaba	5:0728bde67bdb	1021	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1022	}
ADIJake	0:85855ecd3257	1023
Vkadaba	5:0728bde67bdb	1024	ADMW_RESULT admw1001_SetPowerConfig(
Vkadaba	5:0728bde67bdb	1025	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	5:0728bde67bdb	1026	ADMW1001_POWER_CONFIG *pPowerConfig)
ADIJake	0:85855ecd3257	1027	{
Vkadaba	5:0728bde67bdb	1028	ADMW_RESULT eRet;
Vkadaba	5:0728bde67bdb	1029
Vkadaba	5:0728bde67bdb	1030	eRet = admw_SetPowerMode(hDevice, pPowerConfig->powerMode);
Vkadaba	5:0728bde67bdb	1031	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	1032	{
Vkadaba	5:0728bde67bdb	1033	ADMW_LOG_ERROR("Failed to set power mode");
ADIJake	0:85855ecd3257	1034	return eRet;
ADIJake	0:85855ecd3257	1035	}
ADIJake	0:85855ecd3257	1036
Vkadaba	5:0728bde67bdb	1037	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1038	}
ADIJake	0:85855ecd3257	1039
Vkadaba	5:0728bde67bdb	1040	static ADMW_RESULT admw_SetMode(
Vkadaba	5:0728bde67bdb	1041	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	5:0728bde67bdb	1042	ADMW1001_OPERATING_MODE eOperatingMode,
Vkadaba	8:2f2775c34640	1043	ADMW1001_DATAREADY_MODE eDataReadyMode)
ADIJake	0:85855ecd3257	1044	{
Vkadaba	8:2f2775c34640	1045	ADMW_CORE_Mode_t modeReg;
ADIJake	0:85855ecd3257	1046
ADIJake	0:85855ecd3257	1047	modeReg.VALUE8 = REG_RESET_VAL(CORE_MODE);
ADIJake	0:85855ecd3257	1048
Vkadaba	5:0728bde67bdb	1049	if (eOperatingMode == ADMW1001_OPERATING_MODE_SINGLECYCLE)
ADIJake	0:85855ecd3257	1050	{
Vkadaba	5:0728bde67bdb	1051	modeReg.Conversion_Mode = CORE_MODE_SINGLECYCLE;
ADIJake	0:85855ecd3257	1052	}
Vkadaba	5:0728bde67bdb	1053	else if (eOperatingMode == ADMW1001_OPERATING_MODE_CONTINUOUS)
ADIJake	0:85855ecd3257	1054	{
Vkadaba	5:0728bde67bdb	1055	modeReg.Conversion_Mode = CORE_MODE_CONTINUOUS;
ADIJake	0:85855ecd3257	1056	}
ADIJake	0:85855ecd3257	1057	else
ADIJake	0:85855ecd3257	1058	{
Vkadaba	5:0728bde67bdb	1059	ADMW_LOG_ERROR("Invalid operating mode %d specified",
ADIJake	0:85855ecd3257	1060	eOperatingMode);
Vkadaba	5:0728bde67bdb	1061	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1062	}
ADIJake	0:85855ecd3257	1063
Vkadaba	5:0728bde67bdb	1064	if (eDataReadyMode == ADMW1001_DATAREADY_PER_CONVERSION)
ADIJake	0:85855ecd3257	1065	{
Vkadaba	5:0728bde67bdb	1066	modeReg.Drdy_Mode = CORE_MODE_DRDY_PER_CONVERSION;
ADIJake	0:85855ecd3257	1067	}
Vkadaba	5:0728bde67bdb	1068	else if (eDataReadyMode == ADMW1001_DATAREADY_PER_CYCLE)
ADIJake	0:85855ecd3257	1069	{
Vkadaba	5:0728bde67bdb	1070	modeReg.Drdy_Mode = CORE_MODE_DRDY_PER_CYCLE;
ADIJake	0:85855ecd3257	1071	}
ADIJake	0:85855ecd3257	1072	else
ADIJake	0:85855ecd3257	1073	{
Vkadaba	5:0728bde67bdb	1074	ADMW_LOG_ERROR("Invalid data-ready mode %d specified", eDataReadyMode);
Vkadaba	5:0728bde67bdb	1075	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1076	}
ADIJake	0:85855ecd3257	1077
ADIJake	0:85855ecd3257	1078	WRITE_REG_U8(hDevice, modeReg.VALUE8, CORE_MODE);
ADIJake	0:85855ecd3257	1079
Vkadaba	5:0728bde67bdb	1080	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1081	}
ADIJake	0:85855ecd3257	1082
Vkadaba	8:2f2775c34640	1083	ADMW_RESULT admw_SetCycleControl(ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1084	uint32_t nCycleInterval,
Vkadaba	8:2f2775c34640	1085	bool vBiasEnable)
ADIJake	0:85855ecd3257	1086	{
Vkadaba	8:2f2775c34640	1087	ADMW_CORE_Cycle_Control_t cycleControlReg;
ADIJake	0:85855ecd3257	1088
ADIJake	0:85855ecd3257	1089	cycleControlReg.VALUE16 = REG_RESET_VAL(CORE_CYCLE_CONTROL);
ADIJake	0:85855ecd3257	1090
Vkadaba	8:2f2775c34640	1091	if (nCycleInterval < (1000 * (1 << 12)))
ADIJake	0:85855ecd3257	1092	{
Vkadaba	5:0728bde67bdb	1093	cycleControlReg.Cycle_Time_Units = CORE_CYCLE_CONTROL_MILLISECONDS;
ADIJake	0:85855ecd3257	1094	nCycleInterval /= 1000;
ADIJake	0:85855ecd3257	1095	}
ADIJake	0:85855ecd3257	1096	else
ADIJake	0:85855ecd3257	1097	{
Vkadaba	5:0728bde67bdb	1098	cycleControlReg.Cycle_Time_Units = CORE_CYCLE_CONTROL_SECONDS;
ADIJake	0:85855ecd3257	1099	nCycleInterval /= 1000000;
ADIJake	0:85855ecd3257	1100	}
ADIJake	0:85855ecd3257	1101
Vkadaba	8:2f2775c34640	1102	if (vBiasEnable == true)
Vkadaba	8:2f2775c34640	1103	{
Vkadaba	8:2f2775c34640	1104	cycleControlReg.Vbias = 1;
Vkadaba	8:2f2775c34640	1105	}
ADIJake	0:85855ecd3257	1106	CHECK_REG_FIELD_VAL(CORE_CYCLE_CONTROL_CYCLE_TIME, nCycleInterval);
ADIJake	0:85855ecd3257	1107	cycleControlReg.Cycle_Time = nCycleInterval;
ADIJake	0:85855ecd3257	1108
ADIJake	0:85855ecd3257	1109	WRITE_REG_U16(hDevice, cycleControlReg.VALUE16, CORE_CYCLE_CONTROL);
ADIJake	0:85855ecd3257	1110
Vkadaba	5:0728bde67bdb	1111	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1112	}
ADIJake	0:85855ecd3257	1113
Vkadaba	5:0728bde67bdb	1114	static ADMW_RESULT admw_SetExternalReferenceValues(
Vkadaba	5:0728bde67bdb	1115	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	6:9d393a9677f4	1116	float32_t externalRef1Value)
ADIJake	0:85855ecd3257	1117	{
Vkadaba	6:9d393a9677f4	1118	WRITE_REG_FLOAT(hDevice, externalRef1Value, CORE_EXTERNAL_REFERENCE_RESISTOR);
ADIJake	0:85855ecd3257	1119
Vkadaba	5:0728bde67bdb	1120	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1121	}
ADIJake	0:85855ecd3257	1122
Vkadaba	5:0728bde67bdb	1123	ADMW_RESULT admw1001_SetMeasurementConfig(
Vkadaba	5:0728bde67bdb	1124	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	5:0728bde67bdb	1125	ADMW1001_MEASUREMENT_CONFIG *pMeasConfig)
ADIJake	0:85855ecd3257	1126	{
Vkadaba	5:0728bde67bdb	1127	ADMW_RESULT eRet;
Vkadaba	5:0728bde67bdb	1128
Vkadaba	5:0728bde67bdb	1129	eRet = admw_SetMode(hDevice,
Vkadaba	8:2f2775c34640	1130	pMeasConfig->operatingMode,
Vkadaba	8:2f2775c34640	1131	pMeasConfig->dataReadyMode);
Vkadaba	5:0728bde67bdb	1132	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	1133	{
Vkadaba	5:0728bde67bdb	1134	ADMW_LOG_ERROR("Failed to set operating mode");
ADIJake	0:85855ecd3257	1135	return eRet;
ADIJake	0:85855ecd3257	1136	}
ADIJake	0:85855ecd3257	1137
Vkadaba	8:2f2775c34640	1138	eRet = admw_SetCycleControl(hDevice, pMeasConfig->cycleInterval,
Vkadaba	8:2f2775c34640	1139	pMeasConfig->vBiasEnable);
Vkadaba	5:0728bde67bdb	1140	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	1141	{
Vkadaba	5:0728bde67bdb	1142	ADMW_LOG_ERROR("Failed to set cycle control");
ADIJake	0:85855ecd3257	1143	return eRet;
ADIJake	0:85855ecd3257	1144	}
ADIJake	0:85855ecd3257	1145
Vkadaba	8:2f2775c34640	1146	if(pMeasConfig->externalRef1Value>0)
ADIJake	0:85855ecd3257	1147	{
Vkadaba	8:2f2775c34640	1148	eRet = admw_SetExternalReferenceValues(hDevice,
Vkadaba	8:2f2775c34640	1149	pMeasConfig->externalRef1Value);
ADIJake	0:85855ecd3257	1150	}
Vkadaba	8:2f2775c34640	1151
Vkadaba	5:0728bde67bdb	1152	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	1153	{
Vkadaba	5:0728bde67bdb	1154	ADMW_LOG_ERROR("Failed to set external reference values");
ADIJake	0:85855ecd3257	1155	return eRet;
ADIJake	0:85855ecd3257	1156	}
ADIJake	0:85855ecd3257	1157
Vkadaba	5:0728bde67bdb	1158	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1159	}
ADIJake	0:85855ecd3257	1160
Vkadaba	5:0728bde67bdb	1161	ADMW_RESULT admw1001_SetDiagnosticsConfig(
Vkadaba	5:0728bde67bdb	1162	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	5:0728bde67bdb	1163	ADMW1001_DIAGNOSTICS_CONFIG *pDiagnosticsConfig)
ADIJake	0:85855ecd3257	1164	{
Vkadaba	8:2f2775c34640	1165	ADMW_CORE_Diagnostics_Control_t diagnosticsControlReg;
ADIJake	0:85855ecd3257	1166
ADIJake	0:85855ecd3257	1167	diagnosticsControlReg.VALUE16 = REG_RESET_VAL(CORE_DIAGNOSTICS_CONTROL);
ADIJake	0:85855ecd3257	1168
ADIJake	0:85855ecd3257	1169	if (pDiagnosticsConfig->disableGlobalDiag)
ADIJake	0:85855ecd3257	1170	diagnosticsControlReg.Diag_Global_En = 0;
ADIJake	0:85855ecd3257	1171	else
ADIJake	0:85855ecd3257	1172	diagnosticsControlReg.Diag_Global_En = 1;
ADIJake	0:85855ecd3257	1173
ADIJake	0:85855ecd3257	1174	if (pDiagnosticsConfig->disableMeasurementDiag)
ADIJake	0:85855ecd3257	1175	diagnosticsControlReg.Diag_Meas_En = 0;
ADIJake	0:85855ecd3257	1176	else
ADIJake	0:85855ecd3257	1177	diagnosticsControlReg.Diag_Meas_En = 1;
ADIJake	0:85855ecd3257	1178
ADIJake	0:85855ecd3257	1179	switch (pDiagnosticsConfig->osdFrequency)
ADIJake	0:85855ecd3257	1180	{
Vkadaba	5:0728bde67bdb	1181	case ADMW1001_OPEN_SENSOR_DIAGNOSTICS_DISABLED:
Vkadaba	5:0728bde67bdb	1182	diagnosticsControlReg.Diag_OSD_Freq = CORE_DIAGNOSTICS_CONTROL_OCD_OFF;
ADIJake	0:85855ecd3257	1183	break;
Vkadaba	5:0728bde67bdb	1184	case ADMW1001_OPEN_SENSOR_DIAGNOSTICS_PER_CYCLE:
Vkadaba	5:0728bde67bdb	1185	diagnosticsControlReg.Diag_OSD_Freq = CORE_DIAGNOSTICS_CONTROL_OCD_PER_1_CYCLE;
ADIJake	0:85855ecd3257	1186	break;
Vkadaba	5:0728bde67bdb	1187	case ADMW1001_OPEN_SENSOR_DIAGNOSTICS_PER_100_CYCLES:
Vkadaba	5:0728bde67bdb	1188	diagnosticsControlReg.Diag_OSD_Freq = CORE_DIAGNOSTICS_CONTROL_OCD_PER_100_CYCLES;
ADIJake	0:85855ecd3257	1189	break;
Vkadaba	5:0728bde67bdb	1190	case ADMW1001_OPEN_SENSOR_DIAGNOSTICS_PER_1000_CYCLES:
Vkadaba	5:0728bde67bdb	1191	diagnosticsControlReg.Diag_OSD_Freq = CORE_DIAGNOSTICS_CONTROL_OCD_PER_1000_CYCLES;
ADIJake	0:85855ecd3257	1192	break;
ADIJake	0:85855ecd3257	1193	default:
Vkadaba	5:0728bde67bdb	1194	ADMW_LOG_ERROR("Invalid open-sensor diagnostic frequency %d specified",
ADIJake	0:85855ecd3257	1195	pDiagnosticsConfig->osdFrequency);
Vkadaba	5:0728bde67bdb	1196	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1197	}
ADIJake	0:85855ecd3257	1198
ADIJake	0:85855ecd3257	1199	WRITE_REG_U16(hDevice, diagnosticsControlReg.VALUE16, CORE_DIAGNOSTICS_CONTROL);
ADIJake	0:85855ecd3257	1200
Vkadaba	5:0728bde67bdb	1201	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1202	}
ADIJake	0:85855ecd3257	1203
Vkadaba	5:0728bde67bdb	1204	ADMW_RESULT admw1001_SetChannelCount(
Vkadaba	5:0728bde67bdb	1205	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1206	ADMW1001_CH_ID eChannelId,
ADIJake	0:85855ecd3257	1207	uint32_t nMeasurementsPerCycle)
ADIJake	0:85855ecd3257	1208	{
Vkadaba	8:2f2775c34640	1209	ADMW_CORE_Channel_Count_t channelCountReg;
ADIJake	0:85855ecd3257	1210
ADIJake	0:85855ecd3257	1211	channelCountReg.VALUE8 = REG_RESET_VAL(CORE_CHANNEL_COUNTn);
ADIJake	0:85855ecd3257	1212
ADIJake	0:85855ecd3257	1213	if (nMeasurementsPerCycle > 0)
ADIJake	0:85855ecd3257	1214	{
ADIJake	0:85855ecd3257	1215	nMeasurementsPerCycle -= 1;
ADIJake	0:85855ecd3257	1216
ADIJake	0:85855ecd3257	1217	CHECK_REG_FIELD_VAL(CORE_CHANNEL_COUNT_CHANNEL_COUNT,
ADIJake	0:85855ecd3257	1218	nMeasurementsPerCycle);
ADIJake	0:85855ecd3257	1219
ADIJake	0:85855ecd3257	1220	channelCountReg.Channel_Enable = 1;
ADIJake	0:85855ecd3257	1221	channelCountReg.Channel_Count = nMeasurementsPerCycle;
ADIJake	0:85855ecd3257	1222	}
ADIJake	0:85855ecd3257	1223	else
ADIJake	0:85855ecd3257	1224	{
ADIJake	0:85855ecd3257	1225	channelCountReg.Channel_Enable = 0;
ADIJake	0:85855ecd3257	1226	}
ADIJake	0:85855ecd3257	1227
ADIJake	0:85855ecd3257	1228	WRITE_REG_U8(hDevice, channelCountReg.VALUE8, CORE_CHANNEL_COUNTn(eChannelId));
ADIJake	0:85855ecd3257	1229
Vkadaba	5:0728bde67bdb	1230	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1231	}
ADIJake	0:85855ecd3257	1232
Vkadaba	5:0728bde67bdb	1233	ADMW_RESULT admw1001_SetChannelOptions(
Vkadaba	5:0728bde67bdb	1234	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1235	ADMW1001_CH_ID eChannelId,
Vkadaba	6:9d393a9677f4	1236	ADMW1001_CHANNEL_PRIORITY ePriority)
ADIJake	0:85855ecd3257	1237	{
Vkadaba	8:2f2775c34640	1238	ADMW_CORE_Channel_Options_t channelOptionsReg;
ADIJake	0:85855ecd3257	1239
ADIJake	0:85855ecd3257	1240	channelOptionsReg.VALUE8 = REG_RESET_VAL(CORE_CHANNEL_OPTIONSn);
ADIJake	0:85855ecd3257	1241
ADIJake	0:85855ecd3257	1242	CHECK_REG_FIELD_VAL(CORE_CHANNEL_OPTIONS_CHANNEL_PRIORITY, ePriority);
ADIJake	0:85855ecd3257	1243	channelOptionsReg.Channel_Priority = ePriority;
ADIJake	0:85855ecd3257	1244
ADIJake	0:85855ecd3257	1245	WRITE_REG_U8(hDevice, channelOptionsReg.VALUE8, CORE_CHANNEL_OPTIONSn(eChannelId));
ADIJake	0:85855ecd3257	1246
Vkadaba	5:0728bde67bdb	1247	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1248	}
ADIJake	0:85855ecd3257	1249
Vkadaba	5:0728bde67bdb	1250	ADMW_RESULT admw1001_SetChannelSkipCount(
Vkadaba	5:0728bde67bdb	1251	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1252	ADMW1001_CH_ID eChannelId,
ADIJake	0:85855ecd3257	1253	uint32_t nCycleSkipCount)
ADIJake	0:85855ecd3257	1254	{
Vkadaba	8:2f2775c34640	1255	ADMW_CORE_Channel_Skip_t channelSkipReg;
ADIJake	0:85855ecd3257	1256
ADIJake	0:85855ecd3257	1257	channelSkipReg.VALUE16 = REG_RESET_VAL(CORE_CHANNEL_SKIPn);
ADIJake	0:85855ecd3257	1258
ADIJake	0:85855ecd3257	1259	CHECK_REG_FIELD_VAL(CORE_CHANNEL_SKIP_CHANNEL_SKIP, nCycleSkipCount);
ADIJake	0:85855ecd3257	1260
ADIJake	0:85855ecd3257	1261	channelSkipReg.Channel_Skip = nCycleSkipCount;
ADIJake	0:85855ecd3257	1262
ADIJake	0:85855ecd3257	1263	WRITE_REG_U16(hDevice, channelSkipReg.VALUE16, CORE_CHANNEL_SKIPn(eChannelId));
ADIJake	0:85855ecd3257	1264
Vkadaba	5:0728bde67bdb	1265	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1266	}
ADIJake	0:85855ecd3257	1267
Vkadaba	5:0728bde67bdb	1268	static ADMW_RESULT admw_SetChannelAdcSensorType(
Vkadaba	8:2f2775c34640	1269	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1270	ADMW1001_CH_ID eChannelId,
Vkadaba	8:2f2775c34640	1271	ADMW1001_ADC_SENSOR_TYPE sensorType)
ADIJake	0:85855ecd3257	1272	{
Vkadaba	8:2f2775c34640	1273	ADMW_CORE_Sensor_Type_t sensorTypeReg;
ADIJake	0:85855ecd3257	1274
ADIJake	0:85855ecd3257	1275	sensorTypeReg.VALUE16 = REG_RESET_VAL(CORE_SENSOR_TYPEn);
ADIJake	0:85855ecd3257	1276
ADIJake	0:85855ecd3257	1277	/* Ensure that the sensor type is valid for this channel */
ADIJake	0:85855ecd3257	1278	switch(sensorType)
ADIJake	0:85855ecd3257	1279	{
Vkadaba	8:2f2775c34640	1280	case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT100:
Vkadaba	8:2f2775c34640	1281	case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT1000:
Vkadaba	8:2f2775c34640	1282	case ADMW1001_ADC_SENSOR_RTD_3WIRE_1:
Vkadaba	8:2f2775c34640	1283	case ADMW1001_ADC_SENSOR_RTD_3WIRE_2:
Vkadaba	8:2f2775c34640	1284	case ADMW1001_ADC_SENSOR_RTD_3WIRE_3:
Vkadaba	8:2f2775c34640	1285	case ADMW1001_ADC_SENSOR_RTD_3WIRE_4:
Vkadaba	8:2f2775c34640	1286	case ADMW1001_ADC_SENSOR_RTD_4WIRE_PT100:
Vkadaba	8:2f2775c34640	1287	case ADMW1001_ADC_SENSOR_RTD_4WIRE_PT1000:
Vkadaba	8:2f2775c34640	1288	case ADMW1001_ADC_SENSOR_RTD_4WIRE_1:
Vkadaba	8:2f2775c34640	1289	case ADMW1001_ADC_SENSOR_RTD_4WIRE_2:
Vkadaba	8:2f2775c34640	1290	case ADMW1001_ADC_SENSOR_RTD_4WIRE_3:
Vkadaba	8:2f2775c34640	1291	case ADMW1001_ADC_SENSOR_RTD_4WIRE_4:
Vkadaba	8:2f2775c34640	1292	case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE_1:
Vkadaba	8:2f2775c34640	1293	case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE_2:
Vkadaba	8:2f2775c34640	1294	case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE_3:
Vkadaba	8:2f2775c34640	1295	case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE_4:
Vkadaba	8:2f2775c34640	1296	case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE_1:
Vkadaba	8:2f2775c34640	1297	case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE_2:
Vkadaba	8:2f2775c34640	1298	case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE_3:
Vkadaba	8:2f2775c34640	1299	case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE_4:
Vkadaba	8:2f2775c34640	1300	case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT100:
Vkadaba	8:2f2775c34640	1301	case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT1000:
Vkadaba	8:2f2775c34640	1302	case ADMW1001_ADC_SENSOR_RTD_2WIRE_1:
Vkadaba	8:2f2775c34640	1303	case ADMW1001_ADC_SENSOR_RTD_2WIRE_2:
Vkadaba	8:2f2775c34640	1304	case ADMW1001_ADC_SENSOR_RTD_2WIRE_3:
Vkadaba	8:2f2775c34640	1305	case ADMW1001_ADC_SENSOR_RTD_2WIRE_4:
Vkadaba	8:2f2775c34640	1306	case ADMW1001_ADC_SENSOR_DIODE_2C_TYPEA:
Vkadaba	8:2f2775c34640	1307	case ADMW1001_ADC_SENSOR_DIODE_3C_TYPEA:
Vkadaba	8:2f2775c34640	1308	case ADMW1001_ADC_SENSOR_DIODE_2C_1:
Vkadaba	8:2f2775c34640	1309	case ADMW1001_ADC_SENSOR_DIODE_3C_1:
Vkadaba	8:2f2775c34640	1310	case ADMW1001_ADC_SENSOR_THERMISTOR_A_10K:
Vkadaba	8:2f2775c34640	1311	case ADMW1001_ADC_SENSOR_THERMISTOR_B_10K:
Vkadaba	8:2f2775c34640	1312	case ADMW1001_ADC_SENSOR_THERMISTOR_1:
Vkadaba	8:2f2775c34640	1313	case ADMW1001_ADC_SENSOR_THERMISTOR_2:
Vkadaba	8:2f2775c34640	1314	case ADMW1001_ADC_SENSOR_THERMISTOR_3:
Vkadaba	8:2f2775c34640	1315	case ADMW1001_ADC_SENSOR_THERMISTOR_4:
Vkadaba	6:9d393a9677f4	1316	if (! (ADMW1001_CHANNEL_IS_ADC_SENSOR(eChannelId) \|\|
Vkadaba	6:9d393a9677f4	1317	ADMW1001_CHANNEL_IS_ADC_CJC(eChannelId)))
Vkadaba	6:9d393a9677f4	1318	{
Vkadaba	6:9d393a9677f4	1319	ADMW_LOG_ERROR(
Vkadaba	6:9d393a9677f4	1320	"Invalid ADC sensor type %d specified for channel %d",
Vkadaba	6:9d393a9677f4	1321	sensorType, eChannelId);
Vkadaba	6:9d393a9677f4	1322	return ADMW_INVALID_PARAM;
Vkadaba	6:9d393a9677f4	1323	}
Vkadaba	6:9d393a9677f4	1324	break;
Vkadaba	6:9d393a9677f4	1325	case ADMW1001_ADC_SENSOR_VOLTAGE:
Vkadaba	8:2f2775c34640	1326	case ADMW1001_ADC_SENSOR_VOLTAGE_PRESSURE_A:
Vkadaba	8:2f2775c34640	1327	case ADMW1001_ADC_SENSOR_VOLTAGE_PRESSURE_B:
Vkadaba	8:2f2775c34640	1328	case ADMW1001_ADC_SENSOR_VOLTAGE_PRESSURE_1:
Vkadaba	8:2f2775c34640	1329	case ADMW1001_ADC_SENSOR_VOLTAGE_PRESSURE_2:
Vkadaba	8:2f2775c34640	1330	case ADMW1001_ADC_SENSOR_THERMOCOUPLE_J:
Vkadaba	8:2f2775c34640	1331	case ADMW1001_ADC_SENSOR_THERMOCOUPLE_K:
Vkadaba	8:2f2775c34640	1332	case ADMW1001_ADC_SENSOR_THERMOCOUPLE_T:
Vkadaba	8:2f2775c34640	1333	case ADMW1001_ADC_SENSOR_THERMOCOUPLE_1:
Vkadaba	8:2f2775c34640	1334	case ADMW1001_ADC_SENSOR_THERMOCOUPLE_2:
Vkadaba	8:2f2775c34640	1335	case ADMW1001_ADC_SENSOR_THERMOCOUPLE_3:
Vkadaba	8:2f2775c34640	1336	case ADMW1001_ADC_SENSOR_THERMOCOUPLE_4:
Vkadaba	6:9d393a9677f4	1337	if (! ADMW1001_CHANNEL_IS_ADC_VOLTAGE(eChannelId))
Vkadaba	6:9d393a9677f4	1338	{
Vkadaba	6:9d393a9677f4	1339	ADMW_LOG_ERROR(
Vkadaba	6:9d393a9677f4	1340	"Invalid ADC sensor type %d specified for channel %d",
Vkadaba	6:9d393a9677f4	1341	sensorType, eChannelId);
Vkadaba	6:9d393a9677f4	1342	return ADMW_INVALID_PARAM;
Vkadaba	6:9d393a9677f4	1343	}
Vkadaba	6:9d393a9677f4	1344	break;
Vkadaba	6:9d393a9677f4	1345	case ADMW1001_ADC_SENSOR_CURRENT:
Vkadaba	8:2f2775c34640	1346	case ADMW1001_ADC_SENSOR_CURRENT_PRESSURE_A:
Vkadaba	8:2f2775c34640	1347	case ADMW1001_ADC_SENSOR_CURRENT_PRESSURE_1:
Vkadaba	8:2f2775c34640	1348	case ADMW1001_ADC_SENSOR_CURRENT_PRESSURE_2:
Vkadaba	6:9d393a9677f4	1349	if (! ADMW1001_CHANNEL_IS_ADC_CURRENT(eChannelId))
Vkadaba	6:9d393a9677f4	1350	{
Vkadaba	6:9d393a9677f4	1351	ADMW_LOG_ERROR(
Vkadaba	6:9d393a9677f4	1352	"Invalid ADC sensor type %d specified for channel %d",
Vkadaba	6:9d393a9677f4	1353	sensorType, eChannelId);
Vkadaba	6:9d393a9677f4	1354	return ADMW_INVALID_PARAM;
Vkadaba	6:9d393a9677f4	1355	}
Vkadaba	6:9d393a9677f4	1356	break;
Vkadaba	6:9d393a9677f4	1357	default:
Vkadaba	6:9d393a9677f4	1358	ADMW_LOG_ERROR("Invalid/unsupported ADC sensor type %d specified",
Vkadaba	6:9d393a9677f4	1359	sensorType);
Vkadaba	5:0728bde67bdb	1360	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1361	}
ADIJake	0:85855ecd3257	1362
ADIJake	0:85855ecd3257	1363	sensorTypeReg.Sensor_Type = sensorType;
ADIJake	0:85855ecd3257	1364
ADIJake	0:85855ecd3257	1365	WRITE_REG_U16(hDevice, sensorTypeReg.VALUE16, CORE_SENSOR_TYPEn(eChannelId));
ADIJake	0:85855ecd3257	1366
Vkadaba	5:0728bde67bdb	1367	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1368	}
ADIJake	0:85855ecd3257	1369
Vkadaba	5:0728bde67bdb	1370	static ADMW_RESULT admw_SetChannelAdcSensorDetails(
Vkadaba	8:2f2775c34640	1371	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1372	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1373	ADMW1001_CHANNEL_CONFIG *pChannelConfig)
ADIJake	0:85855ecd3257	1374	/*
ADIJake	0:85855ecd3257	1375	* TODO - it would be nice if the general- vs. ADC-specific sensor details could be split into separate registers
ADIJake	0:85855ecd3257	1376	* General details:
ADIJake	0:85855ecd3257	1377	* - Measurement_Units
ADIJake	0:85855ecd3257	1378	* - Compensation_Channel
ADIJake	0:85855ecd3257	1379	* - CJC_Publish (if "CJC" was removed from the name)
ADIJake	0:85855ecd3257	1380	* ADC-specific details:
ADIJake	0:85855ecd3257	1381	* - PGA_Gain
ADIJake	0:85855ecd3257	1382	* - Reference_Select
ADIJake	0:85855ecd3257	1383	* - Reference_Buffer_Disable
ADIJake	0:85855ecd3257	1384	*/
ADIJake	0:85855ecd3257	1385	{
Vkadaba	5:0728bde67bdb	1386	ADMW1001_ADC_CHANNEL_CONFIG *pAdcChannelConfig = &pChannelConfig->adcChannelConfig;
Vkadaba	8:2f2775c34640	1387	ADMW1001_ADC_REFERENCE_TYPE refType = pAdcChannelConfig->reference;
Vkadaba	8:2f2775c34640	1388	ADMW_CORE_Sensor_Details_t sensorDetailsReg;
ADIJake	0:85855ecd3257	1389
ADIJake	0:85855ecd3257	1390	sensorDetailsReg.VALUE32 = REG_RESET_VAL(CORE_SENSOR_DETAILSn);
ADIJake	0:85855ecd3257	1391
ADIJake	0:85855ecd3257	1392	switch(pChannelConfig->measurementUnit)
ADIJake	0:85855ecd3257	1393	{
Vkadaba	8:2f2775c34640	1394	case ADMW1001_MEASUREMENT_UNIT_FAHRENHEIT:
Vkadaba	8:2f2775c34640	1395	sensorDetailsReg.Measurement_Units = CORE_SENSOR_DETAILS_UNITS_DEGF;
Vkadaba	8:2f2775c34640	1396	break;
Vkadaba	8:2f2775c34640	1397	case ADMW1001_MEASUREMENT_UNIT_CELSIUS:
Vkadaba	8:2f2775c34640	1398	sensorDetailsReg.Measurement_Units = CORE_SENSOR_DETAILS_UNITS_DEGC;
Vkadaba	8:2f2775c34640	1399	break;
Vkadaba	8:2f2775c34640	1400	case ADMW1001_MEASUREMENT_UNIT_UNSPECIFIED:
Vkadaba	8:2f2775c34640	1401	sensorDetailsReg.Measurement_Units = CORE_SENSOR_DETAILS_UNITS_UNSPECIFIED;
Vkadaba	8:2f2775c34640	1402	break;
Vkadaba	8:2f2775c34640	1403	default:
Vkadaba	8:2f2775c34640	1404	ADMW_LOG_ERROR("Invalid measurement unit %d specified",
Vkadaba	8:2f2775c34640	1405	pChannelConfig->measurementUnit);
Vkadaba	8:2f2775c34640	1406	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1407	}
ADIJake	0:85855ecd3257	1408
Vkadaba	8:2f2775c34640	1409	if (pChannelConfig->compensationChannel == ADMW1001_CH_ID_NONE)
ADIJake	0:85855ecd3257	1410	{
ADIJake	0:85855ecd3257	1411	sensorDetailsReg.Compensation_Disable = 1;
ADIJake	0:85855ecd3257	1412	sensorDetailsReg.Compensation_Channel = 0;
ADIJake	0:85855ecd3257	1413	}
ADIJake	0:85855ecd3257	1414	else
ADIJake	0:85855ecd3257	1415	{
ADIJake	0:85855ecd3257	1416	sensorDetailsReg.Compensation_Disable = 0;
ADIJake	0:85855ecd3257	1417	sensorDetailsReg.Compensation_Channel = pChannelConfig->compensationChannel;
ADIJake	0:85855ecd3257	1418	}
ADIJake	0:85855ecd3257	1419
Vkadaba	8:2f2775c34640	1420	switch(refType)
ADIJake	0:85855ecd3257	1421	{
Vkadaba	8:2f2775c34640	1422	case ADMW1001_ADC_REFERENCE_VOLTAGE_INTERNAL:
Vkadaba	8:2f2775c34640	1423	sensorDetailsReg.Reference_Select = CORE_SENSOR_DETAILS_REF_VINT;
Vkadaba	8:2f2775c34640	1424	break;
Vkadaba	8:2f2775c34640	1425	case ADMW1001_ADC_REFERENCE_VOLTAGE_EXTERNAL_1:
Vkadaba	8:2f2775c34640	1426	sensorDetailsReg.Reference_Select = CORE_SENSOR_DETAILS_REF_VEXT1;
Vkadaba	8:2f2775c34640	1427	break;
Vkadaba	8:2f2775c34640	1428	case ADMW1001_ADC_REFERENCE_VOLTAGE_AVDD:
Vkadaba	8:2f2775c34640	1429	sensorDetailsReg.Reference_Select = CORE_SENSOR_DETAILS_REF_AVDD;
Vkadaba	8:2f2775c34640	1430	break;
Vkadaba	8:2f2775c34640	1431	default:
Vkadaba	8:2f2775c34640	1432	ADMW_LOG_ERROR("Invalid ADC reference type %d specified", refType);
Vkadaba	8:2f2775c34640	1433	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1434	}
Vkadaba	6:9d393a9677f4	1435
ADIJake	0:85855ecd3257	1436	switch(pAdcChannelConfig->gain)
ADIJake	0:85855ecd3257	1437	{
Vkadaba	8:2f2775c34640	1438	case ADMW1001_ADC_GAIN_1X:
Vkadaba	8:2f2775c34640	1439	sensorDetailsReg.PGA_Gain = CORE_SENSOR_DETAILS_PGA_GAIN_1;
Vkadaba	8:2f2775c34640	1440	break;
Vkadaba	8:2f2775c34640	1441	case ADMW1001_ADC_GAIN_2X:
Vkadaba	8:2f2775c34640	1442	sensorDetailsReg.PGA_Gain = CORE_SENSOR_DETAILS_PGA_GAIN_2;
Vkadaba	8:2f2775c34640	1443	break;
Vkadaba	8:2f2775c34640	1444	case ADMW1001_ADC_GAIN_4X:
Vkadaba	8:2f2775c34640	1445	sensorDetailsReg.PGA_Gain = CORE_SENSOR_DETAILS_PGA_GAIN_4;
Vkadaba	8:2f2775c34640	1446	break;
Vkadaba	8:2f2775c34640	1447	case ADMW1001_ADC_GAIN_8X:
Vkadaba	8:2f2775c34640	1448	sensorDetailsReg.PGA_Gain = CORE_SENSOR_DETAILS_PGA_GAIN_8;
Vkadaba	8:2f2775c34640	1449	break;
Vkadaba	8:2f2775c34640	1450	case ADMW1001_ADC_GAIN_16X:
Vkadaba	8:2f2775c34640	1451	sensorDetailsReg.PGA_Gain = CORE_SENSOR_DETAILS_PGA_GAIN_16;
Vkadaba	8:2f2775c34640	1452	break;
Vkadaba	8:2f2775c34640	1453	case ADMW1001_ADC_GAIN_32X:
Vkadaba	8:2f2775c34640	1454	sensorDetailsReg.PGA_Gain = CORE_SENSOR_DETAILS_PGA_GAIN_32;
Vkadaba	8:2f2775c34640	1455	break;
Vkadaba	8:2f2775c34640	1456	case ADMW1001_ADC_GAIN_64X:
Vkadaba	8:2f2775c34640	1457	sensorDetailsReg.PGA_Gain = CORE_SENSOR_DETAILS_PGA_GAIN_64;
Vkadaba	8:2f2775c34640	1458	break;
Vkadaba	8:2f2775c34640	1459	case ADMW1001_ADC_GAIN_128X:
Vkadaba	8:2f2775c34640	1460	sensorDetailsReg.PGA_Gain = CORE_SENSOR_DETAILS_PGA_GAIN_128;
Vkadaba	8:2f2775c34640	1461	break;
Vkadaba	8:2f2775c34640	1462	default:
Vkadaba	8:2f2775c34640	1463	ADMW_LOG_ERROR("Invalid ADC gain %d specified",
Vkadaba	8:2f2775c34640	1464	pAdcChannelConfig->gain);
Vkadaba	8:2f2775c34640	1465	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1466	}
ADIJake	0:85855ecd3257	1467
Vkadaba	6:9d393a9677f4	1468	switch(pAdcChannelConfig->rtdCurve)
Vkadaba	6:9d393a9677f4	1469	{
Vkadaba	8:2f2775c34640	1470	case ADMW1001_ADC_RTD_CURVE_EUROPEAN:
Vkadaba	8:2f2775c34640	1471	sensorDetailsReg.RTD_Curve = CORE_SENSOR_DETAILS_EUROPEAN_CURVE;
Vkadaba	8:2f2775c34640	1472	break;
Vkadaba	8:2f2775c34640	1473	case ADMW1001_ADC_RTD_CURVE_AMERICAN:
Vkadaba	8:2f2775c34640	1474	sensorDetailsReg.RTD_Curve = CORE_SENSOR_DETAILS_AMERICAN_CURVE;
Vkadaba	8:2f2775c34640	1475	break;
Vkadaba	8:2f2775c34640	1476	case ADMW1001_ADC_RTD_CURVE_JAPANESE:
Vkadaba	8:2f2775c34640	1477	sensorDetailsReg.RTD_Curve = CORE_SENSOR_DETAILS_JAPANESE_CURVE;
Vkadaba	8:2f2775c34640	1478	break;
Vkadaba	8:2f2775c34640	1479	case ADMW1001_ADC_RTD_CURVE_ITS90:
Vkadaba	8:2f2775c34640	1480	sensorDetailsReg.RTD_Curve = CORE_SENSOR_DETAILS_ITS90_CURVE;
Vkadaba	8:2f2775c34640	1481	break;
Vkadaba	8:2f2775c34640	1482	default:
Vkadaba	8:2f2775c34640	1483	ADMW_LOG_ERROR("Invalid RTD Curve %d specified",
Vkadaba	8:2f2775c34640	1484	pAdcChannelConfig->rtdCurve);
Vkadaba	8:2f2775c34640	1485	return ADMW_INVALID_PARAM;
Vkadaba	6:9d393a9677f4	1486	}
Vkadaba	6:9d393a9677f4	1487
ADIJake	0:85855ecd3257	1488	if (pChannelConfig->disablePublishing)
Vkadaba	8:2f2775c34640	1489	{
ADIJake	0:85855ecd3257	1490	sensorDetailsReg.Do_Not_Publish = 1;
Vkadaba	8:2f2775c34640	1491	}
ADIJake	0:85855ecd3257	1492	else
Vkadaba	8:2f2775c34640	1493	{
ADIJake	0:85855ecd3257	1494	sensorDetailsReg.Do_Not_Publish = 0;
Vkadaba	8:2f2775c34640	1495	}
Vkadaba	8:2f2775c34640	1496
Vkadaba	8:2f2775c34640	1497	switch (pChannelConfig->lutSelect)
Vkadaba	8:2f2775c34640	1498	{
Vkadaba	8:2f2775c34640	1499	case ADMW1001_LUT_DEFAULT:
Vkadaba	8:2f2775c34640	1500	case ADMW1001_LUT_UNITY:
Vkadaba	8:2f2775c34640	1501	case ADMW1001_LUT_CUSTOM:
Vkadaba	8:2f2775c34640	1502	sensorDetailsReg.LUT_Select = pChannelConfig->lutSelect;
Vkadaba	8:2f2775c34640	1503	break;
Vkadaba	8:2f2775c34640	1504	default:
Vkadaba	8:2f2775c34640	1505	ADMW_LOG_ERROR("Invalid LUT selection %d specified",
Vkadaba	8:2f2775c34640	1506	pChannelConfig->lutSelect);
Vkadaba	8:2f2775c34640	1507	return ADMW_INVALID_PARAM;
Vkadaba	8:2f2775c34640	1508	}
Vkadaba	8:2f2775c34640	1509
ADIJake	0:85855ecd3257	1510	WRITE_REG_U32(hDevice, sensorDetailsReg.VALUE32, CORE_SENSOR_DETAILSn(eChannelId));
ADIJake	0:85855ecd3257	1511
Vkadaba	5:0728bde67bdb	1512	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1513	}
ADIJake	0:85855ecd3257	1514
Vkadaba	5:0728bde67bdb	1515	static ADMW_RESULT admw_SetChannelAdcFilter(
Vkadaba	5:0728bde67bdb	1516	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1517	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1518	ADMW1001_ADC_FILTER_CONFIG *pFilterConfig)
ADIJake	0:85855ecd3257	1519	{
Vkadaba	8:2f2775c34640	1520	ADMW_CORE_Measurement_Setup_t MeasSetupReg;
Vkadaba	6:9d393a9677f4	1521	MeasSetupReg.VALUE32 = REG_RESET_VAL(CORE_MEASUREMENT_SETUPn);
ADIJake	0:85855ecd3257	1522
Vkadaba	5:0728bde67bdb	1523	if (pFilterConfig->type == ADMW1001_ADC_FILTER_SINC4)
ADIJake	0:85855ecd3257	1524	{
Vkadaba	6:9d393a9677f4	1525	MeasSetupReg.ADC_Filter_Type = CORE_MEASUREMENT_SETUP_ENABLE_SINC4;
Vkadaba	6:9d393a9677f4	1526	MeasSetupReg.ADC_SF = pFilterConfig->sf;
ADIJake	0:85855ecd3257	1527	}
Vkadaba	6:9d393a9677f4	1528	else if (pFilterConfig->type == ADMW1001_ADC_FILTER_SINC3)
ADIJake	0:85855ecd3257	1529	{
Vkadaba	6:9d393a9677f4	1530	MeasSetupReg.ADC_Filter_Type = CORE_MEASUREMENT_SETUP_ENABLE_SINC3;
Vkadaba	6:9d393a9677f4	1531	MeasSetupReg.ADC_SF = pFilterConfig->sf;
ADIJake	0:85855ecd3257	1532	}
ADIJake	0:85855ecd3257	1533	else
ADIJake	0:85855ecd3257	1534	{
Vkadaba	5:0728bde67bdb	1535	ADMW_LOG_ERROR("Invalid ADC filter type %d specified",
ADIJake	0:85855ecd3257	1536	pFilterConfig->type);
Vkadaba	5:0728bde67bdb	1537	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1538	}
Vkadaba	6:9d393a9677f4	1539
Vkadaba	8:2f2775c34640	1540	/* chop mod ecan be 0 (none), 1 (HW, 2 (SW, 3 (HW+SW). */
Vkadaba	17:2f0028880874	1541	MeasSetupReg.Chop_Mode = pFilterConfig->chopMode;
Vkadaba	6:9d393a9677f4	1542
Vkadaba	6:9d393a9677f4	1543	if(pFilterConfig->notch1p2)
Vkadaba	6:9d393a9677f4	1544	MeasSetupReg.NOTCH_EN_2 = 1;
Vkadaba	6:9d393a9677f4	1545	else
Vkadaba	6:9d393a9677f4	1546	MeasSetupReg.NOTCH_EN_2 = 0;
Vkadaba	6:9d393a9677f4	1547
Vkadaba	6:9d393a9677f4	1548	switch(pFilterConfig->groundSwitch)
Vkadaba	6:9d393a9677f4	1549	{
Vkadaba	6:9d393a9677f4	1550	case ADMW1001_ADC_GND_SW_OPEN:
Vkadaba	6:9d393a9677f4	1551	MeasSetupReg.GND_SW = CORE_MEASUREMENT_SETUP_GND_SW_OPEN;
Vkadaba	6:9d393a9677f4	1552	break;
Vkadaba	6:9d393a9677f4	1553	case ADMW1001_ADC_GND_SW_CLOSED:
Vkadaba	6:9d393a9677f4	1554	MeasSetupReg.GND_SW = CORE_MEASUREMENT_SETUP_GND_SW_CLOSED;
Vkadaba	6:9d393a9677f4	1555	break;
Vkadaba	6:9d393a9677f4	1556	default:
Vkadaba	6:9d393a9677f4	1557	ADMW_LOG_ERROR("Invalid ground switch state %d specified",
Vkadaba	6:9d393a9677f4	1558	pFilterConfig->groundSwitch);
Vkadaba	6:9d393a9677f4	1559	return ADMW_INVALID_PARAM;
Vkadaba	6:9d393a9677f4	1560	}
Vkadaba	6:9d393a9677f4	1561
Vkadaba	6:9d393a9677f4	1562	WRITE_REG_U32(hDevice, MeasSetupReg.VALUE32, CORE_MEASUREMENT_SETUPn(eChannelId));
ADIJake	0:85855ecd3257	1563
Vkadaba	5:0728bde67bdb	1564	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1565	}
ADIJake	0:85855ecd3257	1566
Vkadaba	5:0728bde67bdb	1567	static ADMW_RESULT admw_SetChannelAdcCurrentConfig(
Vkadaba	5:0728bde67bdb	1568	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1569	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1570	ADMW1001_ADC_EXC_CURRENT_CONFIG *pCurrentConfig)
ADIJake	0:85855ecd3257	1571	{
Vkadaba	8:2f2775c34640	1572	ADMW_CORE_Channel_Excitation_t channelExcitationReg;
ADIJake	0:85855ecd3257	1573
Vkadaba	6:9d393a9677f4	1574	channelExcitationReg.VALUE16 = REG_RESET_VAL(CORE_CHANNEL_EXCITATIONn);
Vkadaba	6:9d393a9677f4	1575
Vkadaba	18:cbf514cce921	1576	if (pCurrentConfig->outputLevel == ADMW1001_ADC_NO_EXTERNAL_EXC_CURRENT)
Vkadaba	18:cbf514cce921	1577	channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_NONE;
Vkadaba	18:cbf514cce921	1578	else if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_EXTERNAL)
Vkadaba	6:9d393a9677f4	1579	channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_EXTERNAL;
Vkadaba	18:cbf514cce921	1580	else if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_50uA)
Vkadaba	6:9d393a9677f4	1581	channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_IEXC_50UA;
Vkadaba	6:9d393a9677f4	1582	else if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_100uA)
Vkadaba	6:9d393a9677f4	1583	channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_IEXC_100UA;
Vkadaba	6:9d393a9677f4	1584	else if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_250uA)
Vkadaba	6:9d393a9677f4	1585	channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_IEXC_250UA;
Vkadaba	6:9d393a9677f4	1586	else if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_500uA)
Vkadaba	6:9d393a9677f4	1587	channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_IEXC_500UA;
Vkadaba	6:9d393a9677f4	1588	else if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_1000uA)
Vkadaba	6:9d393a9677f4	1589	channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_IEXC_1000UA;
ADIJake	0:85855ecd3257	1590	else
ADIJake	0:85855ecd3257	1591	{
Vkadaba	6:9d393a9677f4	1592	ADMW_LOG_ERROR("Invalid ADC excitation current %d specified",
Vkadaba	6:9d393a9677f4	1593	pCurrentConfig->outputLevel);
Vkadaba	6:9d393a9677f4	1594	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1595	}
ADIJake	0:85855ecd3257	1596
Vkadaba	18:cbf514cce921	1597
Vkadaba	6:9d393a9677f4	1598
Vkadaba	6:9d393a9677f4	1599	switch(pCurrentConfig->diodeRatio) {
Vkadaba	6:9d393a9677f4	1600	case ADMW1001_ADC_EXC_CURRENT_IOUT_DIODE_10UA_100UA:
Vkadaba	6:9d393a9677f4	1601	channelExcitationReg.IOUT_Diode_Ratio = CORE_CHANNEL_EXCITATION_DIODE_2PT_10UA_100UA;
Vkadaba	6:9d393a9677f4	1602	break;
Vkadaba	6:9d393a9677f4	1603	case ADMW1001_ADC_EXC_CURRENT_IOUT_DIODE_20UA_160UA:
Vkadaba	6:9d393a9677f4	1604	channelExcitationReg.IOUT_Diode_Ratio = CORE_CHANNEL_EXCITATION_DIODE_2PT_20UA_160UA;
Vkadaba	6:9d393a9677f4	1605	break;
Vkadaba	6:9d393a9677f4	1606	case ADMW1001_ADC_EXC_CURRENT_IOUT_DIODE_50UA_300UA:
Vkadaba	6:9d393a9677f4	1607	channelExcitationReg.IOUT_Diode_Ratio = CORE_CHANNEL_EXCITATION_DIODE_2PT_50UA_300UA;
Vkadaba	6:9d393a9677f4	1608	break;
Vkadaba	6:9d393a9677f4	1609	case ADMW1001_ADC_EXC_CURRENT_IOUT_DIODE_100UA_600UA:
Vkadaba	6:9d393a9677f4	1610	channelExcitationReg.IOUT_Diode_Ratio = CORE_CHANNEL_EXCITATION_DIODE_2PT_100UA_600UA;
Vkadaba	6:9d393a9677f4	1611	break;
Vkadaba	6:9d393a9677f4	1612	case ADMW1001_ADC_EXC_CURRENT_IOUT_DIODE_10UA_50UA_100UA:
Vkadaba	6:9d393a9677f4	1613	channelExcitationReg.IOUT_Diode_Ratio = CORE_CHANNEL_EXCITATION_DIODE_3PT_10UA_50UA_100UA;
Vkadaba	6:9d393a9677f4	1614	break;
Vkadaba	6:9d393a9677f4	1615	case ADMW1001_ADC_EXC_CURRENT_IOUT_DIODE_20UA_100UA_160UA:
Vkadaba	6:9d393a9677f4	1616	channelExcitationReg.IOUT_Diode_Ratio = CORE_CHANNEL_EXCITATION_DIODE_3PT_20UA_100UA_160UA;
Vkadaba	6:9d393a9677f4	1617	break;
Vkadaba	6:9d393a9677f4	1618	case ADMW1001_ADC_EXC_CURRENT_IOUT_DIODE_50UA_150UA_300UA:
Vkadaba	6:9d393a9677f4	1619	channelExcitationReg.IOUT_Diode_Ratio = CORE_CHANNEL_EXCITATION_DIODE_3PT_50UA_150UA_300UA;
Vkadaba	6:9d393a9677f4	1620	break;
Vkadaba	6:9d393a9677f4	1621	case ADMW1001_ADC_EXC_CURRENT_IOUT_DIODE_100UA_300UA_600UA:
Vkadaba	6:9d393a9677f4	1622	channelExcitationReg.IOUT_Diode_Ratio = CORE_CHANNEL_EXCITATION_DIODE_3PT_100UA_300UA_600UA;
Vkadaba	6:9d393a9677f4	1623	break;
Vkadaba	6:9d393a9677f4	1624	default:
Vkadaba	6:9d393a9677f4	1625	ADMW_LOG_ERROR("Invalid diode ratio %d specified",
Vkadaba	6:9d393a9677f4	1626	pCurrentConfig->diodeRatio);
Vkadaba	6:9d393a9677f4	1627	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1628	}
Vkadaba	6:9d393a9677f4	1629
Vkadaba	6:9d393a9677f4	1630	WRITE_REG_U16(hDevice, channelExcitationReg.VALUE16, CORE_CHANNEL_EXCITATIONn(eChannelId));
ADIJake	0:85855ecd3257	1631
Vkadaba	5:0728bde67bdb	1632	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1633	}
ADIJake	0:85855ecd3257	1634
Vkadaba	5:0728bde67bdb	1635	ADMW_RESULT admw_SetAdcChannelConfig(
Vkadaba	5:0728bde67bdb	1636	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1637	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1638	ADMW1001_CHANNEL_CONFIG *pChannelConfig)
ADIJake	0:85855ecd3257	1639	{
Vkadaba	5:0728bde67bdb	1640	ADMW_RESULT eRet;
Vkadaba	5:0728bde67bdb	1641	ADMW1001_ADC_CHANNEL_CONFIG *pAdcChannelConfig =
ADIJake	0:85855ecd3257	1642	&pChannelConfig->adcChannelConfig;
ADIJake	0:85855ecd3257	1643
Vkadaba	5:0728bde67bdb	1644	eRet = admw_SetChannelAdcSensorType(hDevice, eChannelId,
ADIJake	0:85855ecd3257	1645	pAdcChannelConfig->sensor);
Vkadaba	5:0728bde67bdb	1646	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	1647	{
Vkadaba	5:0728bde67bdb	1648	ADMW_LOG_ERROR("Failed to set ADC sensor type for channel %d",
ADIJake	0:85855ecd3257	1649	eChannelId);
ADIJake	0:85855ecd3257	1650	return eRet;
ADIJake	0:85855ecd3257	1651	}
ADIJake	0:85855ecd3257	1652
Vkadaba	5:0728bde67bdb	1653	eRet = admw_SetChannelAdcSensorDetails(hDevice, eChannelId,
ADIJake	0:85855ecd3257	1654	pChannelConfig);
Vkadaba	5:0728bde67bdb	1655	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	1656	{
Vkadaba	5:0728bde67bdb	1657	ADMW_LOG_ERROR("Failed to set ADC sensor details for channel %d",
ADIJake	0:85855ecd3257	1658	eChannelId);
ADIJake	0:85855ecd3257	1659	return eRet;
ADIJake	0:85855ecd3257	1660	}
ADIJake	0:85855ecd3257	1661
Vkadaba	5:0728bde67bdb	1662	eRet = admw_SetChannelAdcFilter(hDevice, eChannelId,
ADIJake	0:85855ecd3257	1663	&pAdcChannelConfig->filter);
Vkadaba	5:0728bde67bdb	1664	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	1665	{
Vkadaba	5:0728bde67bdb	1666	ADMW_LOG_ERROR("Failed to set ADC filter for channel %d",
ADIJake	0:85855ecd3257	1667	eChannelId);
ADIJake	0:85855ecd3257	1668	return eRet;
ADIJake	0:85855ecd3257	1669	}
ADIJake	0:85855ecd3257	1670
Vkadaba	5:0728bde67bdb	1671	eRet = admw_SetChannelAdcCurrentConfig(hDevice, eChannelId,
ADIJake	0:85855ecd3257	1672	&pAdcChannelConfig->current);
Vkadaba	5:0728bde67bdb	1673	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	1674	{
Vkadaba	5:0728bde67bdb	1675	ADMW_LOG_ERROR("Failed to set ADC current for channel %d",
ADIJake	0:85855ecd3257	1676	eChannelId);
ADIJake	0:85855ecd3257	1677	return eRet;
ADIJake	0:85855ecd3257	1678	}
ADIJake	0:85855ecd3257	1679
Vkadaba	5:0728bde67bdb	1680	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1681	}
ADIJake	0:85855ecd3257	1682
Vkadaba	5:0728bde67bdb	1683	static ADMW_RESULT admw_SetChannelDigitalSensorDetails(
Vkadaba	5:0728bde67bdb	1684	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1685	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1686	ADMW1001_CHANNEL_CONFIG *pChannelConfig)
ADIJake	0:85855ecd3257	1687	{
Vkadaba	8:2f2775c34640	1688	ADMW_CORE_Sensor_Details_t sensorDetailsReg;
ADIJake	0:85855ecd3257	1689
ADIJake	0:85855ecd3257	1690	sensorDetailsReg.VALUE32 = REG_RESET_VAL(CORE_SENSOR_DETAILSn);
ADIJake	0:85855ecd3257	1691
Vkadaba	8:2f2775c34640	1692	if (pChannelConfig->compensationChannel == ADMW1001_CH_ID_NONE)
ADIJake	0:85855ecd3257	1693	{
ADIJake	0:85855ecd3257	1694	sensorDetailsReg.Compensation_Disable = 1;
ADIJake	0:85855ecd3257	1695	sensorDetailsReg.Compensation_Channel = 0;
ADIJake	0:85855ecd3257	1696	}
ADIJake	0:85855ecd3257	1697	else
ADIJake	0:85855ecd3257	1698	{
Vkadaba	5:0728bde67bdb	1699	ADMW_LOG_ERROR("Invalid compensation channel specified for digital sensor");
Vkadaba	5:0728bde67bdb	1700	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1701	}
ADIJake	0:85855ecd3257	1702
Vkadaba	5:0728bde67bdb	1703	if (pChannelConfig->measurementUnit == ADMW1001_MEASUREMENT_UNIT_UNSPECIFIED)
ADIJake	0:85855ecd3257	1704	{
Vkadaba	5:0728bde67bdb	1705	sensorDetailsReg.Measurement_Units = CORE_SENSOR_DETAILS_UNITS_UNSPECIFIED;
ADIJake	0:85855ecd3257	1706	}
ADIJake	0:85855ecd3257	1707	else
ADIJake	0:85855ecd3257	1708	{
Vkadaba	5:0728bde67bdb	1709	ADMW_LOG_ERROR("Invalid measurement unit specified for digital channel");
Vkadaba	5:0728bde67bdb	1710	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1711	}
ADIJake	0:85855ecd3257	1712
ADIJake	0:85855ecd3257	1713	if (pChannelConfig->disablePublishing)
ADIJake	0:85855ecd3257	1714	sensorDetailsReg.Do_Not_Publish = 1;
ADIJake	0:85855ecd3257	1715	else
ADIJake	0:85855ecd3257	1716	sensorDetailsReg.Do_Not_Publish = 0;
ADIJake	0:85855ecd3257	1717
ADIJake	0:85855ecd3257	1718	WRITE_REG_U32(hDevice, sensorDetailsReg.VALUE32, CORE_SENSOR_DETAILSn(eChannelId));
ADIJake	0:85855ecd3257	1719
Vkadaba	5:0728bde67bdb	1720	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1721	}
ADIJake	0:85855ecd3257	1722
Vkadaba	5:0728bde67bdb	1723	static ADMW_RESULT admw_SetDigitalSensorCommands(
Vkadaba	5:0728bde67bdb	1724	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1725	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1726	ADMW1001_DIGITAL_SENSOR_COMMAND *pConfigCommand,
Vkadaba	5:0728bde67bdb	1727	ADMW1001_DIGITAL_SENSOR_COMMAND *pDataRequestCommand)
ADIJake	0:85855ecd3257	1728	{
Vkadaba	8:2f2775c34640	1729	ADMW_CORE_Digital_Sensor_Num_Cmds_t numCmdsReg;
ADIJake	0:85855ecd3257	1730
ADIJake	0:85855ecd3257	1731	numCmdsReg.VALUE8 = REG_RESET_VAL(CORE_DIGITAL_SENSOR_NUM_CMDSn);
ADIJake	0:85855ecd3257	1732
ADIJake	0:85855ecd3257	1733	CHECK_REG_FIELD_VAL(CORE_DIGITAL_SENSOR_NUM_CMDS_DIGITAL_SENSOR_NUM_CFG_CMDS,
ADIJake	0:85855ecd3257	1734	pConfigCommand->commandLength);
ADIJake	0:85855ecd3257	1735	CHECK_REG_FIELD_VAL(CORE_DIGITAL_SENSOR_NUM_CMDS_DIGITAL_SENSOR_NUM_READ_CMDS,
ADIJake	0:85855ecd3257	1736	pDataRequestCommand->commandLength);
ADIJake	0:85855ecd3257	1737
ADIJake	0:85855ecd3257	1738	numCmdsReg.Digital_Sensor_Num_Cfg_Cmds = pConfigCommand->commandLength;
ADIJake	0:85855ecd3257	1739	numCmdsReg.Digital_Sensor_Num_Read_Cmds = pDataRequestCommand->commandLength;
ADIJake	0:85855ecd3257	1740
ADIJake	0:85855ecd3257	1741	WRITE_REG_U8(hDevice, numCmdsReg.VALUE8,
ADIJake	0:85855ecd3257	1742	CORE_DIGITAL_SENSOR_NUM_CMDSn(eChannelId));
ADIJake	0:85855ecd3257	1743
ADIJake	0:85855ecd3257	1744	/*
ADIJake	0:85855ecd3257	1745	* NOTE - the fall-through cases in the switch statement below are
Vkadaba	8:2f2775c34640	1746	* intentional.
ADIJake	0:85855ecd3257	1747	*/
ADIJake	0:85855ecd3257	1748	switch (pConfigCommand->commandLength)
ADIJake	0:85855ecd3257	1749	{
Vkadaba	8:2f2775c34640	1750	case 7:
Vkadaba	8:2f2775c34640	1751	WRITE_REG_U8(hDevice, pConfigCommand->command[6],
Vkadaba	8:2f2775c34640	1752	CORE_DIGITAL_SENSOR_COMMAND7n(eChannelId));
Vkadaba	8:2f2775c34640	1753	case 6:
Vkadaba	8:2f2775c34640	1754	WRITE_REG_U8(hDevice, pConfigCommand->command[5],
Vkadaba	8:2f2775c34640	1755	CORE_DIGITAL_SENSOR_COMMAND6n(eChannelId));
Vkadaba	8:2f2775c34640	1756	case 5:
Vkadaba	8:2f2775c34640	1757	WRITE_REG_U8(hDevice, pConfigCommand->command[4],
Vkadaba	8:2f2775c34640	1758	CORE_DIGITAL_SENSOR_COMMAND5n(eChannelId));
Vkadaba	8:2f2775c34640	1759	case 4:
Vkadaba	8:2f2775c34640	1760	WRITE_REG_U8(hDevice, pConfigCommand->command[3],
Vkadaba	8:2f2775c34640	1761	CORE_DIGITAL_SENSOR_COMMAND4n(eChannelId));
Vkadaba	8:2f2775c34640	1762	case 3:
Vkadaba	8:2f2775c34640	1763	WRITE_REG_U8(hDevice, pConfigCommand->command[2],
Vkadaba	8:2f2775c34640	1764	CORE_DIGITAL_SENSOR_COMMAND3n(eChannelId));
Vkadaba	8:2f2775c34640	1765	case 2:
Vkadaba	8:2f2775c34640	1766	WRITE_REG_U8(hDevice, pConfigCommand->command[1],
Vkadaba	8:2f2775c34640	1767	CORE_DIGITAL_SENSOR_COMMAND2n(eChannelId));
Vkadaba	8:2f2775c34640	1768	case 1:
Vkadaba	8:2f2775c34640	1769	WRITE_REG_U8(hDevice, pConfigCommand->command[0],
Vkadaba	8:2f2775c34640	1770	CORE_DIGITAL_SENSOR_COMMAND1n(eChannelId));
Vkadaba	8:2f2775c34640	1771	case 0:
Vkadaba	8:2f2775c34640	1772	default:
Vkadaba	8:2f2775c34640	1773	break;
ADIJake	0:85855ecd3257	1774	};
ADIJake	0:85855ecd3257	1775
ADIJake	0:85855ecd3257	1776	switch (pDataRequestCommand->commandLength)
ADIJake	0:85855ecd3257	1777	{
Vkadaba	8:2f2775c34640	1778	case 7:
Vkadaba	8:2f2775c34640	1779	WRITE_REG_U8(hDevice, pDataRequestCommand->command[6],
Vkadaba	8:2f2775c34640	1780	CORE_DIGITAL_SENSOR_READ_CMD7n(eChannelId));
Vkadaba	8:2f2775c34640	1781	case 6:
Vkadaba	8:2f2775c34640	1782	WRITE_REG_U8(hDevice, pDataRequestCommand->command[5],
Vkadaba	8:2f2775c34640	1783	CORE_DIGITAL_SENSOR_READ_CMD6n(eChannelId));
Vkadaba	8:2f2775c34640	1784	case 5:
Vkadaba	8:2f2775c34640	1785	WRITE_REG_U8(hDevice, pDataRequestCommand->command[4],
Vkadaba	8:2f2775c34640	1786	CORE_DIGITAL_SENSOR_READ_CMD5n(eChannelId));
Vkadaba	8:2f2775c34640	1787	case 4:
Vkadaba	8:2f2775c34640	1788	WRITE_REG_U8(hDevice, pDataRequestCommand->command[3],
Vkadaba	8:2f2775c34640	1789	CORE_DIGITAL_SENSOR_READ_CMD4n(eChannelId));
Vkadaba	8:2f2775c34640	1790	case 3:
Vkadaba	8:2f2775c34640	1791	WRITE_REG_U8(hDevice, pDataRequestCommand->command[2],
Vkadaba	8:2f2775c34640	1792	CORE_DIGITAL_SENSOR_READ_CMD3n(eChannelId));
Vkadaba	8:2f2775c34640	1793	case 2:
Vkadaba	8:2f2775c34640	1794	WRITE_REG_U8(hDevice, pDataRequestCommand->command[1],
Vkadaba	8:2f2775c34640	1795	CORE_DIGITAL_SENSOR_READ_CMD2n(eChannelId));
Vkadaba	8:2f2775c34640	1796	case 1:
Vkadaba	8:2f2775c34640	1797	WRITE_REG_U8(hDevice, pDataRequestCommand->command[0],
Vkadaba	8:2f2775c34640	1798	CORE_DIGITAL_SENSOR_READ_CMD1n(eChannelId));
Vkadaba	8:2f2775c34640	1799	case 0:
Vkadaba	8:2f2775c34640	1800	default:
Vkadaba	8:2f2775c34640	1801	break;
ADIJake	0:85855ecd3257	1802	};
ADIJake	0:85855ecd3257	1803
Vkadaba	5:0728bde67bdb	1804	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1805	}
ADIJake	0:85855ecd3257	1806
Vkadaba	5:0728bde67bdb	1807	static ADMW_RESULT admw_SetDigitalSensorFormat(
Vkadaba	5:0728bde67bdb	1808	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1809	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1810	ADMW1001_DIGITAL_SENSOR_DATA_FORMAT *pDataFormat)
ADIJake	0:85855ecd3257	1811	{
Vkadaba	8:2f2775c34640	1812	ADMW_CORE_Digital_Sensor_Config_t sensorConfigReg;
ADIJake	0:85855ecd3257	1813
ADIJake	0:85855ecd3257	1814	sensorConfigReg.VALUE16 = REG_RESET_VAL(CORE_DIGITAL_SENSOR_CONFIGn);
ADIJake	0:85855ecd3257	1815
Vkadaba	5:0728bde67bdb	1816	if (pDataFormat->coding != ADMW1001_DIGITAL_SENSOR_DATA_CODING_NONE)
ADIJake	0:85855ecd3257	1817	{
ADIJake	0:85855ecd3257	1818	if (pDataFormat->frameLength == 0)
ADIJake	0:85855ecd3257	1819	{
Vkadaba	5:0728bde67bdb	1820	ADMW_LOG_ERROR("Invalid frame length specified for digital sensor data format");
Vkadaba	5:0728bde67bdb	1821	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1822	}
ADIJake	0:85855ecd3257	1823	if (pDataFormat->numDataBits == 0)
ADIJake	0:85855ecd3257	1824	{
Vkadaba	5:0728bde67bdb	1825	ADMW_LOG_ERROR("Invalid frame length specified for digital sensor data format");
Vkadaba	5:0728bde67bdb	1826	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1827	}
ADIJake	0:85855ecd3257	1828
ADIJake	0:85855ecd3257	1829	CHECK_REG_FIELD_VAL(CORE_DIGITAL_SENSOR_CONFIG_DIGITAL_SENSOR_READ_BYTES,
ADIJake	0:85855ecd3257	1830	pDataFormat->frameLength - 1);
ADIJake	0:85855ecd3257	1831	CHECK_REG_FIELD_VAL(CORE_DIGITAL_SENSOR_CONFIG_DIGITAL_SENSOR_DATA_BITS,
ADIJake	0:85855ecd3257	1832	pDataFormat->numDataBits - 1);
ADIJake	0:85855ecd3257	1833	CHECK_REG_FIELD_VAL(CORE_DIGITAL_SENSOR_CONFIG_DIGITAL_SENSOR_BIT_OFFSET,
ADIJake	0:85855ecd3257	1834	pDataFormat->bitOffset);
ADIJake	0:85855ecd3257	1835
ADIJake	0:85855ecd3257	1836	sensorConfigReg.Digital_Sensor_Read_Bytes = pDataFormat->frameLength - 1;
ADIJake	0:85855ecd3257	1837	sensorConfigReg.Digital_Sensor_Data_Bits = pDataFormat->numDataBits - 1;
ADIJake	0:85855ecd3257	1838	sensorConfigReg.Digital_Sensor_Bit_Offset = pDataFormat->bitOffset;
ADIJake	0:85855ecd3257	1839	sensorConfigReg.Digital_Sensor_Left_Aligned = pDataFormat->leftJustified ? 1 : 0;
ADIJake	0:85855ecd3257	1840	sensorConfigReg.Digital_Sensor_Little_Endian = pDataFormat->littleEndian ? 1 : 0;
ADIJake	0:85855ecd3257	1841
ADIJake	0:85855ecd3257	1842	switch (pDataFormat->coding)
ADIJake	0:85855ecd3257	1843	{
Vkadaba	5:0728bde67bdb	1844	case ADMW1001_DIGITAL_SENSOR_DATA_CODING_UNIPOLAR:
Vkadaba	5:0728bde67bdb	1845	sensorConfigReg.Digital_Sensor_Coding = CORE_DIGITAL_SENSOR_CONFIG_CODING_UNIPOLAR;
ADIJake	0:85855ecd3257	1846	break;
Vkadaba	5:0728bde67bdb	1847	case ADMW1001_DIGITAL_SENSOR_DATA_CODING_TWOS_COMPLEMENT:
Vkadaba	5:0728bde67bdb	1848	sensorConfigReg.Digital_Sensor_Coding = CORE_DIGITAL_SENSOR_CONFIG_CODING_TWOS_COMPL;
ADIJake	0:85855ecd3257	1849	break;
Vkadaba	5:0728bde67bdb	1850	case ADMW1001_DIGITAL_SENSOR_DATA_CODING_OFFSET_BINARY:
Vkadaba	5:0728bde67bdb	1851	sensorConfigReg.Digital_Sensor_Coding = CORE_DIGITAL_SENSOR_CONFIG_CODING_OFFSET_BINARY;
ADIJake	0:85855ecd3257	1852	break;
ADIJake	0:85855ecd3257	1853	default:
Vkadaba	5:0728bde67bdb	1854	ADMW_LOG_ERROR("Invalid coding specified for digital sensor data format");
Vkadaba	5:0728bde67bdb	1855	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1856	}
ADIJake	0:85855ecd3257	1857	}
ADIJake	0:85855ecd3257	1858	else
ADIJake	0:85855ecd3257	1859	{
Vkadaba	5:0728bde67bdb	1860	sensorConfigReg.Digital_Sensor_Coding = CORE_DIGITAL_SENSOR_CONFIG_CODING_NONE;
ADIJake	0:85855ecd3257	1861	}
ADIJake	0:85855ecd3257	1862
ADIJake	0:85855ecd3257	1863	WRITE_REG_U16(hDevice, sensorConfigReg.VALUE16,
ADIJake	0:85855ecd3257	1864	CORE_DIGITAL_SENSOR_CONFIGn(eChannelId));
ADIJake	0:85855ecd3257	1865
ADIJake	0:85855ecd3257	1866
Vkadaba	5:0728bde67bdb	1867	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1868	}
ADIJake	0:85855ecd3257	1869
Vkadaba	5:0728bde67bdb	1870	static ADMW_RESULT admw_SetDigitalCalibrationParam(
Vkadaba	5:0728bde67bdb	1871	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1872	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1873	ADMW1001_DIGITAL_CALIBRATION_COMMAND *pCalibrationParam)
ADIJake	0:85855ecd3257	1874	{
Vkadaba	8:2f2775c34640	1875	ADMW_CORE_Calibration_Parameter_t calibrationParamReg;
ADIJake	0:85855ecd3257	1876
ADIJake	0:85855ecd3257	1877	calibrationParamReg.VALUE32 = REG_RESET_VAL(CORE_CALIBRATION_PARAMETERn);
ADIJake	0:85855ecd3257	1878
ADIJake	0:85855ecd3257	1879	if (pCalibrationParam->enableCalibrationParam == false)
ADIJake	0:85855ecd3257	1880	calibrationParamReg.Calibration_Parameter_Enable = 0;
ADIJake	0:85855ecd3257	1881	else
ADIJake	0:85855ecd3257	1882	calibrationParamReg.Calibration_Parameter_Enable = 1;
ADIJake	0:85855ecd3257	1883
ADIJake	0:85855ecd3257	1884	CHECK_REG_FIELD_VAL(CORE_CALIBRATION_PARAMETER_CALIBRATION_PARAMETER,
ADIJake	0:85855ecd3257	1885	pCalibrationParam->calibrationParam);
ADIJake	0:85855ecd3257	1886
ADIJake	0:85855ecd3257	1887	calibrationParamReg.Calibration_Parameter = pCalibrationParam->calibrationParam;
ADIJake	0:85855ecd3257	1888
ADIJake	0:85855ecd3257	1889	WRITE_REG_U32(hDevice, calibrationParamReg.VALUE32,
ADIJake	0:85855ecd3257	1890	CORE_CALIBRATION_PARAMETERn(eChannelId));
ADIJake	0:85855ecd3257	1891
Vkadaba	5:0728bde67bdb	1892	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1893	}
ADIJake	0:85855ecd3257	1894
Vkadaba	5:0728bde67bdb	1895	static ADMW_RESULT admw_SetChannelI2cSensorType(
Vkadaba	5:0728bde67bdb	1896	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1897	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1898	ADMW1001_I2C_SENSOR_TYPE sensorType)
ADIJake	0:85855ecd3257	1899	{
Vkadaba	8:2f2775c34640	1900	ADMW_CORE_Sensor_Type_t sensorTypeReg;
ADIJake	0:85855ecd3257	1901
ADIJake	0:85855ecd3257	1902	sensorTypeReg.VALUE16 = REG_RESET_VAL(CORE_SENSOR_TYPEn);
ADIJake	0:85855ecd3257	1903
ADIJake	0:85855ecd3257	1904	/* Ensure that the sensor type is valid for this channel */
ADIJake	0:85855ecd3257	1905	switch(sensorType)
ADIJake	0:85855ecd3257	1906	{
Vkadaba	8:2f2775c34640	1907	case ADMW1001_I2C_SENSOR_HUMIDITY_A:
Vkadaba	8:2f2775c34640	1908	case ADMW1001_I2C_SENSOR_HUMIDITY_B:
Vkadaba	8:2f2775c34640	1909	sensorTypeReg.Sensor_Type = sensorType;
Vkadaba	8:2f2775c34640	1910	break;
Vkadaba	8:2f2775c34640	1911	default:
Vkadaba	8:2f2775c34640	1912	ADMW_LOG_ERROR("Unsupported I2C sensor type %d specified", sensorType);
Vkadaba	8:2f2775c34640	1913	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1914	}
ADIJake	0:85855ecd3257	1915
ADIJake	0:85855ecd3257	1916	WRITE_REG_U16(hDevice, sensorTypeReg.VALUE16, CORE_SENSOR_TYPEn(eChannelId));
ADIJake	0:85855ecd3257	1917
Vkadaba	5:0728bde67bdb	1918	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1919	}
ADIJake	0:85855ecd3257	1920
Vkadaba	5:0728bde67bdb	1921	static ADMW_RESULT admw_SetChannelI2cSensorAddress(
Vkadaba	5:0728bde67bdb	1922	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1923	ADMW1001_CH_ID eChannelId,
ADIJake	0:85855ecd3257	1924	uint32_t deviceAddress)
ADIJake	0:85855ecd3257	1925	{
ADIJake	0:85855ecd3257	1926	CHECK_REG_FIELD_VAL(CORE_DIGITAL_SENSOR_ADDRESS_DIGITAL_SENSOR_ADDRESS, deviceAddress);
ADIJake	0:85855ecd3257	1927	WRITE_REG_U8(hDevice, deviceAddress, CORE_DIGITAL_SENSOR_ADDRESSn(eChannelId));
ADIJake	0:85855ecd3257	1928
Vkadaba	5:0728bde67bdb	1929	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1930	}
ADIJake	0:85855ecd3257	1931
Vkadaba	5:0728bde67bdb	1932	static ADMW_RESULT admw_SetDigitalChannelComms(
Vkadaba	5:0728bde67bdb	1933	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1934	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1935	ADMW1001_DIGITAL_SENSOR_COMMS *pDigitalComms)
ADIJake	0:85855ecd3257	1936	{
Vkadaba	8:2f2775c34640	1937	ADMW_CORE_Digital_Sensor_Comms_t digitalSensorComms;
ADIJake	0:85855ecd3257	1938
ADIJake	0:85855ecd3257	1939	digitalSensorComms.VALUE16 = REG_RESET_VAL(CORE_DIGITAL_SENSOR_COMMSn);
ADIJake	0:85855ecd3257	1940
ADIJake	0:85855ecd3257	1941	if(pDigitalComms->useCustomCommsConfig)
ADIJake	0:85855ecd3257	1942	{
ADIJake	0:85855ecd3257	1943	digitalSensorComms.Digital_Sensor_Comms_En = 1;
ADIJake	0:85855ecd3257	1944
Vkadaba	5:0728bde67bdb	1945	if(pDigitalComms->i2cClockSpeed == ADMW1001_DIGITAL_SENSOR_COMMS_I2C_CLOCK_SPEED_100K)
ADIJake	0:85855ecd3257	1946	{
Vkadaba	5:0728bde67bdb	1947	digitalSensorComms.I2C_Clock = CORE_DIGITAL_SENSOR_COMMS_I2C_100K;
ADIJake	0:85855ecd3257	1948	}
Vkadaba	5:0728bde67bdb	1949	else if(pDigitalComms->i2cClockSpeed == ADMW1001_DIGITAL_SENSOR_COMMS_I2C_CLOCK_SPEED_400K)
ADIJake	0:85855ecd3257	1950	{
Vkadaba	5:0728bde67bdb	1951	digitalSensorComms.I2C_Clock = CORE_DIGITAL_SENSOR_COMMS_I2C_400K;
ADIJake	0:85855ecd3257	1952	}
ADIJake	0:85855ecd3257	1953	else
ADIJake	0:85855ecd3257	1954	{
Vkadaba	5:0728bde67bdb	1955	ADMW_LOG_ERROR("Invalid I2C clock speed %d specified",
ADIJake	0:85855ecd3257	1956	pDigitalComms->i2cClockSpeed);
Vkadaba	5:0728bde67bdb	1957	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1958	}
ADIJake	0:85855ecd3257	1959
Vkadaba	5:0728bde67bdb	1960	if(pDigitalComms->spiMode == ADMW1001_DIGITAL_SENSOR_COMMS_SPI_MODE_0)
ADIJake	0:85855ecd3257	1961	{
Vkadaba	5:0728bde67bdb	1962	digitalSensorComms.SPI_Mode = CORE_DIGITAL_SENSOR_COMMS_SPI_MODE_0;
ADIJake	0:85855ecd3257	1963	}
Vkadaba	5:0728bde67bdb	1964	else if(pDigitalComms->spiMode == ADMW1001_DIGITAL_SENSOR_COMMS_SPI_MODE_1)
ADIJake	0:85855ecd3257	1965	{
Vkadaba	5:0728bde67bdb	1966	digitalSensorComms.SPI_Mode = CORE_DIGITAL_SENSOR_COMMS_SPI_MODE_1;
ADIJake	0:85855ecd3257	1967	}
Vkadaba	5:0728bde67bdb	1968	else if(pDigitalComms->spiMode == ADMW1001_DIGITAL_SENSOR_COMMS_SPI_MODE_2)
ADIJake	0:85855ecd3257	1969	{
Vkadaba	5:0728bde67bdb	1970	digitalSensorComms.SPI_Mode = CORE_DIGITAL_SENSOR_COMMS_SPI_MODE_2;
ADIJake	0:85855ecd3257	1971	}
Vkadaba	5:0728bde67bdb	1972	else if(pDigitalComms->spiMode == ADMW1001_DIGITAL_SENSOR_COMMS_SPI_MODE_3)
ADIJake	0:85855ecd3257	1973	{
Vkadaba	5:0728bde67bdb	1974	digitalSensorComms.SPI_Mode = CORE_DIGITAL_SENSOR_COMMS_SPI_MODE_3;
ADIJake	0:85855ecd3257	1975	}
ADIJake	0:85855ecd3257	1976	else
ADIJake	0:85855ecd3257	1977	{
Vkadaba	5:0728bde67bdb	1978	ADMW_LOG_ERROR("Invalid SPI mode %d specified",
ADIJake	0:85855ecd3257	1979	pDigitalComms->spiMode);
Vkadaba	5:0728bde67bdb	1980	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1981	}
ADIJake	0:85855ecd3257	1982
ADIJake	0:85855ecd3257	1983	switch (pDigitalComms->spiClock)
ADIJake	0:85855ecd3257	1984	{
Vkadaba	8:2f2775c34640	1985	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_8MHZ:
Vkadaba	8:2f2775c34640	1986	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_8MHZ;
ADIJake	0:85855ecd3257	1987	break;
Vkadaba	8:2f2775c34640	1988	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_4MHZ:
Vkadaba	8:2f2775c34640	1989	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_4MHZ;
ADIJake	0:85855ecd3257	1990	break;
Vkadaba	8:2f2775c34640	1991	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_2MHZ:
Vkadaba	8:2f2775c34640	1992	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_2MHZ;
ADIJake	0:85855ecd3257	1993	break;
Vkadaba	8:2f2775c34640	1994	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_1MHZ:
Vkadaba	8:2f2775c34640	1995	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_1MHZ;
ADIJake	0:85855ecd3257	1996	break;
Vkadaba	8:2f2775c34640	1997	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_500KHZ:
Vkadaba	8:2f2775c34640	1998	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_500KHZ;
ADIJake	0:85855ecd3257	1999	break;
Vkadaba	8:2f2775c34640	2000	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_250KHZ:
Vkadaba	8:2f2775c34640	2001	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_250KHZ;
ADIJake	0:85855ecd3257	2002	break;
Vkadaba	8:2f2775c34640	2003	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_125KHZ:
Vkadaba	8:2f2775c34640	2004	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_125KHZ;
ADIJake	0:85855ecd3257	2005	break;
Vkadaba	8:2f2775c34640	2006	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_62P5KHZ:
Vkadaba	8:2f2775c34640	2007	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_62P5KHZ;
ADIJake	0:85855ecd3257	2008	break;
Vkadaba	8:2f2775c34640	2009	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_31P3KHZ:
Vkadaba	8:2f2775c34640	2010	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_31P3KHZ;
ADIJake	0:85855ecd3257	2011	break;
Vkadaba	8:2f2775c34640	2012	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_15P6KHZ:
Vkadaba	8:2f2775c34640	2013	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_15P6KHZ;
ADIJake	0:85855ecd3257	2014	break;
Vkadaba	8:2f2775c34640	2015	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_7P8KHZ:
Vkadaba	8:2f2775c34640	2016	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_7P8KHZ;
ADIJake	0:85855ecd3257	2017	break;
Vkadaba	8:2f2775c34640	2018	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_3P9KHZ:
Vkadaba	8:2f2775c34640	2019	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_3P9KHZ;
ADIJake	0:85855ecd3257	2020	break;
Vkadaba	8:2f2775c34640	2021	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_1P9KHZ:
Vkadaba	8:2f2775c34640	2022	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_1P9KHZ;
ADIJake	0:85855ecd3257	2023	break;
Vkadaba	8:2f2775c34640	2024	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_977HZ:
Vkadaba	8:2f2775c34640	2025	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_977HZ;
ADIJake	0:85855ecd3257	2026	break;
Vkadaba	8:2f2775c34640	2027	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_488HZ:
Vkadaba	8:2f2775c34640	2028	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_488HZ;
ADIJake	0:85855ecd3257	2029	break;
Vkadaba	8:2f2775c34640	2030	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_244HZ:
Vkadaba	8:2f2775c34640	2031	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_244HZ;
ADIJake	0:85855ecd3257	2032	break;
ADIJake	0:85855ecd3257	2033	default:
Vkadaba	5:0728bde67bdb	2034	ADMW_LOG_ERROR("Invalid SPI clock %d specified",
ADIJake	0:85855ecd3257	2035	pDigitalComms->spiClock);
Vkadaba	5:0728bde67bdb	2036	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	2037	}
ADIJake	0:85855ecd3257	2038	}
ADIJake	0:85855ecd3257	2039	else
ADIJake	0:85855ecd3257	2040	{
ADIJake	0:85855ecd3257	2041	digitalSensorComms.Digital_Sensor_Comms_En = 0;
ADIJake	0:85855ecd3257	2042	}
ADIJake	0:85855ecd3257	2043
ADIJake	0:85855ecd3257	2044	WRITE_REG_U16(hDevice, digitalSensorComms.VALUE16, CORE_DIGITAL_SENSOR_COMMSn(eChannelId));
ADIJake	0:85855ecd3257	2045
Vkadaba	5:0728bde67bdb	2046	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	2047	}
ADIJake	0:85855ecd3257	2048
Vkadaba	5:0728bde67bdb	2049	ADMW_RESULT admw_SetI2cChannelConfig(
Vkadaba	5:0728bde67bdb	2050	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	2051	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	2052	ADMW1001_CHANNEL_CONFIG *pChannelConfig)
ADIJake	0:85855ecd3257	2053	{
Vkadaba	5:0728bde67bdb	2054	ADMW_RESULT eRet;
Vkadaba	5:0728bde67bdb	2055	ADMW1001_I2C_CHANNEL_CONFIG *pI2cChannelConfig =
ADIJake	0:85855ecd3257	2056	&pChannelConfig->i2cChannelConfig;
ADIJake	0:85855ecd3257	2057
Vkadaba	5:0728bde67bdb	2058	eRet = admw_SetChannelI2cSensorType(hDevice, eChannelId,
ADIJake	0:85855ecd3257	2059	pI2cChannelConfig->sensor);
Vkadaba	5:0728bde67bdb	2060	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	2061	{
Vkadaba	5:0728bde67bdb	2062	ADMW_LOG_ERROR("Failed to set I2C sensor type for channel %d",
ADIJake	0:85855ecd3257	2063	eChannelId);
ADIJake	0:85855ecd3257	2064	return eRet;
ADIJake	0:85855ecd3257	2065	}
ADIJake	0:85855ecd3257	2066
Vkadaba	5:0728bde67bdb	2067	eRet = admw_SetChannelI2cSensorAddress(hDevice, eChannelId,
ADIJake	0:85855ecd3257	2068	pI2cChannelConfig->deviceAddress);
Vkadaba	5:0728bde67bdb	2069	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	2070	{
Vkadaba	5:0728bde67bdb	2071	ADMW_LOG_ERROR("Failed to set I2C sensor address for channel %d",
ADIJake	0:85855ecd3257	2072	eChannelId);
ADIJake	0:85855ecd3257	2073	return eRet;
ADIJake	0:85855ecd3257	2074	}
ADIJake	0:85855ecd3257	2075
Vkadaba	5:0728bde67bdb	2076	eRet = admw_SetChannelDigitalSensorDetails(hDevice, eChannelId,
ADIJake	0:85855ecd3257	2077	pChannelConfig);
Vkadaba	5:0728bde67bdb	2078	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	2079	{
Vkadaba	5:0728bde67bdb	2080	ADMW_LOG_ERROR("Failed to set I2C sensor details for channel %d",
ADIJake	0:85855ecd3257	2081	eChannelId);
ADIJake	0:85855ecd3257	2082	return eRet;
ADIJake	0:85855ecd3257	2083	}
ADIJake	0:85855ecd3257	2084
Vkadaba	5:0728bde67bdb	2085	eRet = admw_SetDigitalSensorCommands(hDevice, eChannelId,
ADIJake	0:85855ecd3257	2086	&pI2cChannelConfig->configurationCommand,
ADIJake	0:85855ecd3257	2087	&pI2cChannelConfig->dataRequestCommand);
Vkadaba	5:0728bde67bdb	2088	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	2089	{
Vkadaba	5:0728bde67bdb	2090	ADMW_LOG_ERROR("Failed to set I2C sensor commands for channel %d",
ADIJake	0:85855ecd3257	2091	eChannelId);
ADIJake	0:85855ecd3257	2092	return eRet;
ADIJake	0:85855ecd3257	2093	}
ADIJake	0:85855ecd3257	2094
Vkadaba	5:0728bde67bdb	2095	eRet = admw_SetDigitalSensorFormat(hDevice, eChannelId,
ADIJake	0:85855ecd3257	2096	&pI2cChannelConfig->dataFormat);
Vkadaba	5:0728bde67bdb	2097	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	2098	{
Vkadaba	5:0728bde67bdb	2099	ADMW_LOG_ERROR("Failed to set I2C sensor data format for channel %d",
ADIJake	0:85855ecd3257	2100	eChannelId);
ADIJake	0:85855ecd3257	2101	return eRet;
ADIJake	0:85855ecd3257	2102	}
ADIJake	0:85855ecd3257	2103
Vkadaba	5:0728bde67bdb	2104	eRet = admw_SetDigitalCalibrationParam(hDevice, eChannelId,
ADIJake	0:85855ecd3257	2105	&pI2cChannelConfig->digitalCalibrationParam);
Vkadaba	5:0728bde67bdb	2106	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	2107	{
Vkadaba	5:0728bde67bdb	2108	ADMW_LOG_ERROR("Failed to set I2C digital calibration param for channel %d",
ADIJake	0:85855ecd3257	2109	eChannelId);
ADIJake	0:85855ecd3257	2110	return eRet;
ADIJake	0:85855ecd3257	2111	}
ADIJake	0:85855ecd3257	2112
Vkadaba	5:0728bde67bdb	2113	eRet = admw_SetDigitalChannelComms(hDevice, eChannelId,
ADIJake	0:85855ecd3257	2114	&pI2cChannelConfig->configureComms);
Vkadaba	5:0728bde67bdb	2115	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	2116	{
Vkadaba	5:0728bde67bdb	2117	ADMW_LOG_ERROR("Failed to set I2C comms for channel %d",
ADIJake	0:85855ecd3257	2118	eChannelId);
ADIJake	0:85855ecd3257	2119	return eRet;
ADIJake	0:85855ecd3257	2120	}
ADIJake	0:85855ecd3257	2121
Vkadaba	5:0728bde67bdb	2122	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	2123	}
ADIJake	0:85855ecd3257	2124
Vkadaba	5:0728bde67bdb	2125	static ADMW_RESULT admw_SetChannelSpiSensorType(
Vkadaba	5:0728bde67bdb	2126	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	2127	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	2128	ADMW1001_SPI_SENSOR_TYPE sensorType)
ADIJake	0:85855ecd3257	2129	{
Vkadaba	8:2f2775c34640	2130	ADMW_CORE_Sensor_Type_t sensorTypeReg;
ADIJake	0:85855ecd3257	2131
ADIJake	0:85855ecd3257	2132	sensorTypeReg.VALUE16 = REG_RESET_VAL(CORE_SENSOR_TYPEn);
ADIJake	0:85855ecd3257	2133
ADIJake	0:85855ecd3257	2134	/* Ensure that the sensor type is valid for this channel */
ADIJake	0:85855ecd3257	2135	switch(sensorType)
ADIJake	0:85855ecd3257	2136	{
Vkadaba	8:2f2775c34640	2137	case ADMW1001_SPI_SENSOR_PRESSURE_A:
Vkadaba	8:2f2775c34640	2138	case ADMW1001_SPI_SENSOR_ACCELEROMETER_A:
Vkadaba	8:2f2775c34640	2139	case ADMW1001_SPI_SENSOR_ACCELEROMETER_B:
Vkadaba	8:2f2775c34640	2140
ADIJake	0:85855ecd3257	2141	sensorTypeReg.Sensor_Type = sensorType;
ADIJake	0:85855ecd3257	2142	break;
ADIJake	0:85855ecd3257	2143	default:
Vkadaba	5:0728bde67bdb	2144	ADMW_LOG_ERROR("Unsupported SPI sensor type %d specified", sensorType);
Vkadaba	5:0728bde67bdb	2145	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	2146	}
ADIJake	0:85855ecd3257	2147
ADIJake	0:85855ecd3257	2148	WRITE_REG_U16(hDevice, sensorTypeReg.VALUE16, CORE_SENSOR_TYPEn(eChannelId));
ADIJake	0:85855ecd3257	2149
Vkadaba	5:0728bde67bdb	2150	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	2151	}
ADIJake	0:85855ecd3257	2152
Vkadaba	5:0728bde67bdb	2153	ADMW_RESULT admw_SetSpiChannelConfig(
Vkadaba	5:0728bde67bdb	2154	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	2155	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	2156	ADMW1001_CHANNEL_CONFIG *pChannelConfig)
ADIJake	0:85855ecd3257	2157	{
Vkadaba	5:0728bde67bdb	2158	ADMW_RESULT eRet;
Vkadaba	5:0728bde67bdb	2159	ADMW1001_SPI_CHANNEL_CONFIG *pSpiChannelConfig =
ADIJake	0:85855ecd3257	2160	&pChannelConfig->spiChannelConfig;
ADIJake	0:85855ecd3257	2161
Vkadaba	5:0728bde67bdb	2162	eRet = admw_SetChannelSpiSensorType(hDevice, eChannelId,
ADIJake	0:85855ecd3257	2163	pSpiChannelConfig->sensor);
Vkadaba	5:0728bde67bdb	2164	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	2165	{
Vkadaba	5:0728bde67bdb	2166	ADMW_LOG_ERROR("Failed to set SPI sensor type for channel %d",
ADIJake	0:85855ecd3257	2167	eChannelId);
ADIJake	0:85855ecd3257	2168	return eRet;
ADIJake	0:85855ecd3257	2169	}
ADIJake	0:85855ecd3257	2170
Vkadaba	5:0728bde67bdb	2171	eRet = admw_SetChannelDigitalSensorDetails(hDevice, eChannelId,
ADIJake	0:85855ecd3257	2172	pChannelConfig);
Vkadaba	5:0728bde67bdb	2173	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	2174	{
Vkadaba	5:0728bde67bdb	2175	ADMW_LOG_ERROR("Failed to set SPI sensor details for channel %d",
ADIJake	0:85855ecd3257	2176	eChannelId);
ADIJake	0:85855ecd3257	2177	return eRet;
ADIJake	0:85855ecd3257	2178	}
ADIJake	0:85855ecd3257	2179
Vkadaba	5:0728bde67bdb	2180	eRet = admw_SetDigitalSensorCommands(hDevice, eChannelId,
ADIJake	0:85855ecd3257	2181	&pSpiChannelConfig->configurationCommand,
ADIJake	0:85855ecd3257	2182	&pSpiChannelConfig->dataRequestCommand);
Vkadaba	5:0728bde67bdb	2183	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	2184	{
Vkadaba	5:0728bde67bdb	2185	ADMW_LOG_ERROR("Failed to set SPI sensor commands for channel %d",
ADIJake	0:85855ecd3257	2186	eChannelId);
ADIJake	0:85855ecd3257	2187	return eRet;
ADIJake	0:85855ecd3257	2188	}
ADIJake	0:85855ecd3257	2189
Vkadaba	5:0728bde67bdb	2190	eRet = admw_SetDigitalSensorFormat(hDevice, eChannelId,
ADIJake	0:85855ecd3257	2191	&pSpiChannelConfig->dataFormat);
Vkadaba	5:0728bde67bdb	2192	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	2193	{
Vkadaba	5:0728bde67bdb	2194	ADMW_LOG_ERROR("Failed to set SPI sensor data format for channel %d",
ADIJake	0:85855ecd3257	2195	eChannelId);
ADIJake	0:85855ecd3257	2196	return eRet;
ADIJake	0:85855ecd3257	2197	}
ADIJake	0:85855ecd3257	2198
Vkadaba	5:0728bde67bdb	2199	eRet = admw_SetDigitalCalibrationParam(hDevice, eChannelId,
ADIJake	0:85855ecd3257	2200	&pSpiChannelConfig->digitalCalibrationParam);
Vkadaba	5:0728bde67bdb	2201	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	2202	{
Vkadaba	5:0728bde67bdb	2203	ADMW_LOG_ERROR("Failed to set SPI digital calibration param for channel %d",
ADIJake	0:85855ecd3257	2204	eChannelId);
ADIJake	0:85855ecd3257	2205	return eRet;
ADIJake	0:85855ecd3257	2206	}
ADIJake	0:85855ecd3257	2207
Vkadaba	5:0728bde67bdb	2208	eRet = admw_SetDigitalChannelComms(hDevice, eChannelId,
ADIJake	0:85855ecd3257	2209	&pSpiChannelConfig->configureComms);
Vkadaba	5:0728bde67bdb	2210	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	2211	{
Vkadaba	5:0728bde67bdb	2212	ADMW_LOG_ERROR("Failed to set SPI comms for channel %d",
ADIJake	0:85855ecd3257	2213	eChannelId);
ADIJake	0:85855ecd3257	2214	return eRet;
ADIJake	0:85855ecd3257	2215	}
ADIJake	0:85855ecd3257	2216
Vkadaba	5:0728bde67bdb	2217	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	2218	}
ADIJake	0:85855ecd3257	2219
Vkadaba	5:0728bde67bdb	2220	ADMW_RESULT admw1001_SetChannelThresholdLimits(
Vkadaba	5:0728bde67bdb	2221	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	2222	ADMW1001_CH_ID eChannelId,
ADIJake	0:85855ecd3257	2223	float32_t fHighThresholdLimit,
ADIJake	0:85855ecd3257	2224	float32_t fLowThresholdLimit)
ADIJake	0:85855ecd3257	2225	{
ADIJake	0:85855ecd3257	2226	/*
ADIJake	0:85855ecd3257	2227	* If the low/high limits are both set to 0 in memory, or NaNs, assume
ADIJake	0:85855ecd3257	2228	* that they are unset, or not required, and use infinity defaults instead
ADIJake	0:85855ecd3257	2229	*/
ADIJake	0:85855ecd3257	2230	if (fHighThresholdLimit == 0.0f && fLowThresholdLimit == 0.0f)
ADIJake	0:85855ecd3257	2231	{
ADIJake	0:85855ecd3257	2232	fHighThresholdLimit = INFINITY;
ADIJake	0:85855ecd3257	2233	fLowThresholdLimit = -INFINITY;
ADIJake	0:85855ecd3257	2234	}
ADIJake	0:85855ecd3257	2235	else
ADIJake	0:85855ecd3257	2236	{
ADIJake	0:85855ecd3257	2237	if (isnan(fHighThresholdLimit))
ADIJake	0:85855ecd3257	2238	fHighThresholdLimit = INFINITY;
ADIJake	0:85855ecd3257	2239	if (isnan(fLowThresholdLimit))
ADIJake	0:85855ecd3257	2240	fLowThresholdLimit = -INFINITY;
ADIJake	0:85855ecd3257	2241	}
ADIJake	0:85855ecd3257	2242
ADIJake	0:85855ecd3257	2243	WRITE_REG_FLOAT(hDevice, fHighThresholdLimit,
ADIJake	0:85855ecd3257	2244	CORE_HIGH_THRESHOLD_LIMITn(eChannelId));
ADIJake	0:85855ecd3257	2245	WRITE_REG_FLOAT(hDevice, fLowThresholdLimit,
ADIJake	0:85855ecd3257	2246	CORE_LOW_THRESHOLD_LIMITn(eChannelId));
ADIJake	0:85855ecd3257	2247
Vkadaba	5:0728bde67bdb	2248	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	2249	}
ADIJake	0:85855ecd3257	2250
Vkadaba	5:0728bde67bdb	2251	ADMW_RESULT admw1001_SetOffsetGain(
Vkadaba	5:0728bde67bdb	2252	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	2253	ADMW1001_CH_ID eChannelId,
ADIJake	0:85855ecd3257	2254	float32_t fOffsetAdjustment,
ADIJake	0:85855ecd3257	2255	float32_t fGainAdjustment)
ADIJake	0:85855ecd3257	2256	{
ADIJake	0:85855ecd3257	2257	/* Replace with default values if NaNs are specified (or 0.0 for gain) */
ADIJake	0:85855ecd3257	2258	if (isnan(fGainAdjustment) \|\| (fGainAdjustment == 0.0f))
ADIJake	0:85855ecd3257	2259	fGainAdjustment = 1.0f;
ADIJake	0:85855ecd3257	2260	if (isnan(fOffsetAdjustment))
ADIJake	0:85855ecd3257	2261	fOffsetAdjustment = 0.0f;
ADIJake	0:85855ecd3257	2262
ADIJake	0:85855ecd3257	2263	WRITE_REG_FLOAT(hDevice, fGainAdjustment, CORE_SENSOR_GAINn(eChannelId));
ADIJake	0:85855ecd3257	2264	WRITE_REG_FLOAT(hDevice, fOffsetAdjustment, CORE_SENSOR_OFFSETn(eChannelId));
ADIJake	0:85855ecd3257	2265
Vkadaba	5:0728bde67bdb	2266	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	2267	}
ADIJake	0:85855ecd3257	2268
Vkadaba	5:0728bde67bdb	2269	ADMW_RESULT admw1001_SetSensorParameter(
Vkadaba	5:0728bde67bdb	2270	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	2271	ADMW1001_CH_ID eChannelId,
ADIJake	0:85855ecd3257	2272	float32_t fSensorParam)
ADIJake	0:85855ecd3257	2273	{
ADIJake	0:85855ecd3257	2274	if (fSensorParam == 0.0f)
ADIJake	0:85855ecd3257	2275	fSensorParam = NAN;
ADIJake	0:85855ecd3257	2276
ADIJake	0:85855ecd3257	2277	WRITE_REG_FLOAT(hDevice, fSensorParam, CORE_SENSOR_PARAMETERn(eChannelId));
ADIJake	0:85855ecd3257	2278
Vkadaba	5:0728bde67bdb	2279	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	2280	}
ADIJake	0:85855ecd3257	2281
Vkadaba	5:0728bde67bdb	2282	ADMW_RESULT admw1001_SetChannelSettlingTime(
Vkadaba	5:0728bde67bdb	2283	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	2284	ADMW1001_CH_ID eChannelId,
ADIJake	0:85855ecd3257	2285	uint32_t nSettlingTime)
ADIJake	0:85855ecd3257	2286	{
Vkadaba	8:2f2775c34640	2287	ADMW_CORE_Settling_Time_t settlingTimeReg;
ADIJake	0:85855ecd3257	2288
ADIJake	0:85855ecd3257	2289	if (nSettlingTime < (1 << 12))
ADIJake	0:85855ecd3257	2290	{
Vkadaba	5:0728bde67bdb	2291	settlingTimeReg.Settling_Time_Units = CORE_SETTLING_TIME_MICROSECONDS;
ADIJake	0:85855ecd3257	2292	}
ADIJake	0:85855ecd3257	2293	else if (nSettlingTime < (1000 * (1 << 12)))
ADIJake	0:85855ecd3257	2294	{
Vkadaba	5:0728bde67bdb	2295	settlingTimeReg.Settling_Time_Units = CORE_SETTLING_TIME_MILLISECONDS;
ADIJake	0:85855ecd3257	2296	nSettlingTime /= 1000;
ADIJake	0:85855ecd3257	2297	}
ADIJake	0:85855ecd3257	2298	else
ADIJake	0:85855ecd3257	2299	{
Vkadaba	5:0728bde67bdb	2300	settlingTimeReg.Settling_Time_Units = CORE_SETTLING_TIME_SECONDS;
ADIJake	0:85855ecd3257	2301	nSettlingTime /= 1000000;
ADIJake	0:85855ecd3257	2302	}
ADIJake	0:85855ecd3257	2303
ADIJake	0:85855ecd3257	2304	CHECK_REG_FIELD_VAL(CORE_SETTLING_TIME_SETTLING_TIME, nSettlingTime);
ADIJake	0:85855ecd3257	2305	settlingTimeReg.Settling_Time = nSettlingTime;
ADIJake	0:85855ecd3257	2306
ADIJake	0:85855ecd3257	2307	WRITE_REG_U16(hDevice, settlingTimeReg.VALUE16, CORE_SETTLING_TIMEn(eChannelId));
ADIJake	0:85855ecd3257	2308
Vkadaba	5:0728bde67bdb	2309	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	2310	}
ADIJake	0:85855ecd3257	2311
Vkadaba	5:0728bde67bdb	2312	ADMW_RESULT admw1001_SetChannelConfig(
Vkadaba	5:0728bde67bdb	2313	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	2314	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	2315	ADMW1001_CHANNEL_CONFIG *pChannelConfig)
ADIJake	0:85855ecd3257	2316	{
Vkadaba	5:0728bde67bdb	2317	ADMW_RESULT eRet;
Vkadaba	5:0728bde67bdb	2318
Vkadaba	5:0728bde67bdb	2319	if (! ADMW1001_CHANNEL_IS_VIRTUAL(eChannelId))
ADIJake	0:85855ecd3257	2320	{
Vkadaba	5:0728bde67bdb	2321	eRet = admw1001_SetChannelCount(hDevice, eChannelId,
ADIJake	0:85855ecd3257	2322	pChannelConfig->enableChannel ?
ADIJake	0:85855ecd3257	2323	pChannelConfig->measurementsPerCycle : 0);
Vkadaba	5:0728bde67bdb	2324	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	2325	{
Vkadaba	5:0728bde67bdb	2326	ADMW_LOG_ERROR("Failed to set measurement count for channel %d",
ADIJake	0:85855ecd3257	2327	eChannelId);
ADIJake	0:85855ecd3257	2328	return eRet;
ADIJake	0:85855ecd3257	2329	}
ADIJake	0:85855ecd3257	2330
Vkadaba	5:0728bde67bdb	2331	eRet = admw1001_SetChannelOptions(hDevice, eChannelId,
Vkadaba	6:9d393a9677f4	2332	pChannelConfig->priority);
Vkadaba	5:0728bde67bdb	2333	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	2334	{
Vkadaba	5:0728bde67bdb	2335	ADMW_LOG_ERROR("Failed to set priority for channel %d",
ADIJake	0:85855ecd3257	2336	eChannelId);
ADIJake	0:85855ecd3257	2337	return eRet;
ADIJake	0:85855ecd3257	2338	}
ADIJake	0:85855ecd3257	2339
ADIJake	0:85855ecd3257	2340	/* If the channel is not enabled, we can skip the following steps */
Vkadaba	6:9d393a9677f4	2341	if (pChannelConfig->enableChannel)
ADIJake	0:85855ecd3257	2342	{
Vkadaba	5:0728bde67bdb	2343	eRet = admw1001_SetChannelSkipCount(hDevice, eChannelId,
ADIJake	0:85855ecd3257	2344	pChannelConfig->cycleSkipCount);
Vkadaba	5:0728bde67bdb	2345	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	2346	{
Vkadaba	5:0728bde67bdb	2347	ADMW_LOG_ERROR("Failed to set cycle skip count for channel %d",
ADIJake	0:85855ecd3257	2348	eChannelId);
ADIJake	0:85855ecd3257	2349	return eRet;
ADIJake	0:85855ecd3257	2350	}
ADIJake	0:85855ecd3257	2351
ADIJake	0:85855ecd3257	2352	switch (eChannelId)
ADIJake	0:85855ecd3257	2353	{
Vkadaba	8:2f2775c34640	2354	case ADMW1001_CH_ID_ANLG_1_UNIVERSAL:
Vkadaba	8:2f2775c34640	2355	case ADMW1001_CH_ID_ANLG_2_UNIVERSAL:
Vkadaba	8:2f2775c34640	2356	case ADMW1001_CH_ID_ANLG_1_DIFFERENTIAL:
Vkadaba	8:2f2775c34640	2357	case ADMW1001_CH_ID_ANLG_2_DIFFERENTIAL:
Vkadaba	5:0728bde67bdb	2358	eRet = admw_SetAdcChannelConfig(hDevice, eChannelId, pChannelConfig);
ADIJake	0:85855ecd3257	2359	break;
Vkadaba	8:2f2775c34640	2360	case ADMW1001_CH_ID_DIG_I2C_0:
Vkadaba	8:2f2775c34640	2361	case ADMW1001_CH_ID_DIG_I2C_1:
Vkadaba	5:0728bde67bdb	2362	eRet = admw_SetI2cChannelConfig(hDevice, eChannelId, pChannelConfig);
ADIJake	0:85855ecd3257	2363	break;
Vkadaba	8:2f2775c34640	2364	case ADMW1001_CH_ID_DIG_SPI_0:
Vkadaba	5:0728bde67bdb	2365	eRet = admw_SetSpiChannelConfig(hDevice, eChannelId, pChannelConfig);
ADIJake	0:85855ecd3257	2366	break;
ADIJake	0:85855ecd3257	2367	default:
Vkadaba	5:0728bde67bdb	2368	ADMW_LOG_ERROR("Invalid channel ID %d specified", eChannelId);
Vkadaba	5:0728bde67bdb	2369	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	2370	}
ADIJake	0:85855ecd3257	2371
Vkadaba	5:0728bde67bdb	2372	eRet = admw1001_SetChannelSettlingTime(hDevice, eChannelId,
ADIJake	0:85855ecd3257	2373	pChannelConfig->extraSettlingTime);
Vkadaba	5:0728bde67bdb	2374	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	2375	{
Vkadaba	5:0728bde67bdb	2376	ADMW_LOG_ERROR("Failed to set settling time for channel %d",
ADIJake	0:85855ecd3257	2377	eChannelId);
ADIJake	0:85855ecd3257	2378	return eRet;
ADIJake	0:85855ecd3257	2379	}
ADIJake	0:85855ecd3257	2380	}
ADIJake	0:85855ecd3257	2381	}
ADIJake	0:85855ecd3257	2382
Vkadaba	6:9d393a9677f4	2383	if (pChannelConfig->enableChannel)
ADIJake	0:85855ecd3257	2384	{
ADIJake	0:85855ecd3257	2385	/* Threshold limits can be configured individually for virtual channels */
Vkadaba	5:0728bde67bdb	2386	eRet = admw1001_SetChannelThresholdLimits(hDevice, eChannelId,
ADIJake	0:85855ecd3257	2387	pChannelConfig->highThreshold,
ADIJake	0:85855ecd3257	2388	pChannelConfig->lowThreshold);
Vkadaba	5:0728bde67bdb	2389	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	2390	{
Vkadaba	5:0728bde67bdb	2391	ADMW_LOG_ERROR("Failed to set threshold limits for channel %d",
ADIJake	0:85855ecd3257	2392	eChannelId);
ADIJake	0:85855ecd3257	2393	return eRet;
ADIJake	0:85855ecd3257	2394	}
ADIJake	0:85855ecd3257	2395
ADIJake	0:85855ecd3257	2396	/* Offset and gain can be configured individually for virtual channels */
Vkadaba	5:0728bde67bdb	2397	eRet = admw1001_SetOffsetGain(hDevice, eChannelId,
ADIJake	0:85855ecd3257	2398	pChannelConfig->offsetAdjustment,
ADIJake	0:85855ecd3257	2399	pChannelConfig->gainAdjustment);
Vkadaba	5:0728bde67bdb	2400	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	2401	{
Vkadaba	5:0728bde67bdb	2402	ADMW_LOG_ERROR("Failed to set offset/gain for channel %d",
ADIJake	0:85855ecd3257	2403	eChannelId);
ADIJake	0:85855ecd3257	2404	return eRet;
ADIJake	0:85855ecd3257	2405	}
ADIJake	0:85855ecd3257	2406
ADIJake	0:85855ecd3257	2407	/* Set sensor specific parameter */
Vkadaba	5:0728bde67bdb	2408	eRet = admw1001_SetSensorParameter(hDevice, eChannelId,
ADIJake	0:85855ecd3257	2409	pChannelConfig->sensorParameter);
Vkadaba	5:0728bde67bdb	2410	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	2411	{
Vkadaba	5:0728bde67bdb	2412	ADMW_LOG_ERROR("Failed to set sensor parameter for channel %d",
ADIJake	0:85855ecd3257	2413	eChannelId);
ADIJake	0:85855ecd3257	2414	return eRet;
ADIJake	0:85855ecd3257	2415	}
ADIJake	0:85855ecd3257	2416	}
ADIJake	0:85855ecd3257	2417
Vkadaba	5:0728bde67bdb	2418	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	2419	}
ADIJake	0:85855ecd3257	2420
Vkadaba	5:0728bde67bdb	2421	ADMW_RESULT admw_SetConfig(
Vkadaba	5:0728bde67bdb	2422	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	5:0728bde67bdb	2423	ADMW_CONFIG * const pConfig)
ADIJake	0:85855ecd3257	2424	{
Vkadaba	5:0728bde67bdb	2425	ADMW1001_CONFIG *pDeviceConfig;
Vkadaba	5:0728bde67bdb	2426	ADMW_PRODUCT_ID productId;
Vkadaba	5:0728bde67bdb	2427	ADMW_RESULT eRet;
Vkadaba	5:0728bde67bdb	2428
Vkadaba	5:0728bde67bdb	2429	if (pConfig->productId != ADMW_PRODUCT_ID_ADMW1001)
ADIJake	0:85855ecd3257	2430	{
Vkadaba	5:0728bde67bdb	2431	ADMW_LOG_ERROR("Configuration Product ID (0x%X) is not supported (0x%0X)",
Vkadaba	5:0728bde67bdb	2432	pConfig->productId, ADMW_PRODUCT_ID_ADMW1001);
Vkadaba	5:0728bde67bdb	2433	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	2434	}
Vkadaba	6:9d393a9677f4	2435
Vkadaba	8:2f2775c34640	2436	if (!((pConfig->versionId.major==VERSIONID_MAJOR) &&
Vkadaba	8:2f2775c34640	2437	(pConfig->versionId.minor==VERSIONID_MINOR)))
Vkadaba	6:9d393a9677f4	2438	{
Vkadaba	6:9d393a9677f4	2439	ADMW_LOG_ERROR("Configuration Version ID (0x%X) is not supported",
Vkadaba	6:9d393a9677f4	2440	pConfig->versionId);
Vkadaba	6:9d393a9677f4	2441	return ADMW_INVALID_PARAM;
Vkadaba	6:9d393a9677f4	2442	}
Vkadaba	6:9d393a9677f4	2443
Vkadaba	6:9d393a9677f4	2444
ADIJake	0:85855ecd3257	2445	/* Check that the actual Product ID is a match? */
Vkadaba	5:0728bde67bdb	2446	eRet = admw_GetProductID(hDevice, &productId);
ADIJake	0:85855ecd3257	2447	if (eRet)
ADIJake	0:85855ecd3257	2448	{
Vkadaba	5:0728bde67bdb	2449	ADMW_LOG_ERROR("Failed to read device Product ID register");
ADIJake	0:85855ecd3257	2450	return eRet;
ADIJake	0:85855ecd3257	2451	}
ADIJake	0:85855ecd3257	2452	if (pConfig->productId != productId)
ADIJake	0:85855ecd3257	2453	{
Vkadaba	5:0728bde67bdb	2454	ADMW_LOG_ERROR("Configuration Product ID (0x%X) does not match device (0x%0X)",
Vkadaba	8:2f2775c34640	2455	pConfig->productId, productId);
Vkadaba	5:0728bde67bdb	2456	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	2457	}
ADIJake	0:85855ecd3257	2458
Vkadaba	5:0728bde67bdb	2459	pDeviceConfig = &pConfig->admw1001;
Vkadaba	5:0728bde67bdb	2460
Vkadaba	5:0728bde67bdb	2461	eRet = admw1001_SetPowerConfig(hDevice, &pDeviceConfig->power);
ADIJake	0:85855ecd3257	2462	if (eRet)
ADIJake	0:85855ecd3257	2463	{
Vkadaba	5:0728bde67bdb	2464	ADMW_LOG_ERROR("Failed to set power configuration");
ADIJake	0:85855ecd3257	2465	return eRet;
ADIJake	0:85855ecd3257	2466	}
ADIJake	0:85855ecd3257	2467
Vkadaba	5:0728bde67bdb	2468	eRet = admw1001_SetMeasurementConfig(hDevice, &pDeviceConfig->measurement);
ADIJake	0:85855ecd3257	2469	if (eRet)
ADIJake	0:85855ecd3257	2470	{
Vkadaba	5:0728bde67bdb	2471	ADMW_LOG_ERROR("Failed to set measurement configuration");
ADIJake	0:85855ecd3257	2472	return eRet;
ADIJake	0:85855ecd3257	2473	}
ADIJake	0:85855ecd3257	2474
Vkadaba	5:0728bde67bdb	2475	eRet = admw1001_SetDiagnosticsConfig(hDevice, &pDeviceConfig->diagnostics);
ADIJake	0:85855ecd3257	2476	if (eRet)
ADIJake	0:85855ecd3257	2477	{
Vkadaba	5:0728bde67bdb	2478	ADMW_LOG_ERROR("Failed to set diagnostics configuration");
ADIJake	0:85855ecd3257	2479	return eRet;
ADIJake	0:85855ecd3257	2480	}
ADIJake	0:85855ecd3257	2481
Vkadaba	8:2f2775c34640	2482	for (ADMW1001_CH_ID id = ADMW1001_CH_ID_ANLG_1_UNIVERSAL;
Vkadaba	5:0728bde67bdb	2483	id < ADMW1001_MAX_CHANNELS;
ADIJake	0:85855ecd3257	2484	id++)
ADIJake	0:85855ecd3257	2485	{
Vkadaba	5:0728bde67bdb	2486	eRet = admw1001_SetChannelConfig(hDevice, id,
ADIJake	0:85855ecd3257	2487	&pDeviceConfig->channels[id]);
ADIJake	0:85855ecd3257	2488	if (eRet)
ADIJake	0:85855ecd3257	2489	{
Vkadaba	5:0728bde67bdb	2490	ADMW_LOG_ERROR("Failed to set channel %d configuration", id);
ADIJake	0:85855ecd3257	2491	return eRet;
ADIJake	0:85855ecd3257	2492	}
ADIJake	0:85855ecd3257	2493	}
ADIJake	0:85855ecd3257	2494
Vkadaba	5:0728bde67bdb	2495	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	2496	}
ADIJake	0:85855ecd3257	2497
Vkadaba	5:0728bde67bdb	2498	ADMW_RESULT admw1001_SetLutData(
Vkadaba	8:2f2775c34640	2499	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	5:0728bde67bdb	2500	ADMW1001_LUT * const pLutData)
ADIJake	0:85855ecd3257	2501	{
Vkadaba	5:0728bde67bdb	2502	ADMW1001_LUT_HEADER *pLutHeader = &pLutData->header;
Vkadaba	8:2f2775c34640	2503	ADMW1001_LUT_TABLE *pLutTable = pLutData->tables;
ADIJake	0:85855ecd3257	2504	unsigned actualLength = 0;
ADIJake	0:85855ecd3257	2505
Vkadaba	5:0728bde67bdb	2506	if (pLutData->header.signature != ADMW_LUT_SIGNATURE)
ADIJake	0:85855ecd3257	2507	{
Vkadaba	5:0728bde67bdb	2508	ADMW_LOG_ERROR("LUT signature incorrect (expected 0x%X, actual 0x%X)",
Vkadaba	5:0728bde67bdb	2509	ADMW_LUT_SIGNATURE, pLutHeader->signature);
Vkadaba	5:0728bde67bdb	2510	return ADMW_INVALID_SIGNATURE;
ADIJake	0:85855ecd3257	2511	}
ADIJake	0:85855ecd3257	2512
ADIJake	0:85855ecd3257	2513	for (unsigned i = 0; i < pLutHeader->numTables; i++)
ADIJake	0:85855ecd3257	2514	{
Vkadaba	5:0728bde67bdb	2515	ADMW1001_LUT_DESCRIPTOR *pDesc = &pLutTable->descriptor;
Vkadaba	5:0728bde67bdb	2516	ADMW1001_LUT_TABLE_DATA *pData = &pLutTable->data;
ADIJake	0:85855ecd3257	2517	unsigned short calculatedCrc;
ADIJake	0:85855ecd3257	2518
ADIJake	0:85855ecd3257	2519	switch (pDesc->geometry)
ADIJake	0:85855ecd3257	2520	{
Vkadaba	5:0728bde67bdb	2521	case ADMW1001_LUT_GEOMETRY_COEFFS:
ADIJake	0:85855ecd3257	2522	switch (pDesc->equation)
ADIJake	0:85855ecd3257	2523	{
Vkadaba	5:0728bde67bdb	2524	case ADMW1001_LUT_EQUATION_POLYN:
Vkadaba	5:0728bde67bdb	2525	case ADMW1001_LUT_EQUATION_POLYNEXP:
Vkadaba	5:0728bde67bdb	2526	case ADMW1001_LUT_EQUATION_QUADRATIC:
Vkadaba	5:0728bde67bdb	2527	case ADMW1001_LUT_EQUATION_STEINHART:
Vkadaba	5:0728bde67bdb	2528	case ADMW1001_LUT_EQUATION_LOGARITHMIC:
Vkadaba	5:0728bde67bdb	2529	case ADMW1001_LUT_EQUATION_BIVARIATE_POLYN:
ADIJake	0:85855ecd3257	2530	break;
ADIJake	0:85855ecd3257	2531	default:
Vkadaba	5:0728bde67bdb	2532	ADMW_LOG_ERROR("Invalid equation %u specified for LUT table %u",
ADIJake	0:85855ecd3257	2533	pDesc->equation, i);
Vkadaba	5:0728bde67bdb	2534	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	2535	}
ADIJake	0:85855ecd3257	2536	break;
Vkadaba	5:0728bde67bdb	2537	case ADMW1001_LUT_GEOMETRY_NES_1D:
Vkadaba	5:0728bde67bdb	2538	case ADMW1001_LUT_GEOMETRY_NES_2D:
Vkadaba	5:0728bde67bdb	2539	case ADMW1001_LUT_GEOMETRY_ES_1D:
Vkadaba	5:0728bde67bdb	2540	case ADMW1001_LUT_GEOMETRY_ES_2D:
Vkadaba	5:0728bde67bdb	2541	if (pDesc->equation != ADMW1001_LUT_EQUATION_LUT) {
Vkadaba	5:0728bde67bdb	2542	ADMW_LOG_ERROR("Invalid equation %u specified for LUT table %u",
ADIJake	0:85855ecd3257	2543	pDesc->equation, i);
Vkadaba	5:0728bde67bdb	2544	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	2545	}
ADIJake	0:85855ecd3257	2546	break;
ADIJake	0:85855ecd3257	2547	default:
Vkadaba	5:0728bde67bdb	2548	ADMW_LOG_ERROR("Invalid geometry %u specified for LUT table %u",
ADIJake	0:85855ecd3257	2549	pDesc->geometry, i);
Vkadaba	5:0728bde67bdb	2550	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	2551	}
ADIJake	0:85855ecd3257	2552
ADIJake	0:85855ecd3257	2553	switch (pDesc->dataType)
ADIJake	0:85855ecd3257	2554	{
Vkadaba	5:0728bde67bdb	2555	case ADMW1001_LUT_DATA_TYPE_FLOAT32:
Vkadaba	5:0728bde67bdb	2556	case ADMW1001_LUT_DATA_TYPE_FLOAT64:
ADIJake	0:85855ecd3257	2557	break;
ADIJake	0:85855ecd3257	2558	default:
Vkadaba	5:0728bde67bdb	2559	ADMW_LOG_ERROR("Invalid vector format %u specified for LUT table %u",
ADIJake	0:85855ecd3257	2560	pDesc->dataType, i);
Vkadaba	5:0728bde67bdb	2561	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	2562	}
ADIJake	0:85855ecd3257	2563
Vkadaba	5:0728bde67bdb	2564	calculatedCrc = admw_crc16_ccitt(pData, pDesc->length);
ADIJake	0:85855ecd3257	2565	if (calculatedCrc != pDesc->crc16)
ADIJake	0:85855ecd3257	2566	{
Vkadaba	5:0728bde67bdb	2567	ADMW_LOG_ERROR("CRC validation failed on LUT table %u (expected 0x%04X, actual 0x%04X)",
ADIJake	0:85855ecd3257	2568	i, pDesc->crc16, calculatedCrc);
Vkadaba	5:0728bde67bdb	2569	return ADMW_CRC_ERROR;
ADIJake	0:85855ecd3257	2570	}
ADIJake	0:85855ecd3257	2571
ADIJake	0:85855ecd3257	2572	actualLength += sizeof(*pDesc) + pDesc->length;
ADIJake	0:85855ecd3257	2573
ADIJake	0:85855ecd3257	2574	/* Move to the next look-up table */
Vkadaba	5:0728bde67bdb	2575	pLutTable = (ADMW1001_LUT_TABLE )((uint8_t )pLutTable + sizeof(*pDesc) + pDesc->length);
ADIJake	0:85855ecd3257	2576	}
ADIJake	0:85855ecd3257	2577
ADIJake	0:85855ecd3257	2578	if (actualLength != pLutHeader->totalLength)
ADIJake	0:85855ecd3257	2579	{
Vkadaba	5:0728bde67bdb	2580	ADMW_LOG_ERROR("LUT table length mismatch (expected %u, actual %u)",
ADIJake	0:85855ecd3257	2581	pLutHeader->totalLength, actualLength);
Vkadaba	5:0728bde67bdb	2582	return ADMW_WRONG_SIZE;
ADIJake	0:85855ecd3257	2583	}
ADIJake	0:85855ecd3257	2584
Vkadaba	5:0728bde67bdb	2585	if (sizeof(*pLutHeader) + pLutHeader->totalLength > ADMW_LUT_MAX_SIZE)
ADIJake	0:85855ecd3257	2586	{
Vkadaba	5:0728bde67bdb	2587	ADMW_LOG_ERROR("Maximum LUT table length (%u bytes) exceeded",
Vkadaba	5:0728bde67bdb	2588	ADMW_LUT_MAX_SIZE);
Vkadaba	5:0728bde67bdb	2589	return ADMW_WRONG_SIZE;
ADIJake	0:85855ecd3257	2590	}
ADIJake	0:85855ecd3257	2591
ADIJake	0:85855ecd3257	2592	/* Write the LUT data to the device */
ADIJake	0:85855ecd3257	2593	unsigned lutSize = sizeof(*pLutHeader) + pLutHeader->totalLength;
ADIJake	0:85855ecd3257	2594	WRITE_REG_U16(hDevice, 0, CORE_LUT_OFFSET);
ADIJake	0:85855ecd3257	2595	WRITE_REG_U8_ARRAY(hDevice, (uint8_t *)pLutData, lutSize, CORE_LUT_DATA);
ADIJake	0:85855ecd3257	2596
Vkadaba	5:0728bde67bdb	2597	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	2598	}
ADIJake	0:85855ecd3257	2599
Vkadaba	5:0728bde67bdb	2600	ADMW_RESULT admw1001_SetLutDataRaw(
Vkadaba	5:0728bde67bdb	2601	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	5:0728bde67bdb	2602	ADMW1001_LUT_RAW * const pLutData)
ADIJake	0:85855ecd3257	2603	{
Vkadaba	5:0728bde67bdb	2604	return admw1001_SetLutData(hDevice,
Vkadaba	5:0728bde67bdb	2605	(ADMW1001_LUT *)pLutData);
ADIJake	0:85855ecd3257	2606	}
ADIJake	0:85855ecd3257	2607
Vkadaba	5:0728bde67bdb	2608	static ADMW_RESULT getLutTableSize(
Vkadaba	5:0728bde67bdb	2609	ADMW1001_LUT_DESCRIPTOR * const pDesc,
Vkadaba	5:0728bde67bdb	2610	ADMW1001_LUT_TABLE_DATA * const pData,
ADIJake	0:85855ecd3257	2611	unsigned *pLength)
ADIJake	0:85855ecd3257	2612	{
ADIJake	0:85855ecd3257	2613	switch (pDesc->geometry)
ADIJake	0:85855ecd3257	2614	{
Vkadaba	5:0728bde67bdb	2615	case ADMW1001_LUT_GEOMETRY_COEFFS:
Vkadaba	5:0728bde67bdb	2616	if (pDesc->equation == ADMW1001_LUT_EQUATION_BIVARIATE_POLYN)
Vkadaba	5:0728bde67bdb	2617	*pLength = ADMW1001_LUT_2D_POLYN_COEFF_LIST_SIZE(pData->coeffList2d);
ADIJake	0:85855ecd3257	2618	else
Vkadaba	5:0728bde67bdb	2619	*pLength = ADMW1001_LUT_COEFF_LIST_SIZE(pData->coeffList);
ADIJake	0:85855ecd3257	2620	break;
Vkadaba	5:0728bde67bdb	2621	case ADMW1001_LUT_GEOMETRY_NES_1D:
Vkadaba	5:0728bde67bdb	2622	*pLength = ADMW1001_LUT_1D_NES_SIZE(pData->lut1dNes);
ADIJake	0:85855ecd3257	2623	break;
Vkadaba	5:0728bde67bdb	2624	case ADMW1001_LUT_GEOMETRY_NES_2D:
Vkadaba	5:0728bde67bdb	2625	*pLength = ADMW1001_LUT_2D_NES_SIZE(pData->lut2dNes);
ADIJake	0:85855ecd3257	2626	break;
Vkadaba	5:0728bde67bdb	2627	case ADMW1001_LUT_GEOMETRY_ES_1D:
Vkadaba	5:0728bde67bdb	2628	*pLength = ADMW1001_LUT_1D_ES_SIZE(pData->lut1dEs);
ADIJake	0:85855ecd3257	2629	break;
Vkadaba	5:0728bde67bdb	2630	case ADMW1001_LUT_GEOMETRY_ES_2D:
Vkadaba	5:0728bde67bdb	2631	*pLength = ADMW1001_LUT_2D_ES_SIZE(pData->lut2dEs);
ADIJake	0:85855ecd3257	2632	break;
ADIJake	0:85855ecd3257	2633	default:
Vkadaba	5:0728bde67bdb	2634	ADMW_LOG_ERROR("Invalid LUT table geometry %d specified\r\n",
ADIJake	0:85855ecd3257	2635	pDesc->geometry);
Vkadaba	5:0728bde67bdb	2636	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	2637	}
ADIJake	0:85855ecd3257	2638
Vkadaba	5:0728bde67bdb	2639	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	2640	}
ADIJake	0:85855ecd3257	2641
Vkadaba	5:0728bde67bdb	2642	ADMW_RESULT admw1001_AssembleLutData(
Vkadaba	5:0728bde67bdb	2643	ADMW1001_LUT * pLutBuffer,
ADIJake	0:85855ecd3257	2644	unsigned nLutBufferSize,
ADIJake	0:85855ecd3257	2645	unsigned const nNumTables,
Vkadaba	5:0728bde67bdb	2646	ADMW1001_LUT_DESCRIPTOR * const ppDesc[],
Vkadaba	5:0728bde67bdb	2647	ADMW1001_LUT_TABLE_DATA * const ppData[])
ADIJake	0:85855ecd3257	2648	{
Vkadaba	5:0728bde67bdb	2649	ADMW1001_LUT_HEADER *pHdr = &pLutBuffer->header;
ADIJake	0:85855ecd3257	2650	uint8_t pLutTableData = (uint8_t )pLutBuffer + sizeof(*pHdr);
ADIJake	0:85855ecd3257	2651
ADIJake	0:85855ecd3257	2652	if (sizeof(*pHdr) > nLutBufferSize)
ADIJake	0:85855ecd3257	2653	{
Vkadaba	5:0728bde67bdb	2654	ADMW_LOG_ERROR("Insufficient LUT buffer size provided");
Vkadaba	5:0728bde67bdb	2655	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	2656	}
ADIJake	0:85855ecd3257	2657
ADIJake	0:85855ecd3257	2658	/* First initialise the top-level header */
Vkadaba	5:0728bde67bdb	2659	pHdr->signature = ADMW_LUT_SIGNATURE;
ADIJake	0:85855ecd3257	2660	pHdr->version.major = 1;
ADIJake	0:85855ecd3257	2661	pHdr->version.minor = 0;
ADIJake	0:85855ecd3257	2662	pHdr->numTables = 0;
ADIJake	0:85855ecd3257	2663	pHdr->totalLength = 0;
ADIJake	0:85855ecd3257	2664
ADIJake	0:85855ecd3257	2665	/*
ADIJake	0:85855ecd3257	2666	* Walk through the list of table pointers provided, appending the table
ADIJake	0:85855ecd3257	2667	* descriptor+data from each one to the provided LUT buffer
ADIJake	0:85855ecd3257	2668	*/
ADIJake	0:85855ecd3257	2669	for (unsigned i = 0; i < nNumTables; i++)
ADIJake	0:85855ecd3257	2670	{
Vkadaba	5:0728bde67bdb	2671	ADMW1001_LUT_DESCRIPTOR * const pDesc = ppDesc[i];
Vkadaba	5:0728bde67bdb	2672	ADMW1001_LUT_TABLE_DATA * const pData = ppData[i];
Vkadaba	5:0728bde67bdb	2673	ADMW_RESULT res;
ADIJake	0:85855ecd3257	2674	unsigned dataLength = 0;
ADIJake	0:85855ecd3257	2675
ADIJake	0:85855ecd3257	2676	/* Calculate the length of the table data */
ADIJake	0:85855ecd3257	2677	res = getLutTableSize(pDesc, pData, &dataLength);
Vkadaba	5:0728bde67bdb	2678	if (res != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	2679	return res;
ADIJake	0:85855ecd3257	2680
ADIJake	0:85855ecd3257	2681	/* Fill in the table descriptor length and CRC fields */
ADIJake	0:85855ecd3257	2682	pDesc->length = dataLength;
Vkadaba	5:0728bde67bdb	2683	pDesc->crc16 = admw_crc16_ccitt(pData, dataLength);
ADIJake	0:85855ecd3257	2684
ADIJake	0:85855ecd3257	2685	if ((sizeof(pHdr) + pHdr->totalLength + sizeof(pDesc) + dataLength) > nLutBufferSize)
ADIJake	0:85855ecd3257	2686	{
Vkadaba	5:0728bde67bdb	2687	ADMW_LOG_ERROR("Insufficient LUT buffer size provided");
Vkadaba	5:0728bde67bdb	2688	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	2689	}
ADIJake	0:85855ecd3257	2690
ADIJake	0:85855ecd3257	2691	/* Append the table to the LUT buffer (desc + data) */
ADIJake	0:85855ecd3257	2692	memcpy(pLutTableData + pHdr->totalLength, pDesc, sizeof(*pDesc));
ADIJake	0:85855ecd3257	2693	pHdr->totalLength += sizeof(*pDesc);
ADIJake	0:85855ecd3257	2694	memcpy(pLutTableData + pHdr->totalLength, pData, dataLength);
ADIJake	0:85855ecd3257	2695	pHdr->totalLength += dataLength;
ADIJake	0:85855ecd3257	2696
ADIJake	0:85855ecd3257	2697	pHdr->numTables++;
ADIJake	0:85855ecd3257	2698	}
ADIJake	0:85855ecd3257	2699
Vkadaba	5:0728bde67bdb	2700	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	2701	}
Vkadaba	14:266ab283b086	2702
Vkadaba	14:266ab283b086	2703	ADMW_RESULT deviceInformation(ADMW_DEVICE_HANDLE hDevice)
Vkadaba	14:266ab283b086	2704	{
Vkadaba	14:266ab283b086	2705	uint16_t nAddress = REG_CORE_REVISION;
Vkadaba	14:266ab283b086	2706	char nData[ADMW_VERSION_REG_VAL_SIZE]; //4 Bytes of version register data
Vkadaba	14:266ab283b086	2707	ADMW_RESULT res;
Vkadaba	14:266ab283b086	2708	res=admw1001_ReadRegister(hDevice,nAddress,nData,sizeof(nData));
Vkadaba	14:266ab283b086	2709	if(res != ADMW_SUCCESS)
Vkadaba	14:266ab283b086	2710	{
Vkadaba	14:266ab283b086	2711	//if reading version register failed, sending 00.00.0000 as ADMW1001 firmware version
Vkadaba	14:266ab283b086	2712	//strcat(nData, ADMW1001_FIRMWARE_VERSION_DEFAULT);
Vkadaba	14:266ab283b086	2713	ADMW_LOG_INFO("Firmware Version Id is %X.%X",nData[2],nData[0]);
Vkadaba	14:266ab283b086	2714	}
Vkadaba	14:266ab283b086	2715	else
Vkadaba	14:266ab283b086	2716	{
Vkadaba	14:266ab283b086	2717	char buffer[ADMW_FORMATTED_VERSION_SIZE]; //00.00.0000 8 digits + 2 Bytes "." + one null character at the end
Vkadaba	14:266ab283b086	2718	strcat(nData, buffer);
Vkadaba	14:266ab283b086	2719	ADMW_LOG_INFO("Firmware Version Id is %X.%X",nData[2],nData[0]);
Vkadaba	14:266ab283b086	2720	}
Vkadaba	14:266ab283b086	2721	return ADMW_SUCCESS;
Vkadaba	14:266ab283b086	2722	}
Vkadaba	14:266ab283b086	2723
Vkadaba	13:97cb32670539	2724	ADMW_RESULT admw1001_getFirmwareStatus(
Vkadaba	13:97cb32670539	2725	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	13:97cb32670539	2726	bool * const bFirmwareStatus)
Vkadaba	13:97cb32670539	2727	{
Vkadaba	13:97cb32670539	2728	bool bitCommand;
Vkadaba	13:97cb32670539	2729	ADMW_RESULT eRet;
Vkadaba	13:97cb32670539	2730	uint8_t pinreg = 0x1;
Vkadaba	13:97cb32670539	2731
Vkadaba	13:97cb32670539	2732	ADMW_DEVICE_CONTEXT *pCtx = hDevice;
Vkadaba	13:97cb32670539	2733	static uint8_t DataBuffer[SPI_BUFFER_SIZE] = {0};
Vkadaba	13:97cb32670539	2734	uint16_t nSize;
Vkadaba	13:97cb32670539	2735
Vkadaba	13:97cb32670539	2736	//Construct Read Status command
Vkadaba	13:97cb32670539	2737	DataBuffer[0] = 0x07;
Vkadaba	13:97cb32670539	2738	DataBuffer[1] = 0x0E; //Packet ID
Vkadaba	13:97cb32670539	2739
Vkadaba	13:97cb32670539	2740	DataBuffer[2] = 0x00;
Vkadaba	13:97cb32670539	2741	DataBuffer[3] = 0x00; //Data words
Vkadaba	13:97cb32670539	2742
Vkadaba	13:97cb32670539	2743	DataBuffer[4] = 0x53;
Vkadaba	13:97cb32670539	2744	DataBuffer[5] = 0x00; //Command ID
Vkadaba	13:97cb32670539	2745
Vkadaba	13:97cb32670539	2746	DataBuffer[6] = 0x00;
Vkadaba	13:97cb32670539	2747	DataBuffer[7] = 0x00;
Vkadaba	13:97cb32670539	2748	DataBuffer[8] = 0x00;
Vkadaba	13:97cb32670539	2749	DataBuffer[9] = 0x00; //Address
Vkadaba	13:97cb32670539	2750
Vkadaba	13:97cb32670539	2751	DataBuffer[10] = 0x53;
Vkadaba	13:97cb32670539	2752	DataBuffer[11] = 0x00;
Vkadaba	13:97cb32670539	2753	DataBuffer[12] = 0x00;
Vkadaba	13:97cb32670539	2754	DataBuffer[13] = 0x00; //Checksum
Vkadaba	13:97cb32670539	2755
Vkadaba	13:97cb32670539	2756	nSize = SFL_READ_STATUS_HDR_SIZE;
Vkadaba	13:97cb32670539	2757
Vkadaba	13:97cb32670539	2758	do
Vkadaba	13:97cb32670539	2759	{
Vkadaba	13:97cb32670539	2760	// Get the SFL command irq pin to check if SFL is ready to receive commands
Vkadaba	13:97cb32670539	2761	// Status pin is not checked since SFL is just booted, there should not be any issue with SFL
Vkadaba	13:97cb32670539	2762	eRet = admw_GetGpioState( hDevice, ADMW_GPIO_PIN_DATAREADY, &bitCommand );
Vkadaba	13:97cb32670539	2763	if( eRet != ADMW_SUCCESS) {
Vkadaba	13:97cb32670539	2764	return eRet;
Vkadaba	13:97cb32670539	2765	}
Vkadaba	13:97cb32670539	2766
Vkadaba	13:97cb32670539	2767	// Command IRQ pin should be low and Status IRQ pin should be high for SFL to be in good state and ready to recieve commands
Vkadaba	13:97cb32670539	2768	// pinreg == '0x00' - Error occured in SFL
Vkadaba	13:97cb32670539	2769	// pinreg == '0x01' - SFL is ready to recieve commands
Vkadaba	13:97cb32670539	2770	// pinreg == '0x02' - Error occured in handling any commands in SFL
Vkadaba	13:97cb32670539	2771	// pinreg == '0x03' - SFL not booted
Vkadaba	13:97cb32670539	2772
Vkadaba	13:97cb32670539	2773	pinreg = (bitCommand);
Vkadaba	13:97cb32670539	2774
Vkadaba	13:97cb32670539	2775	}while(pinreg != 0x0u);
Vkadaba	13:97cb32670539	2776
Vkadaba	13:97cb32670539	2777	eRet = admw_SpiTransfer(pCtx->hSpi, DataBuffer, NULL,
Vkadaba	13:97cb32670539	2778	nSize, false);
Vkadaba	13:97cb32670539	2779	if (eRet)
Vkadaba	13:97cb32670539	2780	{
Vkadaba	13:97cb32670539	2781	return eRet;
Vkadaba	13:97cb32670539	2782	}
Vkadaba	13:97cb32670539	2783
Vkadaba	13:97cb32670539	2784	//wait for command irq line to go low after sending read status header
Vkadaba	13:97cb32670539	2785	wait_ms( 100 );
Vkadaba	13:97cb32670539	2786
Vkadaba	13:97cb32670539	2787	do
Vkadaba	13:97cb32670539	2788	{
Vkadaba	13:97cb32670539	2789	// Get the SFL command irq pin to check if SFL is ready to receive commands
Vkadaba	13:97cb32670539	2790	// Status pin is not checked since SFL is just booted, there should not be any issue with SFL
Vkadaba	13:97cb32670539	2791	eRet = admw_GetGpioState( hDevice, ADMW_GPIO_PIN_DATAREADY, &bitCommand );
Vkadaba	13:97cb32670539	2792	if( eRet != ADMW_SUCCESS) {
Vkadaba	13:97cb32670539	2793	return eRet;
Vkadaba	13:97cb32670539	2794	}
Vkadaba	13:97cb32670539	2795
Vkadaba	13:97cb32670539	2796	// Command IRQ pin should be low and Status IRQ pin should be high for SFL to be in good state and ready to recieve commands
Vkadaba	13:97cb32670539	2797	// pinreg == '0x00' - Error occured in SFL
Vkadaba	13:97cb32670539	2798	// pinreg == '0x01' - SFL is ready to recieve commands
Vkadaba	13:97cb32670539	2799	// pinreg == '0x02' - Error occured in handling any commands in SFL
Vkadaba	13:97cb32670539	2800	// pinreg == '0x03' - SFL not booted
Vkadaba	13:97cb32670539	2801
Vkadaba	13:97cb32670539	2802	pinreg = (bitCommand);
Vkadaba	13:97cb32670539	2803
Vkadaba	13:97cb32670539	2804	}while(pinreg != 0x0u);
Vkadaba	13:97cb32670539	2805
Vkadaba	13:97cb32670539	2806	nSize = SFL_READ_STATUS_RESPONSE_SIZE;
Vkadaba	13:97cb32670539	2807
Vkadaba	13:97cb32670539	2808	eRet = admw_SpiReceive(pCtx->hSpi, NULL, DataBuffer,
Vkadaba	13:97cb32670539	2809	nSize, false);
Vkadaba	13:97cb32670539	2810
Vkadaba	13:97cb32670539	2811	if (eRet)
Vkadaba	13:97cb32670539	2812	{
Vkadaba	13:97cb32670539	2813	return eRet;
Vkadaba	13:97cb32670539	2814	}
Vkadaba	13:97cb32670539	2815
Vkadaba	13:97cb32670539	2816	//Verifying the application version from the response to check if firmware is present or not
Vkadaba	13:97cb32670539	2817	/*
Vkadaba	13:97cb32670539	2818	Flash Memory description
Vkadaba	13:97cb32670539	2819	______________
Vkadaba	13:97cb32670539	2820	\| Secure \| 0x0000 0000
Vkadaba	13:97cb32670539	2821	\| Flashloader \|
Vkadaba	13:97cb32670539	2822	\|______________\| 0x0000 3BFF
Vkadaba	13:97cb32670539	2823	\| Security \|------------------
Vkadaba	13:97cb32670539	2824	\| Page \| 0x0000 3C00
Vkadaba	13:97cb32670539	2825	\| \|
Vkadaba	13:97cb32670539	2826	\|______________\| 0x0000 3FFF
Vkadaba	13:97cb32670539	2827	\| \|------------------
Vkadaba	13:97cb32670539	2828	\| App Info \| 0x0000 4000
Vkadaba	13:97cb32670539	2829	\| Page \|
Vkadaba	13:97cb32670539	2830	\|______________\| 0x0000 4800
Vkadaba	13:97cb32670539	2831	\| \|------------------
Vkadaba	13:97cb32670539	2832	\| Application \|
Vkadaba	13:97cb32670539	2833	\| Image \| Application resides only in this region
Vkadaba	13:97cb32670539	2834	\|______________\|------------------
Vkadaba	13:97cb32670539	2835	\| Reserved \| 0x0003 FFF8
Vkadaba	13:97cb32670539	2836	\| for \| Reserved memory region
Vkadaba	13:97cb32670539	2837	\| Signature \| 0x0003 FFFF
Vkadaba	13:97cb32670539	2838	\|______________\|------------------
Vkadaba	13:97cb32670539	2839
Vkadaba	13:97cb32670539	2840	Application version is stored in the App Info Page, the app version is updated in this region everytime the new application firmware is downloaded.
Vkadaba	13:97cb32670539	2841	Here we verify if Application version is present in the Read Status response
Vkadaba	13:97cb32670539	2842	If the app version bytes value is 0xFFFFFFFF then there is no firmware else there exist a firmware
Vkadaba	13:97cb32670539	2843
Vkadaba	13:97cb32670539	2844	Read Status Response:
Vkadaba	13:97cb32670539	2845	____________________________________________________________________________________________________________________________________
Vkadaba	13:97cb32670539	2846	\| \| \| \| \| \|
Vkadaba	13:97cb32670539	2847	\|uint16_t nFlashLoaderVersion \| uint16_t nStatus \| uint32_t nApplicationVersion \| uint32_t nApplicationHash[8] \| uint16_t nChecksum \|
Vkadaba	13:97cb32670539	2848	\|_____________________________\|__________________\|______________________________\|______________________________\|_____________________\|
Vkadaba	13:97cb32670539	2849
Vkadaba	13:97cb32670539	2850	*/
Vkadaba	13:97cb32670539	2851
Vkadaba	13:97cb32670539	2852	if( ((DataBuffer[4] == 0xFF) &&
Vkadaba	13:97cb32670539	2853	(DataBuffer[5] == 0xFF) &&
Vkadaba	13:97cb32670539	2854	(DataBuffer[6] == 0xFF) &&
Vkadaba	13:97cb32670539	2855	(DataBuffer[7] == 0xFF)) \|\|
Vkadaba	13:97cb32670539	2856	((DataBuffer[4] == 0x00) &&
Vkadaba	13:97cb32670539	2857	(DataBuffer[5] == 0x00) &&
Vkadaba	13:97cb32670539	2858	(DataBuffer[6] == 0x00) &&
Vkadaba	13:97cb32670539	2859	(DataBuffer[7] == 0x00)))
Vkadaba	13:97cb32670539	2860	{
Vkadaba	13:97cb32670539	2861	*bFirmwareStatus = false;
Vkadaba	13:97cb32670539	2862	}
Vkadaba	13:97cb32670539	2863	else
Vkadaba	13:97cb32670539	2864	{
Vkadaba	13:97cb32670539	2865	*bFirmwareStatus = true;
Vkadaba	13:97cb32670539	2866	}
Vkadaba	13:97cb32670539	2867
Vkadaba	13:97cb32670539	2868	return eRet;
Vkadaba	14:266ab283b086	2869	}

Repository toolbox

Export to desktop IDE

Build repository

Repository details

Type:	Program
Mbed OS support:	Mbed OS
Created:	16 Mar 2020
Imports:	0
Forks:	0
Commits:	61
Dependents:	0
Dependencies:	0
Followers:	1

src/admw_1001.c@18:cbf514cce921, 2019-08-20 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning