EV-PRO-MW1001_Development - Mbed Development branch for MeasrueWare

ADMW1001_Mbed_FW » Code » EV-PRO-MW1001_Development

ADMW1001_Mbed_FW / Mbed OS EV-PRO-MW1001_Development

Mbed Development branch for MeasrueWare

src/admw_1001.c@63:2655a04c00f5, 2020-04-14 (annotated)

Committer:: Vkadaba
Date:: Tue Apr 14 06:43:47 2020 +0000
Revision:: 63:2655a04c00f5
Parent:: 61:0f16a2e3b58b
Child:: 64:e8670e971e22

Code clean up - part 1 working; ADMW1001_config.h; ADMW1001_lut_data; ADMW1001_sensors_types.h;

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"
Vkadaba	55:215da406282b	55	#include "inc/mbedVersion.h"
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;
Vkadaba	32:52445bef314d	61	#define ADMW_VERSION_REG_VAL_SIZE 4u
Vkadaba	32:52445bef314d	62	#define ADMW_FORMATTED_VERSION_SIZE 11u
ADIJake	0:85855ecd3257	63
Vkadaba	32:52445bef314d	64	#define ADMW_SFL_READ_STATUS_SIZE 42u
ADIJake	0:85855ecd3257	65	/*
ADIJake	0:85855ecd3257	66	* The following macros are used to encapsulate the register access code
ADIJake	0:85855ecd3257	67	* to improve readability in the functions further below in this file
ADIJake	0:85855ecd3257	68	*/
ADIJake	0:85855ecd3257	69	#define STRINGIFY(name) #name
ADIJake	0:85855ecd3257	70
ADIJake	0:85855ecd3257	71	/* Expand the full name of the reset value macro for the specified register */
Vkadaba	5:0728bde67bdb	72	#define REG_RESET_VAL(_name) REG_##_name##_RESET
ADIJake	0:85855ecd3257	73
ADIJake	0:85855ecd3257	74	/* Checks if a value is outside the bounds of the specified register field */
ADIJake	0:85855ecd3257	75	#define CHECK_REG_FIELD_VAL(_field, _val) \
ADIJake	0:85855ecd3257	76	do { \
Vkadaba	8:2f2775c34640	77	uint32_t _mask = BITM_##_field; \
Vkadaba	8:2f2775c34640	78	uint32_t _shift = BITP_##_field; \
ADIJake	0:85855ecd3257	79	if ((((_val) << _shift) & ~(_mask)) != 0) { \
Vkadaba	6:9d393a9677f4	80	ADMW_LOG_ERROR("Value 0x%08X invalid for register field %s",\
ADIJake	0:85855ecd3257	81	(uint32_t)(_val), \
Vkadaba	6:9d393a9677f4	82	STRINGIFY(ADMW_##_field)); \
Vkadaba	8:2f2775c34640	83	return ADMW_INVALID_PARAM; \
ADIJake	0:85855ecd3257	84	} \
ADIJake	0:85855ecd3257	85	} while(false)
ADIJake	0:85855ecd3257	86
ADIJake	0:85855ecd3257	87	/*
ADIJake	0:85855ecd3257	88	* Encapsulates the write to a specified register
ADIJake	0:85855ecd3257	89	* NOTE - this will cause the calling function to return on error
ADIJake	0:85855ecd3257	90	*/
ADIJake	0:85855ecd3257	91	#define WRITE_REG(_hdev, _val, _name, _type) \
ADIJake	0:85855ecd3257	92	do { \
Vkadaba	8:2f2775c34640	93	ADMW_RESULT _res; \
ADIJake	0:85855ecd3257	94	_type _regval = _val; \
Vkadaba	8:2f2775c34640	95	_res = admw1001_WriteRegister((_hdev), \
Vkadaba	8:2f2775c34640	96	REG_##_name, \
ADIJake	0:85855ecd3257	97	&_regval, sizeof(_regval)); \
Vkadaba	8:2f2775c34640	98	if (_res != ADMW_SUCCESS) \
ADIJake	0:85855ecd3257	99	return _res; \
ADIJake	0:85855ecd3257	100	} while(false)
ADIJake	0:85855ecd3257	101
ADIJake	0:85855ecd3257	102	/* Wrapper macro to write a value to a uint32_t register */
Vkadaba	8:2f2775c34640	103	#define WRITE_REG_U32(_hdev, _val, _name) \
ADIJake	0:85855ecd3257	104	WRITE_REG(_hdev, _val, _name, uint32_t)
ADIJake	0:85855ecd3257	105	/* Wrapper macro to write a value to a uint16_t register */
Vkadaba	8:2f2775c34640	106	#define WRITE_REG_U16(_hdev, _val, _name) \
ADIJake	0:85855ecd3257	107	WRITE_REG(_hdev, _val, _name, uint16_t)
ADIJake	0:85855ecd3257	108	/* Wrapper macro to write a value to a uint8_t register */
Vkadaba	8:2f2775c34640	109	#define WRITE_REG_U8(_hdev, _val, _name) \
ADIJake	0:85855ecd3257	110	WRITE_REG(_hdev, _val, _name, uint8_t)
ADIJake	0:85855ecd3257	111	/* Wrapper macro to write a value to a float32_t register */
Vkadaba	8:2f2775c34640	112	#define WRITE_REG_FLOAT(_hdev, _val, _name) \
ADIJake	0:85855ecd3257	113	WRITE_REG(_hdev, _val, _name, float32_t)
ADIJake	0:85855ecd3257	114
ADIJake	0:85855ecd3257	115	/*
ADIJake	0:85855ecd3257	116	* Encapsulates the read from a specified register
ADIJake	0:85855ecd3257	117	* NOTE - this will cause the calling function to return on error
ADIJake	0:85855ecd3257	118	*/
ADIJake	0:85855ecd3257	119	#define READ_REG(_hdev, _val, _name, _type) \
ADIJake	0:85855ecd3257	120	do { \
Vkadaba	8:2f2775c34640	121	ADMW_RESULT _res; \
ADIJake	0:85855ecd3257	122	_type _regval; \
Vkadaba	8:2f2775c34640	123	_res = admw1001_ReadRegister((_hdev), \
Vkadaba	8:2f2775c34640	124	REG_##_name, \
ADIJake	0:85855ecd3257	125	&_regval, sizeof(_regval)); \
Vkadaba	8:2f2775c34640	126	if (_res != ADMW_SUCCESS) \
ADIJake	0:85855ecd3257	127	return _res; \
ADIJake	0:85855ecd3257	128	_val = _regval; \
ADIJake	0:85855ecd3257	129	} while(false)
ADIJake	0:85855ecd3257	130
ADIJake	0:85855ecd3257	131	/* Wrapper macro to read a value from a uint32_t register */
Vkadaba	8:2f2775c34640	132	#define READ_REG_U32(_hdev, _val, _name) \
ADIJake	0:85855ecd3257	133	READ_REG(_hdev, _val, _name, uint32_t)
ADIJake	0:85855ecd3257	134	/* Wrapper macro to read a value from a uint16_t register */
Vkadaba	8:2f2775c34640	135	#define READ_REG_U16(_hdev, _val, _name) \
ADIJake	0:85855ecd3257	136	READ_REG(_hdev, _val, _name, uint16_t)
ADIJake	0:85855ecd3257	137	/* Wrapper macro to read a value from a uint8_t register */
Vkadaba	8:2f2775c34640	138	#define READ_REG_U8(_hdev, _val, _name) \
ADIJake	0:85855ecd3257	139	READ_REG(_hdev, _val, _name, uint8_t)
ADIJake	0:85855ecd3257	140	/* Wrapper macro to read a value from a float32_t register */
Vkadaba	8:2f2775c34640	141	#define READ_REG_FLOAT(_hdev, _val, _name) \
ADIJake	0:85855ecd3257	142	READ_REG(_hdev, _val, _name, float32_t)
ADIJake	0:85855ecd3257	143
ADIJake	0:85855ecd3257	144	/*
ADIJake	0:85855ecd3257	145	* Wrapper macro to write an array of values to a uint8_t register
ADIJake	0:85855ecd3257	146	* NOTE - this is intended only for writing to a keyhole data register
ADIJake	0:85855ecd3257	147	*/
Vkadaba	8:2f2775c34640	148	#define WRITE_REG_U8_ARRAY(_hdev, _arr, _len, _name) \
Vkadaba	6:9d393a9677f4	149	do { \
Vkadaba	8:2f2775c34640	150	ADMW_RESULT _res; \
Vkadaba	8:2f2775c34640	151	_res = admw1001_WriteRegister(_hdev, \
Vkadaba	8:2f2775c34640	152	REG_##_name, \
Vkadaba	6:9d393a9677f4	153	_arr, _len); \
Vkadaba	8:2f2775c34640	154	if (_res != ADMW_SUCCESS) \
Vkadaba	6:9d393a9677f4	155	return _res; \
ADIJake	0:85855ecd3257	156	} while(false)
ADIJake	0:85855ecd3257	157
ADIJake	0:85855ecd3257	158	/*
ADIJake	0:85855ecd3257	159	* Wrapper macro to read an array of values from a uint8_t register
ADIJake	0:85855ecd3257	160	* NOTE - this is intended only for reading from a keyhole data register
ADIJake	0:85855ecd3257	161	*/
Vkadaba	6:9d393a9677f4	162	#define READ_REG_U8_ARRAY(_hdev, _arr, _len, _name) \
Vkadaba	6:9d393a9677f4	163	do { \
Vkadaba	8:2f2775c34640	164	ADMW_RESULT _res; \
Vkadaba	8:2f2775c34640	165	_res = admw1001_ReadRegister((_hdev), \
Vkadaba	8:2f2775c34640	166	REG##_name, \
Vkadaba	6:9d393a9677f4	167	_arr, _len); \
Vkadaba	8:2f2775c34640	168	if (_res != ADMW_SUCCESS) \
Vkadaba	6:9d393a9677f4	169	return _res; \
ADIJake	0:85855ecd3257	170	} while(false)
ADIJake	0:85855ecd3257	171
Vkadaba	8:2f2775c34640	172	#define ADMW1001_CHANNEL_IS_ADC(c) \
Vkadaba	8:2f2775c34640	173	((c) >= ADMW1001_CH_ID_ANLG_1_UNIVERSAL && (c) <= ADMW1001_CH_ID_ANLG_2_DIFFERENTIAL)
Vkadaba	6:9d393a9677f4	174
Vkadaba	8:2f2775c34640	175	#define ADMW1001_CHANNEL_IS_ADC_CJC(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_SENSOR(c) \
Vkadaba	8:2f2775c34640	179	((c) >= ADMW1001_CH_ID_ANLG_1_UNIVERSAL && (c) <= ADMW1001_CH_ID_ANLG_2_UNIVERSAL)
Vkadaba	6:9d393a9677f4	180
Vkadaba	8:2f2775c34640	181	#define ADMW1001_CHANNEL_IS_ADC_VOLTAGE(c) \
Vkadaba	8:2f2775c34640	182	((c) == ADMW1001_CH_ID_ANLG_1_DIFFERENTIAL \|\| ADMW1001_CH_ID_ANLG_2_DIFFERENTIAL)
Vkadaba	6:9d393a9677f4	183
Vkadaba	8:2f2775c34640	184	#define ADMW1001_CHANNEL_IS_ADC_CURRENT(c) \
Vkadaba	8:2f2775c34640	185	((c) == ADMW1001_CH_ID_ANLG_1_UNIVERSAL \|\| (c) == ADMW1001_CH_ID_ANLG_2_UNIVERSAL)
Vkadaba	6:9d393a9677f4	186
ADIJake	0:85855ecd3257	187
Vkadaba	32:52445bef314d	188	//typedef struct {
Vkadaba	32:52445bef314d	189	// unsigned nDeviceIndex;
Vkadaba	32:52445bef314d	190	// ADMW_SPI_HANDLE hSpi;
Vkadaba	32:52445bef314d	191	// ADMW_GPIO_HANDLE hGpio;
Vkadaba	32:52445bef314d	192	//
Vkadaba	32:52445bef314d	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
Vkadaba	23:bb685f35b08b	254	if (callbackFunction) {
Vkadaba	5:0728bde67bdb	255	return admw_GpioIrqEnable(pCtx->hGpio, ePinId, callbackFunction,
Vkadaba	23:bb685f35b08b	256	pCallbackParam);
Vkadaba	23:bb685f35b08b	257	} else {
Vkadaba	5:0728bde67bdb	258	return admw_GpioIrqDisable(pCtx->hGpio, ePinId);
ADIJake	0:85855ecd3257	259	}
ADIJake	0:85855ecd3257	260	}
ADIJake	0:85855ecd3257	261
Vkadaba	8:2f2775c34640	262	/*!
Vkadaba	8:2f2775c34640	263	* @brief Reset the specified ADMW device.
Vkadaba	8:2f2775c34640	264	*
Vkadaba	8:2f2775c34640	265	* @param[in] hDevice - handle of ADMW device to reset.
Vkadaba	8:2f2775c34640	266	*
Vkadaba	8:2f2775c34640	267	* @return Status
Vkadaba	8:2f2775c34640	268	* - #ADMW_SUCCESS Call completed successfully.
Vkadaba	8:2f2775c34640	269	* - #ADMW_FAILURE If reseet faisl
Vkadaba	8:2f2775c34640	270	*
Vkadaba	23:bb685f35b08b	271	* @details Toggle reset pin of the ADMW device low for a
Vkadaba	8:2f2775c34640	272	* minimum of 4 usec.
Vkadaba	8:2f2775c34640	273	*
ADIJake	0:85855ecd3257	274	*/
Vkadaba	8:2f2775c34640	275	ADMW_RESULT admw_Reset(ADMW_DEVICE_HANDLE const hDevice)
ADIJake	0:85855ecd3257	276	{
Vkadaba	5:0728bde67bdb	277	ADMW_DEVICE_CONTEXT *pCtx = hDevice;
Vkadaba	5:0728bde67bdb	278	ADMW_RESULT eRet;
ADIJake	0:85855ecd3257	279
ADIJake	0:85855ecd3257	280	/* Pulse the Reset GPIO pin low for a minimum of 4 microseconds */
Vkadaba	5:0728bde67bdb	281	eRet = admw_GpioSet(pCtx->hGpio, ADMW_GPIO_PIN_RESET, false);
Vkadaba	5:0728bde67bdb	282	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	283	return eRet;
ADIJake	0:85855ecd3257	284
Vkadaba	5:0728bde67bdb	285	admw_TimeDelayUsec(4);
Vkadaba	5:0728bde67bdb	286
Vkadaba	5:0728bde67bdb	287	eRet = admw_GpioSet(pCtx->hGpio, ADMW_GPIO_PIN_RESET, true);
Vkadaba	5:0728bde67bdb	288	if (eRet != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	289	return eRet;
ADIJake	0:85855ecd3257	290
Vkadaba	5:0728bde67bdb	291	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	292	}
ADIJake	0:85855ecd3257	293
ADIJake	0:85855ecd3257	294	/*!
Vkadaba	8:2f2775c34640	295	* @brief Get general status of ADMW module.
ADIJake	0:85855ecd3257	296	*
ADIJake	0:85855ecd3257	297	* @param[in]
ADIJake	0:85855ecd3257	298	* @param[out] pStatus : Pointer to CORE Status struct.
ADIJake	0:85855ecd3257	299	*
ADIJake	0:85855ecd3257	300	* @return Status
Vkadaba	5:0728bde67bdb	301	* - #ADMW_SUCCESS Call completed successfully.
Vkadaba	5:0728bde67bdb	302	* - #ADMW_FAILURE If status register read fails.
ADIJake	0:85855ecd3257	303	*
Vkadaba	8:2f2775c34640	304	* @details Read the general status register for the ADMW
ADIJake	0:85855ecd3257	305	* module. Indicates Error, Alert conditions, data ready
ADIJake	0:85855ecd3257	306	* and command running.
ADIJake	0:85855ecd3257	307	*
ADIJake	0:85855ecd3257	308	*/
Vkadaba	5:0728bde67bdb	309	ADMW_RESULT admw_GetStatus(
Vkadaba	5:0728bde67bdb	310	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	5:0728bde67bdb	311	ADMW_STATUS * const pStatus)
ADIJake	0:85855ecd3257	312	{
Vkadaba	8:2f2775c34640	313	ADMW_CORE_Status_t statusReg;
ADIJake	0:85855ecd3257	314	READ_REG_U8(hDevice, statusReg.VALUE8, CORE_STATUS);
ADIJake	0:85855ecd3257	315
ADIJake	0:85855ecd3257	316	memset(pStatus, 0, sizeof(*pStatus));
ADIJake	0:85855ecd3257	317
ADIJake	0:85855ecd3257	318	if (!statusReg.Cmd_Running) /* Active-low, so invert it */
Vkadaba	5:0728bde67bdb	319	pStatus->deviceStatus \|= ADMW_DEVICE_STATUS_BUSY;
ADIJake	0:85855ecd3257	320	if (statusReg.Drdy)
Vkadaba	5:0728bde67bdb	321	pStatus->deviceStatus \|= ADMW_DEVICE_STATUS_DATAREADY;
ADIJake	0:85855ecd3257	322	if (statusReg.FIFO_Error)
Vkadaba	5:0728bde67bdb	323	pStatus->deviceStatus \|= ADMW_DEVICE_STATUS_FIFO_ERROR;
Vkadaba	23:bb685f35b08b	324	if (statusReg.Alert_Active) {
Vkadaba	5:0728bde67bdb	325	pStatus->deviceStatus \|= ADMW_DEVICE_STATUS_ALERT;
Vkadaba	5:0728bde67bdb	326
Vkadaba	8:2f2775c34640	327	ADMW_CORE_Channel_Alert_Status_t channelAlertStatusReg;
ADIJake	0:85855ecd3257	328	READ_REG_U16(hDevice, channelAlertStatusReg.VALUE16,
ADIJake	0:85855ecd3257	329	CORE_CHANNEL_ALERT_STATUS);
ADIJake	0:85855ecd3257	330
Vkadaba	23:bb685f35b08b	331	for (unsigned i = 0; i < ADMW1001_MAX_CHANNELS; i++) {
Vkadaba	23:bb685f35b08b	332	if (channelAlertStatusReg.VALUE16 & (1 << i)) {
Vkadaba	8:2f2775c34640	333	ADMW_CORE_Alert_Detail_Ch_t alertDetailReg;
ADIJake	0:85855ecd3257	334	READ_REG_U16(hDevice, alertDetailReg.VALUE16,
ADIJake	0:85855ecd3257	335	CORE_ALERT_DETAIL_CHn(i));
ADIJake	0:85855ecd3257	336
Vkadaba	32:52445bef314d	337	if (alertDetailReg.ADC_Near_Overrange)
Vkadaba	32:52445bef314d	338	pStatus->channelAlerts[i] \|= ADMW_ALERT_DETAIL_CH_ADC_NEAR_OVERRANGE;
Vkadaba	32:52445bef314d	339	if (alertDetailReg.Sensor_UnderRange)
Vkadaba	32:52445bef314d	340	pStatus->channelAlerts[i] \|= ADMW_ALERT_DETAIL_CH_SENSOR_UNDERRANGE;
Vkadaba	32:52445bef314d	341	if (alertDetailReg.Sensor_OverRange)
Vkadaba	32:52445bef314d	342	pStatus->channelAlerts[i] \|= ADMW_ALERT_DETAIL_CH_SENSOR_OVERRANGE ;
Vkadaba	32:52445bef314d	343	if (alertDetailReg.CJ_Soft_Fault)
Vkadaba	32:52445bef314d	344	pStatus->channelAlerts[i] \|= ADMW_ALERT_DETAIL_CH_CJ_SOFT_FAULT ;
Vkadaba	32:52445bef314d	345	if (alertDetailReg.CJ_Hard_Fault)
Vkadaba	32:52445bef314d	346	pStatus->channelAlerts[i] \|= ADMW_ALERT_DETAIL_CH_CJ_HARD_FAULT;
Vkadaba	32:52445bef314d	347	if (alertDetailReg.ADC_Input_OverRange)
Vkadaba	32:52445bef314d	348	pStatus->channelAlerts[i] \|= ADMW_ALERT_DETAIL_CH_ADC_INPUT_OVERRANGE ;
Vkadaba	32:52445bef314d	349	if (alertDetailReg.Sensor_HardFault)
Vkadaba	32:52445bef314d	350	pStatus->channelAlerts[i] \|= ADMW_ALERT_DETAIL_CH_SENSOR_HARDFAULT;
Vkadaba	32:52445bef314d	351
ADIJake	0:85855ecd3257	352	}
ADIJake	0:85855ecd3257	353	}
ADIJake	0:85855ecd3257	354
Vkadaba	32:52445bef314d	355	if (statusReg.Configuration_Error)
Vkadaba	5:0728bde67bdb	356	pStatus->deviceStatus \|= ADMW_DEVICE_STATUS_CONFIG_ERROR;
Vkadaba	32:52445bef314d	357	if (statusReg.LUT_Error)
Vkadaba	5:0728bde67bdb	358	pStatus->deviceStatus \|= ADMW_DEVICE_STATUS_LUT_ERROR;
ADIJake	0:85855ecd3257	359	}
ADIJake	0:85855ecd3257	360
Vkadaba	23:bb685f35b08b	361	if (statusReg.Error) {
Vkadaba	5:0728bde67bdb	362	pStatus->deviceStatus \|= ADMW_DEVICE_STATUS_ERROR;
Vkadaba	5:0728bde67bdb	363
Vkadaba	8:2f2775c34640	364	ADMW_CORE_Error_Code_t errorCodeReg;
ADIJake	0:85855ecd3257	365	READ_REG_U16(hDevice, errorCodeReg.VALUE16, CORE_ERROR_CODE);
ADIJake	0:85855ecd3257	366	pStatus->errorCode = errorCodeReg.Error_Code;
ADIJake	0:85855ecd3257	367
ADIJake	0:85855ecd3257	368	}
Vkadaba	5:0728bde67bdb	369	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	370	}
ADIJake	0:85855ecd3257	371
Vkadaba	5:0728bde67bdb	372	ADMW_RESULT admw_GetCommandRunningState(
Vkadaba	5:0728bde67bdb	373	ADMW_DEVICE_HANDLE hDevice,
ADIJake	0:85855ecd3257	374	bool *pbCommandRunning)
ADIJake	0:85855ecd3257	375	{
Vkadaba	8:2f2775c34640	376	ADMW_CORE_Status_t statusReg;
ADIJake	0:85855ecd3257	377
ADIJake	0:85855ecd3257	378	READ_REG_U8(hDevice, statusReg.VALUE8, CORE_STATUS);
ADIJake	0:85855ecd3257	379
ADIJake	0:85855ecd3257	380	/* We should never normally see 0xFF here if the module is operational */
ADIJake	0:85855ecd3257	381	if (statusReg.VALUE8 == 0xFF)
Vkadaba	5:0728bde67bdb	382	return ADMW_ERR_NOT_INITIALIZED;
ADIJake	0:85855ecd3257	383
ADIJake	0:85855ecd3257	384	pbCommandRunning = !statusReg.Cmd_Running; / Active-low, so invert it */
ADIJake	0:85855ecd3257	385
Vkadaba	5:0728bde67bdb	386	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	387	}
ADIJake	0:85855ecd3257	388
Vkadaba	50:d84305e5e1c0	389	ADMW_RESULT admw_deviceInformation(ADMW_DEVICE_HANDLE hDevice)
Vkadaba	32:52445bef314d	390	{
Vkadaba	32:52445bef314d	391	uint16_t nAddress = REG_CORE_REVISION;
Vkadaba	32:52445bef314d	392	char nData[ADMW_VERSION_REG_VAL_SIZE]; //4 Bytes of version register data
Vkadaba	32:52445bef314d	393	ADMW_RESULT res;
Vkadaba	32:52445bef314d	394	res=admw1001_ReadRegister(hDevice,nAddress,nData,sizeof(nData));
Vkadaba	32:52445bef314d	395	if(res != ADMW_SUCCESS) {
Vkadaba	32:52445bef314d	396	//if reading version register failed, sending 00.00.0000 as ADMW1001 firmware version
Vkadaba	32:52445bef314d	397	//strcat(nData, ADMW1001_FIRMWARE_VERSION_DEFAULT);
Vkadaba	32:52445bef314d	398	ADMW_LOG_INFO("Firmware Version Id is %X.%X",nData[2],nData[0]);
Vkadaba	32:52445bef314d	399	} else {
Vkadaba	32:52445bef314d	400	char buffer[ADMW_FORMATTED_VERSION_SIZE]; //00.00.0000 8 digits + 2 Bytes "." + one null character at the end
Vkadaba	32:52445bef314d	401	strcat(nData, buffer);
Vkadaba	42:c9c5a22e539e	402	ADMW_LOG_INFO("Firmware Version Id is %X.%X.%X",nData[3],nData[2],nData[0]);
Vkadaba	32:52445bef314d	403	}
Vkadaba	32:52445bef314d	404	return ADMW_SUCCESS;
Vkadaba	32:52445bef314d	405	}
Vkadaba	55:215da406282b	406
Vkadaba	5:0728bde67bdb	407	static ADMW_RESULT executeCommand(
Vkadaba	5:0728bde67bdb	408	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	8:2f2775c34640	409	ADMW_CORE_Command_Special_Command const command,
ADIJake	0:85855ecd3257	410	bool const bWaitForCompletion)
ADIJake	0:85855ecd3257	411	{
Vkadaba	8:2f2775c34640	412	ADMW_CORE_Command_t commandReg;
ADIJake	0:85855ecd3257	413	bool bCommandRunning;
Vkadaba	5:0728bde67bdb	414	ADMW_RESULT eRet;
ADIJake	0:85855ecd3257	415
ADIJake	0:85855ecd3257	416	/*
ADIJake	0:85855ecd3257	417	* Don't allow another command to be issued if one is already running, but
Vkadaba	6:9d393a9677f4	418	* make an exception for ENUM_CORE_COMMAND_NOP which can be used to
ADIJake	0:85855ecd3257	419	* request a running command to be stopped (e.g. continuous measurement)
ADIJake	0:85855ecd3257	420	*/
Vkadaba	23:bb685f35b08b	421	if (command != ENUM_CORE_COMMAND_NOP) {
Vkadaba	5:0728bde67bdb	422	eRet = admw_GetCommandRunningState(hDevice, &bCommandRunning);
ADIJake	0:85855ecd3257	423	if (eRet)
ADIJake	0:85855ecd3257	424	return eRet;
ADIJake	0:85855ecd3257	425
ADIJake	0:85855ecd3257	426	if (bCommandRunning)
Vkadaba	5:0728bde67bdb	427	return ADMW_IN_USE;
ADIJake	0:85855ecd3257	428	}
ADIJake	0:85855ecd3257	429
ADIJake	0:85855ecd3257	430	commandReg.Special_Command = command;
ADIJake	0:85855ecd3257	431	WRITE_REG_U8(hDevice, commandReg.VALUE8, CORE_COMMAND);
ADIJake	0:85855ecd3257	432
Vkadaba	23:bb685f35b08b	433	if (bWaitForCompletion) {
ADIJake	0:85855ecd3257	434	do {
Vkadaba	50:d84305e5e1c0	435	/* Allow a minimum 100usec delay for status update before checking */
Vkadaba	50:d84305e5e1c0	436	admw_TimeDelayUsec(100);
Vkadaba	5:0728bde67bdb	437
Vkadaba	5:0728bde67bdb	438	eRet = admw_GetCommandRunningState(hDevice, &bCommandRunning);
ADIJake	0:85855ecd3257	439	if (eRet)
ADIJake	0:85855ecd3257	440	return eRet;
ADIJake	0:85855ecd3257	441	} while (bCommandRunning);
ADIJake	0:85855ecd3257	442	}
ADIJake	0:85855ecd3257	443
Vkadaba	5:0728bde67bdb	444	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	445	}
ADIJake	0:85855ecd3257	446
Vkadaba	5:0728bde67bdb	447	ADMW_RESULT admw_ApplyConfigUpdates(
Vkadaba	5:0728bde67bdb	448	ADMW_DEVICE_HANDLE const hDevice)
ADIJake	0:85855ecd3257	449	{
Vkadaba	5:0728bde67bdb	450	return executeCommand(hDevice, CORE_COMMAND_LATCH_CONFIG, true);
ADIJake	0:85855ecd3257	451	}
ADIJake	0:85855ecd3257	452
ADIJake	0:85855ecd3257	453	/*!
ADIJake	0:85855ecd3257	454	* @brief Start a measurement cycle.
ADIJake	0:85855ecd3257	455	*
ADIJake	0:85855ecd3257	456	* @param[out]
ADIJake	0:85855ecd3257	457	*
ADIJake	0:85855ecd3257	458	* @return Status
Vkadaba	5:0728bde67bdb	459	* - #ADMW_SUCCESS Call completed successfully.
Vkadaba	5:0728bde67bdb	460	* - #ADMW_FAILURE
ADIJake	0:85855ecd3257	461	*
ADIJake	0:85855ecd3257	462	* @details Sends the latch config command. Configuration for channels in
ADIJake	0:85855ecd3257	463	* conversion cycle should be completed before this function.
ADIJake	0:85855ecd3257	464	* Channel enabled bit should be set before this function.
ADIJake	0:85855ecd3257	465	* Starts a conversion and configures the format of the sample.
ADIJake	0:85855ecd3257	466	*
ADIJake	0:85855ecd3257	467	*/
Vkadaba	5:0728bde67bdb	468	ADMW_RESULT admw_StartMeasurement(
Vkadaba	5:0728bde67bdb	469	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	5:0728bde67bdb	470	ADMW_MEASUREMENT_MODE const eMeasurementMode)
ADIJake	0:85855ecd3257	471	{
Vkadaba	23:bb685f35b08b	472	switch (eMeasurementMode) {
Vkadaba	23:bb685f35b08b	473	case ADMW_MEASUREMENT_MODE_NORMAL:
Vkadaba	23:bb685f35b08b	474	return executeCommand(hDevice, CORE_COMMAND_CONVERT_WITH_RAW, false);
Vkadaba	23:bb685f35b08b	475	case ADMW_MEASUREMENT_MODE_OMIT_RAW:
Vkadaba	23:bb685f35b08b	476	return executeCommand(hDevice, CORE_COMMAND_CONVERT, false);
Vkadaba	23:bb685f35b08b	477	default:
Vkadaba	23:bb685f35b08b	478	ADMW_LOG_ERROR("Invalid measurement mode %d specified",
Vkadaba	23:bb685f35b08b	479	eMeasurementMode);
Vkadaba	23:bb685f35b08b	480	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	481	}
ADIJake	0:85855ecd3257	482	}
ADIJake	0:85855ecd3257	483
ADIJake	0:85855ecd3257	484	/*
ADIJake	0:85855ecd3257	485	* Store the configuration settings to persistent memory on the device.
ADIJake	0:85855ecd3257	486	* The settings can be saved to 4 different flash memory areas (slots).
ADIJake	0:85855ecd3257	487	* No other command must be running when this is called.
ADIJake	0:85855ecd3257	488	* Do not power down the device while this command is running.
ADIJake	0:85855ecd3257	489	*/
Vkadaba	5:0728bde67bdb	490	ADMW_RESULT admw_SaveConfig(
Vkadaba	5:0728bde67bdb	491	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	5:0728bde67bdb	492	ADMW_USER_CONFIG_SLOT const eSlotId)
ADIJake	0:85855ecd3257	493	{
Vkadaba	23:bb685f35b08b	494	switch (eSlotId) {
Vkadaba	5:0728bde67bdb	495	case ADMW_FLASH_CONFIG_1:
Vkadaba	5:0728bde67bdb	496	return executeCommand(hDevice, CORE_COMMAND_SAVE_CONFIG_1, true);
ADIJake	0:85855ecd3257	497	default:
Vkadaba	5:0728bde67bdb	498	ADMW_LOG_ERROR("Invalid user config target slot %d specified",
Vkadaba	23:bb685f35b08b	499	eSlotId);
Vkadaba	5:0728bde67bdb	500	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	501	}
ADIJake	0:85855ecd3257	502	}
ADIJake	0:85855ecd3257	503
ADIJake	0:85855ecd3257	504	/*
ADIJake	0:85855ecd3257	505	* Restore the configuration settings from persistent memory on the device.
ADIJake	0:85855ecd3257	506	* No other command must be running when this is called.
ADIJake	0:85855ecd3257	507	*/
Vkadaba	5:0728bde67bdb	508	ADMW_RESULT admw_RestoreConfig(
Vkadaba	5:0728bde67bdb	509	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	5:0728bde67bdb	510	ADMW_USER_CONFIG_SLOT const eSlotId)
ADIJake	0:85855ecd3257	511	{
Vkadaba	23:bb685f35b08b	512	switch (eSlotId) {
Vkadaba	5:0728bde67bdb	513	case ADMW_FLASH_CONFIG_1:
Vkadaba	5:0728bde67bdb	514	return executeCommand(hDevice, CORE_COMMAND_LOAD_CONFIG_1, true);
ADIJake	0:85855ecd3257	515	default:
Vkadaba	5:0728bde67bdb	516	ADMW_LOG_ERROR("Invalid user config source slot %d specified",
Vkadaba	23:bb685f35b08b	517	eSlotId);
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 LUT data to persistent memory on the device.
ADIJake	0:85855ecd3257	524	* No other command must be running when this is called.
ADIJake	0:85855ecd3257	525	* Do not power down the device while this command is running.
ADIJake	0:85855ecd3257	526	*/
Vkadaba	5:0728bde67bdb	527	ADMW_RESULT admw_SaveLutData(
Vkadaba	5:0728bde67bdb	528	ADMW_DEVICE_HANDLE const hDevice)
ADIJake	0:85855ecd3257	529	{
Vkadaba	5:0728bde67bdb	530	return executeCommand(hDevice, CORE_COMMAND_SAVE_LUT, true);
ADIJake	0:85855ecd3257	531	}
ADIJake	0:85855ecd3257	532
ADIJake	0:85855ecd3257	533	/*
ADIJake	0:85855ecd3257	534	* Restore the LUT data from persistent memory on the device.
ADIJake	0:85855ecd3257	535	* No other command must be running when this is called.
ADIJake	0:85855ecd3257	536	*/
Vkadaba	5:0728bde67bdb	537	ADMW_RESULT admw_RestoreLutData(
Vkadaba	5:0728bde67bdb	538	ADMW_DEVICE_HANDLE const hDevice)
ADIJake	0:85855ecd3257	539	{
Vkadaba	5:0728bde67bdb	540	return executeCommand(hDevice, CORE_COMMAND_LOAD_LUT, true);
ADIJake	0:85855ecd3257	541	}
ADIJake	0:85855ecd3257	542
ADIJake	0:85855ecd3257	543	/*
ADIJake	0:85855ecd3257	544	* Stop the measurement cycles on the device.
ADIJake	0:85855ecd3257	545	* To be used only if a measurement command is currently running.
ADIJake	0:85855ecd3257	546	*/
Vkadaba	5:0728bde67bdb	547	ADMW_RESULT admw_StopMeasurement(
Vkadaba	5:0728bde67bdb	548	ADMW_DEVICE_HANDLE const hDevice)
ADIJake	0:85855ecd3257	549	{
Vkadaba	5:0728bde67bdb	550	return executeCommand(hDevice, CORE_COMMAND_NOP, true);
ADIJake	0:85855ecd3257	551	}
ADIJake	0:85855ecd3257	552
ADIJake	0:85855ecd3257	553	/*
Vkadaba	32:52445bef314d	554	*
Vkadaba	32:52445bef314d	555	*/
Vkadaba	32:52445bef314d	556	ADMW_RESULT admw1001_sendRun( ADMW_DEVICE_HANDLE const hDevice)
Vkadaba	32:52445bef314d	557	{
Vkadaba	32:52445bef314d	558	bool bitCommand;
Vkadaba	32:52445bef314d	559	ADMW_RESULT eRet;
Vkadaba	32:52445bef314d	560	uint8_t pinreg = 0x1;
Vkadaba	32:52445bef314d	561
Vkadaba	32:52445bef314d	562	ADMW_DEVICE_CONTEXT *pCtx = hDevice;
Vkadaba	32:52445bef314d	563	static uint8_t DataBuffer[SPI_BUFFER_SIZE] = {0};
Vkadaba	32:52445bef314d	564	uint16_t nSize;
Vkadaba	32:52445bef314d	565
Vkadaba	32:52445bef314d	566	//Construct Read Status command
Vkadaba	32:52445bef314d	567	DataBuffer[0] = 0x07;
Vkadaba	32:52445bef314d	568	DataBuffer[1] = 0x0E; //Packet ID
Vkadaba	32:52445bef314d	569
Vkadaba	32:52445bef314d	570	DataBuffer[2] = 0x00;
Vkadaba	32:52445bef314d	571	DataBuffer[3] = 0x00; //Data words
Vkadaba	32:52445bef314d	572
Vkadaba	32:52445bef314d	573	DataBuffer[4] = 0x45;
Vkadaba	32:52445bef314d	574	DataBuffer[5] = 0x00; //Command ID
Vkadaba	32:52445bef314d	575
Vkadaba	32:52445bef314d	576	DataBuffer[6] = 0x00;
Vkadaba	32:52445bef314d	577	DataBuffer[7] = 0x50;
Vkadaba	32:52445bef314d	578	DataBuffer[8] = 0x00;
Vkadaba	32:52445bef314d	579	DataBuffer[9] = 0x00; //Address
Vkadaba	32:52445bef314d	580
Vkadaba	32:52445bef314d	581	DataBuffer[10] = 0x95;
Vkadaba	32:52445bef314d	582	DataBuffer[11] = 0x00;
Vkadaba	32:52445bef314d	583	DataBuffer[12] = 0x00;
Vkadaba	32:52445bef314d	584	DataBuffer[13] = 0x00; //Checksum
Vkadaba	32:52445bef314d	585
Vkadaba	32:52445bef314d	586	nSize = SFL_READ_STATUS_HDR_SIZE;
Vkadaba	32:52445bef314d	587
Vkadaba	32:52445bef314d	588	do {
Vkadaba	32:52445bef314d	589	// Get the SFL command irq pin to check if SFL is ready to receive commands
Vkadaba	32:52445bef314d	590	// Status pin is not checked since SFL is just booted, there should not be any issue with SFL
Vkadaba	32:52445bef314d	591	eRet = admw_GetGpioState( hDevice, ADMW_GPIO_PIN_DATAREADY, &bitCommand );
Vkadaba	32:52445bef314d	592	if( eRet != ADMW_SUCCESS) {
Vkadaba	32:52445bef314d	593	return eRet;
Vkadaba	32:52445bef314d	594	}
Vkadaba	32:52445bef314d	595
Vkadaba	32:52445bef314d	596	// 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	32:52445bef314d	597	// pinreg == '0x00' - Error occured in SFL
Vkadaba	32:52445bef314d	598	// pinreg == '0x01' - SFL is ready to recieve commands
Vkadaba	32:52445bef314d	599	// pinreg == '0x02' - Error occured in handling any commands in SFL
Vkadaba	32:52445bef314d	600	// pinreg == '0x03' - SFL not booted
Vkadaba	32:52445bef314d	601
Vkadaba	32:52445bef314d	602	pinreg = (bitCommand);
Vkadaba	32:52445bef314d	603
Vkadaba	32:52445bef314d	604	} while(pinreg != 0x0u);
Vkadaba	32:52445bef314d	605
Vkadaba	32:52445bef314d	606	eRet = admw_SpiTransfer(pCtx->hSpi, DataBuffer, NULL,
Vkadaba	32:52445bef314d	607	nSize, false);
Vkadaba	32:52445bef314d	608
Vkadaba	32:52445bef314d	609	return eRet;
Vkadaba	32:52445bef314d	610	}
Vkadaba	32:52445bef314d	611
Vkadaba	32:52445bef314d	612	/*
ADIJake	0:85855ecd3257	613	* Read a set of data samples from the device.
ADIJake	0:85855ecd3257	614	* This may be called at any time.
ADIJake	0:85855ecd3257	615	*/
Vkadaba	32:52445bef314d	616
Vkadaba	5:0728bde67bdb	617	ADMW_RESULT admw_GetData(
Vkadaba	5:0728bde67bdb	618	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	5:0728bde67bdb	619	ADMW_MEASUREMENT_MODE const eMeasurementMode,
Vkadaba	5:0728bde67bdb	620	ADMW_DATA_SAMPLE * const pSamples,
ADIJake	0:85855ecd3257	621	uint8_t const nBytesPerSample,
ADIJake	0:85855ecd3257	622	uint32_t const nRequested,
ADIJake	0:85855ecd3257	623	uint32_t * const pnReturned)
ADIJake	0:85855ecd3257	624	{
Vkadaba	5:0728bde67bdb	625	ADMW1001_Sensor_Result_t sensorResult;
Vkadaba	5:0728bde67bdb	626	ADMW_DEVICE_CONTEXT *pCtx = hDevice;
Vkadaba	5:0728bde67bdb	627	uint16_t command = ADMW1001_HOST_COMMS_READ_CMD \|
Vkadaba	23:bb685f35b08b	628	(REG_CORE_DATA_FIFO & ADMW1001_HOST_COMMS_ADR_MASK);
ADIJake	0:85855ecd3257	629	uint8_t commandData[2] = {
ADIJake	0:85855ecd3257	630	command >> 8,
ADIJake	0:85855ecd3257	631	command & 0xFF
ADIJake	0:85855ecd3257	632	};
ADIJake	0:85855ecd3257	633	uint8_t commandResponse[2];
ADIJake	0:85855ecd3257	634	unsigned nValidSamples = 0;
Vkadaba	5:0728bde67bdb	635	ADMW_RESULT eRet = ADMW_SUCCESS;
ADIJake	0:85855ecd3257	636
ADIJake	0:85855ecd3257	637	do {
Vkadaba	5:0728bde67bdb	638	eRet = admw_SpiTransfer(pCtx->hSpi, commandData, commandResponse,
Vkadaba	23:bb685f35b08b	639	sizeof(command), false);
Vkadaba	23:bb685f35b08b	640	if (eRet) {
Vkadaba	5:0728bde67bdb	641	ADMW_LOG_ERROR("Failed to send read command for FIFO register");
ADIJake	0:85855ecd3257	642	return eRet;
ADIJake	0:85855ecd3257	643	}
Vkadaba	5:0728bde67bdb	644	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
Vkadaba	5:0728bde67bdb	645	} while ((commandResponse[0] != ADMW1001_HOST_COMMS_CMD_RESP_0) \|\|
Vkadaba	5:0728bde67bdb	646	(commandResponse[1] != ADMW1001_HOST_COMMS_CMD_RESP_1));
Vkadaba	50:d84305e5e1c0	647
Vkadaba	23:bb685f35b08b	648	for (unsigned i = 0; i < nRequested; i++) {
ADIJake	0:85855ecd3257	649	bool bHoldCs = true;
ADIJake	0:85855ecd3257	650	/* Keep the CS signal asserted for all but the last sample */
ADIJake	0:85855ecd3257	651	if ((i + 1) == nRequested)
ADIJake	0:85855ecd3257	652	bHoldCs = false;
ADIJake	0:85855ecd3257	653
ADIJake	0:85855ecd3257	654	getDataCnt++;
ADIJake	0:85855ecd3257	655
Vkadaba	5:0728bde67bdb	656	eRet = admw_SpiTransfer(pCtx->hSpi, NULL, &sensorResult,
Vkadaba	23:bb685f35b08b	657	nBytesPerSample, bHoldCs);
Vkadaba	23:bb685f35b08b	658	if (eRet) {
Vkadaba	5:0728bde67bdb	659	ADMW_LOG_ERROR("Failed to read data from FIFO register");
ADIJake	0:85855ecd3257	660	return eRet;
ADIJake	0:85855ecd3257	661	}
ADIJake	0:85855ecd3257	662
Vkadaba	23:bb685f35b08b	663	if (! sensorResult.Ch_Valid) {
ADIJake	0:85855ecd3257	664	/*
ADIJake	0:85855ecd3257	665	* Reading an invalid sample indicates that there are no
ADIJake	0:85855ecd3257	666	* more samples available or we've lost sync with the device.
ADIJake	0:85855ecd3257	667	* In the latter case, it might be recoverable, but return here
ADIJake	0:85855ecd3257	668	* to let the application check the device status and decide itself.
ADIJake	0:85855ecd3257	669	*/
Vkadaba	5:0728bde67bdb	670	eRet = ADMW_INCOMPLETE;
ADIJake	0:85855ecd3257	671	break;
ADIJake	0:85855ecd3257	672	}
ADIJake	0:85855ecd3257	673
Vkadaba	5:0728bde67bdb	674	ADMW_DATA_SAMPLE *pSample = &pSamples[nValidSamples];
Vkadaba	5:0728bde67bdb	675
Vkadaba	5:0728bde67bdb	676	pSample->status = (ADMW_DEVICE_STATUS_FLAGS)0;
ADIJake	0:85855ecd3257	677	if (sensorResult.Ch_Error)
Vkadaba	5:0728bde67bdb	678	pSample->status \|= ADMW_DEVICE_STATUS_ERROR;
ADIJake	0:85855ecd3257	679	if (sensorResult.Ch_Alert)
Vkadaba	5:0728bde67bdb	680	pSample->status \|= ADMW_DEVICE_STATUS_ALERT;
ADIJake	0:85855ecd3257	681
ADIJake	0:85855ecd3257	682	if (sensorResult.Ch_Raw)
ADIJake	0:85855ecd3257	683	pSample->rawValue = sensorResult.Raw_Sample;
ADIJake	0:85855ecd3257	684	else
ADIJake	0:85855ecd3257	685	pSample->rawValue = 0;
ADIJake	0:85855ecd3257	686
ADIJake	0:85855ecd3257	687	pSample->channelId = sensorResult.Channel_ID;
ADIJake	0:85855ecd3257	688	pSample->processedValue = sensorResult.Sensor_Result;
ADIJake	0:85855ecd3257	689
ADIJake	0:85855ecd3257	690	nValidSamples++;
ADIJake	0:85855ecd3257	691
Vkadaba	50:d84305e5e1c0	692	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
ADIJake	0:85855ecd3257	693	}
ADIJake	0:85855ecd3257	694	*pnReturned = nValidSamples;
ADIJake	0:85855ecd3257	695
ADIJake	0:85855ecd3257	696	return eRet;
ADIJake	0:85855ecd3257	697	}
ADIJake	0:85855ecd3257	698
ADIJake	0:85855ecd3257	699	/*
Vkadaba	5:0728bde67bdb	700	* Close the given ADMW device.
ADIJake	0:85855ecd3257	701	*/
Vkadaba	5:0728bde67bdb	702	ADMW_RESULT admw_Close(
Vkadaba	5:0728bde67bdb	703	ADMW_DEVICE_HANDLE const hDevice)
ADIJake	0:85855ecd3257	704	{
Vkadaba	5:0728bde67bdb	705	ADMW_DEVICE_CONTEXT *pCtx = hDevice;
Vkadaba	5:0728bde67bdb	706
Vkadaba	5:0728bde67bdb	707	admw_GpioClose(pCtx->hGpio);
Vkadaba	5:0728bde67bdb	708	admw_SpiClose(pCtx->hSpi);
Vkadaba	5:0728bde67bdb	709	admw_LogClose();
Vkadaba	5:0728bde67bdb	710
Vkadaba	5:0728bde67bdb	711	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	712	}
ADIJake	0:85855ecd3257	713
Vkadaba	5:0728bde67bdb	714	ADMW_RESULT admw1001_WriteRegister(
Vkadaba	5:0728bde67bdb	715	ADMW_DEVICE_HANDLE hDevice,
ADIJake	0:85855ecd3257	716	uint16_t nAddress,
ADIJake	0:85855ecd3257	717	void *pData,
ADIJake	0:85855ecd3257	718	unsigned nLength)
ADIJake	0:85855ecd3257	719	{
Vkadaba	5:0728bde67bdb	720	ADMW_RESULT eRet;
Vkadaba	5:0728bde67bdb	721	ADMW_DEVICE_CONTEXT *pCtx = hDevice;
Vkadaba	5:0728bde67bdb	722	uint16_t command = ADMW1001_HOST_COMMS_WRITE_CMD \|
Vkadaba	23:bb685f35b08b	723	(nAddress & ADMW1001_HOST_COMMS_ADR_MASK);
ADIJake	0:85855ecd3257	724	uint8_t commandData[2] = {
ADIJake	0:85855ecd3257	725	command >> 8,
ADIJake	0:85855ecd3257	726	command & 0xFF
ADIJake	0:85855ecd3257	727	};
ADIJake	0:85855ecd3257	728	uint8_t commandResponse[2];
ADIJake	0:85855ecd3257	729
ADIJake	0:85855ecd3257	730	do {
Vkadaba	5:0728bde67bdb	731	eRet = admw_SpiTransfer(pCtx->hSpi, commandData, commandResponse,
Vkadaba	23:bb685f35b08b	732	sizeof(command), false);
Vkadaba	23:bb685f35b08b	733	if (eRet) {
Vkadaba	5:0728bde67bdb	734	ADMW_LOG_ERROR("Failed to send write command for register %u",
Vkadaba	23:bb685f35b08b	735	nAddress);
ADIJake	0:85855ecd3257	736	return eRet;
ADIJake	0:85855ecd3257	737	}
ADIJake	0:85855ecd3257	738
Vkadaba	5:0728bde67bdb	739	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
Vkadaba	5:0728bde67bdb	740	} while ((commandResponse[0] != ADMW1001_HOST_COMMS_CMD_RESP_0) \|\|
Vkadaba	5:0728bde67bdb	741	(commandResponse[1] != ADMW1001_HOST_COMMS_CMD_RESP_1));
Vkadaba	5:0728bde67bdb	742
Vkadaba	5:0728bde67bdb	743	eRet = admw_SpiTransfer(pCtx->hSpi, pData, NULL, nLength, false);
Vkadaba	23:bb685f35b08b	744	if (eRet) {
Vkadaba	5:0728bde67bdb	745	ADMW_LOG_ERROR("Failed to write data (%dB) to register %u",
Vkadaba	23:bb685f35b08b	746	nLength, nAddress);
ADIJake	0:85855ecd3257	747	return eRet;
ADIJake	0:85855ecd3257	748	}
ADIJake	0:85855ecd3257	749
Vkadaba	5:0728bde67bdb	750	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
Vkadaba	5:0728bde67bdb	751
Vkadaba	5:0728bde67bdb	752	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	753	}
ADIJake	0:85855ecd3257	754
Vkadaba	6:9d393a9677f4	755	ADMW_RESULT admw1001_Write_Debug_Register(
Vkadaba	6:9d393a9677f4	756	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	6:9d393a9677f4	757	uint16_t nAddress,
Vkadaba	6:9d393a9677f4	758	void *pData,
Vkadaba	6:9d393a9677f4	759	unsigned nLength)
Vkadaba	6:9d393a9677f4	760	{
Vkadaba	6:9d393a9677f4	761	ADMW_RESULT eRet;
Vkadaba	6:9d393a9677f4	762	ADMW_DEVICE_CONTEXT *pCtx = hDevice;
Vkadaba	6:9d393a9677f4	763	uint16_t command = ADMW1001_HOST_COMMS_DEBUG_WRITE_CMD \|
Vkadaba	23:bb685f35b08b	764	(nAddress & ADMW1001_HOST_COMMS_ADR_MASK);
Vkadaba	6:9d393a9677f4	765	uint8_t commandData[2] = {
Vkadaba	6:9d393a9677f4	766	command >> 8,
Vkadaba	6:9d393a9677f4	767	command & 0xFF
Vkadaba	6:9d393a9677f4	768	};
Vkadaba	6:9d393a9677f4	769	uint8_t commandResponse[2];
Vkadaba	6:9d393a9677f4	770
Vkadaba	6:9d393a9677f4	771	do {
Vkadaba	6:9d393a9677f4	772	eRet = admw_SpiTransfer(pCtx->hSpi, commandData, commandResponse,
Vkadaba	23:bb685f35b08b	773	sizeof(command), false);
Vkadaba	23:bb685f35b08b	774	if (eRet) {
Vkadaba	6:9d393a9677f4	775	ADMW_LOG_ERROR("Failed to send write command for register %u",
Vkadaba	23:bb685f35b08b	776	nAddress);
Vkadaba	6:9d393a9677f4	777	return eRet;
Vkadaba	6:9d393a9677f4	778	}
Vkadaba	48:5731f1aa2c5a	779	wait_ms(100);
Vkadaba	48:5731f1aa2c5a	780	//admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
Vkadaba	6:9d393a9677f4	781	} while ((commandResponse[0] != ADMW1001_HOST_COMMS_CMD_RESP_0) \|\|
Vkadaba	6:9d393a9677f4	782	(commandResponse[1] != ADMW1001_HOST_COMMS_CMD_RESP_1));
Vkadaba	6:9d393a9677f4	783
Vkadaba	6:9d393a9677f4	784	eRet = admw_SpiTransfer(pCtx->hSpi, pData, NULL, nLength, false);
Vkadaba	23:bb685f35b08b	785	if (eRet) {
Vkadaba	6:9d393a9677f4	786	ADMW_LOG_ERROR("Failed to write data (%dB) to register %u",
Vkadaba	23:bb685f35b08b	787	nLength, nAddress);
Vkadaba	6:9d393a9677f4	788	return eRet;
Vkadaba	6:9d393a9677f4	789	}
Vkadaba	6:9d393a9677f4	790
Vkadaba	6:9d393a9677f4	791	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
Vkadaba	6:9d393a9677f4	792
Vkadaba	6:9d393a9677f4	793	return ADMW_SUCCESS;
Vkadaba	6:9d393a9677f4	794	}
Vkadaba	5:0728bde67bdb	795	ADMW_RESULT admw1001_ReadRegister(
Vkadaba	5:0728bde67bdb	796	ADMW_DEVICE_HANDLE hDevice,
ADIJake	0:85855ecd3257	797	uint16_t nAddress,
ADIJake	0:85855ecd3257	798	void *pData,
ADIJake	0:85855ecd3257	799	unsigned nLength)
ADIJake	0:85855ecd3257	800	{
Vkadaba	5:0728bde67bdb	801	ADMW_RESULT eRet;
Vkadaba	5:0728bde67bdb	802	ADMW_DEVICE_CONTEXT *pCtx = hDevice;
Vkadaba	5:0728bde67bdb	803	uint16_t command = ADMW1001_HOST_COMMS_READ_CMD \|
Vkadaba	23:bb685f35b08b	804	(nAddress & ADMW1001_HOST_COMMS_ADR_MASK);
ADIJake	0:85855ecd3257	805	uint8_t commandData[2] = {
ADIJake	0:85855ecd3257	806	command >> 8,
ADIJake	0:85855ecd3257	807	command & 0xFF
ADIJake	0:85855ecd3257	808	};
ADIJake	0:85855ecd3257	809	uint8_t commandResponse[2];
ADIJake	0:85855ecd3257	810
ADIJake	0:85855ecd3257	811	do {
Vkadaba	5:0728bde67bdb	812	eRet = admw_SpiTransfer(pCtx->hSpi, commandData, commandResponse,
Vkadaba	23:bb685f35b08b	813	sizeof(command), false);
Vkadaba	23:bb685f35b08b	814	if (eRet) {
Vkadaba	5:0728bde67bdb	815	ADMW_LOG_ERROR("Failed to send read command for register %u",
Vkadaba	23:bb685f35b08b	816	nAddress);
ADIJake	0:85855ecd3257	817	return eRet;
ADIJake	0:85855ecd3257	818	}
ADIJake	0:85855ecd3257	819
Vkadaba	5:0728bde67bdb	820	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
Vkadaba	5:0728bde67bdb	821	} while ((commandResponse[0] != ADMW1001_HOST_COMMS_CMD_RESP_0) \|\|
Vkadaba	5:0728bde67bdb	822	(commandResponse[1] != ADMW1001_HOST_COMMS_CMD_RESP_1));
Vkadaba	5:0728bde67bdb	823
Vkadaba	5:0728bde67bdb	824	eRet = admw_SpiTransfer(pCtx->hSpi, NULL, pData, nLength, false);
Vkadaba	23:bb685f35b08b	825	if (eRet) {
Vkadaba	5:0728bde67bdb	826	ADMW_LOG_ERROR("Failed to read data (%uB) from register %u",
Vkadaba	23:bb685f35b08b	827	nLength, nAddress);
ADIJake	0:85855ecd3257	828	return eRet;
ADIJake	0:85855ecd3257	829	}
ADIJake	0:85855ecd3257	830
Vkadaba	5:0728bde67bdb	831	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
Vkadaba	5:0728bde67bdb	832
Vkadaba	5:0728bde67bdb	833	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	834	}
ADIJake	0:85855ecd3257	835
Vkadaba	6:9d393a9677f4	836	ADMW_RESULT admw1001_Read_Debug_Register(
Vkadaba	6:9d393a9677f4	837	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	6:9d393a9677f4	838	uint16_t nAddress,
Vkadaba	6:9d393a9677f4	839	void *pData,
Vkadaba	6:9d393a9677f4	840	unsigned nLength)
Vkadaba	6:9d393a9677f4	841	{
Vkadaba	6:9d393a9677f4	842	ADMW_RESULT eRet;
Vkadaba	6:9d393a9677f4	843	ADMW_DEVICE_CONTEXT *pCtx = hDevice;
Vkadaba	6:9d393a9677f4	844	uint16_t command = ADMW1001_HOST_COMMS_DEBUG_READ_CMD \|
Vkadaba	23:bb685f35b08b	845	(nAddress & ADMW1001_HOST_COMMS_ADR_MASK);
Vkadaba	6:9d393a9677f4	846	uint8_t commandData[2] = {
Vkadaba	6:9d393a9677f4	847	command >> 8,
Vkadaba	6:9d393a9677f4	848	command & 0xFF
Vkadaba	6:9d393a9677f4	849	};
Vkadaba	6:9d393a9677f4	850	uint8_t commandResponse[2];
Vkadaba	6:9d393a9677f4	851
Vkadaba	6:9d393a9677f4	852	do {
Vkadaba	6:9d393a9677f4	853	eRet = admw_SpiTransfer(pCtx->hSpi, commandData, commandResponse,
Vkadaba	23:bb685f35b08b	854	sizeof(command), false);
Vkadaba	23:bb685f35b08b	855	if (eRet) {
Vkadaba	6:9d393a9677f4	856	ADMW_LOG_ERROR("Failed to send read command for register %u",
Vkadaba	23:bb685f35b08b	857	nAddress);
Vkadaba	6:9d393a9677f4	858	return eRet;
Vkadaba	6:9d393a9677f4	859	}
Vkadaba	6:9d393a9677f4	860
Vkadaba	6:9d393a9677f4	861	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
Vkadaba	6:9d393a9677f4	862	} while ((commandResponse[0] != ADMW1001_HOST_COMMS_CMD_RESP_0) \|\|
Vkadaba	6:9d393a9677f4	863	(commandResponse[1] != ADMW1001_HOST_COMMS_CMD_RESP_1));
Vkadaba	6:9d393a9677f4	864
Vkadaba	6:9d393a9677f4	865	eRet = admw_SpiTransfer(pCtx->hSpi, NULL, pData, nLength, false);
Vkadaba	23:bb685f35b08b	866	if (eRet) {
Vkadaba	6:9d393a9677f4	867	ADMW_LOG_ERROR("Failed to read data (%uB) from register %u",
Vkadaba	23:bb685f35b08b	868	nLength, nAddress);
Vkadaba	6:9d393a9677f4	869	return eRet;
Vkadaba	6:9d393a9677f4	870	}
Vkadaba	6:9d393a9677f4	871
Vkadaba	6:9d393a9677f4	872	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
Vkadaba	6:9d393a9677f4	873
Vkadaba	6:9d393a9677f4	874	return ADMW_SUCCESS;
Vkadaba	6:9d393a9677f4	875	}
Vkadaba	5:0728bde67bdb	876	ADMW_RESULT admw_GetDeviceReadyState(
Vkadaba	5:0728bde67bdb	877	ADMW_DEVICE_HANDLE const hDevice,
ADIJake	0:85855ecd3257	878	bool * const bReady)
ADIJake	0:85855ecd3257	879	{
Vkadaba	5:0728bde67bdb	880	ADMW_SPI_Chip_Type_t chipTypeReg;
ADIJake	0:85855ecd3257	881
ADIJake	0:85855ecd3257	882	READ_REG_U8(hDevice, chipTypeReg.VALUE8, SPI_CHIP_TYPE);
ADIJake	0:85855ecd3257	883	/* If we read this register successfully, assume the device is ready */
Vkadaba	5:0728bde67bdb	884	*bReady = (chipTypeReg.VALUE8 == REG_SPI_CHIP_TYPE_RESET);
Vkadaba	5:0728bde67bdb	885
Vkadaba	5:0728bde67bdb	886	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	887	}
ADIJake	0:85855ecd3257	888
Vkadaba	5:0728bde67bdb	889	ADMW_RESULT admw1001_GetDataReadyModeInfo(
Vkadaba	8:2f2775c34640	890	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	8:2f2775c34640	891	ADMW_MEASUREMENT_MODE const eMeasurementMode,
Vkadaba	5:0728bde67bdb	892	ADMW1001_OPERATING_MODE * const peOperatingMode,
Vkadaba	5:0728bde67bdb	893	ADMW1001_DATAREADY_MODE * const peDataReadyMode,
Vkadaba	8:2f2775c34640	894	uint32_t * const pnSamplesPerDataready,
Vkadaba	8:2f2775c34640	895	uint32_t * const pnSamplesPerCycle,
Vkadaba	8:2f2775c34640	896	uint8_t * const pnBytesPerSample)
ADIJake	0:85855ecd3257	897	{
ADIJake	0:85855ecd3257	898	unsigned nChannelsEnabled = 0;
ADIJake	0:85855ecd3257	899	unsigned nSamplesPerCycle = 0;
ADIJake	0:85855ecd3257	900
Vkadaba	8:2f2775c34640	901	ADMW_CORE_Mode_t modeReg;
ADIJake	0:85855ecd3257	902	READ_REG_U8(hDevice, modeReg.VALUE8, CORE_MODE);
ADIJake	0:85855ecd3257	903
Vkadaba	57:c6275de14bc5	904	if (modeReg.Conversion_Mode == CORE_MODE_SINGLECYCLE)
Vkadaba	50:d84305e5e1c0	905	*peOperatingMode = ADMW1001_OPERATING_MODE_SINGLECYCLE;
Vkadaba	50:d84305e5e1c0	906	else
Vkadaba	50:d84305e5e1c0	907	*peOperatingMode = ADMW1001_OPERATING_MODE_CONTINUOUS;
ADIJake	0:85855ecd3257	908
Vkadaba	23:bb685f35b08b	909	if (eMeasurementMode == ADMW_MEASUREMENT_MODE_OMIT_RAW) {
Vkadaba	50:d84305e5e1c0	910	*pnBytesPerSample = 8;
Vkadaba	23:bb685f35b08b	911	} else {
Vkadaba	50:d84305e5e1c0	912	*pnBytesPerSample = 12;
Vkadaba	6:9d393a9677f4	913	}
Vkadaba	23:bb685f35b08b	914
Vkadaba	8:2f2775c34640	915	for (ADMW1001_CH_ID chId = ADMW1001_CH_ID_ANLG_1_UNIVERSAL;
Vkadaba	23:bb685f35b08b	916	chId < ADMW1001_MAX_CHANNELS;
Vkadaba	23:bb685f35b08b	917	chId++) {
Vkadaba	8:2f2775c34640	918	ADMW_CORE_Sensor_Details_t sensorDetailsReg;
Vkadaba	8:2f2775c34640	919	ADMW_CORE_Channel_Count_t channelCountReg;
Vkadaba	23:bb685f35b08b	920
Vkadaba	23:bb685f35b08b	921
Vkadaba	8:2f2775c34640	922	READ_REG_U8(hDevice, channelCountReg.VALUE8, CORE_CHANNEL_COUNTn(chId));
Vkadaba	8:2f2775c34640	923	READ_REG_U32(hDevice, sensorDetailsReg.VALUE32, CORE_SENSOR_DETAILSn(chId));
Vkadaba	23:bb685f35b08b	924
Vkadaba	41:df78b7d7b675	925	if (channelCountReg.Channel_Enable && !sensorDetailsReg.Do_Not_Publish) {
Vkadaba	8:2f2775c34640	926	unsigned nActualChannels = 1;
Vkadaba	63:2655a04c00f5	927
Vkadaba	8:2f2775c34640	928	nChannelsEnabled += nActualChannels;
Vkadaba	23:bb685f35b08b	929
Vkadaba	8:2f2775c34640	930	nSamplesPerCycle += nActualChannels *
Vkadaba	8:2f2775c34640	931	(channelCountReg.Channel_Count + 1);
ADIJake	0:85855ecd3257	932	}
Vkadaba	6:9d393a9677f4	933	}
Vkadaba	23:bb685f35b08b	934
Vkadaba	23:bb685f35b08b	935	if (nChannelsEnabled == 0) {
Vkadaba	8:2f2775c34640	936	*pnSamplesPerDataready = 0;
Vkadaba	8:2f2775c34640	937	*pnSamplesPerCycle = 0;
Vkadaba	8:2f2775c34640	938	return ADMW_SUCCESS;
Vkadaba	6:9d393a9677f4	939	}
Vkadaba	23:bb685f35b08b	940
Vkadaba	6:9d393a9677f4	941	*pnSamplesPerCycle = nSamplesPerCycle;
Vkadaba	23:bb685f35b08b	942
Vkadaba	23:bb685f35b08b	943	if (modeReg.Drdy_Mode == CORE_MODE_DRDY_PER_CONVERSION) {
Vkadaba	8:2f2775c34640	944	*pnSamplesPerDataready = 1;
Vkadaba	50:d84305e5e1c0	945	} else if (modeReg.Drdy_Mode == CORE_MODE_DRDY_PER_CYCLE) {
Vkadaba	50:d84305e5e1c0	946	*pnSamplesPerDataready = nSamplesPerCycle;
Vkadaba	50:d84305e5e1c0	947	} else if (modeReg.Drdy_Mode == CORE_MODE_DRDY_PER_FIFO_FILL) {
Vkadaba	50:d84305e5e1c0	948	ADMW_CORE_Fifo_Num_Cycles_t fifoNumCyclesReg;
Vkadaba	50:d84305e5e1c0	949
Vkadaba	50:d84305e5e1c0	950	READ_REG_U8(hDevice, fifoNumCyclesReg.VALUE8, CORE_FIFO_NUM_CYCLES);
Vkadaba	50:d84305e5e1c0	951
Vkadaba	50:d84305e5e1c0	952	pnSamplesPerDataready = nSamplesPerCycle fifoNumCyclesReg.Fifo_Num_Cycles;
Vkadaba	23:bb685f35b08b	953	} else {
Vkadaba	50:d84305e5e1c0	954	ADMW_LOG_ERROR("Invalid DRDY mode %d specified",
Vkadaba	50:d84305e5e1c0	955	modeReg.Drdy_Mode);
Vkadaba	50:d84305e5e1c0	956	return ADMW_INVALID_PARAM;
Vkadaba	6:9d393a9677f4	957	}
Vkadaba	23:bb685f35b08b	958
Vkadaba	23:bb685f35b08b	959	if (modeReg.Drdy_Mode == CORE_MODE_DRDY_PER_CONVERSION) {
Vkadaba	8:2f2775c34640	960	*peDataReadyMode = ADMW1001_DATAREADY_PER_CONVERSION;
Vkadaba	50:d84305e5e1c0	961	} else if (modeReg.Drdy_Mode == CORE_MODE_DRDY_PER_CYCLE) {
Vkadaba	50:d84305e5e1c0	962	*peDataReadyMode = ADMW1001_DATAREADY_PER_CYCLE;
Vkadaba	50:d84305e5e1c0	963	} else if (modeReg.Drdy_Mode == CORE_MODE_DRDY_PER_FIFO_FILL) {
Vkadaba	50:d84305e5e1c0	964	*peDataReadyMode = ADMW1001_DATAREADY_PER_FIFO_FILL;
Vkadaba	23:bb685f35b08b	965	} else {
Vkadaba	50:d84305e5e1c0	966	ADMW_LOG_ERROR("Invalid DRDY mode %d specified",
Vkadaba	50:d84305e5e1c0	967	modeReg.Drdy_Mode);
Vkadaba	50:d84305e5e1c0	968	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	969	}
Vkadaba	23:bb685f35b08b	970
Vkadaba	5:0728bde67bdb	971	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	972	}
ADIJake	0:85855ecd3257	973
Vkadaba	5:0728bde67bdb	974	ADMW_RESULT admw_GetProductID(
Vkadaba	5:0728bde67bdb	975	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	5:0728bde67bdb	976	ADMW_PRODUCT_ID *pProductId)
ADIJake	0:85855ecd3257	977	{
Vkadaba	5:0728bde67bdb	978	ADMW_SPI_Product_ID_L_t productIdLoReg;
Vkadaba	5:0728bde67bdb	979	ADMW_SPI_Product_ID_H_t productIdHiReg;
ADIJake	0:85855ecd3257	980
ADIJake	0:85855ecd3257	981	READ_REG_U8(hDevice, productIdLoReg.VALUE8, SPI_PRODUCT_ID_L);
ADIJake	0:85855ecd3257	982	READ_REG_U8(hDevice, productIdHiReg.VALUE8, SPI_PRODUCT_ID_H);
ADIJake	0:85855ecd3257	983
Vkadaba	23:bb685f35b08b	984	*pProductId = (ADMW_PRODUCT_ID)((productIdHiReg.VALUE8 << 8) \|
Vkadaba	8:2f2775c34640	985	productIdLoReg.VALUE8);
Vkadaba	5:0728bde67bdb	986	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	987	}
ADIJake	0:85855ecd3257	988
Vkadaba	5:0728bde67bdb	989	static ADMW_RESULT admw_SetPowerMode(
Vkadaba	5:0728bde67bdb	990	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	5:0728bde67bdb	991	ADMW1001_POWER_MODE powerMode)
ADIJake	0:85855ecd3257	992	{
Vkadaba	50:d84305e5e1c0	993	ADMW_CORE_Power_Config_t powerConfigReg = { 0 };
Vkadaba	5:0728bde67bdb	994
Vkadaba	23:bb685f35b08b	995	if (powerMode == ADMW1001_POWER_MODE_HIBERNATION) {
Vkadaba	6:9d393a9677f4	996	powerConfigReg.Power_Mode_MCU = CORE_POWER_CONFIG_HIBERNATION;
Vkadaba	23:bb685f35b08b	997	} else if (powerMode == ADMW1001_POWER_MODE_ACTIVE) {
Vkadaba	6:9d393a9677f4	998	powerConfigReg.Power_Mode_MCU = CORE_POWER_CONFIG_ACTIVE_MODE;
Vkadaba	23:bb685f35b08b	999	} else {
Vkadaba	5:0728bde67bdb	1000	ADMW_LOG_ERROR("Invalid power mode %d specified", powerMode);
Vkadaba	5:0728bde67bdb	1001	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1002	}
ADIJake	0:85855ecd3257	1003
ADIJake	0:85855ecd3257	1004	WRITE_REG_U8(hDevice, powerConfigReg.VALUE8, CORE_POWER_CONFIG);
ADIJake	0:85855ecd3257	1005
Vkadaba	5:0728bde67bdb	1006	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1007	}
ADIJake	0:85855ecd3257	1008
Vkadaba	5:0728bde67bdb	1009	ADMW_RESULT admw1001_SetPowerConfig(
Vkadaba	5:0728bde67bdb	1010	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	5:0728bde67bdb	1011	ADMW1001_POWER_CONFIG *pPowerConfig)
ADIJake	0:85855ecd3257	1012	{
Vkadaba	5:0728bde67bdb	1013	ADMW_RESULT eRet;
Vkadaba	5:0728bde67bdb	1014
Vkadaba	5:0728bde67bdb	1015	eRet = admw_SetPowerMode(hDevice, pPowerConfig->powerMode);
Vkadaba	23:bb685f35b08b	1016	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1017	ADMW_LOG_ERROR("Failed to set power mode");
ADIJake	0:85855ecd3257	1018	return eRet;
ADIJake	0:85855ecd3257	1019	}
ADIJake	0:85855ecd3257	1020
Vkadaba	5:0728bde67bdb	1021	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1022	}
ADIJake	0:85855ecd3257	1023
Vkadaba	33:df7a00f1b8e1	1024	static ADMW_RESULT admw_SetRSenseValue(
Vkadaba	33:df7a00f1b8e1	1025	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	33:df7a00f1b8e1	1026	float32_t RSenseValue)
Vkadaba	33:df7a00f1b8e1	1027	{
Vkadaba	41:df78b7d7b675	1028	ADMW_CORE_External_Reference_Resistor_t RefResistorConfigReg;
Vkadaba	41:df78b7d7b675	1029
Vkadaba	41:df78b7d7b675	1030	RefResistorConfigReg.Ext_Refin1_Value = RSenseValue;
Vkadaba	41:df78b7d7b675	1031
Vkadaba	41:df78b7d7b675	1032	WRITE_REG_FLOAT(hDevice, RefResistorConfigReg.VALUE32, CORE_EXTERNAL_REFERENCE_RESISTOR);
Vkadaba	41:df78b7d7b675	1033
Vkadaba	41:df78b7d7b675	1034	return ADMW_SUCCESS;
Vkadaba	33:df7a00f1b8e1	1035
Vkadaba	33:df7a00f1b8e1	1036	}
Vkadaba	5:0728bde67bdb	1037	static ADMW_RESULT admw_SetMode(
Vkadaba	5:0728bde67bdb	1038	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	5:0728bde67bdb	1039	ADMW1001_OPERATING_MODE eOperatingMode,
Vkadaba	8:2f2775c34640	1040	ADMW1001_DATAREADY_MODE eDataReadyMode)
ADIJake	0:85855ecd3257	1041	{
Vkadaba	8:2f2775c34640	1042	ADMW_CORE_Mode_t modeReg;
ADIJake	0:85855ecd3257	1043
ADIJake	0:85855ecd3257	1044	modeReg.VALUE8 = REG_RESET_VAL(CORE_MODE);
ADIJake	0:85855ecd3257	1045
Vkadaba	23:bb685f35b08b	1046	if (eOperatingMode == ADMW1001_OPERATING_MODE_SINGLECYCLE) {
Vkadaba	5:0728bde67bdb	1047	modeReg.Conversion_Mode = CORE_MODE_SINGLECYCLE;
Vkadaba	23:bb685f35b08b	1048	} else if (eOperatingMode == ADMW1001_OPERATING_MODE_CONTINUOUS) {
Vkadaba	5:0728bde67bdb	1049	modeReg.Conversion_Mode = CORE_MODE_CONTINUOUS;
Vkadaba	23:bb685f35b08b	1050	} else {
Vkadaba	5:0728bde67bdb	1051	ADMW_LOG_ERROR("Invalid operating mode %d specified",
Vkadaba	23:bb685f35b08b	1052	eOperatingMode);
Vkadaba	5:0728bde67bdb	1053	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1054	}
ADIJake	0:85855ecd3257	1055
Vkadaba	23:bb685f35b08b	1056	if (eDataReadyMode == ADMW1001_DATAREADY_PER_CONVERSION) {
Vkadaba	5:0728bde67bdb	1057	modeReg.Drdy_Mode = CORE_MODE_DRDY_PER_CONVERSION;
Vkadaba	23:bb685f35b08b	1058	} else if (eDataReadyMode == ADMW1001_DATAREADY_PER_CYCLE) {
Vkadaba	5:0728bde67bdb	1059	modeReg.Drdy_Mode = CORE_MODE_DRDY_PER_CYCLE;
Vkadaba	50:d84305e5e1c0	1060	} else if (eDataReadyMode == ADMW1001_DATAREADY_PER_FIFO_FILL) {
Vkadaba	50:d84305e5e1c0	1061	modeReg.Drdy_Mode = CORE_MODE_DRDY_PER_FIFO_FILL;
Vkadaba	23:bb685f35b08b	1062	} else {
Vkadaba	5:0728bde67bdb	1063	ADMW_LOG_ERROR("Invalid data-ready mode %d specified", eDataReadyMode);
Vkadaba	5:0728bde67bdb	1064	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1065	}
ADIJake	0:85855ecd3257	1066
ADIJake	0:85855ecd3257	1067	WRITE_REG_U8(hDevice, modeReg.VALUE8, CORE_MODE);
ADIJake	0:85855ecd3257	1068
Vkadaba	5:0728bde67bdb	1069	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1070	}
ADIJake	0:85855ecd3257	1071
Vkadaba	8:2f2775c34640	1072	ADMW_RESULT admw_SetCycleControl(ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1073	uint32_t nCycleInterval,
Vkadaba	50:d84305e5e1c0	1074	bool vBiasEnable,
Vkadaba	43:e1789b7214cf	1075	bool vPostExecCurrentState,
Vkadaba	43:e1789b7214cf	1076	bool vGroundSwitch)
ADIJake	0:85855ecd3257	1077	{
Vkadaba	8:2f2775c34640	1078	ADMW_CORE_Cycle_Control_t cycleControlReg;
ADIJake	0:85855ecd3257	1079
ADIJake	0:85855ecd3257	1080	cycleControlReg.VALUE16 = REG_RESET_VAL(CORE_CYCLE_CONTROL);
ADIJake	0:85855ecd3257	1081
Vkadaba	43:e1789b7214cf	1082	if (nCycleInterval < (1 << 12)) {
Vkadaba	43:e1789b7214cf	1083	cycleControlReg.Cycle_Time_Units = CORE_CYCLE_CONTROL_SECONDS;
Vkadaba	23:bb685f35b08b	1084	} else {
Vkadaba	43:e1789b7214cf	1085	ADMW_LOG_ERROR("Invalid nCycleInterval %d specified", nCycleInterval);
Vkadaba	50:d84305e5e1c0	1086	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1087	}
ADIJake	0:85855ecd3257	1088
Vkadaba	23:bb685f35b08b	1089	if (vBiasEnable == true) {
Vkadaba	8:2f2775c34640	1090	cycleControlReg.Vbias = 1;
Vkadaba	8:2f2775c34640	1091	}
ADIJake	0:85855ecd3257	1092	CHECK_REG_FIELD_VAL(CORE_CYCLE_CONTROL_CYCLE_TIME, nCycleInterval);
ADIJake	0:85855ecd3257	1093	cycleControlReg.Cycle_Time = nCycleInterval;
Vkadaba	50:d84305e5e1c0	1094
Vkadaba	50:d84305e5e1c0	1095	switch(vPostExecCurrentState) {
Vkadaba	50:d84305e5e1c0	1096	case ADMW1001_ADC_EXC_STATE_CYCLE_POWER:
Vkadaba	50:d84305e5e1c0	1097	cycleControlReg.PST_MEAS_EXC_CTRL = CORE_CYCLE_CONTROL_POWERCYCLE;
Vkadaba	50:d84305e5e1c0	1098	break;
Vkadaba	50:d84305e5e1c0	1099	case ADMW1001_ADC_EXC_STATE_ALWAYS_ON:
Vkadaba	50:d84305e5e1c0	1100	cycleControlReg.PST_MEAS_EXC_CTRL = CORE_CYCLE_CONTROL_ALWAYSON;
Vkadaba	50:d84305e5e1c0	1101	break;
Vkadaba	50:d84305e5e1c0	1102	default:
Vkadaba	50:d84305e5e1c0	1103	ADMW_LOG_ERROR("Invalid Post measurement Excitation Current state %d specified",
Vkadaba	50:d84305e5e1c0	1104	vPostExecCurrentState);
Vkadaba	50:d84305e5e1c0	1105	return ADMW_INVALID_PARAM;
Vkadaba	43:e1789b7214cf	1106	}
Vkadaba	50:d84305e5e1c0	1107
Vkadaba	50:d84305e5e1c0	1108	switch(vGroundSwitch) {
Vkadaba	50:d84305e5e1c0	1109	case ADMW1001_ADC_GND_SW_OPEN:
Vkadaba	50:d84305e5e1c0	1110	cycleControlReg.GND_SW_CTRL = CORE_CYCLE_CONTROL_OPEN_SW;
Vkadaba	50:d84305e5e1c0	1111	break;
Vkadaba	50:d84305e5e1c0	1112	case ADMW1001_ADC_GND_SW_CLOSED:
Vkadaba	50:d84305e5e1c0	1113	cycleControlReg.GND_SW_CTRL = CORE_CYCLE_CONTROL_CLOSE_SW;
Vkadaba	50:d84305e5e1c0	1114	break;
Vkadaba	50:d84305e5e1c0	1115	default:
Vkadaba	50:d84305e5e1c0	1116	ADMW_LOG_ERROR("Invalid ground switch state %d specified",
Vkadaba	50:d84305e5e1c0	1117	vGroundSwitch);
Vkadaba	50:d84305e5e1c0	1118	return ADMW_INVALID_PARAM;
Vkadaba	43:e1789b7214cf	1119	}
Vkadaba	50:d84305e5e1c0	1120
ADIJake	0:85855ecd3257	1121	WRITE_REG_U16(hDevice, cycleControlReg.VALUE16, CORE_CYCLE_CONTROL);
ADIJake	0:85855ecd3257	1122
Vkadaba	5:0728bde67bdb	1123	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1124	}
Vkadaba	36:54e2418e7620	1125	static ADMW_RESULT admw_SetExternalReferenceVoltage(
Vkadaba	36:54e2418e7620	1126	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	36:54e2418e7620	1127	float32_t externalRefVoltage)
Vkadaba	36:54e2418e7620	1128	{
Vkadaba	36:54e2418e7620	1129	WRITE_REG_FLOAT(hDevice, externalRefVoltage, CORE_EXTERNAL_VOLTAGE_REFERENCE);
Vkadaba	36:54e2418e7620	1130
Vkadaba	36:54e2418e7620	1131	return ADMW_SUCCESS;
Vkadaba	36:54e2418e7620	1132	}
Vkadaba	50:d84305e5e1c0	1133	static ADMW_RESULT admw_SetFifoNumCycles(
Vkadaba	50:d84305e5e1c0	1134	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	50:d84305e5e1c0	1135	uint8_t fifoNumCycles)
Vkadaba	50:d84305e5e1c0	1136	{
Vkadaba	50:d84305e5e1c0	1137	WRITE_REG_U8(hDevice, fifoNumCycles, CORE_FIFO_NUM_CYCLES);
Vkadaba	50:d84305e5e1c0	1138
Vkadaba	50:d84305e5e1c0	1139	return ADMW_SUCCESS;
Vkadaba	50:d84305e5e1c0	1140	}
ADIJake	0:85855ecd3257	1141
Vkadaba	5:0728bde67bdb	1142	static ADMW_RESULT admw_SetExternalReferenceValues(
Vkadaba	5:0728bde67bdb	1143	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	6:9d393a9677f4	1144	float32_t externalRef1Value)
ADIJake	0:85855ecd3257	1145	{
Vkadaba	6:9d393a9677f4	1146	WRITE_REG_FLOAT(hDevice, externalRef1Value, CORE_EXTERNAL_REFERENCE_RESISTOR);
ADIJake	0:85855ecd3257	1147
Vkadaba	5:0728bde67bdb	1148	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1149	}
Vkadaba	45:f5f553b8c0d5	1150	static ADMW_RESULT admw_SetAVDDVoltage(
Vkadaba	50:d84305e5e1c0	1151	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	50:d84305e5e1c0	1152	float32_t AVDDVoltage)
Vkadaba	50:d84305e5e1c0	1153	{
Vkadaba	45:f5f553b8c0d5	1154
Vkadaba	50:d84305e5e1c0	1155	WRITE_REG_FLOAT(hDevice, AVDDVoltage, CORE_AVDD_VOLTAGE);
Vkadaba	45:f5f553b8c0d5	1156
Vkadaba	50:d84305e5e1c0	1157	return ADMW_SUCCESS;
Vkadaba	50:d84305e5e1c0	1158	}
ADIJake	0:85855ecd3257	1159
Vkadaba	5:0728bde67bdb	1160	ADMW_RESULT admw1001_SetMeasurementConfig(
Vkadaba	5:0728bde67bdb	1161	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	5:0728bde67bdb	1162	ADMW1001_MEASUREMENT_CONFIG *pMeasConfig)
ADIJake	0:85855ecd3257	1163	{
Vkadaba	5:0728bde67bdb	1164	ADMW_RESULT eRet;
Vkadaba	5:0728bde67bdb	1165
Vkadaba	5:0728bde67bdb	1166	eRet = admw_SetMode(hDevice,
Vkadaba	8:2f2775c34640	1167	pMeasConfig->operatingMode,
Vkadaba	8:2f2775c34640	1168	pMeasConfig->dataReadyMode);
Vkadaba	23:bb685f35b08b	1169	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1170	ADMW_LOG_ERROR("Failed to set operating mode");
ADIJake	0:85855ecd3257	1171	return eRet;
ADIJake	0:85855ecd3257	1172	}
ADIJake	0:85855ecd3257	1173
Vkadaba	8:2f2775c34640	1174	eRet = admw_SetCycleControl(hDevice, pMeasConfig->cycleInterval,
Vkadaba	43:e1789b7214cf	1175	pMeasConfig->vBiasEnable,
Vkadaba	43:e1789b7214cf	1176	pMeasConfig->excitationState,
Vkadaba	43:e1789b7214cf	1177	pMeasConfig->groundSwitch );
Vkadaba	23:bb685f35b08b	1178	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1179	ADMW_LOG_ERROR("Failed to set cycle control");
ADIJake	0:85855ecd3257	1180	return eRet;
ADIJake	0:85855ecd3257	1181	}
ADIJake	0:85855ecd3257	1182
Vkadaba	50:d84305e5e1c0	1183	if (pMeasConfig->fifoNumCycles > 0) {
Vkadaba	50:d84305e5e1c0	1184	eRet = admw_SetFifoNumCycles(hDevice,
Vkadaba	50:d84305e5e1c0	1185	pMeasConfig->fifoNumCycles);
Vkadaba	50:d84305e5e1c0	1186	}
Vkadaba	50:d84305e5e1c0	1187
Vkadaba	50:d84305e5e1c0	1188	if (eRet != ADMW_SUCCESS) {
Vkadaba	50:d84305e5e1c0	1189	ADMW_LOG_ERROR("Failed to set the FIFO number of cycles.");
Vkadaba	50:d84305e5e1c0	1190	return eRet;
Vkadaba	50:d84305e5e1c0	1191	}
Vkadaba	50:d84305e5e1c0	1192
Vkadaba	43:e1789b7214cf	1193	if(pMeasConfig->externalRef1Value > 0) {
Vkadaba	8:2f2775c34640	1194	eRet = admw_SetExternalReferenceValues(hDevice,
Vkadaba	8:2f2775c34640	1195	pMeasConfig->externalRef1Value);
ADIJake	0:85855ecd3257	1196	}
Vkadaba	50:d84305e5e1c0	1197
Vkadaba	50:d84305e5e1c0	1198	if (eRet != ADMW_SUCCESS) {
Vkadaba	50:d84305e5e1c0	1199	ADMW_LOG_ERROR("Failed to set external reference values");
Vkadaba	50:d84305e5e1c0	1200	return eRet;
Vkadaba	50:d84305e5e1c0	1201	}
Vkadaba	50:d84305e5e1c0	1202
Vkadaba	50:d84305e5e1c0	1203	if((pMeasConfig->AVDDVoltage >= 3.0) && (pMeasConfig->AVDDVoltage <= 3.6)) {
Vkadaba	45:f5f553b8c0d5	1204	eRet = admw_SetAVDDVoltage(hDevice,
Vkadaba	45:f5f553b8c0d5	1205	pMeasConfig->AVDDVoltage);
Vkadaba	45:f5f553b8c0d5	1206	}
Vkadaba	50:d84305e5e1c0	1207
Vkadaba	23:bb685f35b08b	1208	if (eRet != ADMW_SUCCESS) {
Vkadaba	50:d84305e5e1c0	1209	ADMW_LOG_ERROR("Failed to set AVDD Voltge");
ADIJake	0:85855ecd3257	1210	return eRet;
ADIJake	0:85855ecd3257	1211	}
ADIJake	0:85855ecd3257	1212
Vkadaba	33:df7a00f1b8e1	1213	eRet = admw_SetRSenseValue(hDevice, pMeasConfig->RSenseValue);
Vkadaba	41:df78b7d7b675	1214	if (eRet != ADMW_SUCCESS) {
Vkadaba	33:df7a00f1b8e1	1215	ADMW_LOG_ERROR("Failed to set RSenseValue");
Vkadaba	33:df7a00f1b8e1	1216	return eRet;
Vkadaba	33:df7a00f1b8e1	1217	}
Vkadaba	41:df78b7d7b675	1218
Vkadaba	36:54e2418e7620	1219	eRet = admw_SetExternalReferenceVoltage(hDevice, pMeasConfig->externalRefVoltage);
Vkadaba	41:df78b7d7b675	1220	if (eRet != ADMW_SUCCESS) {
Vkadaba	36:54e2418e7620	1221	ADMW_LOG_ERROR("Failed to set External reference Voltage");
Vkadaba	36:54e2418e7620	1222	return eRet;
Vkadaba	41:df78b7d7b675	1223	}
Vkadaba	41:df78b7d7b675	1224
Vkadaba	5:0728bde67bdb	1225	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1226	}
Vkadaba	36:54e2418e7620	1227	ADMW_RESULT admw1001_SetDiagnosticsConfig(
Vkadaba	36:54e2418e7620	1228	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	36:54e2418e7620	1229	ADMW1001_DIAGNOSTICS_CONFIG *pDiagnosticsConfig)
Vkadaba	36:54e2418e7620	1230	{
Vkadaba	36:54e2418e7620	1231	ADMW_CORE_Diagnostics_Control_t diagnosticsControlReg;
ADIJake	0:85855ecd3257	1232
Vkadaba	36:54e2418e7620	1233	diagnosticsControlReg.VALUE8 = REG_RESET_VAL(CORE_DIAGNOSTICS_CONTROL);
Vkadaba	36:54e2418e7620	1234
Vkadaba	36:54e2418e7620	1235	if (pDiagnosticsConfig->disableMeasurementDiag)
Vkadaba	36:54e2418e7620	1236	diagnosticsControlReg.Diag_Meas_En = 0;
Vkadaba	36:54e2418e7620	1237	else
Vkadaba	36:54e2418e7620	1238	diagnosticsControlReg.Diag_Meas_En = 1;
Vkadaba	36:54e2418e7620	1239
Vkadaba	55:215da406282b	1240	if(pDiagnosticsConfig->osdFrequency <= 0x7F) {
Vkadaba	55:215da406282b	1241	diagnosticsControlReg.Diag_OSD_Freq = pDiagnosticsConfig->osdFrequency;
Vkadaba	55:215da406282b	1242	} else {
Vkadaba	44:94bdfaefddac	1243	ADMW_LOG_ERROR("Invalid open-sensor diagnostic frequency %d specified",
Vkadaba	55:215da406282b	1244	pDiagnosticsConfig->osdFrequency);
Vkadaba	44:94bdfaefddac	1245	return ADMW_INVALID_PARAM;
Vkadaba	44:94bdfaefddac	1246	}
Vkadaba	36:54e2418e7620	1247	WRITE_REG_U8(hDevice, diagnosticsControlReg.VALUE8, CORE_DIAGNOSTICS_CONTROL);
Vkadaba	36:54e2418e7620	1248
Vkadaba	36:54e2418e7620	1249	return ADMW_SUCCESS;
Vkadaba	36:54e2418e7620	1250	}
ADIJake	0:85855ecd3257	1251
Vkadaba	5:0728bde67bdb	1252	ADMW_RESULT admw1001_SetChannelCount(
Vkadaba	5:0728bde67bdb	1253	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1254	ADMW1001_CH_ID eChannelId,
ADIJake	0:85855ecd3257	1255	uint32_t nMeasurementsPerCycle)
ADIJake	0:85855ecd3257	1256	{
Vkadaba	8:2f2775c34640	1257	ADMW_CORE_Channel_Count_t channelCountReg;
ADIJake	0:85855ecd3257	1258
ADIJake	0:85855ecd3257	1259	channelCountReg.VALUE8 = REG_RESET_VAL(CORE_CHANNEL_COUNTn);
ADIJake	0:85855ecd3257	1260
Vkadaba	23:bb685f35b08b	1261	if (nMeasurementsPerCycle > 0) {
ADIJake	0:85855ecd3257	1262	nMeasurementsPerCycle -= 1;
ADIJake	0:85855ecd3257	1263
ADIJake	0:85855ecd3257	1264	CHECK_REG_FIELD_VAL(CORE_CHANNEL_COUNT_CHANNEL_COUNT,
ADIJake	0:85855ecd3257	1265	nMeasurementsPerCycle);
ADIJake	0:85855ecd3257	1266
ADIJake	0:85855ecd3257	1267	channelCountReg.Channel_Enable = 1;
ADIJake	0:85855ecd3257	1268	channelCountReg.Channel_Count = nMeasurementsPerCycle;
Vkadaba	23:bb685f35b08b	1269	} else {
ADIJake	0:85855ecd3257	1270	channelCountReg.Channel_Enable = 0;
ADIJake	0:85855ecd3257	1271	}
ADIJake	0:85855ecd3257	1272
ADIJake	0:85855ecd3257	1273	WRITE_REG_U8(hDevice, channelCountReg.VALUE8, CORE_CHANNEL_COUNTn(eChannelId));
ADIJake	0:85855ecd3257	1274
Vkadaba	5:0728bde67bdb	1275	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1276	}
ADIJake	0:85855ecd3257	1277
Vkadaba	5:0728bde67bdb	1278	ADMW_RESULT admw1001_SetChannelOptions(
Vkadaba	5:0728bde67bdb	1279	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1280	ADMW1001_CH_ID eChannelId,
Vkadaba	6:9d393a9677f4	1281	ADMW1001_CHANNEL_PRIORITY ePriority)
ADIJake	0:85855ecd3257	1282	{
Vkadaba	8:2f2775c34640	1283	ADMW_CORE_Channel_Options_t channelOptionsReg;
ADIJake	0:85855ecd3257	1284
ADIJake	0:85855ecd3257	1285	channelOptionsReg.VALUE8 = REG_RESET_VAL(CORE_CHANNEL_OPTIONSn);
ADIJake	0:85855ecd3257	1286
ADIJake	0:85855ecd3257	1287	CHECK_REG_FIELD_VAL(CORE_CHANNEL_OPTIONS_CHANNEL_PRIORITY, ePriority);
ADIJake	0:85855ecd3257	1288	channelOptionsReg.Channel_Priority = ePriority;
ADIJake	0:85855ecd3257	1289
ADIJake	0:85855ecd3257	1290	WRITE_REG_U8(hDevice, channelOptionsReg.VALUE8, CORE_CHANNEL_OPTIONSn(eChannelId));
ADIJake	0:85855ecd3257	1291
Vkadaba	5:0728bde67bdb	1292	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1293	}
ADIJake	0:85855ecd3257	1294
Vkadaba	5:0728bde67bdb	1295	ADMW_RESULT admw1001_SetChannelSkipCount(
Vkadaba	5:0728bde67bdb	1296	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1297	ADMW1001_CH_ID eChannelId,
ADIJake	0:85855ecd3257	1298	uint32_t nCycleSkipCount)
ADIJake	0:85855ecd3257	1299	{
Vkadaba	8:2f2775c34640	1300	ADMW_CORE_Channel_Skip_t channelSkipReg;
ADIJake	0:85855ecd3257	1301
ADIJake	0:85855ecd3257	1302	channelSkipReg.VALUE16 = REG_RESET_VAL(CORE_CHANNEL_SKIPn);
ADIJake	0:85855ecd3257	1303
ADIJake	0:85855ecd3257	1304	CHECK_REG_FIELD_VAL(CORE_CHANNEL_SKIP_CHANNEL_SKIP, nCycleSkipCount);
ADIJake	0:85855ecd3257	1305
ADIJake	0:85855ecd3257	1306	channelSkipReg.Channel_Skip = nCycleSkipCount;
ADIJake	0:85855ecd3257	1307
ADIJake	0:85855ecd3257	1308	WRITE_REG_U16(hDevice, channelSkipReg.VALUE16, CORE_CHANNEL_SKIPn(eChannelId));
ADIJake	0:85855ecd3257	1309
Vkadaba	5:0728bde67bdb	1310	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1311	}
ADIJake	0:85855ecd3257	1312
Vkadaba	5:0728bde67bdb	1313	static ADMW_RESULT admw_SetChannelAdcSensorType(
Vkadaba	8:2f2775c34640	1314	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1315	ADMW1001_CH_ID eChannelId,
Vkadaba	8:2f2775c34640	1316	ADMW1001_ADC_SENSOR_TYPE sensorType)
ADIJake	0:85855ecd3257	1317	{
Vkadaba	8:2f2775c34640	1318	ADMW_CORE_Sensor_Type_t sensorTypeReg;
ADIJake	0:85855ecd3257	1319
ADIJake	0:85855ecd3257	1320	sensorTypeReg.VALUE16 = REG_RESET_VAL(CORE_SENSOR_TYPEn);
ADIJake	0:85855ecd3257	1321
ADIJake	0:85855ecd3257	1322	/* Ensure that the sensor type is valid for this channel */
Vkadaba	23:bb685f35b08b	1323	switch(sensorType) {
Vkadaba	50:d84305e5e1c0	1324	case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT10:
Vkadaba	50:d84305e5e1c0	1325
Vkadaba	50:d84305e5e1c0	1326	case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT50:
Vkadaba	50:d84305e5e1c0	1327	case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT100:
Vkadaba	50:d84305e5e1c0	1328	case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT200:
Vkadaba	50:d84305e5e1c0	1329	case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT500:
Vkadaba	50:d84305e5e1c0	1330	case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT1000:
Vkadaba	50:d84305e5e1c0	1331	case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT1000_0P00375:
Vkadaba	50:d84305e5e1c0	1332	case ADMW1001_ADC_SENSOR_RTD_2WIRE_NI120:
Vkadaba	50:d84305e5e1c0	1333	case ADMW1001_ADC_SENSOR_RTD_2WIRE_CUSTOM:
Vkadaba	50:d84305e5e1c0	1334	case ADMW1001_ADC_SENSOR_RTD_4WIRE_PT10:
Vkadaba	50:d84305e5e1c0	1335
Vkadaba	50:d84305e5e1c0	1336	case ADMW1001_ADC_SENSOR_RTD_4WIRE_PT50:
Vkadaba	50:d84305e5e1c0	1337	case ADMW1001_ADC_SENSOR_RTD_4WIRE_PT100:
Vkadaba	50:d84305e5e1c0	1338	case ADMW1001_ADC_SENSOR_RTD_4WIRE_PT200:
Vkadaba	50:d84305e5e1c0	1339	case ADMW1001_ADC_SENSOR_RTD_4WIRE_PT500:
Vkadaba	50:d84305e5e1c0	1340	case ADMW1001_ADC_SENSOR_RTD_4WIRE_PT1000:
Vkadaba	50:d84305e5e1c0	1341	case ADMW1001_ADC_SENSOR_RTD_4WIRE_PT1000_0P00375:
Vkadaba	50:d84305e5e1c0	1342	case ADMW1001_ADC_SENSOR_RTD_4WIRE_NI120:
Vkadaba	50:d84305e5e1c0	1343	case ADMW1001_ADC_SENSOR_RTD_4WIRE_CUSTOM:
Vkadaba	50:d84305e5e1c0	1344	case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT10:
Vkadaba	50:d84305e5e1c0	1345
Vkadaba	50:d84305e5e1c0	1346	case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT50:
Vkadaba	8:2f2775c34640	1347	case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT100:
Vkadaba	50:d84305e5e1c0	1348	case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT200:
Vkadaba	50:d84305e5e1c0	1349	case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT500:
Vkadaba	8:2f2775c34640	1350	case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT1000:
Vkadaba	50:d84305e5e1c0	1351	case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT1000_0P00375 :
Vkadaba	50:d84305e5e1c0	1352
Vkadaba	50:d84305e5e1c0	1353	case ADMW1001_ADC_SENSOR_RTD_3WIRE_NI120:
Vkadaba	50:d84305e5e1c0	1354	case ADMW1001_ADC_SENSOR_RTD_3WIRE_CUSTOM:
Vkadaba	58:aa9cd5072f66	1355	case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE:
Vkadaba	58:aa9cd5072f66	1356	case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE:
Vkadaba	50:d84305e5e1c0	1357	case ADMW1001_ADC_SENSOR_DIODE:
Vkadaba	50:d84305e5e1c0	1358	case ADMW1001_ADC_SENSOR_THERMISTOR_44004_44033_2P252K_AT_25C:
Vkadaba	50:d84305e5e1c0	1359	case ADMW1001_ADC_SENSOR_THERMISTOR_44005_44030_3K_AT_25C:
Vkadaba	50:d84305e5e1c0	1360	case ADMW1001_ADC_SENSOR_THERMISTOR_44007_44034_5K_AT_25C:
Vkadaba	50:d84305e5e1c0	1361	case ADMW1001_ADC_SENSOR_THERMISTOR_44006_44031_10K_AT_25C:
Vkadaba	50:d84305e5e1c0	1362	case ADMW1001_ADC_SENSOR_THERMISTOR_44008_44032_30K_AT_25C:
Vkadaba	50:d84305e5e1c0	1363	case ADMW1001_ADC_SENSOR_THERMISTOR_YSI_400:
Vkadaba	50:d84305e5e1c0	1364	case ADMW1001_ADC_SENSOR_THERMISTOR_SPECTRUM_1003K_1K:
Vkadaba	50:d84305e5e1c0	1365	case ADMW1001_ADC_SENSOR_THERMISTOR_CUSTOM_STEINHART_HART:
Vkadaba	50:d84305e5e1c0	1366	case ADMW1001_ADC_SENSOR_THERMISTOR_CUSTOM_TABLE:
Vkadaba	36:54e2418e7620	1367	case ADMW1001_ADC_SENSOR_SINGLE_ENDED_ABSOLUTE:
Vkadaba	36:54e2418e7620	1368	case ADMW1001_ADC_SENSOR_DIFFERENTIAL_ABSOLUTE:
Vkadaba	36:54e2418e7620	1369	case ADMW1001_ADC_SENSOR_SINGLE_ENDED_RATIO:
Vkadaba	36:54e2418e7620	1370	case ADMW1001_ADC_SENSOR_DIFFERENTIAL_RATIO:
Vkadaba	50:d84305e5e1c0	1371
Vkadaba	50:d84305e5e1c0	1372	if (! (ADMW1001_CHANNEL_IS_ADC_CJC(eChannelId) \|\|
Vkadaba	50:d84305e5e1c0	1373	ADMW1001_CHANNEL_IS_ADC(eChannelId) )) {
Vkadaba	6:9d393a9677f4	1374	ADMW_LOG_ERROR(
Vkadaba	6:9d393a9677f4	1375	"Invalid ADC sensor type %d specified for channel %d",
Vkadaba	6:9d393a9677f4	1376	sensorType, eChannelId);
Vkadaba	6:9d393a9677f4	1377	return ADMW_INVALID_PARAM;
Vkadaba	6:9d393a9677f4	1378	}
Vkadaba	6:9d393a9677f4	1379	break;
Vkadaba	8:2f2775c34640	1380	case ADMW1001_ADC_SENSOR_THERMOCOUPLE_J:
Vkadaba	8:2f2775c34640	1381	case ADMW1001_ADC_SENSOR_THERMOCOUPLE_K:
Vkadaba	8:2f2775c34640	1382	case ADMW1001_ADC_SENSOR_THERMOCOUPLE_T:
Vkadaba	50:d84305e5e1c0	1383	case ADMW1001_ADC_SENSOR_THERMOCOUPLE_E:
Vkadaba	50:d84305e5e1c0	1384	case ADMW1001_ADC_SENSOR_THERMOCOUPLE_N:
Vkadaba	50:d84305e5e1c0	1385	case ADMW1001_ADC_SENSOR_THERMOCOUPLE_R:
Vkadaba	50:d84305e5e1c0	1386	case ADMW1001_ADC_SENSOR_THERMOCOUPLE_S:
Vkadaba	50:d84305e5e1c0	1387	case ADMW1001_ADC_SENSOR_THERMOCOUPLE_B:
Vkadaba	50:d84305e5e1c0	1388	case ADMW1001_ADC_SENSOR_THERMOCOUPLE_CUSTOM:
Vkadaba	23:bb685f35b08b	1389	if (! ADMW1001_CHANNEL_IS_ADC_VOLTAGE(eChannelId)) {
Vkadaba	6:9d393a9677f4	1390	ADMW_LOG_ERROR(
Vkadaba	6:9d393a9677f4	1391	"Invalid ADC sensor type %d specified for channel %d",
Vkadaba	6:9d393a9677f4	1392	sensorType, eChannelId);
Vkadaba	6:9d393a9677f4	1393	return ADMW_INVALID_PARAM;
Vkadaba	6:9d393a9677f4	1394	}
Vkadaba	6:9d393a9677f4	1395	break;
Vkadaba	6:9d393a9677f4	1396	default:
Vkadaba	6:9d393a9677f4	1397	ADMW_LOG_ERROR("Invalid/unsupported ADC sensor type %d specified",
Vkadaba	23:bb685f35b08b	1398	sensorType);
Vkadaba	5:0728bde67bdb	1399	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1400	}
ADIJake	0:85855ecd3257	1401
ADIJake	0:85855ecd3257	1402	sensorTypeReg.Sensor_Type = sensorType;
ADIJake	0:85855ecd3257	1403
ADIJake	0:85855ecd3257	1404	WRITE_REG_U16(hDevice, sensorTypeReg.VALUE16, CORE_SENSOR_TYPEn(eChannelId));
ADIJake	0:85855ecd3257	1405
Vkadaba	5:0728bde67bdb	1406	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1407	}
ADIJake	0:85855ecd3257	1408
Vkadaba	5:0728bde67bdb	1409	static ADMW_RESULT admw_SetChannelAdcSensorDetails(
Vkadaba	8:2f2775c34640	1410	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1411	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1412	ADMW1001_CHANNEL_CONFIG *pChannelConfig)
ADIJake	0:85855ecd3257	1413	/*
ADIJake	0:85855ecd3257	1414	* TODO - it would be nice if the general- vs. ADC-specific sensor details could be split into separate registers
ADIJake	0:85855ecd3257	1415	* General details:
ADIJake	0:85855ecd3257	1416	* - Measurement_Units
ADIJake	0:85855ecd3257	1417	* - Compensation_Channel
ADIJake	0:85855ecd3257	1418	* - CJC_Publish (if "CJC" was removed from the name)
ADIJake	0:85855ecd3257	1419	* ADC-specific details:
ADIJake	0:85855ecd3257	1420	* - PGA_Gain
ADIJake	0:85855ecd3257	1421	* - Reference_Select
ADIJake	0:85855ecd3257	1422	* - Reference_Buffer_Disable
ADIJake	0:85855ecd3257	1423	*/
ADIJake	0:85855ecd3257	1424	{
Vkadaba	5:0728bde67bdb	1425	ADMW1001_ADC_CHANNEL_CONFIG *pAdcChannelConfig = &pChannelConfig->adcChannelConfig;
Vkadaba	8:2f2775c34640	1426	ADMW1001_ADC_REFERENCE_TYPE refType = pAdcChannelConfig->reference;
Vkadaba	8:2f2775c34640	1427	ADMW_CORE_Sensor_Details_t sensorDetailsReg;
ADIJake	0:85855ecd3257	1428
ADIJake	0:85855ecd3257	1429	sensorDetailsReg.VALUE32 = REG_RESET_VAL(CORE_SENSOR_DETAILSn);
ADIJake	0:85855ecd3257	1430
Vkadaba	23:bb685f35b08b	1431	switch(pChannelConfig->measurementUnit) {
Vkadaba	8:2f2775c34640	1432	case ADMW1001_MEASUREMENT_UNIT_FAHRENHEIT:
Vkadaba	8:2f2775c34640	1433	sensorDetailsReg.Measurement_Units = CORE_SENSOR_DETAILS_UNITS_DEGF;
Vkadaba	8:2f2775c34640	1434	break;
Vkadaba	8:2f2775c34640	1435	case ADMW1001_MEASUREMENT_UNIT_CELSIUS:
Vkadaba	8:2f2775c34640	1436	sensorDetailsReg.Measurement_Units = CORE_SENSOR_DETAILS_UNITS_DEGC;
Vkadaba	8:2f2775c34640	1437	break;
Vkadaba	8:2f2775c34640	1438	case ADMW1001_MEASUREMENT_UNIT_UNSPECIFIED:
Vkadaba	8:2f2775c34640	1439	sensorDetailsReg.Measurement_Units = CORE_SENSOR_DETAILS_UNITS_UNSPECIFIED;
Vkadaba	8:2f2775c34640	1440	break;
Vkadaba	8:2f2775c34640	1441	default:
Vkadaba	8:2f2775c34640	1442	ADMW_LOG_ERROR("Invalid measurement unit %d specified",
Vkadaba	8:2f2775c34640	1443	pChannelConfig->measurementUnit);
Vkadaba	8:2f2775c34640	1444	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1445	}
ADIJake	0:85855ecd3257	1446
Vkadaba	23:bb685f35b08b	1447	if (pChannelConfig->compensationChannel == ADMW1001_CH_ID_NONE) {
ADIJake	0:85855ecd3257	1448	sensorDetailsReg.Compensation_Disable = 1;
ADIJake	0:85855ecd3257	1449	sensorDetailsReg.Compensation_Channel = 0;
Vkadaba	23:bb685f35b08b	1450	} else {
ADIJake	0:85855ecd3257	1451	sensorDetailsReg.Compensation_Disable = 0;
ADIJake	0:85855ecd3257	1452	sensorDetailsReg.Compensation_Channel = pChannelConfig->compensationChannel;
ADIJake	0:85855ecd3257	1453	}
ADIJake	0:85855ecd3257	1454
Vkadaba	23:bb685f35b08b	1455	switch(refType) {
Vkadaba	8:2f2775c34640	1456	case ADMW1001_ADC_REFERENCE_VOLTAGE_INTERNAL:
Vkadaba	8:2f2775c34640	1457	sensorDetailsReg.Reference_Select = CORE_SENSOR_DETAILS_REF_VINT;
Vkadaba	8:2f2775c34640	1458	break;
Vkadaba	8:2f2775c34640	1459	case ADMW1001_ADC_REFERENCE_VOLTAGE_EXTERNAL_1:
Vkadaba	8:2f2775c34640	1460	sensorDetailsReg.Reference_Select = CORE_SENSOR_DETAILS_REF_VEXT1;
Vkadaba	8:2f2775c34640	1461	break;
Vkadaba	8:2f2775c34640	1462	case ADMW1001_ADC_REFERENCE_VOLTAGE_AVDD:
Vkadaba	8:2f2775c34640	1463	sensorDetailsReg.Reference_Select = CORE_SENSOR_DETAILS_REF_AVDD;
Vkadaba	8:2f2775c34640	1464	break;
Vkadaba	8:2f2775c34640	1465	default:
Vkadaba	8:2f2775c34640	1466	ADMW_LOG_ERROR("Invalid ADC reference type %d specified", refType);
Vkadaba	8:2f2775c34640	1467	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1468	}
Vkadaba	23:bb685f35b08b	1469
Vkadaba	23:bb685f35b08b	1470	switch(pAdcChannelConfig->gain) {
Vkadaba	8:2f2775c34640	1471	case ADMW1001_ADC_GAIN_1X:
Vkadaba	8:2f2775c34640	1472	sensorDetailsReg.PGA_Gain = CORE_SENSOR_DETAILS_PGA_GAIN_1;
Vkadaba	8:2f2775c34640	1473	break;
Vkadaba	8:2f2775c34640	1474	case ADMW1001_ADC_GAIN_2X:
Vkadaba	8:2f2775c34640	1475	sensorDetailsReg.PGA_Gain = CORE_SENSOR_DETAILS_PGA_GAIN_2;
Vkadaba	8:2f2775c34640	1476	break;
Vkadaba	8:2f2775c34640	1477	case ADMW1001_ADC_GAIN_4X:
Vkadaba	8:2f2775c34640	1478	sensorDetailsReg.PGA_Gain = CORE_SENSOR_DETAILS_PGA_GAIN_4;
Vkadaba	8:2f2775c34640	1479	break;
Vkadaba	8:2f2775c34640	1480	case ADMW1001_ADC_GAIN_8X:
Vkadaba	8:2f2775c34640	1481	sensorDetailsReg.PGA_Gain = CORE_SENSOR_DETAILS_PGA_GAIN_8;
Vkadaba	8:2f2775c34640	1482	break;
Vkadaba	8:2f2775c34640	1483	case ADMW1001_ADC_GAIN_16X:
Vkadaba	8:2f2775c34640	1484	sensorDetailsReg.PGA_Gain = CORE_SENSOR_DETAILS_PGA_GAIN_16;
Vkadaba	8:2f2775c34640	1485	break;
Vkadaba	8:2f2775c34640	1486	case ADMW1001_ADC_GAIN_32X:
Vkadaba	8:2f2775c34640	1487	sensorDetailsReg.PGA_Gain = CORE_SENSOR_DETAILS_PGA_GAIN_32;
Vkadaba	8:2f2775c34640	1488	break;
Vkadaba	8:2f2775c34640	1489	case ADMW1001_ADC_GAIN_64X:
Vkadaba	8:2f2775c34640	1490	sensorDetailsReg.PGA_Gain = CORE_SENSOR_DETAILS_PGA_GAIN_64;
Vkadaba	8:2f2775c34640	1491	break;
Vkadaba	8:2f2775c34640	1492	default:
Vkadaba	8:2f2775c34640	1493	ADMW_LOG_ERROR("Invalid ADC gain %d specified",
Vkadaba	23:bb685f35b08b	1494	pAdcChannelConfig->gain);
Vkadaba	8:2f2775c34640	1495	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1496	}
ADIJake	0:85855ecd3257	1497
Vkadaba	23:bb685f35b08b	1498	switch(pAdcChannelConfig->rtdCurve) {
Vkadaba	8:2f2775c34640	1499	case ADMW1001_ADC_RTD_CURVE_EUROPEAN:
Vkadaba	8:2f2775c34640	1500	sensorDetailsReg.RTD_Curve = CORE_SENSOR_DETAILS_EUROPEAN_CURVE;
Vkadaba	8:2f2775c34640	1501	break;
Vkadaba	8:2f2775c34640	1502	case ADMW1001_ADC_RTD_CURVE_AMERICAN:
Vkadaba	8:2f2775c34640	1503	sensorDetailsReg.RTD_Curve = CORE_SENSOR_DETAILS_AMERICAN_CURVE;
Vkadaba	8:2f2775c34640	1504	break;
Vkadaba	8:2f2775c34640	1505	case ADMW1001_ADC_RTD_CURVE_JAPANESE:
Vkadaba	8:2f2775c34640	1506	sensorDetailsReg.RTD_Curve = CORE_SENSOR_DETAILS_JAPANESE_CURVE;
Vkadaba	8:2f2775c34640	1507	break;
Vkadaba	8:2f2775c34640	1508	case ADMW1001_ADC_RTD_CURVE_ITS90:
Vkadaba	8:2f2775c34640	1509	sensorDetailsReg.RTD_Curve = CORE_SENSOR_DETAILS_ITS90_CURVE;
Vkadaba	8:2f2775c34640	1510	break;
Vkadaba	8:2f2775c34640	1511	default:
Vkadaba	8:2f2775c34640	1512	ADMW_LOG_ERROR("Invalid RTD Curve %d specified",
Vkadaba	23:bb685f35b08b	1513	pAdcChannelConfig->rtdCurve);
Vkadaba	8:2f2775c34640	1514	return ADMW_INVALID_PARAM;
Vkadaba	6:9d393a9677f4	1515	}
Vkadaba	6:9d393a9677f4	1516
Vkadaba	23:bb685f35b08b	1517	if (pChannelConfig->disablePublishing) {
ADIJake	0:85855ecd3257	1518	sensorDetailsReg.Do_Not_Publish = 1;
Vkadaba	23:bb685f35b08b	1519	} else {
ADIJake	0:85855ecd3257	1520	sensorDetailsReg.Do_Not_Publish = 0;
Vkadaba	8:2f2775c34640	1521	}
Vkadaba	23:bb685f35b08b	1522
Vkadaba	23:bb685f35b08b	1523	switch (pChannelConfig->lutSelect) {
Vkadaba	8:2f2775c34640	1524	case ADMW1001_LUT_DEFAULT:
Vkadaba	8:2f2775c34640	1525	case ADMW1001_LUT_CUSTOM:
Vkadaba	8:2f2775c34640	1526	sensorDetailsReg.LUT_Select = pChannelConfig->lutSelect;
Vkadaba	8:2f2775c34640	1527	break;
Vkadaba	8:2f2775c34640	1528	default:
Vkadaba	8:2f2775c34640	1529	ADMW_LOG_ERROR("Invalid LUT selection %d specified",
Vkadaba	23:bb685f35b08b	1530	pChannelConfig->lutSelect);
Vkadaba	23:bb685f35b08b	1531	return ADMW_INVALID_PARAM;
Vkadaba	8:2f2775c34640	1532	}
Vkadaba	23:bb685f35b08b	1533
ADIJake	0:85855ecd3257	1534	WRITE_REG_U32(hDevice, sensorDetailsReg.VALUE32, CORE_SENSOR_DETAILSn(eChannelId));
ADIJake	0:85855ecd3257	1535
Vkadaba	5:0728bde67bdb	1536	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1537	}
ADIJake	0:85855ecd3257	1538
Vkadaba	33:df7a00f1b8e1	1539	static ADMW_RESULT admw_SetChannelAdcMeasurementSetup(
Vkadaba	5:0728bde67bdb	1540	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1541	ADMW1001_CH_ID eChannelId,
Vkadaba	33:df7a00f1b8e1	1542	ADMW1001_ADC_CHANNEL_CONFIG *pAdcChannelConfig)
ADIJake	0:85855ecd3257	1543	{
Vkadaba	8:2f2775c34640	1544	ADMW_CORE_Measurement_Setup_t MeasSetupReg;
Vkadaba	33:df7a00f1b8e1	1545	ADMW1001_ADC_FILTER_CONFIG *pFilterConfig = &pAdcChannelConfig->filter;
Vkadaba	6:9d393a9677f4	1546	MeasSetupReg.VALUE32 = REG_RESET_VAL(CORE_MEASUREMENT_SETUPn);
Vkadaba	33:df7a00f1b8e1	1547	MeasSetupReg.Buffer_Bypass = pAdcChannelConfig->bufferBypass;
Vkadaba	41:df78b7d7b675	1548
Vkadaba	23:bb685f35b08b	1549	if (pFilterConfig->type == ADMW1001_ADC_FILTER_SINC4) {
Vkadaba	6:9d393a9677f4	1550	MeasSetupReg.ADC_Filter_Type = CORE_MEASUREMENT_SETUP_ENABLE_SINC4;
Vkadaba	6:9d393a9677f4	1551	MeasSetupReg.ADC_SF = pFilterConfig->sf;
Vkadaba	23:bb685f35b08b	1552	} else if (pFilterConfig->type == ADMW1001_ADC_FILTER_SINC3) {
Vkadaba	6:9d393a9677f4	1553	MeasSetupReg.ADC_Filter_Type = CORE_MEASUREMENT_SETUP_ENABLE_SINC3;
Vkadaba	23:bb685f35b08b	1554	MeasSetupReg.ADC_SF = pFilterConfig->sf;
Vkadaba	23:bb685f35b08b	1555	} else {
Vkadaba	5:0728bde67bdb	1556	ADMW_LOG_ERROR("Invalid ADC filter type %d specified",
Vkadaba	23:bb685f35b08b	1557	pFilterConfig->type);
Vkadaba	5:0728bde67bdb	1558	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1559	}
Vkadaba	23:bb685f35b08b	1560
Vkadaba	8:2f2775c34640	1561	/* chop mod ecan be 0 (none), 1 (HW, 2 (SW, 3 (HW+SW). */
Vkadaba	17:2f0028880874	1562	MeasSetupReg.Chop_Mode = pFilterConfig->chopMode;
Vkadaba	23:bb685f35b08b	1563
Vkadaba	6:9d393a9677f4	1564	if(pFilterConfig->notch1p2)
Vkadaba	6:9d393a9677f4	1565	MeasSetupReg.NOTCH_EN_2 = 1;
Vkadaba	6:9d393a9677f4	1566	else
Vkadaba	6:9d393a9677f4	1567	MeasSetupReg.NOTCH_EN_2 = 0;
Vkadaba	23:bb685f35b08b	1568
Vkadaba	6:9d393a9677f4	1569	WRITE_REG_U32(hDevice, MeasSetupReg.VALUE32, CORE_MEASUREMENT_SETUPn(eChannelId));
ADIJake	0:85855ecd3257	1570
Vkadaba	5:0728bde67bdb	1571	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1572	}
ADIJake	0:85855ecd3257	1573
Vkadaba	5:0728bde67bdb	1574	static ADMW_RESULT admw_SetChannelAdcCurrentConfig(
Vkadaba	5:0728bde67bdb	1575	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1576	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1577	ADMW1001_ADC_EXC_CURRENT_CONFIG *pCurrentConfig)
ADIJake	0:85855ecd3257	1578	{
Vkadaba	8:2f2775c34640	1579	ADMW_CORE_Channel_Excitation_t channelExcitationReg;
ADIJake	0:85855ecd3257	1580
Vkadaba	6:9d393a9677f4	1581	channelExcitationReg.VALUE16 = REG_RESET_VAL(CORE_CHANNEL_EXCITATIONn);
Vkadaba	6:9d393a9677f4	1582
Vkadaba	18:cbf514cce921	1583	if (pCurrentConfig->outputLevel == ADMW1001_ADC_NO_EXTERNAL_EXC_CURRENT)
Vkadaba	18:cbf514cce921	1584	channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_NONE;
Vkadaba	18:cbf514cce921	1585	else if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_EXTERNAL)
Vkadaba	6:9d393a9677f4	1586	channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_EXTERNAL;
Vkadaba	18:cbf514cce921	1587	else if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_50uA)
Vkadaba	6:9d393a9677f4	1588	channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_IEXC_50UA;
Vkadaba	6:9d393a9677f4	1589	else if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_100uA)
Vkadaba	6:9d393a9677f4	1590	channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_IEXC_100UA;
Vkadaba	6:9d393a9677f4	1591	else if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_250uA)
Vkadaba	6:9d393a9677f4	1592	channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_IEXC_250UA;
Vkadaba	6:9d393a9677f4	1593	else if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_500uA)
Vkadaba	6:9d393a9677f4	1594	channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_IEXC_500UA;
Vkadaba	6:9d393a9677f4	1595	else if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_1000uA)
Vkadaba	6:9d393a9677f4	1596	channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_IEXC_1000UA;
Vkadaba	23:bb685f35b08b	1597	else {
Vkadaba	6:9d393a9677f4	1598	ADMW_LOG_ERROR("Invalid ADC excitation current %d specified",
Vkadaba	6:9d393a9677f4	1599	pCurrentConfig->outputLevel);
Vkadaba	6:9d393a9677f4	1600	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1601	}
ADIJake	0:85855ecd3257	1602
Vkadaba	6:9d393a9677f4	1603	WRITE_REG_U16(hDevice, channelExcitationReg.VALUE16, CORE_CHANNEL_EXCITATIONn(eChannelId));
ADIJake	0:85855ecd3257	1604
Vkadaba	5:0728bde67bdb	1605	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1606	}
ADIJake	0:85855ecd3257	1607
Vkadaba	5:0728bde67bdb	1608	ADMW_RESULT admw_SetAdcChannelConfig(
Vkadaba	5:0728bde67bdb	1609	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1610	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1611	ADMW1001_CHANNEL_CONFIG *pChannelConfig)
ADIJake	0:85855ecd3257	1612	{
Vkadaba	5:0728bde67bdb	1613	ADMW_RESULT eRet;
Vkadaba	5:0728bde67bdb	1614	ADMW1001_ADC_CHANNEL_CONFIG *pAdcChannelConfig =
ADIJake	0:85855ecd3257	1615	&pChannelConfig->adcChannelConfig;
ADIJake	0:85855ecd3257	1616
Vkadaba	5:0728bde67bdb	1617	eRet = admw_SetChannelAdcSensorType(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	1618	pAdcChannelConfig->sensor);
Vkadaba	23:bb685f35b08b	1619	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1620	ADMW_LOG_ERROR("Failed to set ADC sensor type for channel %d",
Vkadaba	23:bb685f35b08b	1621	eChannelId);
ADIJake	0:85855ecd3257	1622	return eRet;
ADIJake	0:85855ecd3257	1623	}
ADIJake	0:85855ecd3257	1624
Vkadaba	5:0728bde67bdb	1625	eRet = admw_SetChannelAdcSensorDetails(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	1626	pChannelConfig);
Vkadaba	23:bb685f35b08b	1627	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1628	ADMW_LOG_ERROR("Failed to set ADC sensor details for channel %d",
Vkadaba	23:bb685f35b08b	1629	eChannelId);
ADIJake	0:85855ecd3257	1630	return eRet;
ADIJake	0:85855ecd3257	1631	}
ADIJake	0:85855ecd3257	1632
Vkadaba	33:df7a00f1b8e1	1633	eRet = admw_SetChannelAdcMeasurementSetup(hDevice, eChannelId,
Vkadaba	41:df78b7d7b675	1634	pAdcChannelConfig);
Vkadaba	23:bb685f35b08b	1635	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1636	ADMW_LOG_ERROR("Failed to set ADC filter for channel %d",
Vkadaba	23:bb685f35b08b	1637	eChannelId);
ADIJake	0:85855ecd3257	1638	return eRet;
ADIJake	0:85855ecd3257	1639	}
ADIJake	0:85855ecd3257	1640
Vkadaba	5:0728bde67bdb	1641	eRet = admw_SetChannelAdcCurrentConfig(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	1642	&pAdcChannelConfig->current);
Vkadaba	23:bb685f35b08b	1643	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1644	ADMW_LOG_ERROR("Failed to set ADC current for channel %d",
Vkadaba	23:bb685f35b08b	1645	eChannelId);
ADIJake	0:85855ecd3257	1646	return eRet;
ADIJake	0:85855ecd3257	1647	}
ADIJake	0:85855ecd3257	1648
Vkadaba	5:0728bde67bdb	1649	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1650	}
ADIJake	0:85855ecd3257	1651
Vkadaba	5:0728bde67bdb	1652	static ADMW_RESULT admw_SetChannelDigitalSensorDetails(
Vkadaba	5:0728bde67bdb	1653	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1654	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1655	ADMW1001_CHANNEL_CONFIG *pChannelConfig)
ADIJake	0:85855ecd3257	1656	{
Vkadaba	8:2f2775c34640	1657	ADMW_CORE_Sensor_Details_t sensorDetailsReg;
ADIJake	0:85855ecd3257	1658
ADIJake	0:85855ecd3257	1659	sensorDetailsReg.VALUE32 = REG_RESET_VAL(CORE_SENSOR_DETAILSn);
ADIJake	0:85855ecd3257	1660
Vkadaba	23:bb685f35b08b	1661	if (pChannelConfig->compensationChannel == ADMW1001_CH_ID_NONE) {
ADIJake	0:85855ecd3257	1662	sensorDetailsReg.Compensation_Disable = 1;
ADIJake	0:85855ecd3257	1663	sensorDetailsReg.Compensation_Channel = 0;
Vkadaba	23:bb685f35b08b	1664	} else {
Vkadaba	5:0728bde67bdb	1665	ADMW_LOG_ERROR("Invalid compensation channel specified for digital sensor");
Vkadaba	5:0728bde67bdb	1666	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1667	}
ADIJake	0:85855ecd3257	1668
Vkadaba	23:bb685f35b08b	1669	if (pChannelConfig->measurementUnit == ADMW1001_MEASUREMENT_UNIT_UNSPECIFIED) {
Vkadaba	5:0728bde67bdb	1670	sensorDetailsReg.Measurement_Units = CORE_SENSOR_DETAILS_UNITS_UNSPECIFIED;
Vkadaba	23:bb685f35b08b	1671	} else {
Vkadaba	5:0728bde67bdb	1672	ADMW_LOG_ERROR("Invalid measurement unit specified for digital channel");
Vkadaba	5:0728bde67bdb	1673	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1674	}
ADIJake	0:85855ecd3257	1675
ADIJake	0:85855ecd3257	1676	if (pChannelConfig->disablePublishing)
ADIJake	0:85855ecd3257	1677	sensorDetailsReg.Do_Not_Publish = 1;
ADIJake	0:85855ecd3257	1678	else
ADIJake	0:85855ecd3257	1679	sensorDetailsReg.Do_Not_Publish = 0;
ADIJake	0:85855ecd3257	1680
ADIJake	0:85855ecd3257	1681	WRITE_REG_U32(hDevice, sensorDetailsReg.VALUE32, CORE_SENSOR_DETAILSn(eChannelId));
ADIJake	0:85855ecd3257	1682
Vkadaba	5:0728bde67bdb	1683	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1684	}
ADIJake	0:85855ecd3257	1685
Vkadaba	5:0728bde67bdb	1686	static ADMW_RESULT admw_SetDigitalSensorFormat(
Vkadaba	5:0728bde67bdb	1687	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1688	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1689	ADMW1001_DIGITAL_SENSOR_DATA_FORMAT *pDataFormat)
ADIJake	0:85855ecd3257	1690	{
Vkadaba	8:2f2775c34640	1691	ADMW_CORE_Digital_Sensor_Config_t sensorConfigReg;
ADIJake	0:85855ecd3257	1692
ADIJake	0:85855ecd3257	1693	sensorConfigReg.VALUE16 = REG_RESET_VAL(CORE_DIGITAL_SENSOR_CONFIGn);
ADIJake	0:85855ecd3257	1694
Vkadaba	23:bb685f35b08b	1695	if (pDataFormat->coding != ADMW1001_DIGITAL_SENSOR_DATA_CODING_NONE) {
Vkadaba	23:bb685f35b08b	1696	if (pDataFormat->frameLength == 0) {
Vkadaba	5:0728bde67bdb	1697	ADMW_LOG_ERROR("Invalid frame length specified for digital sensor data format");
Vkadaba	5:0728bde67bdb	1698	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1699	}
Vkadaba	23:bb685f35b08b	1700	if (pDataFormat->numDataBits == 0) {
Vkadaba	5:0728bde67bdb	1701	ADMW_LOG_ERROR("Invalid frame length specified for digital sensor data format");
Vkadaba	5:0728bde67bdb	1702	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1703	}
ADIJake	0:85855ecd3257	1704
ADIJake	0:85855ecd3257	1705	CHECK_REG_FIELD_VAL(CORE_DIGITAL_SENSOR_CONFIG_DIGITAL_SENSOR_READ_BYTES,
ADIJake	0:85855ecd3257	1706	pDataFormat->frameLength - 1);
ADIJake	0:85855ecd3257	1707	CHECK_REG_FIELD_VAL(CORE_DIGITAL_SENSOR_CONFIG_DIGITAL_SENSOR_DATA_BITS,
ADIJake	0:85855ecd3257	1708	pDataFormat->numDataBits - 1);
ADIJake	0:85855ecd3257	1709	CHECK_REG_FIELD_VAL(CORE_DIGITAL_SENSOR_CONFIG_DIGITAL_SENSOR_BIT_OFFSET,
ADIJake	0:85855ecd3257	1710	pDataFormat->bitOffset);
ADIJake	0:85855ecd3257	1711
ADIJake	0:85855ecd3257	1712	sensorConfigReg.Digital_Sensor_Read_Bytes = pDataFormat->frameLength - 1;
ADIJake	0:85855ecd3257	1713	sensorConfigReg.Digital_Sensor_Data_Bits = pDataFormat->numDataBits - 1;
ADIJake	0:85855ecd3257	1714	sensorConfigReg.Digital_Sensor_Bit_Offset = pDataFormat->bitOffset;
ADIJake	0:85855ecd3257	1715	sensorConfigReg.Digital_Sensor_Left_Aligned = pDataFormat->leftJustified ? 1 : 0;
ADIJake	0:85855ecd3257	1716	sensorConfigReg.Digital_Sensor_Little_Endian = pDataFormat->littleEndian ? 1 : 0;
ADIJake	0:85855ecd3257	1717
Vkadaba	23:bb685f35b08b	1718	switch (pDataFormat->coding) {
Vkadaba	23:bb685f35b08b	1719	case ADMW1001_DIGITAL_SENSOR_DATA_CODING_UNIPOLAR:
Vkadaba	23:bb685f35b08b	1720	sensorConfigReg.Digital_Sensor_Coding = CORE_DIGITAL_SENSOR_CONFIG_CODING_UNIPOLAR;
Vkadaba	23:bb685f35b08b	1721	break;
Vkadaba	23:bb685f35b08b	1722	case ADMW1001_DIGITAL_SENSOR_DATA_CODING_TWOS_COMPLEMENT:
Vkadaba	23:bb685f35b08b	1723	sensorConfigReg.Digital_Sensor_Coding = CORE_DIGITAL_SENSOR_CONFIG_CODING_TWOS_COMPL;
Vkadaba	23:bb685f35b08b	1724	break;
Vkadaba	23:bb685f35b08b	1725	case ADMW1001_DIGITAL_SENSOR_DATA_CODING_OFFSET_BINARY:
Vkadaba	23:bb685f35b08b	1726	sensorConfigReg.Digital_Sensor_Coding = CORE_DIGITAL_SENSOR_CONFIG_CODING_OFFSET_BINARY;
Vkadaba	23:bb685f35b08b	1727	break;
Vkadaba	23:bb685f35b08b	1728	default:
Vkadaba	23:bb685f35b08b	1729	ADMW_LOG_ERROR("Invalid coding specified for digital sensor data format");
Vkadaba	23:bb685f35b08b	1730	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1731	}
Vkadaba	23:bb685f35b08b	1732	} else {
Vkadaba	5:0728bde67bdb	1733	sensorConfigReg.Digital_Sensor_Coding = CORE_DIGITAL_SENSOR_CONFIG_CODING_NONE;
ADIJake	0:85855ecd3257	1734	}
ADIJake	0:85855ecd3257	1735
ADIJake	0:85855ecd3257	1736	WRITE_REG_U16(hDevice, sensorConfigReg.VALUE16,
ADIJake	0:85855ecd3257	1737	CORE_DIGITAL_SENSOR_CONFIGn(eChannelId));
ADIJake	0:85855ecd3257	1738
ADIJake	0:85855ecd3257	1739
Vkadaba	5:0728bde67bdb	1740	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1741	}
ADIJake	0:85855ecd3257	1742
ADIJake	0:85855ecd3257	1743
Vkadaba	5:0728bde67bdb	1744	static ADMW_RESULT admw_SetChannelI2cSensorType(
Vkadaba	5:0728bde67bdb	1745	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1746	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1747	ADMW1001_I2C_SENSOR_TYPE sensorType)
ADIJake	0:85855ecd3257	1748	{
Vkadaba	8:2f2775c34640	1749	ADMW_CORE_Sensor_Type_t sensorTypeReg;
ADIJake	0:85855ecd3257	1750
ADIJake	0:85855ecd3257	1751	sensorTypeReg.VALUE16 = REG_RESET_VAL(CORE_SENSOR_TYPEn);
ADIJake	0:85855ecd3257	1752
ADIJake	0:85855ecd3257	1753	/* Ensure that the sensor type is valid for this channel */
Vkadaba	23:bb685f35b08b	1754	switch(sensorType) {
Vkadaba	58:aa9cd5072f66	1755	case ADMW1001_I2C_SENSOR_HUMIDITY:
Vkadaba	50:d84305e5e1c0	1756	case ADMW1001_I2C_SENSOR_TEMPERATURE_ADT742X:
Vkadaba	8:2f2775c34640	1757	sensorTypeReg.Sensor_Type = sensorType;
Vkadaba	8:2f2775c34640	1758	break;
Vkadaba	8:2f2775c34640	1759	default:
Vkadaba	8:2f2775c34640	1760	ADMW_LOG_ERROR("Unsupported I2C sensor type %d specified", sensorType);
Vkadaba	8:2f2775c34640	1761	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1762	}
ADIJake	0:85855ecd3257	1763
ADIJake	0:85855ecd3257	1764	WRITE_REG_U16(hDevice, sensorTypeReg.VALUE16, CORE_SENSOR_TYPEn(eChannelId));
ADIJake	0:85855ecd3257	1765
Vkadaba	5:0728bde67bdb	1766	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1767	}
ADIJake	0:85855ecd3257	1768
Vkadaba	5:0728bde67bdb	1769	static ADMW_RESULT admw_SetChannelI2cSensorAddress(
Vkadaba	5:0728bde67bdb	1770	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1771	ADMW1001_CH_ID eChannelId,
ADIJake	0:85855ecd3257	1772	uint32_t deviceAddress)
ADIJake	0:85855ecd3257	1773	{
ADIJake	0:85855ecd3257	1774	CHECK_REG_FIELD_VAL(CORE_DIGITAL_SENSOR_ADDRESS_DIGITAL_SENSOR_ADDRESS, deviceAddress);
ADIJake	0:85855ecd3257	1775	WRITE_REG_U8(hDevice, deviceAddress, CORE_DIGITAL_SENSOR_ADDRESSn(eChannelId));
ADIJake	0:85855ecd3257	1776
Vkadaba	5:0728bde67bdb	1777	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1778	}
ADIJake	0:85855ecd3257	1779
Vkadaba	5:0728bde67bdb	1780	static ADMW_RESULT admw_SetDigitalChannelComms(
Vkadaba	5:0728bde67bdb	1781	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1782	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1783	ADMW1001_DIGITAL_SENSOR_COMMS *pDigitalComms)
ADIJake	0:85855ecd3257	1784	{
Vkadaba	8:2f2775c34640	1785	ADMW_CORE_Digital_Sensor_Comms_t digitalSensorComms;
ADIJake	0:85855ecd3257	1786
ADIJake	0:85855ecd3257	1787	digitalSensorComms.VALUE16 = REG_RESET_VAL(CORE_DIGITAL_SENSOR_COMMSn);
ADIJake	0:85855ecd3257	1788
Vkadaba	23:bb685f35b08b	1789	if(pDigitalComms->useCustomCommsConfig) {
ADIJake	0:85855ecd3257	1790
Vkadaba	23:bb685f35b08b	1791	if(pDigitalComms->i2cClockSpeed == ADMW1001_DIGITAL_SENSOR_COMMS_I2C_CLOCK_SPEED_100K) {
Vkadaba	5:0728bde67bdb	1792	digitalSensorComms.I2C_Clock = CORE_DIGITAL_SENSOR_COMMS_I2C_100K;
Vkadaba	23:bb685f35b08b	1793	} else if(pDigitalComms->i2cClockSpeed == ADMW1001_DIGITAL_SENSOR_COMMS_I2C_CLOCK_SPEED_400K) {
Vkadaba	5:0728bde67bdb	1794	digitalSensorComms.I2C_Clock = CORE_DIGITAL_SENSOR_COMMS_I2C_400K;
Vkadaba	23:bb685f35b08b	1795	} else {
Vkadaba	5:0728bde67bdb	1796	ADMW_LOG_ERROR("Invalid I2C clock speed %d specified",
Vkadaba	23:bb685f35b08b	1797	pDigitalComms->i2cClockSpeed);
Vkadaba	5:0728bde67bdb	1798	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1799	}
Vkadaba	63:2655a04c00f5	1800	}
ADIJake	0:85855ecd3257	1801	WRITE_REG_U16(hDevice, digitalSensorComms.VALUE16, CORE_DIGITAL_SENSOR_COMMSn(eChannelId));
ADIJake	0:85855ecd3257	1802
Vkadaba	5:0728bde67bdb	1803	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1804	}
ADIJake	0:85855ecd3257	1805
Vkadaba	5:0728bde67bdb	1806	ADMW_RESULT admw_SetI2cChannelConfig(
Vkadaba	5:0728bde67bdb	1807	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1808	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1809	ADMW1001_CHANNEL_CONFIG *pChannelConfig)
ADIJake	0:85855ecd3257	1810	{
Vkadaba	5:0728bde67bdb	1811	ADMW_RESULT eRet;
Vkadaba	5:0728bde67bdb	1812	ADMW1001_I2C_CHANNEL_CONFIG *pI2cChannelConfig =
ADIJake	0:85855ecd3257	1813	&pChannelConfig->i2cChannelConfig;
ADIJake	0:85855ecd3257	1814
Vkadaba	5:0728bde67bdb	1815	eRet = admw_SetChannelI2cSensorType(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	1816	pI2cChannelConfig->sensor);
Vkadaba	23:bb685f35b08b	1817	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1818	ADMW_LOG_ERROR("Failed to set I2C sensor type for channel %d",
Vkadaba	23:bb685f35b08b	1819	eChannelId);
ADIJake	0:85855ecd3257	1820	return eRet;
ADIJake	0:85855ecd3257	1821	}
ADIJake	0:85855ecd3257	1822
Vkadaba	5:0728bde67bdb	1823	eRet = admw_SetChannelI2cSensorAddress(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	1824	pI2cChannelConfig->deviceAddress);
Vkadaba	23:bb685f35b08b	1825	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1826	ADMW_LOG_ERROR("Failed to set I2C sensor address for channel %d",
Vkadaba	23:bb685f35b08b	1827	eChannelId);
ADIJake	0:85855ecd3257	1828	return eRet;
ADIJake	0:85855ecd3257	1829	}
ADIJake	0:85855ecd3257	1830
Vkadaba	5:0728bde67bdb	1831	eRet = admw_SetChannelDigitalSensorDetails(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	1832	pChannelConfig);
Vkadaba	23:bb685f35b08b	1833	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1834	ADMW_LOG_ERROR("Failed to set I2C sensor details for channel %d",
Vkadaba	23:bb685f35b08b	1835	eChannelId);
ADIJake	0:85855ecd3257	1836	return eRet;
ADIJake	0:85855ecd3257	1837	}
ADIJake	0:85855ecd3257	1838
Vkadaba	5:0728bde67bdb	1839	eRet = admw_SetDigitalSensorFormat(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	1840	&pI2cChannelConfig->dataFormat);
Vkadaba	23:bb685f35b08b	1841	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1842	ADMW_LOG_ERROR("Failed to set I2C sensor data format for channel %d",
Vkadaba	23:bb685f35b08b	1843	eChannelId);
ADIJake	0:85855ecd3257	1844	return eRet;
ADIJake	0:85855ecd3257	1845	}
ADIJake	0:85855ecd3257	1846
ADIJake	0:85855ecd3257	1847
Vkadaba	5:0728bde67bdb	1848	eRet = admw_SetDigitalChannelComms(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	1849	&pI2cChannelConfig->configureComms);
Vkadaba	23:bb685f35b08b	1850	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1851	ADMW_LOG_ERROR("Failed to set I2C comms for channel %d",
Vkadaba	23:bb685f35b08b	1852	eChannelId);
ADIJake	0:85855ecd3257	1853	return eRet;
ADIJake	0:85855ecd3257	1854	}
ADIJake	0:85855ecd3257	1855
Vkadaba	5:0728bde67bdb	1856	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1857	}
ADIJake	0:85855ecd3257	1858
Vkadaba	5:0728bde67bdb	1859	static ADMW_RESULT admw_SetChannelSpiSensorType(
Vkadaba	5:0728bde67bdb	1860	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1861	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1862	ADMW1001_SPI_SENSOR_TYPE sensorType)
ADIJake	0:85855ecd3257	1863	{
Vkadaba	8:2f2775c34640	1864	ADMW_CORE_Sensor_Type_t sensorTypeReg;
ADIJake	0:85855ecd3257	1865
ADIJake	0:85855ecd3257	1866	sensorTypeReg.VALUE16 = REG_RESET_VAL(CORE_SENSOR_TYPEn);
ADIJake	0:85855ecd3257	1867
ADIJake	0:85855ecd3257	1868	/* Ensure that the sensor type is valid for this channel */
Vkadaba	23:bb685f35b08b	1869	switch(sensorType) {
Vkadaba	58:aa9cd5072f66	1870	case ADMW1001_SPI_SENSOR:
Vkadaba	23:bb685f35b08b	1871
Vkadaba	23:bb685f35b08b	1872	sensorTypeReg.Sensor_Type = sensorType;
Vkadaba	23:bb685f35b08b	1873	break;
Vkadaba	23:bb685f35b08b	1874	default:
Vkadaba	23:bb685f35b08b	1875	ADMW_LOG_ERROR("Unsupported SPI sensor type %d specified", sensorType);
Vkadaba	23:bb685f35b08b	1876	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1877	}
ADIJake	0:85855ecd3257	1878
ADIJake	0:85855ecd3257	1879	WRITE_REG_U16(hDevice, sensorTypeReg.VALUE16, CORE_SENSOR_TYPEn(eChannelId));
ADIJake	0:85855ecd3257	1880
Vkadaba	5:0728bde67bdb	1881	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1882	}
ADIJake	0:85855ecd3257	1883
ADIJake	0:85855ecd3257	1884
Vkadaba	5:0728bde67bdb	1885	ADMW_RESULT admw1001_SetChannelThresholdLimits(
Vkadaba	5:0728bde67bdb	1886	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1887	ADMW1001_CH_ID eChannelId,
ADIJake	0:85855ecd3257	1888	float32_t fHighThresholdLimit,
ADIJake	0:85855ecd3257	1889	float32_t fLowThresholdLimit)
ADIJake	0:85855ecd3257	1890	{
ADIJake	0:85855ecd3257	1891	/*
ADIJake	0:85855ecd3257	1892	* If the low/high limits are both set to 0 in memory, or NaNs, assume
ADIJake	0:85855ecd3257	1893	* that they are unset, or not required, and use infinity defaults instead
ADIJake	0:85855ecd3257	1894	*/
Vkadaba	23:bb685f35b08b	1895	if (fHighThresholdLimit == 0.0f && fLowThresholdLimit == 0.0f) {
ADIJake	0:85855ecd3257	1896	fHighThresholdLimit = INFINITY;
ADIJake	0:85855ecd3257	1897	fLowThresholdLimit = -INFINITY;
Vkadaba	23:bb685f35b08b	1898	} else {
ADIJake	0:85855ecd3257	1899	if (isnan(fHighThresholdLimit))
ADIJake	0:85855ecd3257	1900	fHighThresholdLimit = INFINITY;
ADIJake	0:85855ecd3257	1901	if (isnan(fLowThresholdLimit))
ADIJake	0:85855ecd3257	1902	fLowThresholdLimit = -INFINITY;
ADIJake	0:85855ecd3257	1903	}
ADIJake	0:85855ecd3257	1904
ADIJake	0:85855ecd3257	1905	WRITE_REG_FLOAT(hDevice, fHighThresholdLimit,
ADIJake	0:85855ecd3257	1906	CORE_HIGH_THRESHOLD_LIMITn(eChannelId));
ADIJake	0:85855ecd3257	1907	WRITE_REG_FLOAT(hDevice, fLowThresholdLimit,
ADIJake	0:85855ecd3257	1908	CORE_LOW_THRESHOLD_LIMITn(eChannelId));
ADIJake	0:85855ecd3257	1909
Vkadaba	5:0728bde67bdb	1910	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1911	}
ADIJake	0:85855ecd3257	1912
Vkadaba	5:0728bde67bdb	1913	ADMW_RESULT admw1001_SetOffsetGain(
Vkadaba	5:0728bde67bdb	1914	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1915	ADMW1001_CH_ID eChannelId,
ADIJake	0:85855ecd3257	1916	float32_t fOffsetAdjustment,
ADIJake	0:85855ecd3257	1917	float32_t fGainAdjustment)
ADIJake	0:85855ecd3257	1918	{
ADIJake	0:85855ecd3257	1919	/* Replace with default values if NaNs are specified (or 0.0 for gain) */
ADIJake	0:85855ecd3257	1920	if (isnan(fGainAdjustment) \|\| (fGainAdjustment == 0.0f))
ADIJake	0:85855ecd3257	1921	fGainAdjustment = 1.0f;
ADIJake	0:85855ecd3257	1922	if (isnan(fOffsetAdjustment))
ADIJake	0:85855ecd3257	1923	fOffsetAdjustment = 0.0f;
ADIJake	0:85855ecd3257	1924
ADIJake	0:85855ecd3257	1925	WRITE_REG_FLOAT(hDevice, fGainAdjustment, CORE_SENSOR_GAINn(eChannelId));
ADIJake	0:85855ecd3257	1926	WRITE_REG_FLOAT(hDevice, fOffsetAdjustment, CORE_SENSOR_OFFSETn(eChannelId));
ADIJake	0:85855ecd3257	1927
Vkadaba	5:0728bde67bdb	1928	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1929	}
ADIJake	0:85855ecd3257	1930
Vkadaba	5:0728bde67bdb	1931	ADMW_RESULT admw1001_SetSensorParameter(
Vkadaba	5:0728bde67bdb	1932	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1933	ADMW1001_CH_ID eChannelId,
ADIJake	0:85855ecd3257	1934	float32_t fSensorParam)
ADIJake	0:85855ecd3257	1935	{
ADIJake	0:85855ecd3257	1936	if (fSensorParam == 0.0f)
ADIJake	0:85855ecd3257	1937	fSensorParam = NAN;
ADIJake	0:85855ecd3257	1938
Vkadaba	32:52445bef314d	1939	//WRITE_REG_FLOAT(hDevice, fSensorParam, CORE_SENSOR_PARAMETERn(eChannelId));
ADIJake	0:85855ecd3257	1940
Vkadaba	5:0728bde67bdb	1941	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1942	}
ADIJake	0:85855ecd3257	1943
Vkadaba	5:0728bde67bdb	1944	ADMW_RESULT admw1001_SetChannelSettlingTime(
Vkadaba	5:0728bde67bdb	1945	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1946	ADMW1001_CH_ID eChannelId,
ADIJake	0:85855ecd3257	1947	uint32_t nSettlingTime)
ADIJake	0:85855ecd3257	1948	{
Vkadaba	8:2f2775c34640	1949	ADMW_CORE_Settling_Time_t settlingTimeReg;
ADIJake	0:85855ecd3257	1950
ADIJake	0:85855ecd3257	1951	CHECK_REG_FIELD_VAL(CORE_SETTLING_TIME_SETTLING_TIME, nSettlingTime);
ADIJake	0:85855ecd3257	1952	settlingTimeReg.Settling_Time = nSettlingTime;
ADIJake	0:85855ecd3257	1953
ADIJake	0:85855ecd3257	1954	WRITE_REG_U16(hDevice, settlingTimeReg.VALUE16, CORE_SETTLING_TIMEn(eChannelId));
ADIJake	0:85855ecd3257	1955
Vkadaba	5:0728bde67bdb	1956	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1957	}
ADIJake	0:85855ecd3257	1958
Vkadaba	5:0728bde67bdb	1959	ADMW_RESULT admw1001_SetChannelConfig(
Vkadaba	5:0728bde67bdb	1960	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1961	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1962	ADMW1001_CHANNEL_CONFIG *pChannelConfig)
ADIJake	0:85855ecd3257	1963	{
Vkadaba	5:0728bde67bdb	1964	ADMW_RESULT eRet;
Vkadaba	5:0728bde67bdb	1965
Vkadaba	5:0728bde67bdb	1966	eRet = admw1001_SetChannelCount(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	1967	pChannelConfig->enableChannel ?
Vkadaba	23:bb685f35b08b	1968	pChannelConfig->measurementsPerCycle : 0);
Vkadaba	23:bb685f35b08b	1969	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1970	ADMW_LOG_ERROR("Failed to set measurement count for channel %d",
Vkadaba	23:bb685f35b08b	1971	eChannelId);
ADIJake	0:85855ecd3257	1972	return eRet;
ADIJake	0:85855ecd3257	1973	}
ADIJake	0:85855ecd3257	1974
Vkadaba	5:0728bde67bdb	1975	eRet = admw1001_SetChannelOptions(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	1976	pChannelConfig->priority);
Vkadaba	23:bb685f35b08b	1977	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1978	ADMW_LOG_ERROR("Failed to set priority for channel %d",
Vkadaba	23:bb685f35b08b	1979	eChannelId);
ADIJake	0:85855ecd3257	1980	return eRet;
ADIJake	0:85855ecd3257	1981	}
ADIJake	0:85855ecd3257	1982
ADIJake	0:85855ecd3257	1983	/* If the channel is not enabled, we can skip the following steps */
Vkadaba	23:bb685f35b08b	1984	if (pChannelConfig->enableChannel) {
Vkadaba	5:0728bde67bdb	1985	eRet = admw1001_SetChannelSkipCount(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	1986	pChannelConfig->cycleSkipCount);
Vkadaba	23:bb685f35b08b	1987	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1988	ADMW_LOG_ERROR("Failed to set cycle skip count for channel %d",
Vkadaba	23:bb685f35b08b	1989	eChannelId);
ADIJake	0:85855ecd3257	1990	return eRet;
ADIJake	0:85855ecd3257	1991	}
ADIJake	0:85855ecd3257	1992
Vkadaba	23:bb685f35b08b	1993	switch (eChannelId) {
Vkadaba	23:bb685f35b08b	1994	case ADMW1001_CH_ID_ANLG_1_UNIVERSAL:
Vkadaba	23:bb685f35b08b	1995	case ADMW1001_CH_ID_ANLG_2_UNIVERSAL:
Vkadaba	23:bb685f35b08b	1996	case ADMW1001_CH_ID_ANLG_1_DIFFERENTIAL:
Vkadaba	23:bb685f35b08b	1997	case ADMW1001_CH_ID_ANLG_2_DIFFERENTIAL:
Vkadaba	23:bb685f35b08b	1998	eRet = admw_SetAdcChannelConfig(hDevice, eChannelId, pChannelConfig);
Vkadaba	23:bb685f35b08b	1999	break;
Vkadaba	23:bb685f35b08b	2000	case ADMW1001_CH_ID_DIG_I2C_0:
Vkadaba	23:bb685f35b08b	2001	case ADMW1001_CH_ID_DIG_I2C_1:
Vkadaba	23:bb685f35b08b	2002	eRet = admw_SetI2cChannelConfig(hDevice, eChannelId, pChannelConfig);
Vkadaba	23:bb685f35b08b	2003	break;
Vkadaba	23:bb685f35b08b	2004	default:
Vkadaba	23:bb685f35b08b	2005	ADMW_LOG_ERROR("Invalid channel ID %d specified", eChannelId);
Vkadaba	32:52445bef314d	2006	eRet = ADMW_INVALID_PARAM;
Vkadaba	32:52445bef314d	2007	#if 0
Vkadaba	32:52445bef314d	2008	/* when using i2c sensors there is an error ( dataformat->length=0)
Vkadaba	32:52445bef314d	2009	the code below catches this error and this causes further problems.*/
Vkadaba	32:52445bef314d	2010	break;
Vkadaba	32:52445bef314d	2011	}
Vkadaba	32:52445bef314d	2012	if (eRet != ADMW_SUCCESS) {
Vkadaba	32:52445bef314d	2013	ADMW_LOG_ERROR("Failed to set config for channel %d",
Vkadaba	32:52445bef314d	2014	eChannelId);
Vkadaba	32:52445bef314d	2015	return eRet;
Vkadaba	32:52445bef314d	2016	#endif
ADIJake	0:85855ecd3257	2017	}
ADIJake	0:85855ecd3257	2018
Vkadaba	5:0728bde67bdb	2019	eRet = admw1001_SetChannelSettlingTime(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	2020	pChannelConfig->extraSettlingTime);
Vkadaba	23:bb685f35b08b	2021	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	2022	ADMW_LOG_ERROR("Failed to set settling time for channel %d",
Vkadaba	23:bb685f35b08b	2023	eChannelId);
ADIJake	0:85855ecd3257	2024	return eRet;
ADIJake	0:85855ecd3257	2025	}
ADIJake	0:85855ecd3257	2026	}
ADIJake	0:85855ecd3257	2027
Vkadaba	23:bb685f35b08b	2028	if (pChannelConfig->enableChannel) {
ADIJake	0:85855ecd3257	2029	/* Threshold limits can be configured individually for virtual channels */
Vkadaba	5:0728bde67bdb	2030	eRet = admw1001_SetChannelThresholdLimits(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	2031	pChannelConfig->highThreshold,
Vkadaba	23:bb685f35b08b	2032	pChannelConfig->lowThreshold);
Vkadaba	23:bb685f35b08b	2033	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	2034	ADMW_LOG_ERROR("Failed to set threshold limits for channel %d",
Vkadaba	23:bb685f35b08b	2035	eChannelId);
ADIJake	0:85855ecd3257	2036	return eRet;
ADIJake	0:85855ecd3257	2037	}
ADIJake	0:85855ecd3257	2038
ADIJake	0:85855ecd3257	2039	/* Offset and gain can be configured individually for virtual channels */
Vkadaba	5:0728bde67bdb	2040	eRet = admw1001_SetOffsetGain(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	2041	pChannelConfig->offsetAdjustment,
Vkadaba	23:bb685f35b08b	2042	pChannelConfig->gainAdjustment);
Vkadaba	23:bb685f35b08b	2043	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	2044	ADMW_LOG_ERROR("Failed to set offset/gain for channel %d",
Vkadaba	23:bb685f35b08b	2045	eChannelId);
ADIJake	0:85855ecd3257	2046	return eRet;
ADIJake	0:85855ecd3257	2047	}
ADIJake	0:85855ecd3257	2048
ADIJake	0:85855ecd3257	2049	/* Set sensor specific parameter */
Vkadaba	5:0728bde67bdb	2050	eRet = admw1001_SetSensorParameter(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	2051	pChannelConfig->sensorParameter);
Vkadaba	23:bb685f35b08b	2052	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	2053	ADMW_LOG_ERROR("Failed to set sensor parameter for channel %d",
Vkadaba	23:bb685f35b08b	2054	eChannelId);
ADIJake	0:85855ecd3257	2055	return eRet;
ADIJake	0:85855ecd3257	2056	}
ADIJake	0:85855ecd3257	2057	}
ADIJake	0:85855ecd3257	2058
Vkadaba	5:0728bde67bdb	2059	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	2060	}
ADIJake	0:85855ecd3257	2061
Vkadaba	5:0728bde67bdb	2062	ADMW_RESULT admw_SetConfig(
Vkadaba	5:0728bde67bdb	2063	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	5:0728bde67bdb	2064	ADMW_CONFIG * const pConfig)
ADIJake	0:85855ecd3257	2065	{
Vkadaba	5:0728bde67bdb	2066	ADMW1001_CONFIG *pDeviceConfig;
Vkadaba	5:0728bde67bdb	2067	ADMW_PRODUCT_ID productId;
Vkadaba	5:0728bde67bdb	2068	ADMW_RESULT eRet;
Vkadaba	5:0728bde67bdb	2069
Vkadaba	23:bb685f35b08b	2070	if (pConfig->productId != ADMW_PRODUCT_ID_ADMW1001) {
Vkadaba	5:0728bde67bdb	2071	ADMW_LOG_ERROR("Configuration Product ID (0x%X) is not supported (0x%0X)",
Vkadaba	23:bb685f35b08b	2072	pConfig->productId, ADMW_PRODUCT_ID_ADMW1001);
Vkadaba	5:0728bde67bdb	2073	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	2074	}
Vkadaba	23:bb685f35b08b	2075
Vkadaba	23:bb685f35b08b	2076	if (!((pConfig->versionId.major==VERSIONID_MAJOR) &&
Vkadaba	23:bb685f35b08b	2077	(pConfig->versionId.minor==VERSIONID_MINOR))) {
Vkadaba	23:bb685f35b08b	2078	ADMW_LOG_ERROR("Configuration Version ID (0x%X) is not supported",
Vkadaba	23:bb685f35b08b	2079	pConfig->versionId);
Vkadaba	6:9d393a9677f4	2080	return ADMW_INVALID_PARAM;
Vkadaba	6:9d393a9677f4	2081	}
Vkadaba	23:bb685f35b08b	2082
Vkadaba	23:bb685f35b08b	2083
ADIJake	0:85855ecd3257	2084	/* Check that the actual Product ID is a match? */
Vkadaba	5:0728bde67bdb	2085	eRet = admw_GetProductID(hDevice, &productId);
Vkadaba	23:bb685f35b08b	2086	if (eRet) {
Vkadaba	5:0728bde67bdb	2087	ADMW_LOG_ERROR("Failed to read device Product ID register");
ADIJake	0:85855ecd3257	2088	return eRet;
ADIJake	0:85855ecd3257	2089	}
Vkadaba	23:bb685f35b08b	2090	if (pConfig->productId != productId) {
Vkadaba	5:0728bde67bdb	2091	ADMW_LOG_ERROR("Configuration Product ID (0x%X) does not match device (0x%0X)",
Vkadaba	8:2f2775c34640	2092	pConfig->productId, productId);
Vkadaba	5:0728bde67bdb	2093	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	2094	}
ADIJake	0:85855ecd3257	2095
Vkadaba	5:0728bde67bdb	2096	pDeviceConfig = &pConfig->admw1001;
Vkadaba	5:0728bde67bdb	2097
Vkadaba	5:0728bde67bdb	2098	eRet = admw1001_SetPowerConfig(hDevice, &pDeviceConfig->power);
Vkadaba	23:bb685f35b08b	2099	if (eRet) {
Vkadaba	5:0728bde67bdb	2100	ADMW_LOG_ERROR("Failed to set power configuration");
ADIJake	0:85855ecd3257	2101	return eRet;
ADIJake	0:85855ecd3257	2102	}
ADIJake	0:85855ecd3257	2103
Vkadaba	5:0728bde67bdb	2104	eRet = admw1001_SetMeasurementConfig(hDevice, &pDeviceConfig->measurement);
Vkadaba	23:bb685f35b08b	2105	if (eRet) {
Vkadaba	5:0728bde67bdb	2106	ADMW_LOG_ERROR("Failed to set measurement configuration");
ADIJake	0:85855ecd3257	2107	return eRet;
ADIJake	0:85855ecd3257	2108	}
ADIJake	0:85855ecd3257	2109
Vkadaba	36:54e2418e7620	2110	eRet = admw1001_SetDiagnosticsConfig(hDevice, &pDeviceConfig->diagnostics);
Vkadaba	41:df78b7d7b675	2111	if (eRet) {
Vkadaba	36:54e2418e7620	2112	ADMW_LOG_ERROR("Failed to set diagnostics configuration");
Vkadaba	36:54e2418e7620	2113	return eRet;
Vkadaba	36:54e2418e7620	2114	}
ADIJake	0:85855ecd3257	2115
Vkadaba	8:2f2775c34640	2116	for (ADMW1001_CH_ID id = ADMW1001_CH_ID_ANLG_1_UNIVERSAL;
Vkadaba	23:bb685f35b08b	2117	id < ADMW1001_MAX_CHANNELS;
Vkadaba	23:bb685f35b08b	2118	id++) {
Vkadaba	5:0728bde67bdb	2119	eRet = admw1001_SetChannelConfig(hDevice, id,
Vkadaba	23:bb685f35b08b	2120	&pDeviceConfig->channels[id]);
Vkadaba	23:bb685f35b08b	2121	if (eRet) {
Vkadaba	5:0728bde67bdb	2122	ADMW_LOG_ERROR("Failed to set channel %d configuration", id);
ADIJake	0:85855ecd3257	2123	return eRet;
ADIJake	0:85855ecd3257	2124	}
ADIJake	0:85855ecd3257	2125	}
ADIJake	0:85855ecd3257	2126
Vkadaba	5:0728bde67bdb	2127	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	2128	}
ADIJake	0:85855ecd3257	2129
Vkadaba	50:d84305e5e1c0	2130
Vkadaba	5:0728bde67bdb	2131	ADMW_RESULT admw1001_SetLutDataRaw(
Vkadaba	5:0728bde67bdb	2132	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	5:0728bde67bdb	2133	ADMW1001_LUT_RAW * const pLutData)
ADIJake	0:85855ecd3257	2134	{
Vkadaba	5:0728bde67bdb	2135	return admw1001_SetLutData(hDevice,
Vkadaba	23:bb685f35b08b	2136	(ADMW1001_LUT *)pLutData);
ADIJake	0:85855ecd3257	2137	}
ADIJake	0:85855ecd3257	2138
Vkadaba	5:0728bde67bdb	2139	static ADMW_RESULT getLutTableSize(
Vkadaba	5:0728bde67bdb	2140	ADMW1001_LUT_DESCRIPTOR * const pDesc,
Vkadaba	5:0728bde67bdb	2141	ADMW1001_LUT_TABLE_DATA * const pData,
ADIJake	0:85855ecd3257	2142	unsigned *pLength)
ADIJake	0:85855ecd3257	2143	{
Vkadaba	23:bb685f35b08b	2144	switch (pDesc->geometry) {
Vkadaba	23:bb685f35b08b	2145	case ADMW1001_LUT_GEOMETRY_NES_1D:
Vkadaba	23:bb685f35b08b	2146	*pLength = ADMW1001_LUT_1D_NES_SIZE(pData->lut1dNes);
Vkadaba	23:bb685f35b08b	2147	break;
Vkadaba	23:bb685f35b08b	2148	default:
Vkadaba	23:bb685f35b08b	2149	ADMW_LOG_ERROR("Invalid LUT table geometry %d specified\r\n",
Vkadaba	23:bb685f35b08b	2150	pDesc->geometry);
Vkadaba	23:bb685f35b08b	2151	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	2152	}
ADIJake	0:85855ecd3257	2153
Vkadaba	5:0728bde67bdb	2154	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	2155	}
ADIJake	0:85855ecd3257	2156
Vkadaba	5:0728bde67bdb	2157	ADMW_RESULT admw1001_AssembleLutData(
Vkadaba	5:0728bde67bdb	2158	ADMW1001_LUT * pLutBuffer,
ADIJake	0:85855ecd3257	2159	unsigned nLutBufferSize,
ADIJake	0:85855ecd3257	2160	unsigned const nNumTables,
Vkadaba	5:0728bde67bdb	2161	ADMW1001_LUT_DESCRIPTOR * const ppDesc[],
Vkadaba	5:0728bde67bdb	2162	ADMW1001_LUT_TABLE_DATA * const ppData[])
ADIJake	0:85855ecd3257	2163	{
Vkadaba	5:0728bde67bdb	2164	ADMW1001_LUT_HEADER *pHdr = &pLutBuffer->header;
ADIJake	0:85855ecd3257	2165	uint8_t pLutTableData = (uint8_t )pLutBuffer + sizeof(*pHdr);
ADIJake	0:85855ecd3257	2166
Vkadaba	61:0f16a2e3b58b	2167	if (sizeof(*pHdr) > nLutBufferSize)
Vkadaba	61:0f16a2e3b58b	2168	{
Vkadaba	5:0728bde67bdb	2169	ADMW_LOG_ERROR("Insufficient LUT buffer size provided");
Vkadaba	5:0728bde67bdb	2170	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	2171	}
ADIJake	0:85855ecd3257	2172
ADIJake	0:85855ecd3257	2173	/* First initialise the top-level header */
Vkadaba	5:0728bde67bdb	2174	pHdr->signature = ADMW_LUT_SIGNATURE;
ADIJake	0:85855ecd3257	2175	pHdr->version.major = 1;
ADIJake	0:85855ecd3257	2176	pHdr->version.minor = 0;
ADIJake	0:85855ecd3257	2177	pHdr->numTables = 0;
ADIJake	0:85855ecd3257	2178	pHdr->totalLength = 0;
ADIJake	0:85855ecd3257	2179
ADIJake	0:85855ecd3257	2180	/*
ADIJake	0:85855ecd3257	2181	* Walk through the list of table pointers provided, appending the table
ADIJake	0:85855ecd3257	2182	* descriptor+data from each one to the provided LUT buffer
ADIJake	0:85855ecd3257	2183	*/
Vkadaba	61:0f16a2e3b58b	2184	for (unsigned i = 0; i < nNumTables; i++)
Vkadaba	61:0f16a2e3b58b	2185	{
Vkadaba	5:0728bde67bdb	2186	ADMW1001_LUT_DESCRIPTOR * const pDesc = ppDesc[i];
Vkadaba	5:0728bde67bdb	2187	ADMW1001_LUT_TABLE_DATA * const pData = ppData[i];
Vkadaba	5:0728bde67bdb	2188	ADMW_RESULT res;
ADIJake	0:85855ecd3257	2189	unsigned dataLength = 0;
ADIJake	0:85855ecd3257	2190
ADIJake	0:85855ecd3257	2191	/* Calculate the length of the table data */
ADIJake	0:85855ecd3257	2192	res = getLutTableSize(pDesc, pData, &dataLength);
Vkadaba	5:0728bde67bdb	2193	if (res != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	2194	return res;
ADIJake	0:85855ecd3257	2195
ADIJake	0:85855ecd3257	2196	/* Fill in the table descriptor length and CRC fields */
ADIJake	0:85855ecd3257	2197	pDesc->length = dataLength;
ADIJake	0:85855ecd3257	2198
Vkadaba	61:0f16a2e3b58b	2199	if ((sizeof(pHdr) + pHdr->totalLength + sizeof(pDesc) + dataLength) > nLutBufferSize)
Vkadaba	61:0f16a2e3b58b	2200	{
Vkadaba	5:0728bde67bdb	2201	ADMW_LOG_ERROR("Insufficient LUT buffer size provided");
Vkadaba	5:0728bde67bdb	2202	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	2203	}
ADIJake	0:85855ecd3257	2204
ADIJake	0:85855ecd3257	2205	/* Append the table to the LUT buffer (desc + data) */
ADIJake	0:85855ecd3257	2206	memcpy(pLutTableData + pHdr->totalLength, pDesc, sizeof(*pDesc));
ADIJake	0:85855ecd3257	2207	pHdr->totalLength += sizeof(*pDesc);
ADIJake	0:85855ecd3257	2208	memcpy(pLutTableData + pHdr->totalLength, pData, dataLength);
ADIJake	0:85855ecd3257	2209	pHdr->totalLength += dataLength;
ADIJake	0:85855ecd3257	2210
ADIJake	0:85855ecd3257	2211	pHdr->numTables++;
ADIJake	0:85855ecd3257	2212	}
ADIJake	0:85855ecd3257	2213
Vkadaba	5:0728bde67bdb	2214	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	2215	}
Vkadaba	54:31921ad29828	2216	ADMW_RESULT admw1001_SetLutData(
Vkadaba	54:31921ad29828	2217	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	54:31921ad29828	2218	ADMW1001_LUT * const pLutData)
Vkadaba	54:31921ad29828	2219	{
Vkadaba	61:0f16a2e3b58b	2220	#pragma diag_suppress=Pa039
Vkadaba	54:31921ad29828	2221	ADMW1001_LUT_HEADER *pLutHeader = &pLutData->header;
Vkadaba	54:31921ad29828	2222	ADMW1001_LUT_TABLE *pLutTable = pLutData->tables;
Vkadaba	54:31921ad29828	2223
Vkadaba	54:31921ad29828	2224	unsigned actualLength = 0;
Vkadaba	54:31921ad29828	2225
Vkadaba	61:0f16a2e3b58b	2226	if (pLutData->header.signature != ADMW_LUT_SIGNATURE)
Vkadaba	61:0f16a2e3b58b	2227	{
Vkadaba	54:31921ad29828	2228	ADMW_LOG_ERROR("LUT signature incorrect (expected 0x%X, actual 0x%X)",
Vkadaba	61:0f16a2e3b58b	2229	ADMW_LUT_SIGNATURE, pLutHeader->signature);
Vkadaba	54:31921ad29828	2230	return ADMW_INVALID_SIGNATURE;
Vkadaba	54:31921ad29828	2231	}
Vkadaba	54:31921ad29828	2232	if ((pLutData->tables->descriptor.geometry!= ADMW1001_LUT_GEOMETRY_NES_1D) &&
Vkadaba	61:0f16a2e3b58b	2233	(pLutData->tables->data.lut1dNes.nElements > MAX_LUT_NUM_ENTRIES))
Vkadaba	61:0f16a2e3b58b	2234	{
Vkadaba	54:31921ad29828	2235	return ADMW_INVALID_PARAM;
Vkadaba	54:31921ad29828	2236	}
Vkadaba	61:0f16a2e3b58b	2237	for (unsigned i = 0; i < pLutHeader->numTables; i++)
Vkadaba	61:0f16a2e3b58b	2238	{
Vkadaba	54:31921ad29828	2239	ADMW1001_LUT_DESCRIPTOR *pDesc = &pLutTable->descriptor;
Vkadaba	54:31921ad29828	2240
Vkadaba	61:0f16a2e3b58b	2241	switch (pDesc->geometry)
Vkadaba	61:0f16a2e3b58b	2242	{
Vkadaba	61:0f16a2e3b58b	2243	case ADMW1001_LUT_GEOMETRY_COEFFS:
Vkadaba	61:0f16a2e3b58b	2244	switch (pDesc->equation)
Vkadaba	61:0f16a2e3b58b	2245	{
Vkadaba	61:0f16a2e3b58b	2246	case ADMW1001_LUT_EQUATION_POLYN:
Vkadaba	61:0f16a2e3b58b	2247	case ADMW1001_LUT_EQUATION_POLYNEXP:
Vkadaba	61:0f16a2e3b58b	2248	case ADMW1001_LUT_EQUATION_QUADRATIC:
Vkadaba	61:0f16a2e3b58b	2249	case ADMW1001_LUT_EQUATION_STEINHART:
Vkadaba	61:0f16a2e3b58b	2250	case ADMW1001_LUT_EQUATION_LOGARITHMIC:
Vkadaba	61:0f16a2e3b58b	2251	case ADMW1001_LUT_EQUATION_BIVARIATE_POLYN:
Vkadaba	61:0f16a2e3b58b	2252	break;
Vkadaba	61:0f16a2e3b58b	2253	default:
Vkadaba	61:0f16a2e3b58b	2254	ADMW_LOG_ERROR("Invalid equation %u specified for LUT table %u",
Vkadaba	61:0f16a2e3b58b	2255	pDesc->equation, i);
Vkadaba	61:0f16a2e3b58b	2256	return ADMW_INVALID_PARAM;
Vkadaba	55:215da406282b	2257	}
Vkadaba	61:0f16a2e3b58b	2258	break;
Vkadaba	61:0f16a2e3b58b	2259	case ADMW1001_LUT_GEOMETRY_NES_1D:
Vkadaba	61:0f16a2e3b58b	2260	break;
Vkadaba	61:0f16a2e3b58b	2261	default:
Vkadaba	61:0f16a2e3b58b	2262	ADMW_LOG_ERROR("Invalid geometry %u specified for LUT table %u",
Vkadaba	61:0f16a2e3b58b	2263	pDesc->geometry, i);
Vkadaba	61:0f16a2e3b58b	2264	return ADMW_INVALID_PARAM;
Vkadaba	54:31921ad29828	2265	}
Vkadaba	54:31921ad29828	2266
Vkadaba	61:0f16a2e3b58b	2267	switch (pDesc->dataType)
Vkadaba	61:0f16a2e3b58b	2268	{
Vkadaba	61:0f16a2e3b58b	2269	case ADMW1001_LUT_DATA_TYPE_FLOAT32:
Vkadaba	61:0f16a2e3b58b	2270	case ADMW1001_LUT_DATA_TYPE_FLOAT64:
Vkadaba	61:0f16a2e3b58b	2271	break;
Vkadaba	61:0f16a2e3b58b	2272	default:
Vkadaba	61:0f16a2e3b58b	2273	ADMW_LOG_ERROR("Invalid vector format %u specified for LUT table %u",
Vkadaba	61:0f16a2e3b58b	2274	pDesc->dataType, i);
Vkadaba	61:0f16a2e3b58b	2275	return ADMW_INVALID_PARAM;
Vkadaba	54:31921ad29828	2276	}
Vkadaba	54:31921ad29828	2277
Vkadaba	54:31921ad29828	2278
Vkadaba	54:31921ad29828	2279	actualLength += sizeof(*pDesc) + pDesc->length;
Vkadaba	54:31921ad29828	2280
Vkadaba	54:31921ad29828	2281	/* Move to the next look-up table */
Vkadaba	54:31921ad29828	2282	pLutTable = (ADMW1001_LUT_TABLE )((uint8_t )pLutTable + sizeof(*pDesc) + pDesc->length);
Vkadaba	54:31921ad29828	2283	}
Vkadaba	54:31921ad29828	2284
Vkadaba	61:0f16a2e3b58b	2285	if (actualLength != pLutHeader->totalLength)
Vkadaba	61:0f16a2e3b58b	2286	{
Vkadaba	54:31921ad29828	2287	ADMW_LOG_ERROR("LUT table length mismatch (expected %u, actual %u)",
Vkadaba	61:0f16a2e3b58b	2288	pLutHeader->totalLength, actualLength);
Vkadaba	54:31921ad29828	2289	return ADMW_WRONG_SIZE;
Vkadaba	54:31921ad29828	2290	}
Vkadaba	54:31921ad29828	2291
Vkadaba	61:0f16a2e3b58b	2292	if (sizeof(*pLutHeader) + pLutHeader->totalLength > ADMW_LUT_MAX_SIZE)
Vkadaba	61:0f16a2e3b58b	2293	{
Vkadaba	54:31921ad29828	2294	ADMW_LOG_ERROR("Maximum LUT table length (%u bytes) exceeded",
Vkadaba	61:0f16a2e3b58b	2295	ADMW_LUT_MAX_SIZE);
Vkadaba	54:31921ad29828	2296	return ADMW_WRONG_SIZE;
Vkadaba	54:31921ad29828	2297	}
Vkadaba	54:31921ad29828	2298
Vkadaba	54:31921ad29828	2299	/* Write the LUT data to the device */
Vkadaba	54:31921ad29828	2300	unsigned lutSize = sizeof(*pLutHeader) + pLutHeader->totalLength;
Vkadaba	54:31921ad29828	2301	WRITE_REG_U16(hDevice, 0, CORE_LUT_OFFSET);
Vkadaba	54:31921ad29828	2302	WRITE_REG_U8_ARRAY(hDevice, (uint8_t *)pLutData, lutSize, CORE_LUT_DATA);
Vkadaba	54:31921ad29828	2303
Vkadaba	54:31921ad29828	2304	return ADMW_SUCCESS;
Vkadaba	54:31921ad29828	2305	}

Repository toolbox

Export to desktop IDE

Build repository

Repository details

Type:	Program
Mbed OS support:	Mbed OS
Created:	26 Feb 2020
Imports:	52
Forks:	0
Commits:	80
Dependents:	0
Dependencies:	0
Followers:	10

src/admw_1001.c@63:2655a04c00f5, 2020-04-14 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning