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

Users » Vkadaba » Code » EV-PRO-MW1001_Development

Vybhav Kadaba / Mbed OS EV-PRO-MW1001_Development

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

src/admw_1001.c@55:215da406282b, 2020-02-24 (annotated)

Committer:: Vkadaba
Date:: Mon Feb 24 07:04:35 2020 +0000
Revision:: 55:215da406282b
Parent:: 54:31921ad29828
Child:: 56:38b36e947602

Added readMbedVersion functionality

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

Repository toolbox

Export to desktop IDE

Build repository

Repository details

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

src/admw_1001.c@55:215da406282b, 2020-02-24 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning