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@33:df7a00f1b8e1, 2019-11-14 (annotated)

Committer:: Vkadaba
Date:: Thu Nov 14 05:35:08 2019 +0000
Revision:: 33:df7a00f1b8e1
Parent:: 32:52445bef314d
Child:: 36:54e2418e7620

Added support for the following:; 1.Rsense; 2.Excitation current state; 3.Buffer bypass ; ; the aobve support is only for analog sensors.; Tested and the system is working fine

Who changed what in which revision?

User	Revision	Line number	New contents of line
ADIJake	0:85855ecd3257	1	/*
Vkadaba	8:2f2775c34640	2	Copyright 2019 (c) Analog Devices, Inc.
ADIJake	0:85855ecd3257	3
ADIJake	0:85855ecd3257	4	All rights reserved.
ADIJake	0:85855ecd3257	5
ADIJake	0:85855ecd3257	6	Redistribution and use in source and binary forms, with or without
ADIJake	0:85855ecd3257	7	modification, are permitted provided that the following conditions are met:
ADIJake	0:85855ecd3257	8	- Redistributions of source code must retain the above copyright
ADIJake	0:85855ecd3257	9	notice, this list of conditions and the following disclaimer.
ADIJake	0:85855ecd3257	10	- Redistributions in binary form must reproduce the above copyright
ADIJake	0:85855ecd3257	11	notice, this list of conditions and the following disclaimer in
ADIJake	0:85855ecd3257	12	the documentation and/or other materials provided with the
ADIJake	0:85855ecd3257	13	distribution.
ADIJake	0:85855ecd3257	14	- Neither the name of Analog Devices, Inc. nor the names of its
ADIJake	0:85855ecd3257	15	contributors may be used to endorse or promote products derived
ADIJake	0:85855ecd3257	16	from this software without specific prior written permission.
ADIJake	0:85855ecd3257	17	- The use of this software may or may not infringe the patent rights
ADIJake	0:85855ecd3257	18	of one or more patent holders. This license does not release you
ADIJake	0:85855ecd3257	19	from the requirement that you obtain separate licenses from these
ADIJake	0:85855ecd3257	20	patent holders to use this software.
ADIJake	0:85855ecd3257	21	- Use of the software either in source or binary form, must be run
ADIJake	0:85855ecd3257	22	on or directly connected to an Analog Devices Inc. component.
ADIJake	0:85855ecd3257	23
ADIJake	0:85855ecd3257	24	THIS SOFTWARE IS PROVIDED BY ANALOG DEVICES "AS IS" AND ANY EXPRESS OR
ADIJake	0:85855ecd3257	25	IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, NON-INFRINGEMENT,
ADIJake	0:85855ecd3257	26	MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
ADIJake	0:85855ecd3257	27	IN NO EVENT SHALL ANALOG DEVICES BE LIABLE FOR ANY DIRECT, INDIRECT,
ADIJake	0:85855ecd3257	28	INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
ADIJake	0:85855ecd3257	29	LIMITED TO, INTELLECTUAL PROPERTY RIGHTS, PROCUREMENT OF SUBSTITUTE GOODS OR
ADIJake	0:85855ecd3257	30	SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
ADIJake	0:85855ecd3257	31	CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
ADIJake	0:85855ecd3257	32	OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
ADIJake	0:85855ecd3257	33	OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
ADIJake	0:85855ecd3257	34	*/
ADIJake	0:85855ecd3257	35
ADIJake	0:85855ecd3257	36	/*!
ADIJake	0:85855ecd3257	37	******************************************************************************
ADIJake	0:85855ecd3257	38	* @file:
Vkadaba	8:2f2775c34640	39	* @brief: API implementation for ADMW1001
ADIJake	0:85855ecd3257	40	*-----------------------------------------------------------------------------
ADIJake	0:85855ecd3257	41	*/
ADIJake	0:85855ecd3257	42
ADIJake	0:85855ecd3257	43	#include <float.h>
ADIJake	0:85855ecd3257	44	#include <math.h>
ADIJake	0:85855ecd3257	45	#include <string.h>
ADIJake	0:85855ecd3257	46
Vkadaba	5:0728bde67bdb	47	#include "admw_platform.h"
Vkadaba	5:0728bde67bdb	48	#include "admw_api.h"
Vkadaba	5:0728bde67bdb	49	#include "admw1001/admw1001_api.h"
Vkadaba	5:0728bde67bdb	50
Vkadaba	5:0728bde67bdb	51	#include "admw1001/ADMW1001_REGISTERS_typedefs.h"
Vkadaba	5:0728bde67bdb	52	#include "admw1001/ADMW1001_REGISTERS.h"
Vkadaba	5:0728bde67bdb	53	#include "admw1001/admw1001_lut_data.h"
Vkadaba	5:0728bde67bdb	54	#include "admw1001/admw1001_host_comms.h"
ADIJake	0:85855ecd3257	55
ADIJake	0:85855ecd3257	56	#include "crc16.h"
Vkadaba	13:97cb32670539	57	#define VERSIONID_MAJOR 2
Vkadaba	13:97cb32670539	58	#define VERSIONID_MINOR 0
ADIJake	0:85855ecd3257	59
ADIJake	0:85855ecd3257	60	uint32_t getDataCnt = 0;
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	32:52445bef314d	391	ADMW_RESULT 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	32:52445bef314d	404	ADMW_LOG_INFO("Firmware Version Id is %X.%X",nData[2],nData[0]);
Vkadaba	32:52445bef314d	405	}
Vkadaba	32:52445bef314d	406	return ADMW_SUCCESS;
Vkadaba	32:52445bef314d	407	}
Vkadaba	5:0728bde67bdb	408	static ADMW_RESULT executeCommand(
Vkadaba	5:0728bde67bdb	409	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	8:2f2775c34640	410	ADMW_CORE_Command_Special_Command const command,
ADIJake	0:85855ecd3257	411	bool const bWaitForCompletion)
ADIJake	0:85855ecd3257	412	{
Vkadaba	8:2f2775c34640	413	ADMW_CORE_Command_t commandReg;
ADIJake	0:85855ecd3257	414	bool bCommandRunning;
Vkadaba	5:0728bde67bdb	415	ADMW_RESULT eRet;
ADIJake	0:85855ecd3257	416
ADIJake	0:85855ecd3257	417	/*
ADIJake	0:85855ecd3257	418	* Don't allow another command to be issued if one is already running, but
Vkadaba	6:9d393a9677f4	419	* make an exception for ENUM_CORE_COMMAND_NOP which can be used to
ADIJake	0:85855ecd3257	420	* request a running command to be stopped (e.g. continuous measurement)
ADIJake	0:85855ecd3257	421	*/
Vkadaba	23:bb685f35b08b	422	if (command != ENUM_CORE_COMMAND_NOP) {
Vkadaba	5:0728bde67bdb	423	eRet = admw_GetCommandRunningState(hDevice, &bCommandRunning);
ADIJake	0:85855ecd3257	424	if (eRet)
ADIJake	0:85855ecd3257	425	return eRet;
ADIJake	0:85855ecd3257	426
ADIJake	0:85855ecd3257	427	if (bCommandRunning)
Vkadaba	5:0728bde67bdb	428	return ADMW_IN_USE;
ADIJake	0:85855ecd3257	429	}
ADIJake	0:85855ecd3257	430
ADIJake	0:85855ecd3257	431	commandReg.Special_Command = command;
ADIJake	0:85855ecd3257	432	WRITE_REG_U8(hDevice, commandReg.VALUE8, CORE_COMMAND);
ADIJake	0:85855ecd3257	433
Vkadaba	23:bb685f35b08b	434	if (bWaitForCompletion) {
ADIJake	0:85855ecd3257	435	do {
ADIJake	0:85855ecd3257	436	/* Allow a minimum 50usec delay for status update before checking */
Vkadaba	5:0728bde67bdb	437	admw_TimeDelayUsec(50);
Vkadaba	5:0728bde67bdb	438
Vkadaba	5:0728bde67bdb	439	eRet = admw_GetCommandRunningState(hDevice, &bCommandRunning);
ADIJake	0:85855ecd3257	440	if (eRet)
ADIJake	0:85855ecd3257	441	return eRet;
ADIJake	0:85855ecd3257	442	} while (bCommandRunning);
ADIJake	0:85855ecd3257	443	}
ADIJake	0:85855ecd3257	444
Vkadaba	5:0728bde67bdb	445	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	446	}
ADIJake	0:85855ecd3257	447
Vkadaba	5:0728bde67bdb	448	ADMW_RESULT admw_ApplyConfigUpdates(
Vkadaba	5:0728bde67bdb	449	ADMW_DEVICE_HANDLE const hDevice)
ADIJake	0:85855ecd3257	450	{
Vkadaba	5:0728bde67bdb	451	return executeCommand(hDevice, CORE_COMMAND_LATCH_CONFIG, true);
ADIJake	0:85855ecd3257	452	}
ADIJake	0:85855ecd3257	453
ADIJake	0:85855ecd3257	454	/*!
ADIJake	0:85855ecd3257	455	* @brief Start a measurement cycle.
ADIJake	0:85855ecd3257	456	*
ADIJake	0:85855ecd3257	457	* @param[out]
ADIJake	0:85855ecd3257	458	*
ADIJake	0:85855ecd3257	459	* @return Status
Vkadaba	5:0728bde67bdb	460	* - #ADMW_SUCCESS Call completed successfully.
Vkadaba	5:0728bde67bdb	461	* - #ADMW_FAILURE
ADIJake	0:85855ecd3257	462	*
ADIJake	0:85855ecd3257	463	* @details Sends the latch config command. Configuration for channels in
ADIJake	0:85855ecd3257	464	* conversion cycle should be completed before this function.
ADIJake	0:85855ecd3257	465	* Channel enabled bit should be set before this function.
ADIJake	0:85855ecd3257	466	* Starts a conversion and configures the format of the sample.
ADIJake	0:85855ecd3257	467	*
ADIJake	0:85855ecd3257	468	*/
Vkadaba	5:0728bde67bdb	469	ADMW_RESULT admw_StartMeasurement(
Vkadaba	5:0728bde67bdb	470	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	5:0728bde67bdb	471	ADMW_MEASUREMENT_MODE const eMeasurementMode)
ADIJake	0:85855ecd3257	472	{
Vkadaba	23:bb685f35b08b	473	switch (eMeasurementMode) {
Vkadaba	23:bb685f35b08b	474	case ADMW_MEASUREMENT_MODE_NORMAL:
Vkadaba	23:bb685f35b08b	475	return executeCommand(hDevice, CORE_COMMAND_CONVERT_WITH_RAW, false);
Vkadaba	23:bb685f35b08b	476	case ADMW_MEASUREMENT_MODE_OMIT_RAW:
Vkadaba	23:bb685f35b08b	477	return executeCommand(hDevice, CORE_COMMAND_CONVERT, false);
Vkadaba	23:bb685f35b08b	478	default:
Vkadaba	23:bb685f35b08b	479	ADMW_LOG_ERROR("Invalid measurement mode %d specified",
Vkadaba	23:bb685f35b08b	480	eMeasurementMode);
Vkadaba	23:bb685f35b08b	481	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	482	}
ADIJake	0:85855ecd3257	483	}
ADIJake	0:85855ecd3257	484
ADIJake	0:85855ecd3257	485	/*
ADIJake	0:85855ecd3257	486	* Store the configuration settings to persistent memory on the device.
ADIJake	0:85855ecd3257	487	* The settings can be saved to 4 different flash memory areas (slots).
ADIJake	0:85855ecd3257	488	* No other command must be running when this is called.
ADIJake	0:85855ecd3257	489	* Do not power down the device while this command is running.
ADIJake	0:85855ecd3257	490	*/
Vkadaba	5:0728bde67bdb	491	ADMW_RESULT admw_SaveConfig(
Vkadaba	5:0728bde67bdb	492	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	5:0728bde67bdb	493	ADMW_USER_CONFIG_SLOT const eSlotId)
ADIJake	0:85855ecd3257	494	{
Vkadaba	23:bb685f35b08b	495	switch (eSlotId) {
Vkadaba	5:0728bde67bdb	496	case ADMW_FLASH_CONFIG_1:
Vkadaba	5:0728bde67bdb	497	return executeCommand(hDevice, CORE_COMMAND_SAVE_CONFIG_1, true);
ADIJake	0:85855ecd3257	498	default:
Vkadaba	5:0728bde67bdb	499	ADMW_LOG_ERROR("Invalid user config target slot %d specified",
Vkadaba	23:bb685f35b08b	500	eSlotId);
Vkadaba	5:0728bde67bdb	501	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	502	}
ADIJake	0:85855ecd3257	503	}
ADIJake	0:85855ecd3257	504
ADIJake	0:85855ecd3257	505	/*
ADIJake	0:85855ecd3257	506	* Restore the configuration settings from persistent memory on the device.
ADIJake	0:85855ecd3257	507	* No other command must be running when this is called.
ADIJake	0:85855ecd3257	508	*/
Vkadaba	5:0728bde67bdb	509	ADMW_RESULT admw_RestoreConfig(
Vkadaba	5:0728bde67bdb	510	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	5:0728bde67bdb	511	ADMW_USER_CONFIG_SLOT const eSlotId)
ADIJake	0:85855ecd3257	512	{
Vkadaba	23:bb685f35b08b	513	switch (eSlotId) {
Vkadaba	5:0728bde67bdb	514	case ADMW_FLASH_CONFIG_1:
Vkadaba	5:0728bde67bdb	515	return executeCommand(hDevice, CORE_COMMAND_LOAD_CONFIG_1, true);
ADIJake	0:85855ecd3257	516	default:
Vkadaba	5:0728bde67bdb	517	ADMW_LOG_ERROR("Invalid user config source slot %d specified",
Vkadaba	23:bb685f35b08b	518	eSlotId);
Vkadaba	5:0728bde67bdb	519	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	520	}
ADIJake	0:85855ecd3257	521	}
ADIJake	0:85855ecd3257	522
ADIJake	0:85855ecd3257	523	/*
ADIJake	0:85855ecd3257	524	* Store the LUT data to persistent memory on the device.
ADIJake	0:85855ecd3257	525	* No other command must be running when this is called.
ADIJake	0:85855ecd3257	526	* Do not power down the device while this command is running.
ADIJake	0:85855ecd3257	527	*/
Vkadaba	5:0728bde67bdb	528	ADMW_RESULT admw_SaveLutData(
Vkadaba	5:0728bde67bdb	529	ADMW_DEVICE_HANDLE const hDevice)
ADIJake	0:85855ecd3257	530	{
Vkadaba	5:0728bde67bdb	531	return executeCommand(hDevice, CORE_COMMAND_SAVE_LUT, true);
ADIJake	0:85855ecd3257	532	}
ADIJake	0:85855ecd3257	533
ADIJake	0:85855ecd3257	534	/*
ADIJake	0:85855ecd3257	535	* Restore the LUT data from persistent memory on the device.
ADIJake	0:85855ecd3257	536	* No other command must be running when this is called.
ADIJake	0:85855ecd3257	537	*/
Vkadaba	5:0728bde67bdb	538	ADMW_RESULT admw_RestoreLutData(
Vkadaba	5:0728bde67bdb	539	ADMW_DEVICE_HANDLE const hDevice)
ADIJake	0:85855ecd3257	540	{
Vkadaba	5:0728bde67bdb	541	return executeCommand(hDevice, CORE_COMMAND_LOAD_LUT, true);
ADIJake	0:85855ecd3257	542	}
ADIJake	0:85855ecd3257	543
ADIJake	0:85855ecd3257	544	/*
ADIJake	0:85855ecd3257	545	* Stop the measurement cycles on the device.
ADIJake	0:85855ecd3257	546	* To be used only if a measurement command is currently running.
ADIJake	0:85855ecd3257	547	*/
Vkadaba	5:0728bde67bdb	548	ADMW_RESULT admw_StopMeasurement(
Vkadaba	5:0728bde67bdb	549	ADMW_DEVICE_HANDLE const hDevice)
ADIJake	0:85855ecd3257	550	{
Vkadaba	5:0728bde67bdb	551	return executeCommand(hDevice, CORE_COMMAND_NOP, true);
ADIJake	0:85855ecd3257	552	}
ADIJake	0:85855ecd3257	553
ADIJake	0:85855ecd3257	554	/*
Vkadaba	32:52445bef314d	555	*
Vkadaba	32:52445bef314d	556	*/
Vkadaba	32:52445bef314d	557	ADMW_RESULT admw1001_sendRun( ADMW_DEVICE_HANDLE const hDevice)
Vkadaba	32:52445bef314d	558	{
Vkadaba	32:52445bef314d	559	bool bitCommand;
Vkadaba	32:52445bef314d	560	ADMW_RESULT eRet;
Vkadaba	32:52445bef314d	561	uint8_t pinreg = 0x1;
Vkadaba	32:52445bef314d	562
Vkadaba	32:52445bef314d	563	ADMW_DEVICE_CONTEXT *pCtx = hDevice;
Vkadaba	32:52445bef314d	564	static uint8_t DataBuffer[SPI_BUFFER_SIZE] = {0};
Vkadaba	32:52445bef314d	565	uint16_t nSize;
Vkadaba	32:52445bef314d	566
Vkadaba	32:52445bef314d	567	//Construct Read Status command
Vkadaba	32:52445bef314d	568	DataBuffer[0] = 0x07;
Vkadaba	32:52445bef314d	569	DataBuffer[1] = 0x0E; //Packet ID
Vkadaba	32:52445bef314d	570
Vkadaba	32:52445bef314d	571	DataBuffer[2] = 0x00;
Vkadaba	32:52445bef314d	572	DataBuffer[3] = 0x00; //Data words
Vkadaba	32:52445bef314d	573
Vkadaba	32:52445bef314d	574	DataBuffer[4] = 0x45;
Vkadaba	32:52445bef314d	575	DataBuffer[5] = 0x00; //Command ID
Vkadaba	32:52445bef314d	576
Vkadaba	32:52445bef314d	577	DataBuffer[6] = 0x00;
Vkadaba	32:52445bef314d	578	DataBuffer[7] = 0x50;
Vkadaba	32:52445bef314d	579	DataBuffer[8] = 0x00;
Vkadaba	32:52445bef314d	580	DataBuffer[9] = 0x00; //Address
Vkadaba	32:52445bef314d	581
Vkadaba	32:52445bef314d	582	DataBuffer[10] = 0x95;
Vkadaba	32:52445bef314d	583	DataBuffer[11] = 0x00;
Vkadaba	32:52445bef314d	584	DataBuffer[12] = 0x00;
Vkadaba	32:52445bef314d	585	DataBuffer[13] = 0x00; //Checksum
Vkadaba	32:52445bef314d	586
Vkadaba	32:52445bef314d	587	nSize = SFL_READ_STATUS_HDR_SIZE;
Vkadaba	32:52445bef314d	588
Vkadaba	32:52445bef314d	589	do {
Vkadaba	32:52445bef314d	590	// Get the SFL command irq pin to check if SFL is ready to receive commands
Vkadaba	32:52445bef314d	591	// Status pin is not checked since SFL is just booted, there should not be any issue with SFL
Vkadaba	32:52445bef314d	592	eRet = admw_GetGpioState( hDevice, ADMW_GPIO_PIN_DATAREADY, &bitCommand );
Vkadaba	32:52445bef314d	593	if( eRet != ADMW_SUCCESS) {
Vkadaba	32:52445bef314d	594	return eRet;
Vkadaba	32:52445bef314d	595	}
Vkadaba	32:52445bef314d	596
Vkadaba	32:52445bef314d	597	// 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	598	// pinreg == '0x00' - Error occured in SFL
Vkadaba	32:52445bef314d	599	// pinreg == '0x01' - SFL is ready to recieve commands
Vkadaba	32:52445bef314d	600	// pinreg == '0x02' - Error occured in handling any commands in SFL
Vkadaba	32:52445bef314d	601	// pinreg == '0x03' - SFL not booted
Vkadaba	32:52445bef314d	602
Vkadaba	32:52445bef314d	603	pinreg = (bitCommand);
Vkadaba	32:52445bef314d	604
Vkadaba	32:52445bef314d	605	} while(pinreg != 0x0u);
Vkadaba	32:52445bef314d	606
Vkadaba	32:52445bef314d	607	eRet = admw_SpiTransfer(pCtx->hSpi, DataBuffer, NULL,
Vkadaba	32:52445bef314d	608	nSize, false);
Vkadaba	32:52445bef314d	609
Vkadaba	32:52445bef314d	610	return eRet;
Vkadaba	32:52445bef314d	611	}
Vkadaba	32:52445bef314d	612
Vkadaba	32:52445bef314d	613	/*
ADIJake	0:85855ecd3257	614	* Read a set of data samples from the device.
ADIJake	0:85855ecd3257	615	* This may be called at any time.
ADIJake	0:85855ecd3257	616	*/
Vkadaba	32:52445bef314d	617
Vkadaba	5:0728bde67bdb	618	ADMW_RESULT admw_GetData(
Vkadaba	5:0728bde67bdb	619	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	5:0728bde67bdb	620	ADMW_MEASUREMENT_MODE const eMeasurementMode,
Vkadaba	5:0728bde67bdb	621	ADMW_DATA_SAMPLE * const pSamples,
ADIJake	0:85855ecd3257	622	uint8_t const nBytesPerSample,
ADIJake	0:85855ecd3257	623	uint32_t const nRequested,
ADIJake	0:85855ecd3257	624	uint32_t * const pnReturned)
ADIJake	0:85855ecd3257	625	{
Vkadaba	5:0728bde67bdb	626	ADMW1001_Sensor_Result_t sensorResult;
Vkadaba	5:0728bde67bdb	627	ADMW_DEVICE_CONTEXT *pCtx = hDevice;
Vkadaba	5:0728bde67bdb	628	uint16_t command = ADMW1001_HOST_COMMS_READ_CMD \|
Vkadaba	23:bb685f35b08b	629	(REG_CORE_DATA_FIFO & ADMW1001_HOST_COMMS_ADR_MASK);
ADIJake	0:85855ecd3257	630	uint8_t commandData[2] = {
ADIJake	0:85855ecd3257	631	command >> 8,
ADIJake	0:85855ecd3257	632	command & 0xFF
ADIJake	0:85855ecd3257	633	};
ADIJake	0:85855ecd3257	634	uint8_t commandResponse[2];
ADIJake	0:85855ecd3257	635	unsigned nValidSamples = 0;
Vkadaba	5:0728bde67bdb	636	ADMW_RESULT eRet = ADMW_SUCCESS;
ADIJake	0:85855ecd3257	637
ADIJake	0:85855ecd3257	638	do {
Vkadaba	5:0728bde67bdb	639	eRet = admw_SpiTransfer(pCtx->hSpi, commandData, commandResponse,
Vkadaba	23:bb685f35b08b	640	sizeof(command), false);
Vkadaba	23:bb685f35b08b	641	if (eRet) {
Vkadaba	5:0728bde67bdb	642	ADMW_LOG_ERROR("Failed to send read command for FIFO register");
ADIJake	0:85855ecd3257	643	return eRet;
ADIJake	0:85855ecd3257	644	}
Vkadaba	5:0728bde67bdb	645	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
Vkadaba	5:0728bde67bdb	646	} while ((commandResponse[0] != ADMW1001_HOST_COMMS_CMD_RESP_0) \|\|
Vkadaba	5:0728bde67bdb	647	(commandResponse[1] != ADMW1001_HOST_COMMS_CMD_RESP_1));
ADIJake	0:85855ecd3257	648
Vkadaba	23:bb685f35b08b	649	for (unsigned i = 0; i < nRequested; i++) {
ADIJake	0:85855ecd3257	650	bool bHoldCs = true;
ADIJake	0:85855ecd3257	651
ADIJake	0:85855ecd3257	652	/* Keep the CS signal asserted for all but the last sample */
ADIJake	0:85855ecd3257	653	if ((i + 1) == nRequested)
ADIJake	0:85855ecd3257	654	bHoldCs = false;
ADIJake	0:85855ecd3257	655
ADIJake	0:85855ecd3257	656	getDataCnt++;
ADIJake	0:85855ecd3257	657
Vkadaba	5:0728bde67bdb	658	eRet = admw_SpiTransfer(pCtx->hSpi, NULL, &sensorResult,
Vkadaba	23:bb685f35b08b	659	nBytesPerSample, bHoldCs);
Vkadaba	23:bb685f35b08b	660	if (eRet) {
Vkadaba	5:0728bde67bdb	661	ADMW_LOG_ERROR("Failed to read data from FIFO register");
ADIJake	0:85855ecd3257	662	return eRet;
ADIJake	0:85855ecd3257	663	}
ADIJake	0:85855ecd3257	664
Vkadaba	23:bb685f35b08b	665	if (! sensorResult.Ch_Valid) {
ADIJake	0:85855ecd3257	666	/*
ADIJake	0:85855ecd3257	667	* Reading an invalid sample indicates that there are no
ADIJake	0:85855ecd3257	668	* more samples available or we've lost sync with the device.
ADIJake	0:85855ecd3257	669	* In the latter case, it might be recoverable, but return here
ADIJake	0:85855ecd3257	670	* to let the application check the device status and decide itself.
ADIJake	0:85855ecd3257	671	*/
Vkadaba	5:0728bde67bdb	672	eRet = ADMW_INCOMPLETE;
ADIJake	0:85855ecd3257	673	break;
ADIJake	0:85855ecd3257	674	}
ADIJake	0:85855ecd3257	675
Vkadaba	5:0728bde67bdb	676	ADMW_DATA_SAMPLE *pSample = &pSamples[nValidSamples];
Vkadaba	5:0728bde67bdb	677
Vkadaba	5:0728bde67bdb	678	pSample->status = (ADMW_DEVICE_STATUS_FLAGS)0;
ADIJake	0:85855ecd3257	679	if (sensorResult.Ch_Error)
Vkadaba	5:0728bde67bdb	680	pSample->status \|= ADMW_DEVICE_STATUS_ERROR;
ADIJake	0:85855ecd3257	681	if (sensorResult.Ch_Alert)
Vkadaba	5:0728bde67bdb	682	pSample->status \|= ADMW_DEVICE_STATUS_ALERT;
ADIJake	0:85855ecd3257	683
ADIJake	0:85855ecd3257	684	if (sensorResult.Ch_Raw)
ADIJake	0:85855ecd3257	685	pSample->rawValue = sensorResult.Raw_Sample;
ADIJake	0:85855ecd3257	686	else
ADIJake	0:85855ecd3257	687	pSample->rawValue = 0;
ADIJake	0:85855ecd3257	688
ADIJake	0:85855ecd3257	689	pSample->channelId = sensorResult.Channel_ID;
ADIJake	0:85855ecd3257	690	pSample->processedValue = sensorResult.Sensor_Result;
ADIJake	0:85855ecd3257	691
ADIJake	0:85855ecd3257	692	nValidSamples++;
ADIJake	0:85855ecd3257	693
Vkadaba	5:0728bde67bdb	694	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
ADIJake	0:85855ecd3257	695	}
ADIJake	0:85855ecd3257	696	*pnReturned = nValidSamples;
ADIJake	0:85855ecd3257	697
ADIJake	0:85855ecd3257	698	return eRet;
ADIJake	0:85855ecd3257	699	}
ADIJake	0:85855ecd3257	700
ADIJake	0:85855ecd3257	701	/*
Vkadaba	5:0728bde67bdb	702	* Close the given ADMW device.
ADIJake	0:85855ecd3257	703	*/
Vkadaba	5:0728bde67bdb	704	ADMW_RESULT admw_Close(
Vkadaba	5:0728bde67bdb	705	ADMW_DEVICE_HANDLE const hDevice)
ADIJake	0:85855ecd3257	706	{
Vkadaba	5:0728bde67bdb	707	ADMW_DEVICE_CONTEXT *pCtx = hDevice;
Vkadaba	5:0728bde67bdb	708
Vkadaba	5:0728bde67bdb	709	admw_GpioClose(pCtx->hGpio);
Vkadaba	5:0728bde67bdb	710	admw_SpiClose(pCtx->hSpi);
Vkadaba	5:0728bde67bdb	711	admw_LogClose();
Vkadaba	5:0728bde67bdb	712
Vkadaba	5:0728bde67bdb	713	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	714	}
ADIJake	0:85855ecd3257	715
Vkadaba	5:0728bde67bdb	716	ADMW_RESULT admw1001_WriteRegister(
Vkadaba	5:0728bde67bdb	717	ADMW_DEVICE_HANDLE hDevice,
ADIJake	0:85855ecd3257	718	uint16_t nAddress,
ADIJake	0:85855ecd3257	719	void *pData,
ADIJake	0:85855ecd3257	720	unsigned nLength)
ADIJake	0:85855ecd3257	721	{
Vkadaba	5:0728bde67bdb	722	ADMW_RESULT eRet;
Vkadaba	5:0728bde67bdb	723	ADMW_DEVICE_CONTEXT *pCtx = hDevice;
Vkadaba	5:0728bde67bdb	724	uint16_t command = ADMW1001_HOST_COMMS_WRITE_CMD \|
Vkadaba	23:bb685f35b08b	725	(nAddress & ADMW1001_HOST_COMMS_ADR_MASK);
ADIJake	0:85855ecd3257	726	uint8_t commandData[2] = {
ADIJake	0:85855ecd3257	727	command >> 8,
ADIJake	0:85855ecd3257	728	command & 0xFF
ADIJake	0:85855ecd3257	729	};
ADIJake	0:85855ecd3257	730	uint8_t commandResponse[2];
ADIJake	0:85855ecd3257	731
ADIJake	0:85855ecd3257	732	do {
Vkadaba	5:0728bde67bdb	733	eRet = admw_SpiTransfer(pCtx->hSpi, commandData, commandResponse,
Vkadaba	23:bb685f35b08b	734	sizeof(command), false);
Vkadaba	23:bb685f35b08b	735	if (eRet) {
Vkadaba	5:0728bde67bdb	736	ADMW_LOG_ERROR("Failed to send write command for register %u",
Vkadaba	23:bb685f35b08b	737	nAddress);
ADIJake	0:85855ecd3257	738	return eRet;
ADIJake	0:85855ecd3257	739	}
ADIJake	0:85855ecd3257	740
Vkadaba	5:0728bde67bdb	741	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
Vkadaba	5:0728bde67bdb	742	} while ((commandResponse[0] != ADMW1001_HOST_COMMS_CMD_RESP_0) \|\|
Vkadaba	5:0728bde67bdb	743	(commandResponse[1] != ADMW1001_HOST_COMMS_CMD_RESP_1));
Vkadaba	5:0728bde67bdb	744
Vkadaba	5:0728bde67bdb	745	eRet = admw_SpiTransfer(pCtx->hSpi, pData, NULL, nLength, false);
Vkadaba	23:bb685f35b08b	746	if (eRet) {
Vkadaba	5:0728bde67bdb	747	ADMW_LOG_ERROR("Failed to write data (%dB) to register %u",
Vkadaba	23:bb685f35b08b	748	nLength, nAddress);
ADIJake	0:85855ecd3257	749	return eRet;
ADIJake	0:85855ecd3257	750	}
ADIJake	0:85855ecd3257	751
Vkadaba	5:0728bde67bdb	752	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
Vkadaba	5:0728bde67bdb	753
Vkadaba	5:0728bde67bdb	754	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	755	}
ADIJake	0:85855ecd3257	756
Vkadaba	6:9d393a9677f4	757	ADMW_RESULT admw1001_Write_Debug_Register(
Vkadaba	6:9d393a9677f4	758	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	6:9d393a9677f4	759	uint16_t nAddress,
Vkadaba	6:9d393a9677f4	760	void *pData,
Vkadaba	6:9d393a9677f4	761	unsigned nLength)
Vkadaba	6:9d393a9677f4	762	{
Vkadaba	6:9d393a9677f4	763	ADMW_RESULT eRet;
Vkadaba	6:9d393a9677f4	764	ADMW_DEVICE_CONTEXT *pCtx = hDevice;
Vkadaba	6:9d393a9677f4	765	uint16_t command = ADMW1001_HOST_COMMS_DEBUG_WRITE_CMD \|
Vkadaba	23:bb685f35b08b	766	(nAddress & ADMW1001_HOST_COMMS_ADR_MASK);
Vkadaba	6:9d393a9677f4	767	uint8_t commandData[2] = {
Vkadaba	6:9d393a9677f4	768	command >> 8,
Vkadaba	6:9d393a9677f4	769	command & 0xFF
Vkadaba	6:9d393a9677f4	770	};
Vkadaba	6:9d393a9677f4	771	uint8_t commandResponse[2];
Vkadaba	6:9d393a9677f4	772
Vkadaba	6:9d393a9677f4	773	do {
Vkadaba	6:9d393a9677f4	774	eRet = admw_SpiTransfer(pCtx->hSpi, commandData, commandResponse,
Vkadaba	23:bb685f35b08b	775	sizeof(command), false);
Vkadaba	23:bb685f35b08b	776	if (eRet) {
Vkadaba	6:9d393a9677f4	777	ADMW_LOG_ERROR("Failed to send write command for register %u",
Vkadaba	23:bb685f35b08b	778	nAddress);
Vkadaba	6:9d393a9677f4	779	return eRet;
Vkadaba	6:9d393a9677f4	780	}
Vkadaba	6:9d393a9677f4	781
Vkadaba	6:9d393a9677f4	782	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
Vkadaba	6:9d393a9677f4	783	} while ((commandResponse[0] != ADMW1001_HOST_COMMS_CMD_RESP_0) \|\|
Vkadaba	6:9d393a9677f4	784	(commandResponse[1] != ADMW1001_HOST_COMMS_CMD_RESP_1));
Vkadaba	6:9d393a9677f4	785
Vkadaba	6:9d393a9677f4	786	eRet = admw_SpiTransfer(pCtx->hSpi, pData, NULL, nLength, false);
Vkadaba	23:bb685f35b08b	787	if (eRet) {
Vkadaba	6:9d393a9677f4	788	ADMW_LOG_ERROR("Failed to write data (%dB) to register %u",
Vkadaba	23:bb685f35b08b	789	nLength, nAddress);
Vkadaba	6:9d393a9677f4	790	return eRet;
Vkadaba	6:9d393a9677f4	791	}
Vkadaba	6:9d393a9677f4	792
Vkadaba	6:9d393a9677f4	793	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
Vkadaba	6:9d393a9677f4	794
Vkadaba	6:9d393a9677f4	795	return ADMW_SUCCESS;
Vkadaba	6:9d393a9677f4	796	}
Vkadaba	5:0728bde67bdb	797	ADMW_RESULT admw1001_ReadRegister(
Vkadaba	5:0728bde67bdb	798	ADMW_DEVICE_HANDLE hDevice,
ADIJake	0:85855ecd3257	799	uint16_t nAddress,
ADIJake	0:85855ecd3257	800	void *pData,
ADIJake	0:85855ecd3257	801	unsigned nLength)
ADIJake	0:85855ecd3257	802	{
Vkadaba	5:0728bde67bdb	803	ADMW_RESULT eRet;
Vkadaba	5:0728bde67bdb	804	ADMW_DEVICE_CONTEXT *pCtx = hDevice;
Vkadaba	5:0728bde67bdb	805	uint16_t command = ADMW1001_HOST_COMMS_READ_CMD \|
Vkadaba	23:bb685f35b08b	806	(nAddress & ADMW1001_HOST_COMMS_ADR_MASK);
ADIJake	0:85855ecd3257	807	uint8_t commandData[2] = {
ADIJake	0:85855ecd3257	808	command >> 8,
ADIJake	0:85855ecd3257	809	command & 0xFF
ADIJake	0:85855ecd3257	810	};
ADIJake	0:85855ecd3257	811	uint8_t commandResponse[2];
ADIJake	0:85855ecd3257	812
ADIJake	0:85855ecd3257	813	do {
Vkadaba	5:0728bde67bdb	814	eRet = admw_SpiTransfer(pCtx->hSpi, commandData, commandResponse,
Vkadaba	23:bb685f35b08b	815	sizeof(command), false);
Vkadaba	23:bb685f35b08b	816	if (eRet) {
Vkadaba	5:0728bde67bdb	817	ADMW_LOG_ERROR("Failed to send read command for register %u",
Vkadaba	23:bb685f35b08b	818	nAddress);
ADIJake	0:85855ecd3257	819	return eRet;
ADIJake	0:85855ecd3257	820	}
ADIJake	0:85855ecd3257	821
Vkadaba	5:0728bde67bdb	822	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
Vkadaba	5:0728bde67bdb	823	} while ((commandResponse[0] != ADMW1001_HOST_COMMS_CMD_RESP_0) \|\|
Vkadaba	5:0728bde67bdb	824	(commandResponse[1] != ADMW1001_HOST_COMMS_CMD_RESP_1));
Vkadaba	5:0728bde67bdb	825
Vkadaba	5:0728bde67bdb	826	eRet = admw_SpiTransfer(pCtx->hSpi, NULL, pData, nLength, false);
Vkadaba	23:bb685f35b08b	827	if (eRet) {
Vkadaba	5:0728bde67bdb	828	ADMW_LOG_ERROR("Failed to read data (%uB) from register %u",
Vkadaba	23:bb685f35b08b	829	nLength, nAddress);
ADIJake	0:85855ecd3257	830	return eRet;
ADIJake	0:85855ecd3257	831	}
ADIJake	0:85855ecd3257	832
Vkadaba	5:0728bde67bdb	833	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
Vkadaba	5:0728bde67bdb	834
Vkadaba	5:0728bde67bdb	835	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	836	}
ADIJake	0:85855ecd3257	837
Vkadaba	6:9d393a9677f4	838	ADMW_RESULT admw1001_Read_Debug_Register(
Vkadaba	6:9d393a9677f4	839	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	6:9d393a9677f4	840	uint16_t nAddress,
Vkadaba	6:9d393a9677f4	841	void *pData,
Vkadaba	6:9d393a9677f4	842	unsigned nLength)
Vkadaba	6:9d393a9677f4	843	{
Vkadaba	6:9d393a9677f4	844	ADMW_RESULT eRet;
Vkadaba	6:9d393a9677f4	845	ADMW_DEVICE_CONTEXT *pCtx = hDevice;
Vkadaba	6:9d393a9677f4	846	uint16_t command = ADMW1001_HOST_COMMS_DEBUG_READ_CMD \|
Vkadaba	23:bb685f35b08b	847	(nAddress & ADMW1001_HOST_COMMS_ADR_MASK);
Vkadaba	6:9d393a9677f4	848	uint8_t commandData[2] = {
Vkadaba	6:9d393a9677f4	849	command >> 8,
Vkadaba	6:9d393a9677f4	850	command & 0xFF
Vkadaba	6:9d393a9677f4	851	};
Vkadaba	6:9d393a9677f4	852	uint8_t commandResponse[2];
Vkadaba	6:9d393a9677f4	853
Vkadaba	6:9d393a9677f4	854	do {
Vkadaba	6:9d393a9677f4	855	eRet = admw_SpiTransfer(pCtx->hSpi, commandData, commandResponse,
Vkadaba	23:bb685f35b08b	856	sizeof(command), false);
Vkadaba	23:bb685f35b08b	857	if (eRet) {
Vkadaba	6:9d393a9677f4	858	ADMW_LOG_ERROR("Failed to send read command for register %u",
Vkadaba	23:bb685f35b08b	859	nAddress);
Vkadaba	6:9d393a9677f4	860	return eRet;
Vkadaba	6:9d393a9677f4	861	}
Vkadaba	6:9d393a9677f4	862
Vkadaba	6:9d393a9677f4	863	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
Vkadaba	6:9d393a9677f4	864	} while ((commandResponse[0] != ADMW1001_HOST_COMMS_CMD_RESP_0) \|\|
Vkadaba	6:9d393a9677f4	865	(commandResponse[1] != ADMW1001_HOST_COMMS_CMD_RESP_1));
Vkadaba	6:9d393a9677f4	866
Vkadaba	6:9d393a9677f4	867	eRet = admw_SpiTransfer(pCtx->hSpi, NULL, pData, nLength, false);
Vkadaba	23:bb685f35b08b	868	if (eRet) {
Vkadaba	6:9d393a9677f4	869	ADMW_LOG_ERROR("Failed to read data (%uB) from register %u",
Vkadaba	23:bb685f35b08b	870	nLength, nAddress);
Vkadaba	6:9d393a9677f4	871	return eRet;
Vkadaba	6:9d393a9677f4	872	}
Vkadaba	6:9d393a9677f4	873
Vkadaba	6:9d393a9677f4	874	admw_TimeDelayUsec(ADMW1001_HOST_COMMS_XFER_DELAY);
Vkadaba	6:9d393a9677f4	875
Vkadaba	6:9d393a9677f4	876	return ADMW_SUCCESS;
Vkadaba	6:9d393a9677f4	877	}
Vkadaba	5:0728bde67bdb	878	ADMW_RESULT admw_GetDeviceReadyState(
Vkadaba	5:0728bde67bdb	879	ADMW_DEVICE_HANDLE const hDevice,
ADIJake	0:85855ecd3257	880	bool * const bReady)
ADIJake	0:85855ecd3257	881	{
Vkadaba	5:0728bde67bdb	882	ADMW_SPI_Chip_Type_t chipTypeReg;
ADIJake	0:85855ecd3257	883
ADIJake	0:85855ecd3257	884	READ_REG_U8(hDevice, chipTypeReg.VALUE8, SPI_CHIP_TYPE);
ADIJake	0:85855ecd3257	885	/* If we read this register successfully, assume the device is ready */
Vkadaba	5:0728bde67bdb	886	*bReady = (chipTypeReg.VALUE8 == REG_SPI_CHIP_TYPE_RESET);
Vkadaba	5:0728bde67bdb	887
Vkadaba	5:0728bde67bdb	888	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	889	}
ADIJake	0:85855ecd3257	890
Vkadaba	5:0728bde67bdb	891	ADMW_RESULT admw1001_GetDataReadyModeInfo(
Vkadaba	8:2f2775c34640	892	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	8:2f2775c34640	893	ADMW_MEASUREMENT_MODE const eMeasurementMode,
Vkadaba	5:0728bde67bdb	894	ADMW1001_OPERATING_MODE * const peOperatingMode,
Vkadaba	5:0728bde67bdb	895	ADMW1001_DATAREADY_MODE * const peDataReadyMode,
Vkadaba	8:2f2775c34640	896	uint32_t * const pnSamplesPerDataready,
Vkadaba	8:2f2775c34640	897	uint32_t * const pnSamplesPerCycle,
Vkadaba	8:2f2775c34640	898	uint8_t * const pnBytesPerSample)
ADIJake	0:85855ecd3257	899	{
ADIJake	0:85855ecd3257	900	unsigned nChannelsEnabled = 0;
ADIJake	0:85855ecd3257	901	unsigned nSamplesPerCycle = 0;
ADIJake	0:85855ecd3257	902
Vkadaba	8:2f2775c34640	903	ADMW_CORE_Mode_t modeReg;
ADIJake	0:85855ecd3257	904	READ_REG_U8(hDevice, modeReg.VALUE8, CORE_MODE);
ADIJake	0:85855ecd3257	905
Vkadaba	6:9d393a9677f4	906	if (eMeasurementMode == (modeReg.Conversion_Mode == CORE_MODE_SINGLECYCLE))
Vkadaba	5:0728bde67bdb	907	*peOperatingMode = ADMW1001_OPERATING_MODE_SINGLECYCLE;
ADIJake	0:85855ecd3257	908	else
Vkadaba	5:0728bde67bdb	909	*peOperatingMode = ADMW1001_OPERATING_MODE_CONTINUOUS;
ADIJake	0:85855ecd3257	910
Vkadaba	23:bb685f35b08b	911	if (eMeasurementMode == ADMW_MEASUREMENT_MODE_OMIT_RAW) {
Vkadaba	8:2f2775c34640	912	*pnBytesPerSample = 5;
Vkadaba	23:bb685f35b08b	913	} else {
Vkadaba	8:2f2775c34640	914	*pnBytesPerSample = 8;
Vkadaba	6:9d393a9677f4	915	}
Vkadaba	23:bb685f35b08b	916
Vkadaba	8:2f2775c34640	917	for (ADMW1001_CH_ID chId = ADMW1001_CH_ID_ANLG_1_UNIVERSAL;
Vkadaba	23:bb685f35b08b	918	chId < ADMW1001_MAX_CHANNELS;
Vkadaba	23:bb685f35b08b	919	chId++) {
Vkadaba	8:2f2775c34640	920	ADMW_CORE_Sensor_Details_t sensorDetailsReg;
Vkadaba	8:2f2775c34640	921	ADMW_CORE_Channel_Count_t channelCountReg;
Vkadaba	23:bb685f35b08b	922
Vkadaba	8:2f2775c34640	923	if (ADMW1001_CHANNEL_IS_VIRTUAL(chId))
Vkadaba	8:2f2775c34640	924	continue;
Vkadaba	23:bb685f35b08b	925
Vkadaba	8:2f2775c34640	926	READ_REG_U8(hDevice, channelCountReg.VALUE8, CORE_CHANNEL_COUNTn(chId));
Vkadaba	8:2f2775c34640	927	READ_REG_U32(hDevice, sensorDetailsReg.VALUE32, CORE_SENSOR_DETAILSn(chId));
Vkadaba	23:bb685f35b08b	928
Vkadaba	23:bb685f35b08b	929	if (channelCountReg.Channel_Enable && !sensorDetailsReg.Do_Not_Publish) {
Vkadaba	8:2f2775c34640	930	ADMW_CORE_Sensor_Type_t sensorTypeReg;
Vkadaba	8:2f2775c34640	931	unsigned nActualChannels = 1;
Vkadaba	23:bb685f35b08b	932
Vkadaba	8:2f2775c34640	933	READ_REG_U16(hDevice, sensorTypeReg.VALUE16, CORE_SENSOR_TYPEn(chId));
Vkadaba	23:bb685f35b08b	934
Vkadaba	23:bb685f35b08b	935	if (chId == ADMW1001_CH_ID_DIG_SPI_0) {
Vkadaba	23:bb685f35b08b	936	/* Some sensors automatically generate samples on additional
Vkadaba	23:bb685f35b08b	937	* "virtual" channels so these channels must be counted as
Vkadaba	23:bb685f35b08b	938	* active when those sensors are selected and we use the count
Vkadaba	23:bb685f35b08b	939	* from the corresponding "physical" channel
Vkadaba	8:2f2775c34640	940	*/
Vkadaba	32:52445bef314d	941	#if 0 /* SPI sensors arent supported at present to be added back once there is
Vkadaba	32:52445bef314d	942	* support for these sensors
Vkadaba	32:52445bef314d	943	*/
Vkadaba	8:2f2775c34640	944	if ((sensorTypeReg.Sensor_Type >=
Vkadaba	23:bb685f35b08b	945	CORE_SENSOR_TYPE_SPI_ACCELEROMETER_A) &&
Vkadaba	23:bb685f35b08b	946	(sensorTypeReg.Sensor_Type <=
Vkadaba	23:bb685f35b08b	947	CORE_SENSOR_TYPE_SPI_ACCELEROMETER_B)) {
Vkadaba	8:2f2775c34640	948	nActualChannels += 2;
Vkadaba	8:2f2775c34640	949	}
Vkadaba	32:52445bef314d	950	#endif
Vkadaba	8:2f2775c34640	951	}
Vkadaba	23:bb685f35b08b	952
Vkadaba	8:2f2775c34640	953	nChannelsEnabled += nActualChannels;
Vkadaba	23:bb685f35b08b	954
Vkadaba	8:2f2775c34640	955	nSamplesPerCycle += nActualChannels *
Vkadaba	8:2f2775c34640	956	(channelCountReg.Channel_Count + 1);
ADIJake	0:85855ecd3257	957	}
Vkadaba	6:9d393a9677f4	958	}
Vkadaba	23:bb685f35b08b	959
Vkadaba	23:bb685f35b08b	960	if (nChannelsEnabled == 0) {
Vkadaba	8:2f2775c34640	961	*pnSamplesPerDataready = 0;
Vkadaba	8:2f2775c34640	962	*pnSamplesPerCycle = 0;
Vkadaba	8:2f2775c34640	963	return ADMW_SUCCESS;
Vkadaba	6:9d393a9677f4	964	}
Vkadaba	23:bb685f35b08b	965
Vkadaba	6:9d393a9677f4	966	*pnSamplesPerCycle = nSamplesPerCycle;
Vkadaba	23:bb685f35b08b	967
Vkadaba	23:bb685f35b08b	968	if (modeReg.Drdy_Mode == CORE_MODE_DRDY_PER_CONVERSION) {
Vkadaba	8:2f2775c34640	969	*pnSamplesPerDataready = 1;
Vkadaba	23:bb685f35b08b	970	} else {
Vkadaba	8:2f2775c34640	971	*pnSamplesPerDataready = nSamplesPerCycle;
Vkadaba	6:9d393a9677f4	972	}
Vkadaba	23:bb685f35b08b	973
Vkadaba	23:bb685f35b08b	974	if (modeReg.Drdy_Mode == CORE_MODE_DRDY_PER_CONVERSION) {
Vkadaba	8:2f2775c34640	975	*peDataReadyMode = ADMW1001_DATAREADY_PER_CONVERSION;
Vkadaba	23:bb685f35b08b	976	} else {
Vkadaba	8:2f2775c34640	977	*peDataReadyMode = ADMW1001_DATAREADY_PER_CYCLE;
ADIJake	0:85855ecd3257	978	}
Vkadaba	23:bb685f35b08b	979
Vkadaba	5:0728bde67bdb	980	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	981	}
ADIJake	0:85855ecd3257	982
Vkadaba	5:0728bde67bdb	983	ADMW_RESULT admw_GetProductID(
Vkadaba	5:0728bde67bdb	984	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	5:0728bde67bdb	985	ADMW_PRODUCT_ID *pProductId)
ADIJake	0:85855ecd3257	986	{
Vkadaba	5:0728bde67bdb	987	ADMW_SPI_Product_ID_L_t productIdLoReg;
Vkadaba	5:0728bde67bdb	988	ADMW_SPI_Product_ID_H_t productIdHiReg;
ADIJake	0:85855ecd3257	989
ADIJake	0:85855ecd3257	990	READ_REG_U8(hDevice, productIdLoReg.VALUE8, SPI_PRODUCT_ID_L);
ADIJake	0:85855ecd3257	991	READ_REG_U8(hDevice, productIdHiReg.VALUE8, SPI_PRODUCT_ID_H);
ADIJake	0:85855ecd3257	992
Vkadaba	23:bb685f35b08b	993	*pProductId = (ADMW_PRODUCT_ID)((productIdHiReg.VALUE8 << 8) \|
Vkadaba	8:2f2775c34640	994	productIdLoReg.VALUE8);
Vkadaba	5:0728bde67bdb	995	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	996	}
ADIJake	0:85855ecd3257	997
Vkadaba	5:0728bde67bdb	998	static ADMW_RESULT admw_SetPowerMode(
Vkadaba	5:0728bde67bdb	999	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	5:0728bde67bdb	1000	ADMW1001_POWER_MODE powerMode)
ADIJake	0:85855ecd3257	1001	{
Vkadaba	8:2f2775c34640	1002	ADMW_CORE_Power_Config_t powerConfigReg;
Vkadaba	5:0728bde67bdb	1003
Vkadaba	23:bb685f35b08b	1004	if (powerMode == ADMW1001_POWER_MODE_HIBERNATION) {
Vkadaba	6:9d393a9677f4	1005	powerConfigReg.Power_Mode_MCU = CORE_POWER_CONFIG_HIBERNATION;
Vkadaba	23:bb685f35b08b	1006	} else if (powerMode == ADMW1001_POWER_MODE_ACTIVE) {
Vkadaba	6:9d393a9677f4	1007	powerConfigReg.Power_Mode_MCU = CORE_POWER_CONFIG_ACTIVE_MODE;
Vkadaba	23:bb685f35b08b	1008	} else {
Vkadaba	5:0728bde67bdb	1009	ADMW_LOG_ERROR("Invalid power mode %d specified", powerMode);
Vkadaba	5:0728bde67bdb	1010	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1011	}
ADIJake	0:85855ecd3257	1012
ADIJake	0:85855ecd3257	1013	WRITE_REG_U8(hDevice, powerConfigReg.VALUE8, CORE_POWER_CONFIG);
ADIJake	0:85855ecd3257	1014
Vkadaba	5:0728bde67bdb	1015	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1016	}
ADIJake	0:85855ecd3257	1017
Vkadaba	5:0728bde67bdb	1018	ADMW_RESULT admw1001_SetPowerConfig(
Vkadaba	5:0728bde67bdb	1019	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	5:0728bde67bdb	1020	ADMW1001_POWER_CONFIG *pPowerConfig)
ADIJake	0:85855ecd3257	1021	{
Vkadaba	5:0728bde67bdb	1022	ADMW_RESULT eRet;
Vkadaba	5:0728bde67bdb	1023
Vkadaba	5:0728bde67bdb	1024	eRet = admw_SetPowerMode(hDevice, pPowerConfig->powerMode);
Vkadaba	23:bb685f35b08b	1025	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1026	ADMW_LOG_ERROR("Failed to set power mode");
ADIJake	0:85855ecd3257	1027	return eRet;
ADIJake	0:85855ecd3257	1028	}
ADIJake	0:85855ecd3257	1029
Vkadaba	5:0728bde67bdb	1030	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1031	}
ADIJake	0:85855ecd3257	1032
Vkadaba	33:df7a00f1b8e1	1033	static ADMW_RESULT admw_SetRSenseValue(
Vkadaba	33:df7a00f1b8e1	1034	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	33:df7a00f1b8e1	1035	float32_t RSenseValue)
Vkadaba	33:df7a00f1b8e1	1036	{
Vkadaba	33:df7a00f1b8e1	1037	ADMW_CORE_External_Reference_Resistor_t RefResistorConfigReg;
Vkadaba	33:df7a00f1b8e1	1038
Vkadaba	33:df7a00f1b8e1	1039	RefResistorConfigReg.Ext_Refin1_Value = RSenseValue;
Vkadaba	33:df7a00f1b8e1	1040
Vkadaba	33:df7a00f1b8e1	1041	WRITE_REG_FLOAT(hDevice, RefResistorConfigReg.VALUE32, CORE_EXTERNAL_REFERENCE_RESISTOR);
Vkadaba	33:df7a00f1b8e1	1042
Vkadaba	33:df7a00f1b8e1	1043	return ADMW_SUCCESS;
Vkadaba	33:df7a00f1b8e1	1044
Vkadaba	33:df7a00f1b8e1	1045	}
Vkadaba	5:0728bde67bdb	1046	static ADMW_RESULT admw_SetMode(
Vkadaba	5:0728bde67bdb	1047	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	5:0728bde67bdb	1048	ADMW1001_OPERATING_MODE eOperatingMode,
Vkadaba	8:2f2775c34640	1049	ADMW1001_DATAREADY_MODE eDataReadyMode)
ADIJake	0:85855ecd3257	1050	{
Vkadaba	8:2f2775c34640	1051	ADMW_CORE_Mode_t modeReg;
ADIJake	0:85855ecd3257	1052
ADIJake	0:85855ecd3257	1053	modeReg.VALUE8 = REG_RESET_VAL(CORE_MODE);
ADIJake	0:85855ecd3257	1054
Vkadaba	23:bb685f35b08b	1055	if (eOperatingMode == ADMW1001_OPERATING_MODE_SINGLECYCLE) {
Vkadaba	5:0728bde67bdb	1056	modeReg.Conversion_Mode = CORE_MODE_SINGLECYCLE;
Vkadaba	23:bb685f35b08b	1057	} else if (eOperatingMode == ADMW1001_OPERATING_MODE_CONTINUOUS) {
Vkadaba	5:0728bde67bdb	1058	modeReg.Conversion_Mode = CORE_MODE_CONTINUOUS;
Vkadaba	23:bb685f35b08b	1059	} else {
Vkadaba	5:0728bde67bdb	1060	ADMW_LOG_ERROR("Invalid operating mode %d specified",
Vkadaba	23:bb685f35b08b	1061	eOperatingMode);
Vkadaba	5:0728bde67bdb	1062	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1063	}
ADIJake	0:85855ecd3257	1064
Vkadaba	23:bb685f35b08b	1065	if (eDataReadyMode == ADMW1001_DATAREADY_PER_CONVERSION) {
Vkadaba	5:0728bde67bdb	1066	modeReg.Drdy_Mode = CORE_MODE_DRDY_PER_CONVERSION;
Vkadaba	23:bb685f35b08b	1067	} else if (eDataReadyMode == ADMW1001_DATAREADY_PER_CYCLE) {
Vkadaba	5:0728bde67bdb	1068	modeReg.Drdy_Mode = CORE_MODE_DRDY_PER_CYCLE;
Vkadaba	23:bb685f35b08b	1069	} else {
Vkadaba	5:0728bde67bdb	1070	ADMW_LOG_ERROR("Invalid data-ready mode %d specified", eDataReadyMode);
Vkadaba	5:0728bde67bdb	1071	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1072	}
ADIJake	0:85855ecd3257	1073
ADIJake	0:85855ecd3257	1074	WRITE_REG_U8(hDevice, modeReg.VALUE8, CORE_MODE);
ADIJake	0:85855ecd3257	1075
Vkadaba	5:0728bde67bdb	1076	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1077	}
ADIJake	0:85855ecd3257	1078
Vkadaba	8:2f2775c34640	1079	ADMW_RESULT admw_SetCycleControl(ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1080	uint32_t nCycleInterval,
Vkadaba	8:2f2775c34640	1081	bool vBiasEnable)
ADIJake	0:85855ecd3257	1082	{
Vkadaba	8:2f2775c34640	1083	ADMW_CORE_Cycle_Control_t cycleControlReg;
ADIJake	0:85855ecd3257	1084
ADIJake	0:85855ecd3257	1085	cycleControlReg.VALUE16 = REG_RESET_VAL(CORE_CYCLE_CONTROL);
ADIJake	0:85855ecd3257	1086
Vkadaba	23:bb685f35b08b	1087	if (nCycleInterval < (1000 * (1 << 12))) {
Vkadaba	5:0728bde67bdb	1088	cycleControlReg.Cycle_Time_Units = CORE_CYCLE_CONTROL_MILLISECONDS;
ADIJake	0:85855ecd3257	1089	nCycleInterval /= 1000;
Vkadaba	23:bb685f35b08b	1090	} else {
Vkadaba	5:0728bde67bdb	1091	cycleControlReg.Cycle_Time_Units = CORE_CYCLE_CONTROL_SECONDS;
ADIJake	0:85855ecd3257	1092	nCycleInterval /= 1000000;
ADIJake	0:85855ecd3257	1093	}
ADIJake	0:85855ecd3257	1094
Vkadaba	23:bb685f35b08b	1095	if (vBiasEnable == true) {
Vkadaba	8:2f2775c34640	1096	cycleControlReg.Vbias = 1;
Vkadaba	8:2f2775c34640	1097	}
ADIJake	0:85855ecd3257	1098	CHECK_REG_FIELD_VAL(CORE_CYCLE_CONTROL_CYCLE_TIME, nCycleInterval);
ADIJake	0:85855ecd3257	1099	cycleControlReg.Cycle_Time = nCycleInterval;
ADIJake	0:85855ecd3257	1100
ADIJake	0:85855ecd3257	1101	WRITE_REG_U16(hDevice, cycleControlReg.VALUE16, CORE_CYCLE_CONTROL);
ADIJake	0:85855ecd3257	1102
Vkadaba	5:0728bde67bdb	1103	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1104	}
ADIJake	0:85855ecd3257	1105
Vkadaba	5:0728bde67bdb	1106	static ADMW_RESULT admw_SetExternalReferenceValues(
Vkadaba	5:0728bde67bdb	1107	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	6:9d393a9677f4	1108	float32_t externalRef1Value)
ADIJake	0:85855ecd3257	1109	{
Vkadaba	6:9d393a9677f4	1110	WRITE_REG_FLOAT(hDevice, externalRef1Value, CORE_EXTERNAL_REFERENCE_RESISTOR);
ADIJake	0:85855ecd3257	1111
Vkadaba	5:0728bde67bdb	1112	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1113	}
ADIJake	0:85855ecd3257	1114
Vkadaba	5:0728bde67bdb	1115	ADMW_RESULT admw1001_SetMeasurementConfig(
Vkadaba	5:0728bde67bdb	1116	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	5:0728bde67bdb	1117	ADMW1001_MEASUREMENT_CONFIG *pMeasConfig)
ADIJake	0:85855ecd3257	1118	{
Vkadaba	5:0728bde67bdb	1119	ADMW_RESULT eRet;
Vkadaba	5:0728bde67bdb	1120
Vkadaba	5:0728bde67bdb	1121	eRet = admw_SetMode(hDevice,
Vkadaba	8:2f2775c34640	1122	pMeasConfig->operatingMode,
Vkadaba	8:2f2775c34640	1123	pMeasConfig->dataReadyMode);
Vkadaba	23:bb685f35b08b	1124	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1125	ADMW_LOG_ERROR("Failed to set operating mode");
ADIJake	0:85855ecd3257	1126	return eRet;
ADIJake	0:85855ecd3257	1127	}
ADIJake	0:85855ecd3257	1128
Vkadaba	8:2f2775c34640	1129	eRet = admw_SetCycleControl(hDevice, pMeasConfig->cycleInterval,
Vkadaba	8:2f2775c34640	1130	pMeasConfig->vBiasEnable);
Vkadaba	23:bb685f35b08b	1131	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1132	ADMW_LOG_ERROR("Failed to set cycle control");
ADIJake	0:85855ecd3257	1133	return eRet;
ADIJake	0:85855ecd3257	1134	}
ADIJake	0:85855ecd3257	1135
Vkadaba	23:bb685f35b08b	1136	if(pMeasConfig->externalRef1Value>0) {
Vkadaba	8:2f2775c34640	1137	eRet = admw_SetExternalReferenceValues(hDevice,
Vkadaba	8:2f2775c34640	1138	pMeasConfig->externalRef1Value);
ADIJake	0:85855ecd3257	1139	}
Vkadaba	8:2f2775c34640	1140
Vkadaba	23:bb685f35b08b	1141	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1142	ADMW_LOG_ERROR("Failed to set external reference values");
ADIJake	0:85855ecd3257	1143	return eRet;
ADIJake	0:85855ecd3257	1144	}
ADIJake	0:85855ecd3257	1145
Vkadaba	33:df7a00f1b8e1	1146	eRet = admw_SetRSenseValue(hDevice, pMeasConfig->RSenseValue);
Vkadaba	33:df7a00f1b8e1	1147	if (eRet != ADMW_SUCCESS)
Vkadaba	33:df7a00f1b8e1	1148	{
Vkadaba	33:df7a00f1b8e1	1149	ADMW_LOG_ERROR("Failed to set RSenseValue");
Vkadaba	33:df7a00f1b8e1	1150	return eRet;
Vkadaba	33:df7a00f1b8e1	1151	}
Vkadaba	5:0728bde67bdb	1152	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1153	}
ADIJake	0:85855ecd3257	1154
ADIJake	0:85855ecd3257	1155
ADIJake	0:85855ecd3257	1156
Vkadaba	5:0728bde67bdb	1157	ADMW_RESULT admw1001_SetChannelCount(
Vkadaba	5:0728bde67bdb	1158	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1159	ADMW1001_CH_ID eChannelId,
ADIJake	0:85855ecd3257	1160	uint32_t nMeasurementsPerCycle)
ADIJake	0:85855ecd3257	1161	{
Vkadaba	8:2f2775c34640	1162	ADMW_CORE_Channel_Count_t channelCountReg;
ADIJake	0:85855ecd3257	1163
ADIJake	0:85855ecd3257	1164	channelCountReg.VALUE8 = REG_RESET_VAL(CORE_CHANNEL_COUNTn);
ADIJake	0:85855ecd3257	1165
Vkadaba	23:bb685f35b08b	1166	if (nMeasurementsPerCycle > 0) {
ADIJake	0:85855ecd3257	1167	nMeasurementsPerCycle -= 1;
ADIJake	0:85855ecd3257	1168
ADIJake	0:85855ecd3257	1169	CHECK_REG_FIELD_VAL(CORE_CHANNEL_COUNT_CHANNEL_COUNT,
ADIJake	0:85855ecd3257	1170	nMeasurementsPerCycle);
ADIJake	0:85855ecd3257	1171
ADIJake	0:85855ecd3257	1172	channelCountReg.Channel_Enable = 1;
ADIJake	0:85855ecd3257	1173	channelCountReg.Channel_Count = nMeasurementsPerCycle;
Vkadaba	23:bb685f35b08b	1174	} else {
ADIJake	0:85855ecd3257	1175	channelCountReg.Channel_Enable = 0;
ADIJake	0:85855ecd3257	1176	}
ADIJake	0:85855ecd3257	1177
ADIJake	0:85855ecd3257	1178	WRITE_REG_U8(hDevice, channelCountReg.VALUE8, CORE_CHANNEL_COUNTn(eChannelId));
ADIJake	0:85855ecd3257	1179
Vkadaba	5:0728bde67bdb	1180	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1181	}
ADIJake	0:85855ecd3257	1182
Vkadaba	5:0728bde67bdb	1183	ADMW_RESULT admw1001_SetChannelOptions(
Vkadaba	5:0728bde67bdb	1184	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1185	ADMW1001_CH_ID eChannelId,
Vkadaba	6:9d393a9677f4	1186	ADMW1001_CHANNEL_PRIORITY ePriority)
ADIJake	0:85855ecd3257	1187	{
Vkadaba	8:2f2775c34640	1188	ADMW_CORE_Channel_Options_t channelOptionsReg;
ADIJake	0:85855ecd3257	1189
ADIJake	0:85855ecd3257	1190	channelOptionsReg.VALUE8 = REG_RESET_VAL(CORE_CHANNEL_OPTIONSn);
ADIJake	0:85855ecd3257	1191
ADIJake	0:85855ecd3257	1192	CHECK_REG_FIELD_VAL(CORE_CHANNEL_OPTIONS_CHANNEL_PRIORITY, ePriority);
ADIJake	0:85855ecd3257	1193	channelOptionsReg.Channel_Priority = ePriority;
ADIJake	0:85855ecd3257	1194
ADIJake	0:85855ecd3257	1195	WRITE_REG_U8(hDevice, channelOptionsReg.VALUE8, CORE_CHANNEL_OPTIONSn(eChannelId));
ADIJake	0:85855ecd3257	1196
Vkadaba	5:0728bde67bdb	1197	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1198	}
ADIJake	0:85855ecd3257	1199
Vkadaba	5:0728bde67bdb	1200	ADMW_RESULT admw1001_SetChannelSkipCount(
Vkadaba	5:0728bde67bdb	1201	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1202	ADMW1001_CH_ID eChannelId,
ADIJake	0:85855ecd3257	1203	uint32_t nCycleSkipCount)
ADIJake	0:85855ecd3257	1204	{
Vkadaba	8:2f2775c34640	1205	ADMW_CORE_Channel_Skip_t channelSkipReg;
ADIJake	0:85855ecd3257	1206
ADIJake	0:85855ecd3257	1207	channelSkipReg.VALUE16 = REG_RESET_VAL(CORE_CHANNEL_SKIPn);
ADIJake	0:85855ecd3257	1208
ADIJake	0:85855ecd3257	1209	CHECK_REG_FIELD_VAL(CORE_CHANNEL_SKIP_CHANNEL_SKIP, nCycleSkipCount);
ADIJake	0:85855ecd3257	1210
ADIJake	0:85855ecd3257	1211	channelSkipReg.Channel_Skip = nCycleSkipCount;
ADIJake	0:85855ecd3257	1212
ADIJake	0:85855ecd3257	1213	WRITE_REG_U16(hDevice, channelSkipReg.VALUE16, CORE_CHANNEL_SKIPn(eChannelId));
ADIJake	0:85855ecd3257	1214
Vkadaba	5:0728bde67bdb	1215	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1216	}
ADIJake	0:85855ecd3257	1217
Vkadaba	5:0728bde67bdb	1218	static ADMW_RESULT admw_SetChannelAdcSensorType(
Vkadaba	8:2f2775c34640	1219	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1220	ADMW1001_CH_ID eChannelId,
Vkadaba	8:2f2775c34640	1221	ADMW1001_ADC_SENSOR_TYPE sensorType)
ADIJake	0:85855ecd3257	1222	{
Vkadaba	8:2f2775c34640	1223	ADMW_CORE_Sensor_Type_t sensorTypeReg;
ADIJake	0:85855ecd3257	1224
ADIJake	0:85855ecd3257	1225	sensorTypeReg.VALUE16 = REG_RESET_VAL(CORE_SENSOR_TYPEn);
ADIJake	0:85855ecd3257	1226
ADIJake	0:85855ecd3257	1227	/* Ensure that the sensor type is valid for this channel */
Vkadaba	23:bb685f35b08b	1228	switch(sensorType) {
Vkadaba	8:2f2775c34640	1229	case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT100:
Vkadaba	8:2f2775c34640	1230	case ADMW1001_ADC_SENSOR_RTD_3WIRE_PT1000:
Vkadaba	8:2f2775c34640	1231	case ADMW1001_ADC_SENSOR_RTD_3WIRE_1:
Vkadaba	8:2f2775c34640	1232	case ADMW1001_ADC_SENSOR_RTD_3WIRE_2:
Vkadaba	8:2f2775c34640	1233	case ADMW1001_ADC_SENSOR_RTD_3WIRE_3:
Vkadaba	8:2f2775c34640	1234	case ADMW1001_ADC_SENSOR_RTD_3WIRE_4:
Vkadaba	8:2f2775c34640	1235	case ADMW1001_ADC_SENSOR_RTD_4WIRE_PT100:
Vkadaba	8:2f2775c34640	1236	case ADMW1001_ADC_SENSOR_RTD_4WIRE_PT1000:
Vkadaba	8:2f2775c34640	1237	case ADMW1001_ADC_SENSOR_RTD_4WIRE_1:
Vkadaba	8:2f2775c34640	1238	case ADMW1001_ADC_SENSOR_RTD_4WIRE_2:
Vkadaba	8:2f2775c34640	1239	case ADMW1001_ADC_SENSOR_RTD_4WIRE_3:
Vkadaba	8:2f2775c34640	1240	case ADMW1001_ADC_SENSOR_RTD_4WIRE_4:
Vkadaba	8:2f2775c34640	1241	case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE_1:
Vkadaba	8:2f2775c34640	1242	case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE_2:
Vkadaba	8:2f2775c34640	1243	case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE_3:
Vkadaba	8:2f2775c34640	1244	case ADMW1001_ADC_SENSOR_BRIDGE_4WIRE_4:
Vkadaba	8:2f2775c34640	1245	case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE_1:
Vkadaba	8:2f2775c34640	1246	case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE_2:
Vkadaba	8:2f2775c34640	1247	case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE_3:
Vkadaba	8:2f2775c34640	1248	case ADMW1001_ADC_SENSOR_BRIDGE_6WIRE_4:
Vkadaba	8:2f2775c34640	1249	case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT100:
Vkadaba	8:2f2775c34640	1250	case ADMW1001_ADC_SENSOR_RTD_2WIRE_PT1000:
Vkadaba	8:2f2775c34640	1251	case ADMW1001_ADC_SENSOR_RTD_2WIRE_1:
Vkadaba	8:2f2775c34640	1252	case ADMW1001_ADC_SENSOR_RTD_2WIRE_2:
Vkadaba	8:2f2775c34640	1253	case ADMW1001_ADC_SENSOR_RTD_2WIRE_3:
Vkadaba	8:2f2775c34640	1254	case ADMW1001_ADC_SENSOR_RTD_2WIRE_4:
Vkadaba	8:2f2775c34640	1255	case ADMW1001_ADC_SENSOR_DIODE_2C_TYPEA:
Vkadaba	8:2f2775c34640	1256	case ADMW1001_ADC_SENSOR_DIODE_3C_TYPEA:
Vkadaba	8:2f2775c34640	1257	case ADMW1001_ADC_SENSOR_DIODE_2C_1:
Vkadaba	8:2f2775c34640	1258	case ADMW1001_ADC_SENSOR_DIODE_3C_1:
Vkadaba	8:2f2775c34640	1259	case ADMW1001_ADC_SENSOR_THERMISTOR_A_10K:
Vkadaba	8:2f2775c34640	1260	case ADMW1001_ADC_SENSOR_THERMISTOR_B_10K:
Vkadaba	8:2f2775c34640	1261	case ADMW1001_ADC_SENSOR_THERMISTOR_1:
Vkadaba	8:2f2775c34640	1262	case ADMW1001_ADC_SENSOR_THERMISTOR_2:
Vkadaba	8:2f2775c34640	1263	case ADMW1001_ADC_SENSOR_THERMISTOR_3:
Vkadaba	8:2f2775c34640	1264	case ADMW1001_ADC_SENSOR_THERMISTOR_4:
Vkadaba	6:9d393a9677f4	1265	if (! (ADMW1001_CHANNEL_IS_ADC_SENSOR(eChannelId) \|\|
Vkadaba	23:bb685f35b08b	1266	ADMW1001_CHANNEL_IS_ADC_CJC(eChannelId))) {
Vkadaba	6:9d393a9677f4	1267	ADMW_LOG_ERROR(
Vkadaba	6:9d393a9677f4	1268	"Invalid ADC sensor type %d specified for channel %d",
Vkadaba	6:9d393a9677f4	1269	sensorType, eChannelId);
Vkadaba	6:9d393a9677f4	1270	return ADMW_INVALID_PARAM;
Vkadaba	6:9d393a9677f4	1271	}
Vkadaba	6:9d393a9677f4	1272	break;
Vkadaba	6:9d393a9677f4	1273	case ADMW1001_ADC_SENSOR_VOLTAGE:
Vkadaba	8:2f2775c34640	1274	case ADMW1001_ADC_SENSOR_VOLTAGE_PRESSURE_A:
Vkadaba	8:2f2775c34640	1275	case ADMW1001_ADC_SENSOR_VOLTAGE_PRESSURE_B:
Vkadaba	8:2f2775c34640	1276	case ADMW1001_ADC_SENSOR_VOLTAGE_PRESSURE_1:
Vkadaba	8:2f2775c34640	1277	case ADMW1001_ADC_SENSOR_VOLTAGE_PRESSURE_2:
Vkadaba	8:2f2775c34640	1278	case ADMW1001_ADC_SENSOR_THERMOCOUPLE_J:
Vkadaba	8:2f2775c34640	1279	case ADMW1001_ADC_SENSOR_THERMOCOUPLE_K:
Vkadaba	8:2f2775c34640	1280	case ADMW1001_ADC_SENSOR_THERMOCOUPLE_T:
Vkadaba	8:2f2775c34640	1281	case ADMW1001_ADC_SENSOR_THERMOCOUPLE_1:
Vkadaba	8:2f2775c34640	1282	case ADMW1001_ADC_SENSOR_THERMOCOUPLE_2:
Vkadaba	8:2f2775c34640	1283	case ADMW1001_ADC_SENSOR_THERMOCOUPLE_3:
Vkadaba	8:2f2775c34640	1284	case ADMW1001_ADC_SENSOR_THERMOCOUPLE_4:
Vkadaba	23:bb685f35b08b	1285	if (! ADMW1001_CHANNEL_IS_ADC_VOLTAGE(eChannelId)) {
Vkadaba	6:9d393a9677f4	1286	ADMW_LOG_ERROR(
Vkadaba	6:9d393a9677f4	1287	"Invalid ADC sensor type %d specified for channel %d",
Vkadaba	6:9d393a9677f4	1288	sensorType, eChannelId);
Vkadaba	6:9d393a9677f4	1289	return ADMW_INVALID_PARAM;
Vkadaba	6:9d393a9677f4	1290	}
Vkadaba	6:9d393a9677f4	1291	break;
Vkadaba	6:9d393a9677f4	1292	case ADMW1001_ADC_SENSOR_CURRENT:
Vkadaba	8:2f2775c34640	1293	case ADMW1001_ADC_SENSOR_CURRENT_PRESSURE_A:
Vkadaba	8:2f2775c34640	1294	case ADMW1001_ADC_SENSOR_CURRENT_PRESSURE_1:
Vkadaba	8:2f2775c34640	1295	case ADMW1001_ADC_SENSOR_CURRENT_PRESSURE_2:
Vkadaba	23:bb685f35b08b	1296	if (! ADMW1001_CHANNEL_IS_ADC_CURRENT(eChannelId)) {
Vkadaba	6:9d393a9677f4	1297	ADMW_LOG_ERROR(
Vkadaba	6:9d393a9677f4	1298	"Invalid ADC sensor type %d specified for channel %d",
Vkadaba	6:9d393a9677f4	1299	sensorType, eChannelId);
Vkadaba	6:9d393a9677f4	1300	return ADMW_INVALID_PARAM;
Vkadaba	6:9d393a9677f4	1301	}
Vkadaba	6:9d393a9677f4	1302	break;
Vkadaba	6:9d393a9677f4	1303	default:
Vkadaba	6:9d393a9677f4	1304	ADMW_LOG_ERROR("Invalid/unsupported ADC sensor type %d specified",
Vkadaba	23:bb685f35b08b	1305	sensorType);
Vkadaba	5:0728bde67bdb	1306	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1307	}
ADIJake	0:85855ecd3257	1308
ADIJake	0:85855ecd3257	1309	sensorTypeReg.Sensor_Type = sensorType;
ADIJake	0:85855ecd3257	1310
ADIJake	0:85855ecd3257	1311	WRITE_REG_U16(hDevice, sensorTypeReg.VALUE16, CORE_SENSOR_TYPEn(eChannelId));
ADIJake	0:85855ecd3257	1312
Vkadaba	5:0728bde67bdb	1313	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1314	}
ADIJake	0:85855ecd3257	1315
Vkadaba	5:0728bde67bdb	1316	static ADMW_RESULT admw_SetChannelAdcSensorDetails(
Vkadaba	8:2f2775c34640	1317	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1318	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1319	ADMW1001_CHANNEL_CONFIG *pChannelConfig)
ADIJake	0:85855ecd3257	1320	/*
ADIJake	0:85855ecd3257	1321	* TODO - it would be nice if the general- vs. ADC-specific sensor details could be split into separate registers
ADIJake	0:85855ecd3257	1322	* General details:
ADIJake	0:85855ecd3257	1323	* - Measurement_Units
ADIJake	0:85855ecd3257	1324	* - Compensation_Channel
ADIJake	0:85855ecd3257	1325	* - CJC_Publish (if "CJC" was removed from the name)
ADIJake	0:85855ecd3257	1326	* ADC-specific details:
ADIJake	0:85855ecd3257	1327	* - PGA_Gain
ADIJake	0:85855ecd3257	1328	* - Reference_Select
ADIJake	0:85855ecd3257	1329	* - Reference_Buffer_Disable
ADIJake	0:85855ecd3257	1330	*/
ADIJake	0:85855ecd3257	1331	{
Vkadaba	5:0728bde67bdb	1332	ADMW1001_ADC_CHANNEL_CONFIG *pAdcChannelConfig = &pChannelConfig->adcChannelConfig;
Vkadaba	8:2f2775c34640	1333	ADMW1001_ADC_REFERENCE_TYPE refType = pAdcChannelConfig->reference;
Vkadaba	8:2f2775c34640	1334	ADMW_CORE_Sensor_Details_t sensorDetailsReg;
ADIJake	0:85855ecd3257	1335
ADIJake	0:85855ecd3257	1336	sensorDetailsReg.VALUE32 = REG_RESET_VAL(CORE_SENSOR_DETAILSn);
ADIJake	0:85855ecd3257	1337
Vkadaba	23:bb685f35b08b	1338	switch(pChannelConfig->measurementUnit) {
Vkadaba	8:2f2775c34640	1339	case ADMW1001_MEASUREMENT_UNIT_FAHRENHEIT:
Vkadaba	8:2f2775c34640	1340	sensorDetailsReg.Measurement_Units = CORE_SENSOR_DETAILS_UNITS_DEGF;
Vkadaba	8:2f2775c34640	1341	break;
Vkadaba	8:2f2775c34640	1342	case ADMW1001_MEASUREMENT_UNIT_CELSIUS:
Vkadaba	8:2f2775c34640	1343	sensorDetailsReg.Measurement_Units = CORE_SENSOR_DETAILS_UNITS_DEGC;
Vkadaba	8:2f2775c34640	1344	break;
Vkadaba	8:2f2775c34640	1345	case ADMW1001_MEASUREMENT_UNIT_UNSPECIFIED:
Vkadaba	8:2f2775c34640	1346	sensorDetailsReg.Measurement_Units = CORE_SENSOR_DETAILS_UNITS_UNSPECIFIED;
Vkadaba	8:2f2775c34640	1347	break;
Vkadaba	8:2f2775c34640	1348	default:
Vkadaba	8:2f2775c34640	1349	ADMW_LOG_ERROR("Invalid measurement unit %d specified",
Vkadaba	8:2f2775c34640	1350	pChannelConfig->measurementUnit);
Vkadaba	8:2f2775c34640	1351	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1352	}
ADIJake	0:85855ecd3257	1353
Vkadaba	23:bb685f35b08b	1354	if (pChannelConfig->compensationChannel == ADMW1001_CH_ID_NONE) {
ADIJake	0:85855ecd3257	1355	sensorDetailsReg.Compensation_Disable = 1;
ADIJake	0:85855ecd3257	1356	sensorDetailsReg.Compensation_Channel = 0;
Vkadaba	23:bb685f35b08b	1357	} else {
ADIJake	0:85855ecd3257	1358	sensorDetailsReg.Compensation_Disable = 0;
ADIJake	0:85855ecd3257	1359	sensorDetailsReg.Compensation_Channel = pChannelConfig->compensationChannel;
ADIJake	0:85855ecd3257	1360	}
ADIJake	0:85855ecd3257	1361
Vkadaba	23:bb685f35b08b	1362	switch(refType) {
Vkadaba	8:2f2775c34640	1363	case ADMW1001_ADC_REFERENCE_VOLTAGE_INTERNAL:
Vkadaba	8:2f2775c34640	1364	sensorDetailsReg.Reference_Select = CORE_SENSOR_DETAILS_REF_VINT;
Vkadaba	8:2f2775c34640	1365	break;
Vkadaba	8:2f2775c34640	1366	case ADMW1001_ADC_REFERENCE_VOLTAGE_EXTERNAL_1:
Vkadaba	8:2f2775c34640	1367	sensorDetailsReg.Reference_Select = CORE_SENSOR_DETAILS_REF_VEXT1;
Vkadaba	8:2f2775c34640	1368	break;
Vkadaba	8:2f2775c34640	1369	case ADMW1001_ADC_REFERENCE_VOLTAGE_AVDD:
Vkadaba	8:2f2775c34640	1370	sensorDetailsReg.Reference_Select = CORE_SENSOR_DETAILS_REF_AVDD;
Vkadaba	8:2f2775c34640	1371	break;
Vkadaba	8:2f2775c34640	1372	default:
Vkadaba	8:2f2775c34640	1373	ADMW_LOG_ERROR("Invalid ADC reference type %d specified", refType);
Vkadaba	8:2f2775c34640	1374	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1375	}
Vkadaba	23:bb685f35b08b	1376
Vkadaba	23:bb685f35b08b	1377	switch(pAdcChannelConfig->gain) {
Vkadaba	8:2f2775c34640	1378	case ADMW1001_ADC_GAIN_1X:
Vkadaba	8:2f2775c34640	1379	sensorDetailsReg.PGA_Gain = CORE_SENSOR_DETAILS_PGA_GAIN_1;
Vkadaba	8:2f2775c34640	1380	break;
Vkadaba	8:2f2775c34640	1381	case ADMW1001_ADC_GAIN_2X:
Vkadaba	8:2f2775c34640	1382	sensorDetailsReg.PGA_Gain = CORE_SENSOR_DETAILS_PGA_GAIN_2;
Vkadaba	8:2f2775c34640	1383	break;
Vkadaba	8:2f2775c34640	1384	case ADMW1001_ADC_GAIN_4X:
Vkadaba	8:2f2775c34640	1385	sensorDetailsReg.PGA_Gain = CORE_SENSOR_DETAILS_PGA_GAIN_4;
Vkadaba	8:2f2775c34640	1386	break;
Vkadaba	8:2f2775c34640	1387	case ADMW1001_ADC_GAIN_8X:
Vkadaba	8:2f2775c34640	1388	sensorDetailsReg.PGA_Gain = CORE_SENSOR_DETAILS_PGA_GAIN_8;
Vkadaba	8:2f2775c34640	1389	break;
Vkadaba	8:2f2775c34640	1390	case ADMW1001_ADC_GAIN_16X:
Vkadaba	8:2f2775c34640	1391	sensorDetailsReg.PGA_Gain = CORE_SENSOR_DETAILS_PGA_GAIN_16;
Vkadaba	8:2f2775c34640	1392	break;
Vkadaba	8:2f2775c34640	1393	case ADMW1001_ADC_GAIN_32X:
Vkadaba	8:2f2775c34640	1394	sensorDetailsReg.PGA_Gain = CORE_SENSOR_DETAILS_PGA_GAIN_32;
Vkadaba	8:2f2775c34640	1395	break;
Vkadaba	8:2f2775c34640	1396	case ADMW1001_ADC_GAIN_64X:
Vkadaba	8:2f2775c34640	1397	sensorDetailsReg.PGA_Gain = CORE_SENSOR_DETAILS_PGA_GAIN_64;
Vkadaba	8:2f2775c34640	1398	break;
Vkadaba	8:2f2775c34640	1399	case ADMW1001_ADC_GAIN_128X:
Vkadaba	8:2f2775c34640	1400	sensorDetailsReg.PGA_Gain = CORE_SENSOR_DETAILS_PGA_GAIN_128;
Vkadaba	8:2f2775c34640	1401	break;
Vkadaba	8:2f2775c34640	1402	default:
Vkadaba	8:2f2775c34640	1403	ADMW_LOG_ERROR("Invalid ADC gain %d specified",
Vkadaba	23:bb685f35b08b	1404	pAdcChannelConfig->gain);
Vkadaba	8:2f2775c34640	1405	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1406	}
ADIJake	0:85855ecd3257	1407
Vkadaba	23:bb685f35b08b	1408	switch(pAdcChannelConfig->rtdCurve) {
Vkadaba	8:2f2775c34640	1409	case ADMW1001_ADC_RTD_CURVE_EUROPEAN:
Vkadaba	8:2f2775c34640	1410	sensorDetailsReg.RTD_Curve = CORE_SENSOR_DETAILS_EUROPEAN_CURVE;
Vkadaba	8:2f2775c34640	1411	break;
Vkadaba	8:2f2775c34640	1412	case ADMW1001_ADC_RTD_CURVE_AMERICAN:
Vkadaba	8:2f2775c34640	1413	sensorDetailsReg.RTD_Curve = CORE_SENSOR_DETAILS_AMERICAN_CURVE;
Vkadaba	8:2f2775c34640	1414	break;
Vkadaba	8:2f2775c34640	1415	case ADMW1001_ADC_RTD_CURVE_JAPANESE:
Vkadaba	8:2f2775c34640	1416	sensorDetailsReg.RTD_Curve = CORE_SENSOR_DETAILS_JAPANESE_CURVE;
Vkadaba	8:2f2775c34640	1417	break;
Vkadaba	8:2f2775c34640	1418	case ADMW1001_ADC_RTD_CURVE_ITS90:
Vkadaba	8:2f2775c34640	1419	sensorDetailsReg.RTD_Curve = CORE_SENSOR_DETAILS_ITS90_CURVE;
Vkadaba	8:2f2775c34640	1420	break;
Vkadaba	8:2f2775c34640	1421	default:
Vkadaba	8:2f2775c34640	1422	ADMW_LOG_ERROR("Invalid RTD Curve %d specified",
Vkadaba	23:bb685f35b08b	1423	pAdcChannelConfig->rtdCurve);
Vkadaba	8:2f2775c34640	1424	return ADMW_INVALID_PARAM;
Vkadaba	6:9d393a9677f4	1425	}
Vkadaba	6:9d393a9677f4	1426
Vkadaba	23:bb685f35b08b	1427	if (pChannelConfig->disablePublishing) {
ADIJake	0:85855ecd3257	1428	sensorDetailsReg.Do_Not_Publish = 1;
Vkadaba	23:bb685f35b08b	1429	} else {
ADIJake	0:85855ecd3257	1430	sensorDetailsReg.Do_Not_Publish = 0;
Vkadaba	8:2f2775c34640	1431	}
Vkadaba	23:bb685f35b08b	1432
Vkadaba	23:bb685f35b08b	1433	switch (pChannelConfig->lutSelect) {
Vkadaba	8:2f2775c34640	1434	case ADMW1001_LUT_DEFAULT:
Vkadaba	8:2f2775c34640	1435	case ADMW1001_LUT_UNITY:
Vkadaba	8:2f2775c34640	1436	case ADMW1001_LUT_CUSTOM:
Vkadaba	8:2f2775c34640	1437	sensorDetailsReg.LUT_Select = pChannelConfig->lutSelect;
Vkadaba	8:2f2775c34640	1438	break;
Vkadaba	8:2f2775c34640	1439	default:
Vkadaba	8:2f2775c34640	1440	ADMW_LOG_ERROR("Invalid LUT selection %d specified",
Vkadaba	23:bb685f35b08b	1441	pChannelConfig->lutSelect);
Vkadaba	23:bb685f35b08b	1442	return ADMW_INVALID_PARAM;
Vkadaba	8:2f2775c34640	1443	}
Vkadaba	23:bb685f35b08b	1444
ADIJake	0:85855ecd3257	1445	WRITE_REG_U32(hDevice, sensorDetailsReg.VALUE32, CORE_SENSOR_DETAILSn(eChannelId));
ADIJake	0:85855ecd3257	1446
Vkadaba	5:0728bde67bdb	1447	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1448	}
ADIJake	0:85855ecd3257	1449
Vkadaba	33:df7a00f1b8e1	1450	static ADMW_RESULT admw_SetChannelAdcMeasurementSetup(
Vkadaba	5:0728bde67bdb	1451	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1452	ADMW1001_CH_ID eChannelId,
Vkadaba	33:df7a00f1b8e1	1453	ADMW1001_ADC_CHANNEL_CONFIG *pAdcChannelConfig)
ADIJake	0:85855ecd3257	1454	{
Vkadaba	8:2f2775c34640	1455	ADMW_CORE_Measurement_Setup_t MeasSetupReg;
Vkadaba	33:df7a00f1b8e1	1456	ADMW1001_ADC_FILTER_CONFIG *pFilterConfig = &pAdcChannelConfig->filter;
Vkadaba	6:9d393a9677f4	1457	MeasSetupReg.VALUE32 = REG_RESET_VAL(CORE_MEASUREMENT_SETUPn);
Vkadaba	33:df7a00f1b8e1	1458	MeasSetupReg.PST_MEAS_EXC_CTRL = pAdcChannelConfig->current.excitationState;
Vkadaba	33:df7a00f1b8e1	1459	MeasSetupReg.Buffer_Bypass = pAdcChannelConfig->bufferBypass;
Vkadaba	33:df7a00f1b8e1	1460
Vkadaba	23:bb685f35b08b	1461	if (pFilterConfig->type == ADMW1001_ADC_FILTER_SINC4) {
Vkadaba	6:9d393a9677f4	1462	MeasSetupReg.ADC_Filter_Type = CORE_MEASUREMENT_SETUP_ENABLE_SINC4;
Vkadaba	6:9d393a9677f4	1463	MeasSetupReg.ADC_SF = pFilterConfig->sf;
Vkadaba	23:bb685f35b08b	1464	} else if (pFilterConfig->type == ADMW1001_ADC_FILTER_SINC3) {
Vkadaba	6:9d393a9677f4	1465	MeasSetupReg.ADC_Filter_Type = CORE_MEASUREMENT_SETUP_ENABLE_SINC3;
Vkadaba	23:bb685f35b08b	1466	MeasSetupReg.ADC_SF = pFilterConfig->sf;
Vkadaba	23:bb685f35b08b	1467	} else {
Vkadaba	5:0728bde67bdb	1468	ADMW_LOG_ERROR("Invalid ADC filter type %d specified",
Vkadaba	23:bb685f35b08b	1469	pFilterConfig->type);
Vkadaba	5:0728bde67bdb	1470	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1471	}
Vkadaba	23:bb685f35b08b	1472
Vkadaba	8:2f2775c34640	1473	/* chop mod ecan be 0 (none), 1 (HW, 2 (SW, 3 (HW+SW). */
Vkadaba	17:2f0028880874	1474	MeasSetupReg.Chop_Mode = pFilterConfig->chopMode;
Vkadaba	23:bb685f35b08b	1475
Vkadaba	6:9d393a9677f4	1476	if(pFilterConfig->notch1p2)
Vkadaba	6:9d393a9677f4	1477	MeasSetupReg.NOTCH_EN_2 = 1;
Vkadaba	6:9d393a9677f4	1478	else
Vkadaba	6:9d393a9677f4	1479	MeasSetupReg.NOTCH_EN_2 = 0;
Vkadaba	23:bb685f35b08b	1480
Vkadaba	23:bb685f35b08b	1481	switch(pFilterConfig->groundSwitch) {
Vkadaba	23:bb685f35b08b	1482	case ADMW1001_ADC_GND_SW_OPEN:
Vkadaba	23:bb685f35b08b	1483	MeasSetupReg.GND_SW = CORE_MEASUREMENT_SETUP_GND_SW_OPEN;
Vkadaba	23:bb685f35b08b	1484	break;
Vkadaba	23:bb685f35b08b	1485	case ADMW1001_ADC_GND_SW_CLOSED:
Vkadaba	23:bb685f35b08b	1486	MeasSetupReg.GND_SW = CORE_MEASUREMENT_SETUP_GND_SW_CLOSED;
Vkadaba	23:bb685f35b08b	1487	break;
Vkadaba	23:bb685f35b08b	1488	default:
Vkadaba	23:bb685f35b08b	1489	ADMW_LOG_ERROR("Invalid ground switch state %d specified",
Vkadaba	23:bb685f35b08b	1490	pFilterConfig->groundSwitch);
Vkadaba	23:bb685f35b08b	1491	return ADMW_INVALID_PARAM;
Vkadaba	6:9d393a9677f4	1492	}
Vkadaba	23:bb685f35b08b	1493
Vkadaba	6:9d393a9677f4	1494	WRITE_REG_U32(hDevice, MeasSetupReg.VALUE32, CORE_MEASUREMENT_SETUPn(eChannelId));
ADIJake	0:85855ecd3257	1495
Vkadaba	5:0728bde67bdb	1496	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1497	}
ADIJake	0:85855ecd3257	1498
Vkadaba	5:0728bde67bdb	1499	static ADMW_RESULT admw_SetChannelAdcCurrentConfig(
Vkadaba	5:0728bde67bdb	1500	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1501	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1502	ADMW1001_ADC_EXC_CURRENT_CONFIG *pCurrentConfig)
ADIJake	0:85855ecd3257	1503	{
Vkadaba	8:2f2775c34640	1504	ADMW_CORE_Channel_Excitation_t channelExcitationReg;
ADIJake	0:85855ecd3257	1505
Vkadaba	6:9d393a9677f4	1506	channelExcitationReg.VALUE16 = REG_RESET_VAL(CORE_CHANNEL_EXCITATIONn);
Vkadaba	6:9d393a9677f4	1507
Vkadaba	18:cbf514cce921	1508	if (pCurrentConfig->outputLevel == ADMW1001_ADC_NO_EXTERNAL_EXC_CURRENT)
Vkadaba	18:cbf514cce921	1509	channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_NONE;
Vkadaba	18:cbf514cce921	1510	else if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_EXTERNAL)
Vkadaba	6:9d393a9677f4	1511	channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_EXTERNAL;
Vkadaba	18:cbf514cce921	1512	else if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_50uA)
Vkadaba	6:9d393a9677f4	1513	channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_IEXC_50UA;
Vkadaba	6:9d393a9677f4	1514	else if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_100uA)
Vkadaba	6:9d393a9677f4	1515	channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_IEXC_100UA;
Vkadaba	6:9d393a9677f4	1516	else if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_250uA)
Vkadaba	6:9d393a9677f4	1517	channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_IEXC_250UA;
Vkadaba	6:9d393a9677f4	1518	else if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_500uA)
Vkadaba	6:9d393a9677f4	1519	channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_IEXC_500UA;
Vkadaba	6:9d393a9677f4	1520	else if (pCurrentConfig->outputLevel == ADMW1001_ADC_EXC_CURRENT_1000uA)
Vkadaba	6:9d393a9677f4	1521	channelExcitationReg.IOUT_Excitation_Current = CORE_CHANNEL_EXCITATION_IEXC_1000UA;
Vkadaba	23:bb685f35b08b	1522	else {
Vkadaba	6:9d393a9677f4	1523	ADMW_LOG_ERROR("Invalid ADC excitation current %d specified",
Vkadaba	6:9d393a9677f4	1524	pCurrentConfig->outputLevel);
Vkadaba	6:9d393a9677f4	1525	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1526	}
ADIJake	0:85855ecd3257	1527
Vkadaba	6:9d393a9677f4	1528	WRITE_REG_U16(hDevice, channelExcitationReg.VALUE16, CORE_CHANNEL_EXCITATIONn(eChannelId));
ADIJake	0:85855ecd3257	1529
Vkadaba	5:0728bde67bdb	1530	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1531	}
ADIJake	0:85855ecd3257	1532
Vkadaba	5:0728bde67bdb	1533	ADMW_RESULT admw_SetAdcChannelConfig(
Vkadaba	5:0728bde67bdb	1534	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1535	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1536	ADMW1001_CHANNEL_CONFIG *pChannelConfig)
ADIJake	0:85855ecd3257	1537	{
Vkadaba	5:0728bde67bdb	1538	ADMW_RESULT eRet;
Vkadaba	5:0728bde67bdb	1539	ADMW1001_ADC_CHANNEL_CONFIG *pAdcChannelConfig =
ADIJake	0:85855ecd3257	1540	&pChannelConfig->adcChannelConfig;
ADIJake	0:85855ecd3257	1541
Vkadaba	5:0728bde67bdb	1542	eRet = admw_SetChannelAdcSensorType(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	1543	pAdcChannelConfig->sensor);
Vkadaba	23:bb685f35b08b	1544	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1545	ADMW_LOG_ERROR("Failed to set ADC sensor type for channel %d",
Vkadaba	23:bb685f35b08b	1546	eChannelId);
ADIJake	0:85855ecd3257	1547	return eRet;
ADIJake	0:85855ecd3257	1548	}
ADIJake	0:85855ecd3257	1549
Vkadaba	5:0728bde67bdb	1550	eRet = admw_SetChannelAdcSensorDetails(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	1551	pChannelConfig);
Vkadaba	23:bb685f35b08b	1552	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1553	ADMW_LOG_ERROR("Failed to set ADC sensor details for channel %d",
Vkadaba	23:bb685f35b08b	1554	eChannelId);
ADIJake	0:85855ecd3257	1555	return eRet;
ADIJake	0:85855ecd3257	1556	}
ADIJake	0:85855ecd3257	1557
Vkadaba	33:df7a00f1b8e1	1558	eRet = admw_SetChannelAdcMeasurementSetup(hDevice, eChannelId,
Vkadaba	33:df7a00f1b8e1	1559	pAdcChannelConfig);
Vkadaba	23:bb685f35b08b	1560	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1561	ADMW_LOG_ERROR("Failed to set ADC filter for channel %d",
Vkadaba	23:bb685f35b08b	1562	eChannelId);
ADIJake	0:85855ecd3257	1563	return eRet;
ADIJake	0:85855ecd3257	1564	}
ADIJake	0:85855ecd3257	1565
Vkadaba	5:0728bde67bdb	1566	eRet = admw_SetChannelAdcCurrentConfig(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	1567	&pAdcChannelConfig->current);
Vkadaba	23:bb685f35b08b	1568	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1569	ADMW_LOG_ERROR("Failed to set ADC current for channel %d",
Vkadaba	23:bb685f35b08b	1570	eChannelId);
ADIJake	0:85855ecd3257	1571	return eRet;
ADIJake	0:85855ecd3257	1572	}
ADIJake	0:85855ecd3257	1573
Vkadaba	5:0728bde67bdb	1574	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1575	}
ADIJake	0:85855ecd3257	1576
Vkadaba	5:0728bde67bdb	1577	static ADMW_RESULT admw_SetChannelDigitalSensorDetails(
Vkadaba	5:0728bde67bdb	1578	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1579	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1580	ADMW1001_CHANNEL_CONFIG *pChannelConfig)
ADIJake	0:85855ecd3257	1581	{
Vkadaba	8:2f2775c34640	1582	ADMW_CORE_Sensor_Details_t sensorDetailsReg;
ADIJake	0:85855ecd3257	1583
ADIJake	0:85855ecd3257	1584	sensorDetailsReg.VALUE32 = REG_RESET_VAL(CORE_SENSOR_DETAILSn);
ADIJake	0:85855ecd3257	1585
Vkadaba	23:bb685f35b08b	1586	if (pChannelConfig->compensationChannel == ADMW1001_CH_ID_NONE) {
ADIJake	0:85855ecd3257	1587	sensorDetailsReg.Compensation_Disable = 1;
ADIJake	0:85855ecd3257	1588	sensorDetailsReg.Compensation_Channel = 0;
Vkadaba	23:bb685f35b08b	1589	} else {
Vkadaba	5:0728bde67bdb	1590	ADMW_LOG_ERROR("Invalid compensation channel specified for digital sensor");
Vkadaba	5:0728bde67bdb	1591	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1592	}
ADIJake	0:85855ecd3257	1593
Vkadaba	23:bb685f35b08b	1594	if (pChannelConfig->measurementUnit == ADMW1001_MEASUREMENT_UNIT_UNSPECIFIED) {
Vkadaba	5:0728bde67bdb	1595	sensorDetailsReg.Measurement_Units = CORE_SENSOR_DETAILS_UNITS_UNSPECIFIED;
Vkadaba	23:bb685f35b08b	1596	} else {
Vkadaba	5:0728bde67bdb	1597	ADMW_LOG_ERROR("Invalid measurement unit specified for digital channel");
Vkadaba	5:0728bde67bdb	1598	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1599	}
ADIJake	0:85855ecd3257	1600
ADIJake	0:85855ecd3257	1601	if (pChannelConfig->disablePublishing)
ADIJake	0:85855ecd3257	1602	sensorDetailsReg.Do_Not_Publish = 1;
ADIJake	0:85855ecd3257	1603	else
ADIJake	0:85855ecd3257	1604	sensorDetailsReg.Do_Not_Publish = 0;
ADIJake	0:85855ecd3257	1605
ADIJake	0:85855ecd3257	1606	WRITE_REG_U32(hDevice, sensorDetailsReg.VALUE32, CORE_SENSOR_DETAILSn(eChannelId));
ADIJake	0:85855ecd3257	1607
Vkadaba	5:0728bde67bdb	1608	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1609	}
ADIJake	0:85855ecd3257	1610
Vkadaba	5:0728bde67bdb	1611	static ADMW_RESULT admw_SetDigitalSensorFormat(
Vkadaba	5:0728bde67bdb	1612	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1613	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1614	ADMW1001_DIGITAL_SENSOR_DATA_FORMAT *pDataFormat)
ADIJake	0:85855ecd3257	1615	{
Vkadaba	8:2f2775c34640	1616	ADMW_CORE_Digital_Sensor_Config_t sensorConfigReg;
ADIJake	0:85855ecd3257	1617
ADIJake	0:85855ecd3257	1618	sensorConfigReg.VALUE16 = REG_RESET_VAL(CORE_DIGITAL_SENSOR_CONFIGn);
ADIJake	0:85855ecd3257	1619
Vkadaba	23:bb685f35b08b	1620	if (pDataFormat->coding != ADMW1001_DIGITAL_SENSOR_DATA_CODING_NONE) {
Vkadaba	23:bb685f35b08b	1621	if (pDataFormat->frameLength == 0) {
Vkadaba	5:0728bde67bdb	1622	ADMW_LOG_ERROR("Invalid frame length specified for digital sensor data format");
Vkadaba	5:0728bde67bdb	1623	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1624	}
Vkadaba	23:bb685f35b08b	1625	if (pDataFormat->numDataBits == 0) {
Vkadaba	5:0728bde67bdb	1626	ADMW_LOG_ERROR("Invalid frame length specified for digital sensor data format");
Vkadaba	5:0728bde67bdb	1627	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1628	}
ADIJake	0:85855ecd3257	1629
ADIJake	0:85855ecd3257	1630	CHECK_REG_FIELD_VAL(CORE_DIGITAL_SENSOR_CONFIG_DIGITAL_SENSOR_READ_BYTES,
ADIJake	0:85855ecd3257	1631	pDataFormat->frameLength - 1);
ADIJake	0:85855ecd3257	1632	CHECK_REG_FIELD_VAL(CORE_DIGITAL_SENSOR_CONFIG_DIGITAL_SENSOR_DATA_BITS,
ADIJake	0:85855ecd3257	1633	pDataFormat->numDataBits - 1);
ADIJake	0:85855ecd3257	1634	CHECK_REG_FIELD_VAL(CORE_DIGITAL_SENSOR_CONFIG_DIGITAL_SENSOR_BIT_OFFSET,
ADIJake	0:85855ecd3257	1635	pDataFormat->bitOffset);
ADIJake	0:85855ecd3257	1636
ADIJake	0:85855ecd3257	1637	sensorConfigReg.Digital_Sensor_Read_Bytes = pDataFormat->frameLength - 1;
ADIJake	0:85855ecd3257	1638	sensorConfigReg.Digital_Sensor_Data_Bits = pDataFormat->numDataBits - 1;
ADIJake	0:85855ecd3257	1639	sensorConfigReg.Digital_Sensor_Bit_Offset = pDataFormat->bitOffset;
ADIJake	0:85855ecd3257	1640	sensorConfigReg.Digital_Sensor_Left_Aligned = pDataFormat->leftJustified ? 1 : 0;
ADIJake	0:85855ecd3257	1641	sensorConfigReg.Digital_Sensor_Little_Endian = pDataFormat->littleEndian ? 1 : 0;
ADIJake	0:85855ecd3257	1642
Vkadaba	23:bb685f35b08b	1643	switch (pDataFormat->coding) {
Vkadaba	23:bb685f35b08b	1644	case ADMW1001_DIGITAL_SENSOR_DATA_CODING_UNIPOLAR:
Vkadaba	23:bb685f35b08b	1645	sensorConfigReg.Digital_Sensor_Coding = CORE_DIGITAL_SENSOR_CONFIG_CODING_UNIPOLAR;
Vkadaba	23:bb685f35b08b	1646	break;
Vkadaba	23:bb685f35b08b	1647	case ADMW1001_DIGITAL_SENSOR_DATA_CODING_TWOS_COMPLEMENT:
Vkadaba	23:bb685f35b08b	1648	sensorConfigReg.Digital_Sensor_Coding = CORE_DIGITAL_SENSOR_CONFIG_CODING_TWOS_COMPL;
Vkadaba	23:bb685f35b08b	1649	break;
Vkadaba	23:bb685f35b08b	1650	case ADMW1001_DIGITAL_SENSOR_DATA_CODING_OFFSET_BINARY:
Vkadaba	23:bb685f35b08b	1651	sensorConfigReg.Digital_Sensor_Coding = CORE_DIGITAL_SENSOR_CONFIG_CODING_OFFSET_BINARY;
Vkadaba	23:bb685f35b08b	1652	break;
Vkadaba	23:bb685f35b08b	1653	default:
Vkadaba	23:bb685f35b08b	1654	ADMW_LOG_ERROR("Invalid coding specified for digital sensor data format");
Vkadaba	23:bb685f35b08b	1655	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1656	}
Vkadaba	23:bb685f35b08b	1657	} else {
Vkadaba	5:0728bde67bdb	1658	sensorConfigReg.Digital_Sensor_Coding = CORE_DIGITAL_SENSOR_CONFIG_CODING_NONE;
ADIJake	0:85855ecd3257	1659	}
ADIJake	0:85855ecd3257	1660
ADIJake	0:85855ecd3257	1661	WRITE_REG_U16(hDevice, sensorConfigReg.VALUE16,
ADIJake	0:85855ecd3257	1662	CORE_DIGITAL_SENSOR_CONFIGn(eChannelId));
ADIJake	0:85855ecd3257	1663
ADIJake	0:85855ecd3257	1664
Vkadaba	5:0728bde67bdb	1665	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1666	}
ADIJake	0:85855ecd3257	1667
Vkadaba	5:0728bde67bdb	1668	static ADMW_RESULT admw_SetDigitalCalibrationParam(
Vkadaba	23:bb685f35b08b	1669	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	23:bb685f35b08b	1670	ADMW1001_CH_ID eChannelId,
Vkadaba	23:bb685f35b08b	1671	ADMW1001_DIGITAL_CALIBRATION_COMMAND *pCalibrationParam)
ADIJake	0:85855ecd3257	1672	{
Vkadaba	32:52445bef314d	1673	// ADMW_CORE_Calibration_Parameter_t calibrationParamReg;
Vkadaba	32:52445bef314d	1674	//
Vkadaba	32:52445bef314d	1675	// calibrationParamReg.VALUE32 = REG_RESET_VAL(CORE_CALIBRATION_PARAMETERn);
Vkadaba	32:52445bef314d	1676	//
Vkadaba	32:52445bef314d	1677	// if (pCalibrationParam->enableCalibrationParam == false)
Vkadaba	32:52445bef314d	1678	// calibrationParamReg.Calibration_Parameter_Enable = 0;
Vkadaba	32:52445bef314d	1679	// else
Vkadaba	32:52445bef314d	1680	// calibrationParamReg.Calibration_Parameter_Enable = 1;
Vkadaba	32:52445bef314d	1681	//
Vkadaba	32:52445bef314d	1682	// CHECK_REG_FIELD_VAL(CORE_CALIBRATION_PARAMETER_CALIBRATION_PARAMETER,
Vkadaba	32:52445bef314d	1683	// pCalibrationParam->calibrationParam);
Vkadaba	32:52445bef314d	1684	//
Vkadaba	32:52445bef314d	1685	// calibrationParamReg.Calibration_Parameter = pCalibrationParam->calibrationParam;
Vkadaba	32:52445bef314d	1686	//
Vkadaba	32:52445bef314d	1687	// WRITE_REG_U32(hDevice, calibrationParamReg.VALUE32,
Vkadaba	32:52445bef314d	1688	// CORE_CALIBRATION_PARAMETERn(eChannelId));
Vkadaba	32:52445bef314d	1689	//
Vkadaba	5:0728bde67bdb	1690	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1691	}
ADIJake	0:85855ecd3257	1692
Vkadaba	5:0728bde67bdb	1693	static ADMW_RESULT admw_SetChannelI2cSensorType(
Vkadaba	5:0728bde67bdb	1694	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1695	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1696	ADMW1001_I2C_SENSOR_TYPE sensorType)
ADIJake	0:85855ecd3257	1697	{
Vkadaba	8:2f2775c34640	1698	ADMW_CORE_Sensor_Type_t sensorTypeReg;
ADIJake	0:85855ecd3257	1699
ADIJake	0:85855ecd3257	1700	sensorTypeReg.VALUE16 = REG_RESET_VAL(CORE_SENSOR_TYPEn);
ADIJake	0:85855ecd3257	1701
ADIJake	0:85855ecd3257	1702	/* Ensure that the sensor type is valid for this channel */
Vkadaba	23:bb685f35b08b	1703	switch(sensorType) {
Vkadaba	8:2f2775c34640	1704	case ADMW1001_I2C_SENSOR_HUMIDITY_A:
Vkadaba	8:2f2775c34640	1705	case ADMW1001_I2C_SENSOR_HUMIDITY_B:
Vkadaba	8:2f2775c34640	1706	sensorTypeReg.Sensor_Type = sensorType;
Vkadaba	8:2f2775c34640	1707	break;
Vkadaba	8:2f2775c34640	1708	default:
Vkadaba	8:2f2775c34640	1709	ADMW_LOG_ERROR("Unsupported I2C sensor type %d specified", sensorType);
Vkadaba	8:2f2775c34640	1710	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1711	}
ADIJake	0:85855ecd3257	1712
ADIJake	0:85855ecd3257	1713	WRITE_REG_U16(hDevice, sensorTypeReg.VALUE16, CORE_SENSOR_TYPEn(eChannelId));
ADIJake	0:85855ecd3257	1714
Vkadaba	5:0728bde67bdb	1715	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1716	}
ADIJake	0:85855ecd3257	1717
Vkadaba	5:0728bde67bdb	1718	static ADMW_RESULT admw_SetChannelI2cSensorAddress(
Vkadaba	5:0728bde67bdb	1719	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1720	ADMW1001_CH_ID eChannelId,
ADIJake	0:85855ecd3257	1721	uint32_t deviceAddress)
ADIJake	0:85855ecd3257	1722	{
ADIJake	0:85855ecd3257	1723	CHECK_REG_FIELD_VAL(CORE_DIGITAL_SENSOR_ADDRESS_DIGITAL_SENSOR_ADDRESS, deviceAddress);
ADIJake	0:85855ecd3257	1724	WRITE_REG_U8(hDevice, deviceAddress, CORE_DIGITAL_SENSOR_ADDRESSn(eChannelId));
ADIJake	0:85855ecd3257	1725
Vkadaba	5:0728bde67bdb	1726	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1727	}
ADIJake	0:85855ecd3257	1728
Vkadaba	5:0728bde67bdb	1729	static ADMW_RESULT admw_SetDigitalChannelComms(
Vkadaba	5:0728bde67bdb	1730	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1731	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1732	ADMW1001_DIGITAL_SENSOR_COMMS *pDigitalComms)
ADIJake	0:85855ecd3257	1733	{
Vkadaba	8:2f2775c34640	1734	ADMW_CORE_Digital_Sensor_Comms_t digitalSensorComms;
ADIJake	0:85855ecd3257	1735
ADIJake	0:85855ecd3257	1736	digitalSensorComms.VALUE16 = REG_RESET_VAL(CORE_DIGITAL_SENSOR_COMMSn);
ADIJake	0:85855ecd3257	1737
Vkadaba	23:bb685f35b08b	1738	if(pDigitalComms->useCustomCommsConfig) {
ADIJake	0:85855ecd3257	1739	digitalSensorComms.Digital_Sensor_Comms_En = 1;
ADIJake	0:85855ecd3257	1740
Vkadaba	23:bb685f35b08b	1741	if(pDigitalComms->i2cClockSpeed == ADMW1001_DIGITAL_SENSOR_COMMS_I2C_CLOCK_SPEED_100K) {
Vkadaba	5:0728bde67bdb	1742	digitalSensorComms.I2C_Clock = CORE_DIGITAL_SENSOR_COMMS_I2C_100K;
Vkadaba	23:bb685f35b08b	1743	} else if(pDigitalComms->i2cClockSpeed == ADMW1001_DIGITAL_SENSOR_COMMS_I2C_CLOCK_SPEED_400K) {
Vkadaba	5:0728bde67bdb	1744	digitalSensorComms.I2C_Clock = CORE_DIGITAL_SENSOR_COMMS_I2C_400K;
Vkadaba	23:bb685f35b08b	1745	} else {
Vkadaba	5:0728bde67bdb	1746	ADMW_LOG_ERROR("Invalid I2C clock speed %d specified",
Vkadaba	23:bb685f35b08b	1747	pDigitalComms->i2cClockSpeed);
Vkadaba	5:0728bde67bdb	1748	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1749	}
ADIJake	0:85855ecd3257	1750
Vkadaba	23:bb685f35b08b	1751	if(pDigitalComms->spiMode == ADMW1001_DIGITAL_SENSOR_COMMS_SPI_MODE_0) {
Vkadaba	5:0728bde67bdb	1752	digitalSensorComms.SPI_Mode = CORE_DIGITAL_SENSOR_COMMS_SPI_MODE_0;
Vkadaba	23:bb685f35b08b	1753	} else if(pDigitalComms->spiMode == ADMW1001_DIGITAL_SENSOR_COMMS_SPI_MODE_1) {
Vkadaba	5:0728bde67bdb	1754	digitalSensorComms.SPI_Mode = CORE_DIGITAL_SENSOR_COMMS_SPI_MODE_1;
Vkadaba	23:bb685f35b08b	1755	} else if(pDigitalComms->spiMode == ADMW1001_DIGITAL_SENSOR_COMMS_SPI_MODE_2) {
Vkadaba	5:0728bde67bdb	1756	digitalSensorComms.SPI_Mode = CORE_DIGITAL_SENSOR_COMMS_SPI_MODE_2;
Vkadaba	23:bb685f35b08b	1757	} else if(pDigitalComms->spiMode == ADMW1001_DIGITAL_SENSOR_COMMS_SPI_MODE_3) {
Vkadaba	5:0728bde67bdb	1758	digitalSensorComms.SPI_Mode = CORE_DIGITAL_SENSOR_COMMS_SPI_MODE_3;
Vkadaba	23:bb685f35b08b	1759	} else {
Vkadaba	5:0728bde67bdb	1760	ADMW_LOG_ERROR("Invalid SPI mode %d specified",
Vkadaba	23:bb685f35b08b	1761	pDigitalComms->spiMode);
Vkadaba	5:0728bde67bdb	1762	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1763	}
ADIJake	0:85855ecd3257	1764
Vkadaba	23:bb685f35b08b	1765	switch (pDigitalComms->spiClock) {
Vkadaba	23:bb685f35b08b	1766	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_8MHZ:
Vkadaba	23:bb685f35b08b	1767	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_8MHZ;
Vkadaba	23:bb685f35b08b	1768	break;
Vkadaba	23:bb685f35b08b	1769	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_4MHZ:
Vkadaba	23:bb685f35b08b	1770	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_4MHZ;
Vkadaba	23:bb685f35b08b	1771	break;
Vkadaba	23:bb685f35b08b	1772	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_2MHZ:
Vkadaba	23:bb685f35b08b	1773	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_2MHZ;
Vkadaba	23:bb685f35b08b	1774	break;
Vkadaba	23:bb685f35b08b	1775	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_1MHZ:
Vkadaba	23:bb685f35b08b	1776	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_1MHZ;
Vkadaba	23:bb685f35b08b	1777	break;
Vkadaba	23:bb685f35b08b	1778	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_500KHZ:
Vkadaba	23:bb685f35b08b	1779	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_500KHZ;
Vkadaba	23:bb685f35b08b	1780	break;
Vkadaba	23:bb685f35b08b	1781	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_250KHZ:
Vkadaba	23:bb685f35b08b	1782	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_250KHZ;
Vkadaba	23:bb685f35b08b	1783	break;
Vkadaba	23:bb685f35b08b	1784	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_125KHZ:
Vkadaba	23:bb685f35b08b	1785	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_125KHZ;
Vkadaba	23:bb685f35b08b	1786	break;
Vkadaba	23:bb685f35b08b	1787	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_62P5KHZ:
Vkadaba	23:bb685f35b08b	1788	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_62P5KHZ;
Vkadaba	23:bb685f35b08b	1789	break;
Vkadaba	23:bb685f35b08b	1790	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_31P3KHZ:
Vkadaba	23:bb685f35b08b	1791	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_31P3KHZ;
Vkadaba	23:bb685f35b08b	1792	break;
Vkadaba	23:bb685f35b08b	1793	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_15P6KHZ:
Vkadaba	23:bb685f35b08b	1794	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_15P6KHZ;
Vkadaba	23:bb685f35b08b	1795	break;
Vkadaba	23:bb685f35b08b	1796	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_7P8KHZ:
Vkadaba	23:bb685f35b08b	1797	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_7P8KHZ;
Vkadaba	23:bb685f35b08b	1798	break;
Vkadaba	23:bb685f35b08b	1799	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_3P9KHZ:
Vkadaba	23:bb685f35b08b	1800	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_3P9KHZ;
Vkadaba	23:bb685f35b08b	1801	break;
Vkadaba	23:bb685f35b08b	1802	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_1P9KHZ:
Vkadaba	23:bb685f35b08b	1803	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_1P9KHZ;
Vkadaba	23:bb685f35b08b	1804	break;
Vkadaba	23:bb685f35b08b	1805	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_977HZ:
Vkadaba	23:bb685f35b08b	1806	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_977HZ;
Vkadaba	23:bb685f35b08b	1807	break;
Vkadaba	23:bb685f35b08b	1808	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_488HZ:
Vkadaba	23:bb685f35b08b	1809	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_488HZ;
Vkadaba	23:bb685f35b08b	1810	break;
Vkadaba	23:bb685f35b08b	1811	case ADMW1001_DIGITAL_SENSOR_COMMS_SPI_CLOCK_244HZ:
Vkadaba	23:bb685f35b08b	1812	digitalSensorComms.SPI_Clock = CORE_DIGITAL_SENSOR_COMMS_SPI_244HZ;
Vkadaba	23:bb685f35b08b	1813	break;
Vkadaba	23:bb685f35b08b	1814	default:
Vkadaba	23:bb685f35b08b	1815	ADMW_LOG_ERROR("Invalid SPI clock %d specified",
Vkadaba	23:bb685f35b08b	1816	pDigitalComms->spiClock);
Vkadaba	23:bb685f35b08b	1817	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1818	}
Vkadaba	23:bb685f35b08b	1819	} else {
ADIJake	0:85855ecd3257	1820	digitalSensorComms.Digital_Sensor_Comms_En = 0;
ADIJake	0:85855ecd3257	1821	}
ADIJake	0:85855ecd3257	1822
ADIJake	0:85855ecd3257	1823	WRITE_REG_U16(hDevice, digitalSensorComms.VALUE16, CORE_DIGITAL_SENSOR_COMMSn(eChannelId));
ADIJake	0:85855ecd3257	1824
Vkadaba	5:0728bde67bdb	1825	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1826	}
ADIJake	0:85855ecd3257	1827
Vkadaba	5:0728bde67bdb	1828	ADMW_RESULT admw_SetI2cChannelConfig(
Vkadaba	5:0728bde67bdb	1829	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1830	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1831	ADMW1001_CHANNEL_CONFIG *pChannelConfig)
ADIJake	0:85855ecd3257	1832	{
Vkadaba	5:0728bde67bdb	1833	ADMW_RESULT eRet;
Vkadaba	5:0728bde67bdb	1834	ADMW1001_I2C_CHANNEL_CONFIG *pI2cChannelConfig =
ADIJake	0:85855ecd3257	1835	&pChannelConfig->i2cChannelConfig;
ADIJake	0:85855ecd3257	1836
Vkadaba	5:0728bde67bdb	1837	eRet = admw_SetChannelI2cSensorType(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	1838	pI2cChannelConfig->sensor);
Vkadaba	23:bb685f35b08b	1839	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1840	ADMW_LOG_ERROR("Failed to set I2C sensor type for channel %d",
Vkadaba	23:bb685f35b08b	1841	eChannelId);
ADIJake	0:85855ecd3257	1842	return eRet;
ADIJake	0:85855ecd3257	1843	}
ADIJake	0:85855ecd3257	1844
Vkadaba	5:0728bde67bdb	1845	eRet = admw_SetChannelI2cSensorAddress(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	1846	pI2cChannelConfig->deviceAddress);
Vkadaba	23:bb685f35b08b	1847	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1848	ADMW_LOG_ERROR("Failed to set I2C sensor address for channel %d",
Vkadaba	23:bb685f35b08b	1849	eChannelId);
ADIJake	0:85855ecd3257	1850	return eRet;
ADIJake	0:85855ecd3257	1851	}
ADIJake	0:85855ecd3257	1852
Vkadaba	5:0728bde67bdb	1853	eRet = admw_SetChannelDigitalSensorDetails(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	1854	pChannelConfig);
Vkadaba	23:bb685f35b08b	1855	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1856	ADMW_LOG_ERROR("Failed to set I2C sensor details for channel %d",
Vkadaba	23:bb685f35b08b	1857	eChannelId);
ADIJake	0:85855ecd3257	1858	return eRet;
ADIJake	0:85855ecd3257	1859	}
ADIJake	0:85855ecd3257	1860
Vkadaba	5:0728bde67bdb	1861	eRet = admw_SetDigitalSensorFormat(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	1862	&pI2cChannelConfig->dataFormat);
Vkadaba	23:bb685f35b08b	1863	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1864	ADMW_LOG_ERROR("Failed to set I2C sensor data format for channel %d",
Vkadaba	23:bb685f35b08b	1865	eChannelId);
ADIJake	0:85855ecd3257	1866	return eRet;
ADIJake	0:85855ecd3257	1867	}
ADIJake	0:85855ecd3257	1868
Vkadaba	5:0728bde67bdb	1869	eRet = admw_SetDigitalCalibrationParam(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	1870	&pI2cChannelConfig->digitalCalibrationParam);
Vkadaba	23:bb685f35b08b	1871	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1872	ADMW_LOG_ERROR("Failed to set I2C digital calibration param for channel %d",
Vkadaba	23:bb685f35b08b	1873	eChannelId);
ADIJake	0:85855ecd3257	1874	return eRet;
ADIJake	0:85855ecd3257	1875	}
ADIJake	0:85855ecd3257	1876
Vkadaba	5:0728bde67bdb	1877	eRet = admw_SetDigitalChannelComms(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	1878	&pI2cChannelConfig->configureComms);
Vkadaba	23:bb685f35b08b	1879	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1880	ADMW_LOG_ERROR("Failed to set I2C comms for channel %d",
Vkadaba	23:bb685f35b08b	1881	eChannelId);
ADIJake	0:85855ecd3257	1882	return eRet;
ADIJake	0:85855ecd3257	1883	}
ADIJake	0:85855ecd3257	1884
Vkadaba	5:0728bde67bdb	1885	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1886	}
ADIJake	0:85855ecd3257	1887
Vkadaba	5:0728bde67bdb	1888	static ADMW_RESULT admw_SetChannelSpiSensorType(
Vkadaba	5:0728bde67bdb	1889	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1890	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1891	ADMW1001_SPI_SENSOR_TYPE sensorType)
ADIJake	0:85855ecd3257	1892	{
Vkadaba	8:2f2775c34640	1893	ADMW_CORE_Sensor_Type_t sensorTypeReg;
ADIJake	0:85855ecd3257	1894
ADIJake	0:85855ecd3257	1895	sensorTypeReg.VALUE16 = REG_RESET_VAL(CORE_SENSOR_TYPEn);
ADIJake	0:85855ecd3257	1896
ADIJake	0:85855ecd3257	1897	/* Ensure that the sensor type is valid for this channel */
Vkadaba	23:bb685f35b08b	1898	switch(sensorType) {
Vkadaba	23:bb685f35b08b	1899	case ADMW1001_SPI_SENSOR_PRESSURE_A:
Vkadaba	23:bb685f35b08b	1900	case ADMW1001_SPI_SENSOR_ACCELEROMETER_A:
Vkadaba	23:bb685f35b08b	1901	case ADMW1001_SPI_SENSOR_ACCELEROMETER_B:
Vkadaba	23:bb685f35b08b	1902
Vkadaba	23:bb685f35b08b	1903	sensorTypeReg.Sensor_Type = sensorType;
Vkadaba	23:bb685f35b08b	1904	break;
Vkadaba	23:bb685f35b08b	1905	default:
Vkadaba	23:bb685f35b08b	1906	ADMW_LOG_ERROR("Unsupported SPI sensor type %d specified", sensorType);
Vkadaba	23:bb685f35b08b	1907	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	1908	}
ADIJake	0:85855ecd3257	1909
ADIJake	0:85855ecd3257	1910	WRITE_REG_U16(hDevice, sensorTypeReg.VALUE16, CORE_SENSOR_TYPEn(eChannelId));
ADIJake	0:85855ecd3257	1911
Vkadaba	5:0728bde67bdb	1912	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1913	}
ADIJake	0:85855ecd3257	1914
Vkadaba	5:0728bde67bdb	1915	ADMW_RESULT admw_SetSpiChannelConfig(
Vkadaba	5:0728bde67bdb	1916	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1917	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	1918	ADMW1001_CHANNEL_CONFIG *pChannelConfig)
ADIJake	0:85855ecd3257	1919	{
Vkadaba	5:0728bde67bdb	1920	ADMW_RESULT eRet;
Vkadaba	5:0728bde67bdb	1921	ADMW1001_SPI_CHANNEL_CONFIG *pSpiChannelConfig =
ADIJake	0:85855ecd3257	1922	&pChannelConfig->spiChannelConfig;
ADIJake	0:85855ecd3257	1923
Vkadaba	5:0728bde67bdb	1924	eRet = admw_SetChannelSpiSensorType(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	1925	pSpiChannelConfig->sensor);
Vkadaba	23:bb685f35b08b	1926	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1927	ADMW_LOG_ERROR("Failed to set SPI sensor type for channel %d",
Vkadaba	23:bb685f35b08b	1928	eChannelId);
ADIJake	0:85855ecd3257	1929	return eRet;
ADIJake	0:85855ecd3257	1930	}
ADIJake	0:85855ecd3257	1931
Vkadaba	5:0728bde67bdb	1932	eRet = admw_SetChannelDigitalSensorDetails(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	1933	pChannelConfig);
Vkadaba	23:bb685f35b08b	1934	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1935	ADMW_LOG_ERROR("Failed to set SPI sensor details for channel %d",
Vkadaba	23:bb685f35b08b	1936	eChannelId);
ADIJake	0:85855ecd3257	1937	return eRet;
ADIJake	0:85855ecd3257	1938	}
ADIJake	0:85855ecd3257	1939
Vkadaba	5:0728bde67bdb	1940	eRet = admw_SetDigitalSensorFormat(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	1941	&pSpiChannelConfig->dataFormat);
Vkadaba	23:bb685f35b08b	1942	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1943	ADMW_LOG_ERROR("Failed to set SPI sensor data format for channel %d",
Vkadaba	23:bb685f35b08b	1944	eChannelId);
ADIJake	0:85855ecd3257	1945	return eRet;
ADIJake	0:85855ecd3257	1946	}
ADIJake	0:85855ecd3257	1947
Vkadaba	5:0728bde67bdb	1948	eRet = admw_SetDigitalCalibrationParam(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	1949	&pSpiChannelConfig->digitalCalibrationParam);
Vkadaba	23:bb685f35b08b	1950	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1951	ADMW_LOG_ERROR("Failed to set SPI digital calibration param for channel %d",
Vkadaba	23:bb685f35b08b	1952	eChannelId);
ADIJake	0:85855ecd3257	1953	return eRet;
ADIJake	0:85855ecd3257	1954	}
ADIJake	0:85855ecd3257	1955
Vkadaba	5:0728bde67bdb	1956	eRet = admw_SetDigitalChannelComms(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	1957	&pSpiChannelConfig->configureComms);
Vkadaba	23:bb685f35b08b	1958	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	1959	ADMW_LOG_ERROR("Failed to set SPI comms for channel %d",
Vkadaba	23:bb685f35b08b	1960	eChannelId);
ADIJake	0:85855ecd3257	1961	return eRet;
ADIJake	0:85855ecd3257	1962	}
ADIJake	0:85855ecd3257	1963
Vkadaba	5:0728bde67bdb	1964	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1965	}
ADIJake	0:85855ecd3257	1966
Vkadaba	5:0728bde67bdb	1967	ADMW_RESULT admw1001_SetChannelThresholdLimits(
Vkadaba	5:0728bde67bdb	1968	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1969	ADMW1001_CH_ID eChannelId,
ADIJake	0:85855ecd3257	1970	float32_t fHighThresholdLimit,
ADIJake	0:85855ecd3257	1971	float32_t fLowThresholdLimit)
ADIJake	0:85855ecd3257	1972	{
ADIJake	0:85855ecd3257	1973	/*
ADIJake	0:85855ecd3257	1974	* If the low/high limits are both set to 0 in memory, or NaNs, assume
ADIJake	0:85855ecd3257	1975	* that they are unset, or not required, and use infinity defaults instead
ADIJake	0:85855ecd3257	1976	*/
Vkadaba	23:bb685f35b08b	1977	if (fHighThresholdLimit == 0.0f && fLowThresholdLimit == 0.0f) {
ADIJake	0:85855ecd3257	1978	fHighThresholdLimit = INFINITY;
ADIJake	0:85855ecd3257	1979	fLowThresholdLimit = -INFINITY;
Vkadaba	23:bb685f35b08b	1980	} else {
ADIJake	0:85855ecd3257	1981	if (isnan(fHighThresholdLimit))
ADIJake	0:85855ecd3257	1982	fHighThresholdLimit = INFINITY;
ADIJake	0:85855ecd3257	1983	if (isnan(fLowThresholdLimit))
ADIJake	0:85855ecd3257	1984	fLowThresholdLimit = -INFINITY;
ADIJake	0:85855ecd3257	1985	}
ADIJake	0:85855ecd3257	1986
ADIJake	0:85855ecd3257	1987	WRITE_REG_FLOAT(hDevice, fHighThresholdLimit,
ADIJake	0:85855ecd3257	1988	CORE_HIGH_THRESHOLD_LIMITn(eChannelId));
ADIJake	0:85855ecd3257	1989	WRITE_REG_FLOAT(hDevice, fLowThresholdLimit,
ADIJake	0:85855ecd3257	1990	CORE_LOW_THRESHOLD_LIMITn(eChannelId));
ADIJake	0:85855ecd3257	1991
Vkadaba	5:0728bde67bdb	1992	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	1993	}
ADIJake	0:85855ecd3257	1994
Vkadaba	5:0728bde67bdb	1995	ADMW_RESULT admw1001_SetOffsetGain(
Vkadaba	5:0728bde67bdb	1996	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	1997	ADMW1001_CH_ID eChannelId,
ADIJake	0:85855ecd3257	1998	float32_t fOffsetAdjustment,
ADIJake	0:85855ecd3257	1999	float32_t fGainAdjustment)
ADIJake	0:85855ecd3257	2000	{
ADIJake	0:85855ecd3257	2001	/* Replace with default values if NaNs are specified (or 0.0 for gain) */
ADIJake	0:85855ecd3257	2002	if (isnan(fGainAdjustment) \|\| (fGainAdjustment == 0.0f))
ADIJake	0:85855ecd3257	2003	fGainAdjustment = 1.0f;
ADIJake	0:85855ecd3257	2004	if (isnan(fOffsetAdjustment))
ADIJake	0:85855ecd3257	2005	fOffsetAdjustment = 0.0f;
ADIJake	0:85855ecd3257	2006
ADIJake	0:85855ecd3257	2007	WRITE_REG_FLOAT(hDevice, fGainAdjustment, CORE_SENSOR_GAINn(eChannelId));
ADIJake	0:85855ecd3257	2008	WRITE_REG_FLOAT(hDevice, fOffsetAdjustment, CORE_SENSOR_OFFSETn(eChannelId));
ADIJake	0:85855ecd3257	2009
Vkadaba	5:0728bde67bdb	2010	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	2011	}
ADIJake	0:85855ecd3257	2012
Vkadaba	5:0728bde67bdb	2013	ADMW_RESULT admw1001_SetSensorParameter(
Vkadaba	5:0728bde67bdb	2014	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	2015	ADMW1001_CH_ID eChannelId,
ADIJake	0:85855ecd3257	2016	float32_t fSensorParam)
ADIJake	0:85855ecd3257	2017	{
ADIJake	0:85855ecd3257	2018	if (fSensorParam == 0.0f)
ADIJake	0:85855ecd3257	2019	fSensorParam = NAN;
ADIJake	0:85855ecd3257	2020
Vkadaba	32:52445bef314d	2021	//WRITE_REG_FLOAT(hDevice, fSensorParam, CORE_SENSOR_PARAMETERn(eChannelId));
ADIJake	0:85855ecd3257	2022
Vkadaba	5:0728bde67bdb	2023	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	2024	}
ADIJake	0:85855ecd3257	2025
Vkadaba	5:0728bde67bdb	2026	ADMW_RESULT admw1001_SetChannelSettlingTime(
Vkadaba	5:0728bde67bdb	2027	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	2028	ADMW1001_CH_ID eChannelId,
ADIJake	0:85855ecd3257	2029	uint32_t nSettlingTime)
ADIJake	0:85855ecd3257	2030	{
Vkadaba	8:2f2775c34640	2031	ADMW_CORE_Settling_Time_t settlingTimeReg;
ADIJake	0:85855ecd3257	2032
Vkadaba	23:bb685f35b08b	2033	if (nSettlingTime < (1 << 12)) {
Vkadaba	5:0728bde67bdb	2034	settlingTimeReg.Settling_Time_Units = CORE_SETTLING_TIME_MICROSECONDS;
Vkadaba	23:bb685f35b08b	2035	} else if (nSettlingTime < (1000 * (1 << 12))) {
Vkadaba	5:0728bde67bdb	2036	settlingTimeReg.Settling_Time_Units = CORE_SETTLING_TIME_MILLISECONDS;
ADIJake	0:85855ecd3257	2037	nSettlingTime /= 1000;
Vkadaba	23:bb685f35b08b	2038	} else {
Vkadaba	5:0728bde67bdb	2039	settlingTimeReg.Settling_Time_Units = CORE_SETTLING_TIME_SECONDS;
ADIJake	0:85855ecd3257	2040	nSettlingTime /= 1000000;
ADIJake	0:85855ecd3257	2041	}
ADIJake	0:85855ecd3257	2042
ADIJake	0:85855ecd3257	2043	CHECK_REG_FIELD_VAL(CORE_SETTLING_TIME_SETTLING_TIME, nSettlingTime);
ADIJake	0:85855ecd3257	2044	settlingTimeReg.Settling_Time = nSettlingTime;
ADIJake	0:85855ecd3257	2045
ADIJake	0:85855ecd3257	2046	WRITE_REG_U16(hDevice, settlingTimeReg.VALUE16, CORE_SETTLING_TIMEn(eChannelId));
ADIJake	0:85855ecd3257	2047
Vkadaba	5:0728bde67bdb	2048	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	2049	}
ADIJake	0:85855ecd3257	2050
Vkadaba	5:0728bde67bdb	2051	ADMW_RESULT admw1001_SetChannelConfig(
Vkadaba	5:0728bde67bdb	2052	ADMW_DEVICE_HANDLE hDevice,
Vkadaba	8:2f2775c34640	2053	ADMW1001_CH_ID eChannelId,
Vkadaba	5:0728bde67bdb	2054	ADMW1001_CHANNEL_CONFIG *pChannelConfig)
ADIJake	0:85855ecd3257	2055	{
Vkadaba	5:0728bde67bdb	2056	ADMW_RESULT eRet;
Vkadaba	5:0728bde67bdb	2057
Vkadaba	23:bb685f35b08b	2058	if (! ADMW1001_CHANNEL_IS_VIRTUAL(eChannelId)) {
Vkadaba	5:0728bde67bdb	2059	eRet = admw1001_SetChannelCount(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	2060	pChannelConfig->enableChannel ?
Vkadaba	23:bb685f35b08b	2061	pChannelConfig->measurementsPerCycle : 0);
Vkadaba	23:bb685f35b08b	2062	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	2063	ADMW_LOG_ERROR("Failed to set measurement count for channel %d",
Vkadaba	23:bb685f35b08b	2064	eChannelId);
ADIJake	0:85855ecd3257	2065	return eRet;
ADIJake	0:85855ecd3257	2066	}
ADIJake	0:85855ecd3257	2067
Vkadaba	5:0728bde67bdb	2068	eRet = admw1001_SetChannelOptions(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	2069	pChannelConfig->priority);
Vkadaba	23:bb685f35b08b	2070	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	2071	ADMW_LOG_ERROR("Failed to set priority for channel %d",
Vkadaba	23:bb685f35b08b	2072	eChannelId);
ADIJake	0:85855ecd3257	2073	return eRet;
ADIJake	0:85855ecd3257	2074	}
ADIJake	0:85855ecd3257	2075
ADIJake	0:85855ecd3257	2076	/* If the channel is not enabled, we can skip the following steps */
Vkadaba	23:bb685f35b08b	2077	if (pChannelConfig->enableChannel) {
Vkadaba	5:0728bde67bdb	2078	eRet = admw1001_SetChannelSkipCount(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	2079	pChannelConfig->cycleSkipCount);
Vkadaba	23:bb685f35b08b	2080	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	2081	ADMW_LOG_ERROR("Failed to set cycle skip count for channel %d",
Vkadaba	23:bb685f35b08b	2082	eChannelId);
ADIJake	0:85855ecd3257	2083	return eRet;
ADIJake	0:85855ecd3257	2084	}
ADIJake	0:85855ecd3257	2085
Vkadaba	23:bb685f35b08b	2086	switch (eChannelId) {
Vkadaba	23:bb685f35b08b	2087	case ADMW1001_CH_ID_ANLG_1_UNIVERSAL:
Vkadaba	23:bb685f35b08b	2088	case ADMW1001_CH_ID_ANLG_2_UNIVERSAL:
Vkadaba	23:bb685f35b08b	2089	case ADMW1001_CH_ID_ANLG_1_DIFFERENTIAL:
Vkadaba	23:bb685f35b08b	2090	case ADMW1001_CH_ID_ANLG_2_DIFFERENTIAL:
Vkadaba	23:bb685f35b08b	2091	eRet = admw_SetAdcChannelConfig(hDevice, eChannelId, pChannelConfig);
Vkadaba	23:bb685f35b08b	2092	break;
Vkadaba	23:bb685f35b08b	2093	case ADMW1001_CH_ID_DIG_I2C_0:
Vkadaba	23:bb685f35b08b	2094	case ADMW1001_CH_ID_DIG_I2C_1:
Vkadaba	23:bb685f35b08b	2095	eRet = admw_SetI2cChannelConfig(hDevice, eChannelId, pChannelConfig);
Vkadaba	23:bb685f35b08b	2096	break;
Vkadaba	23:bb685f35b08b	2097	case ADMW1001_CH_ID_DIG_SPI_0:
Vkadaba	23:bb685f35b08b	2098	eRet = admw_SetSpiChannelConfig(hDevice, eChannelId, pChannelConfig);
Vkadaba	23:bb685f35b08b	2099	break;
Vkadaba	23:bb685f35b08b	2100	default:
Vkadaba	23:bb685f35b08b	2101	ADMW_LOG_ERROR("Invalid channel ID %d specified", eChannelId);
Vkadaba	32:52445bef314d	2102	eRet = ADMW_INVALID_PARAM;
Vkadaba	32:52445bef314d	2103	#if 0
Vkadaba	32:52445bef314d	2104	/* when using i2c sensors there is an error ( dataformat->length=0)
Vkadaba	32:52445bef314d	2105	the code below catches this error and this causes further problems.*/
Vkadaba	32:52445bef314d	2106	break;
Vkadaba	32:52445bef314d	2107	}
Vkadaba	32:52445bef314d	2108	if (eRet != ADMW_SUCCESS) {
Vkadaba	32:52445bef314d	2109	ADMW_LOG_ERROR("Failed to set config for channel %d",
Vkadaba	32:52445bef314d	2110	eChannelId);
Vkadaba	32:52445bef314d	2111	return eRet;
Vkadaba	32:52445bef314d	2112	#endif
ADIJake	0:85855ecd3257	2113	}
ADIJake	0:85855ecd3257	2114
Vkadaba	5:0728bde67bdb	2115	eRet = admw1001_SetChannelSettlingTime(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	2116	pChannelConfig->extraSettlingTime);
Vkadaba	23:bb685f35b08b	2117	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	2118	ADMW_LOG_ERROR("Failed to set settling time for channel %d",
Vkadaba	23:bb685f35b08b	2119	eChannelId);
ADIJake	0:85855ecd3257	2120	return eRet;
ADIJake	0:85855ecd3257	2121	}
ADIJake	0:85855ecd3257	2122	}
ADIJake	0:85855ecd3257	2123	}
ADIJake	0:85855ecd3257	2124
Vkadaba	23:bb685f35b08b	2125	if (pChannelConfig->enableChannel) {
ADIJake	0:85855ecd3257	2126	/* Threshold limits can be configured individually for virtual channels */
Vkadaba	5:0728bde67bdb	2127	eRet = admw1001_SetChannelThresholdLimits(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	2128	pChannelConfig->highThreshold,
Vkadaba	23:bb685f35b08b	2129	pChannelConfig->lowThreshold);
Vkadaba	23:bb685f35b08b	2130	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	2131	ADMW_LOG_ERROR("Failed to set threshold limits for channel %d",
Vkadaba	23:bb685f35b08b	2132	eChannelId);
ADIJake	0:85855ecd3257	2133	return eRet;
ADIJake	0:85855ecd3257	2134	}
ADIJake	0:85855ecd3257	2135
ADIJake	0:85855ecd3257	2136	/* Offset and gain can be configured individually for virtual channels */
Vkadaba	5:0728bde67bdb	2137	eRet = admw1001_SetOffsetGain(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	2138	pChannelConfig->offsetAdjustment,
Vkadaba	23:bb685f35b08b	2139	pChannelConfig->gainAdjustment);
Vkadaba	23:bb685f35b08b	2140	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	2141	ADMW_LOG_ERROR("Failed to set offset/gain for channel %d",
Vkadaba	23:bb685f35b08b	2142	eChannelId);
ADIJake	0:85855ecd3257	2143	return eRet;
ADIJake	0:85855ecd3257	2144	}
ADIJake	0:85855ecd3257	2145
ADIJake	0:85855ecd3257	2146	/* Set sensor specific parameter */
Vkadaba	5:0728bde67bdb	2147	eRet = admw1001_SetSensorParameter(hDevice, eChannelId,
Vkadaba	23:bb685f35b08b	2148	pChannelConfig->sensorParameter);
Vkadaba	23:bb685f35b08b	2149	if (eRet != ADMW_SUCCESS) {
Vkadaba	5:0728bde67bdb	2150	ADMW_LOG_ERROR("Failed to set sensor parameter for channel %d",
Vkadaba	23:bb685f35b08b	2151	eChannelId);
ADIJake	0:85855ecd3257	2152	return eRet;
ADIJake	0:85855ecd3257	2153	}
ADIJake	0:85855ecd3257	2154	}
ADIJake	0:85855ecd3257	2155
Vkadaba	5:0728bde67bdb	2156	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	2157	}
ADIJake	0:85855ecd3257	2158
Vkadaba	5:0728bde67bdb	2159	ADMW_RESULT admw_SetConfig(
Vkadaba	5:0728bde67bdb	2160	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	5:0728bde67bdb	2161	ADMW_CONFIG * const pConfig)
ADIJake	0:85855ecd3257	2162	{
Vkadaba	5:0728bde67bdb	2163	ADMW1001_CONFIG *pDeviceConfig;
Vkadaba	5:0728bde67bdb	2164	ADMW_PRODUCT_ID productId;
Vkadaba	5:0728bde67bdb	2165	ADMW_RESULT eRet;
Vkadaba	5:0728bde67bdb	2166
Vkadaba	23:bb685f35b08b	2167	if (pConfig->productId != ADMW_PRODUCT_ID_ADMW1001) {
Vkadaba	5:0728bde67bdb	2168	ADMW_LOG_ERROR("Configuration Product ID (0x%X) is not supported (0x%0X)",
Vkadaba	23:bb685f35b08b	2169	pConfig->productId, ADMW_PRODUCT_ID_ADMW1001);
Vkadaba	5:0728bde67bdb	2170	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	2171	}
Vkadaba	23:bb685f35b08b	2172
Vkadaba	23:bb685f35b08b	2173	if (!((pConfig->versionId.major==VERSIONID_MAJOR) &&
Vkadaba	23:bb685f35b08b	2174	(pConfig->versionId.minor==VERSIONID_MINOR))) {
Vkadaba	23:bb685f35b08b	2175	ADMW_LOG_ERROR("Configuration Version ID (0x%X) is not supported",
Vkadaba	23:bb685f35b08b	2176	pConfig->versionId);
Vkadaba	6:9d393a9677f4	2177	return ADMW_INVALID_PARAM;
Vkadaba	6:9d393a9677f4	2178	}
Vkadaba	23:bb685f35b08b	2179
Vkadaba	23:bb685f35b08b	2180
ADIJake	0:85855ecd3257	2181	/* Check that the actual Product ID is a match? */
Vkadaba	5:0728bde67bdb	2182	eRet = admw_GetProductID(hDevice, &productId);
Vkadaba	23:bb685f35b08b	2183	if (eRet) {
Vkadaba	5:0728bde67bdb	2184	ADMW_LOG_ERROR("Failed to read device Product ID register");
ADIJake	0:85855ecd3257	2185	return eRet;
ADIJake	0:85855ecd3257	2186	}
Vkadaba	23:bb685f35b08b	2187	if (pConfig->productId != productId) {
Vkadaba	5:0728bde67bdb	2188	ADMW_LOG_ERROR("Configuration Product ID (0x%X) does not match device (0x%0X)",
Vkadaba	8:2f2775c34640	2189	pConfig->productId, productId);
Vkadaba	5:0728bde67bdb	2190	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	2191	}
ADIJake	0:85855ecd3257	2192
Vkadaba	5:0728bde67bdb	2193	pDeviceConfig = &pConfig->admw1001;
Vkadaba	5:0728bde67bdb	2194
Vkadaba	5:0728bde67bdb	2195	eRet = admw1001_SetPowerConfig(hDevice, &pDeviceConfig->power);
Vkadaba	23:bb685f35b08b	2196	if (eRet) {
Vkadaba	5:0728bde67bdb	2197	ADMW_LOG_ERROR("Failed to set power configuration");
ADIJake	0:85855ecd3257	2198	return eRet;
ADIJake	0:85855ecd3257	2199	}
ADIJake	0:85855ecd3257	2200
Vkadaba	5:0728bde67bdb	2201	eRet = admw1001_SetMeasurementConfig(hDevice, &pDeviceConfig->measurement);
Vkadaba	23:bb685f35b08b	2202	if (eRet) {
Vkadaba	5:0728bde67bdb	2203	ADMW_LOG_ERROR("Failed to set measurement configuration");
ADIJake	0:85855ecd3257	2204	return eRet;
ADIJake	0:85855ecd3257	2205	}
ADIJake	0:85855ecd3257	2206
Vkadaba	32:52445bef314d	2207	// eRet = admw1001_SetDiagnosticsConfig(hDevice, &pDeviceConfig->diagnostics);
Vkadaba	32:52445bef314d	2208	// if (eRet)
Vkadaba	32:52445bef314d	2209	// {
Vkadaba	32:52445bef314d	2210	// ADMW_LOG_ERROR("Failed to set diagnostics configuration");
Vkadaba	32:52445bef314d	2211	// return eRet;
Vkadaba	32:52445bef314d	2212	// }
ADIJake	0:85855ecd3257	2213
Vkadaba	8:2f2775c34640	2214	for (ADMW1001_CH_ID id = ADMW1001_CH_ID_ANLG_1_UNIVERSAL;
Vkadaba	23:bb685f35b08b	2215	id < ADMW1001_MAX_CHANNELS;
Vkadaba	23:bb685f35b08b	2216	id++) {
Vkadaba	5:0728bde67bdb	2217	eRet = admw1001_SetChannelConfig(hDevice, id,
Vkadaba	23:bb685f35b08b	2218	&pDeviceConfig->channels[id]);
Vkadaba	23:bb685f35b08b	2219	if (eRet) {
Vkadaba	5:0728bde67bdb	2220	ADMW_LOG_ERROR("Failed to set channel %d configuration", id);
ADIJake	0:85855ecd3257	2221	return eRet;
ADIJake	0:85855ecd3257	2222	}
ADIJake	0:85855ecd3257	2223	}
ADIJake	0:85855ecd3257	2224
Vkadaba	5:0728bde67bdb	2225	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	2226	}
ADIJake	0:85855ecd3257	2227
Vkadaba	5:0728bde67bdb	2228	ADMW_RESULT admw1001_SetLutData(
Vkadaba	8:2f2775c34640	2229	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	5:0728bde67bdb	2230	ADMW1001_LUT * const pLutData)
ADIJake	0:85855ecd3257	2231	{
Vkadaba	5:0728bde67bdb	2232	ADMW1001_LUT_HEADER *pLutHeader = &pLutData->header;
Vkadaba	8:2f2775c34640	2233	ADMW1001_LUT_TABLE *pLutTable = pLutData->tables;
ADIJake	0:85855ecd3257	2234	unsigned actualLength = 0;
ADIJake	0:85855ecd3257	2235
Vkadaba	23:bb685f35b08b	2236	if (pLutData->header.signature != ADMW_LUT_SIGNATURE) {
Vkadaba	5:0728bde67bdb	2237	ADMW_LOG_ERROR("LUT signature incorrect (expected 0x%X, actual 0x%X)",
Vkadaba	23:bb685f35b08b	2238	ADMW_LUT_SIGNATURE, pLutHeader->signature);
Vkadaba	5:0728bde67bdb	2239	return ADMW_INVALID_SIGNATURE;
ADIJake	0:85855ecd3257	2240	}
ADIJake	0:85855ecd3257	2241
Vkadaba	23:bb685f35b08b	2242	for (unsigned i = 0; i < pLutHeader->numTables; i++) {
Vkadaba	5:0728bde67bdb	2243	ADMW1001_LUT_DESCRIPTOR *pDesc = &pLutTable->descriptor;
Vkadaba	5:0728bde67bdb	2244	ADMW1001_LUT_TABLE_DATA *pData = &pLutTable->data;
ADIJake	0:85855ecd3257	2245	unsigned short calculatedCrc;
ADIJake	0:85855ecd3257	2246
Vkadaba	23:bb685f35b08b	2247	switch (pDesc->geometry) {
Vkadaba	23:bb685f35b08b	2248	case ADMW1001_LUT_GEOMETRY_COEFFS:
Vkadaba	23:bb685f35b08b	2249	switch (pDesc->equation) {
Vkadaba	23:bb685f35b08b	2250	case ADMW1001_LUT_EQUATION_POLYN:
Vkadaba	23:bb685f35b08b	2251	case ADMW1001_LUT_EQUATION_POLYNEXP:
Vkadaba	23:bb685f35b08b	2252	case ADMW1001_LUT_EQUATION_QUADRATIC:
Vkadaba	23:bb685f35b08b	2253	case ADMW1001_LUT_EQUATION_STEINHART:
Vkadaba	23:bb685f35b08b	2254	case ADMW1001_LUT_EQUATION_LOGARITHMIC:
Vkadaba	23:bb685f35b08b	2255	case ADMW1001_LUT_EQUATION_BIVARIATE_POLYN:
Vkadaba	23:bb685f35b08b	2256	break;
Vkadaba	23:bb685f35b08b	2257	default:
Vkadaba	23:bb685f35b08b	2258	ADMW_LOG_ERROR("Invalid equation %u specified for LUT table %u",
Vkadaba	23:bb685f35b08b	2259	pDesc->equation, i);
Vkadaba	23:bb685f35b08b	2260	return ADMW_INVALID_PARAM;
Vkadaba	23:bb685f35b08b	2261	}
ADIJake	0:85855ecd3257	2262	break;
Vkadaba	23:bb685f35b08b	2263	case ADMW1001_LUT_GEOMETRY_NES_1D:
Vkadaba	23:bb685f35b08b	2264	case ADMW1001_LUT_GEOMETRY_NES_2D:
Vkadaba	23:bb685f35b08b	2265	case ADMW1001_LUT_GEOMETRY_ES_1D:
Vkadaba	23:bb685f35b08b	2266	case ADMW1001_LUT_GEOMETRY_ES_2D:
Vkadaba	23:bb685f35b08b	2267	if (pDesc->equation != ADMW1001_LUT_EQUATION_LUT) {
Vkadaba	5:0728bde67bdb	2268	ADMW_LOG_ERROR("Invalid equation %u specified for LUT table %u",
Vkadaba	23:bb685f35b08b	2269	pDesc->equation, i);
Vkadaba	5:0728bde67bdb	2270	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	2271	}
Vkadaba	23:bb685f35b08b	2272	break;
Vkadaba	23:bb685f35b08b	2273	default:
Vkadaba	23:bb685f35b08b	2274	ADMW_LOG_ERROR("Invalid geometry %u specified for LUT table %u",
Vkadaba	23:bb685f35b08b	2275	pDesc->geometry, i);
Vkadaba	23:bb685f35b08b	2276	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	2277	}
ADIJake	0:85855ecd3257	2278
Vkadaba	23:bb685f35b08b	2279	switch (pDesc->dataType) {
Vkadaba	23:bb685f35b08b	2280	case ADMW1001_LUT_DATA_TYPE_FLOAT32:
Vkadaba	23:bb685f35b08b	2281	case ADMW1001_LUT_DATA_TYPE_FLOAT64:
Vkadaba	23:bb685f35b08b	2282	break;
Vkadaba	23:bb685f35b08b	2283	default:
Vkadaba	23:bb685f35b08b	2284	ADMW_LOG_ERROR("Invalid vector format %u specified for LUT table %u",
Vkadaba	23:bb685f35b08b	2285	pDesc->dataType, i);
Vkadaba	23:bb685f35b08b	2286	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	2287	}
ADIJake	0:85855ecd3257	2288
Vkadaba	5:0728bde67bdb	2289	calculatedCrc = admw_crc16_ccitt(pData, pDesc->length);
Vkadaba	23:bb685f35b08b	2290	if (calculatedCrc != pDesc->crc16) {
Vkadaba	5:0728bde67bdb	2291	ADMW_LOG_ERROR("CRC validation failed on LUT table %u (expected 0x%04X, actual 0x%04X)",
Vkadaba	23:bb685f35b08b	2292	i, pDesc->crc16, calculatedCrc);
Vkadaba	5:0728bde67bdb	2293	return ADMW_CRC_ERROR;
ADIJake	0:85855ecd3257	2294	}
ADIJake	0:85855ecd3257	2295
ADIJake	0:85855ecd3257	2296	actualLength += sizeof(*pDesc) + pDesc->length;
ADIJake	0:85855ecd3257	2297
ADIJake	0:85855ecd3257	2298	/* Move to the next look-up table */
Vkadaba	5:0728bde67bdb	2299	pLutTable = (ADMW1001_LUT_TABLE )((uint8_t )pLutTable + sizeof(*pDesc) + pDesc->length);
ADIJake	0:85855ecd3257	2300	}
ADIJake	0:85855ecd3257	2301
Vkadaba	23:bb685f35b08b	2302	if (actualLength != pLutHeader->totalLength) {
Vkadaba	5:0728bde67bdb	2303	ADMW_LOG_ERROR("LUT table length mismatch (expected %u, actual %u)",
Vkadaba	23:bb685f35b08b	2304	pLutHeader->totalLength, actualLength);
Vkadaba	5:0728bde67bdb	2305	return ADMW_WRONG_SIZE;
ADIJake	0:85855ecd3257	2306	}
ADIJake	0:85855ecd3257	2307
Vkadaba	23:bb685f35b08b	2308	if (sizeof(*pLutHeader) + pLutHeader->totalLength > ADMW_LUT_MAX_SIZE) {
Vkadaba	5:0728bde67bdb	2309	ADMW_LOG_ERROR("Maximum LUT table length (%u bytes) exceeded",
Vkadaba	23:bb685f35b08b	2310	ADMW_LUT_MAX_SIZE);
Vkadaba	5:0728bde67bdb	2311	return ADMW_WRONG_SIZE;
ADIJake	0:85855ecd3257	2312	}
ADIJake	0:85855ecd3257	2313
ADIJake	0:85855ecd3257	2314	/* Write the LUT data to the device */
ADIJake	0:85855ecd3257	2315	unsigned lutSize = sizeof(*pLutHeader) + pLutHeader->totalLength;
ADIJake	0:85855ecd3257	2316	WRITE_REG_U16(hDevice, 0, CORE_LUT_OFFSET);
ADIJake	0:85855ecd3257	2317	WRITE_REG_U8_ARRAY(hDevice, (uint8_t *)pLutData, lutSize, CORE_LUT_DATA);
ADIJake	0:85855ecd3257	2318
Vkadaba	5:0728bde67bdb	2319	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	2320	}
ADIJake	0:85855ecd3257	2321
Vkadaba	5:0728bde67bdb	2322	ADMW_RESULT admw1001_SetLutDataRaw(
Vkadaba	5:0728bde67bdb	2323	ADMW_DEVICE_HANDLE const hDevice,
Vkadaba	5:0728bde67bdb	2324	ADMW1001_LUT_RAW * const pLutData)
ADIJake	0:85855ecd3257	2325	{
Vkadaba	5:0728bde67bdb	2326	return admw1001_SetLutData(hDevice,
Vkadaba	23:bb685f35b08b	2327	(ADMW1001_LUT *)pLutData);
ADIJake	0:85855ecd3257	2328	}
ADIJake	0:85855ecd3257	2329
Vkadaba	5:0728bde67bdb	2330	static ADMW_RESULT getLutTableSize(
Vkadaba	5:0728bde67bdb	2331	ADMW1001_LUT_DESCRIPTOR * const pDesc,
Vkadaba	5:0728bde67bdb	2332	ADMW1001_LUT_TABLE_DATA * const pData,
ADIJake	0:85855ecd3257	2333	unsigned *pLength)
ADIJake	0:85855ecd3257	2334	{
Vkadaba	23:bb685f35b08b	2335	switch (pDesc->geometry) {
Vkadaba	23:bb685f35b08b	2336	case ADMW1001_LUT_GEOMETRY_COEFFS:
Vkadaba	23:bb685f35b08b	2337	if (pDesc->equation == ADMW1001_LUT_EQUATION_BIVARIATE_POLYN)
Vkadaba	23:bb685f35b08b	2338	*pLength = ADMW1001_LUT_2D_POLYN_COEFF_LIST_SIZE(pData->coeffList2d);
Vkadaba	23:bb685f35b08b	2339	else
Vkadaba	23:bb685f35b08b	2340	*pLength = ADMW1001_LUT_COEFF_LIST_SIZE(pData->coeffList);
Vkadaba	23:bb685f35b08b	2341	break;
Vkadaba	23:bb685f35b08b	2342	case ADMW1001_LUT_GEOMETRY_NES_1D:
Vkadaba	23:bb685f35b08b	2343	*pLength = ADMW1001_LUT_1D_NES_SIZE(pData->lut1dNes);
Vkadaba	23:bb685f35b08b	2344	break;
Vkadaba	23:bb685f35b08b	2345	case ADMW1001_LUT_GEOMETRY_NES_2D:
Vkadaba	23:bb685f35b08b	2346	*pLength = ADMW1001_LUT_2D_NES_SIZE(pData->lut2dNes);
Vkadaba	23:bb685f35b08b	2347	break;
Vkadaba	23:bb685f35b08b	2348	case ADMW1001_LUT_GEOMETRY_ES_1D:
Vkadaba	23:bb685f35b08b	2349	*pLength = ADMW1001_LUT_1D_ES_SIZE(pData->lut1dEs);
Vkadaba	23:bb685f35b08b	2350	break;
Vkadaba	23:bb685f35b08b	2351	case ADMW1001_LUT_GEOMETRY_ES_2D:
Vkadaba	23:bb685f35b08b	2352	*pLength = ADMW1001_LUT_2D_ES_SIZE(pData->lut2dEs);
Vkadaba	23:bb685f35b08b	2353	break;
Vkadaba	23:bb685f35b08b	2354	default:
Vkadaba	23:bb685f35b08b	2355	ADMW_LOG_ERROR("Invalid LUT table geometry %d specified\r\n",
Vkadaba	23:bb685f35b08b	2356	pDesc->geometry);
Vkadaba	23:bb685f35b08b	2357	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	2358	}
ADIJake	0:85855ecd3257	2359
Vkadaba	5:0728bde67bdb	2360	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	2361	}
ADIJake	0:85855ecd3257	2362
Vkadaba	5:0728bde67bdb	2363	ADMW_RESULT admw1001_AssembleLutData(
Vkadaba	5:0728bde67bdb	2364	ADMW1001_LUT * pLutBuffer,
ADIJake	0:85855ecd3257	2365	unsigned nLutBufferSize,
ADIJake	0:85855ecd3257	2366	unsigned const nNumTables,
Vkadaba	5:0728bde67bdb	2367	ADMW1001_LUT_DESCRIPTOR * const ppDesc[],
Vkadaba	5:0728bde67bdb	2368	ADMW1001_LUT_TABLE_DATA * const ppData[])
ADIJake	0:85855ecd3257	2369	{
Vkadaba	5:0728bde67bdb	2370	ADMW1001_LUT_HEADER *pHdr = &pLutBuffer->header;
ADIJake	0:85855ecd3257	2371	uint8_t pLutTableData = (uint8_t )pLutBuffer + sizeof(*pHdr);
ADIJake	0:85855ecd3257	2372
Vkadaba	23:bb685f35b08b	2373	if (sizeof(*pHdr) > nLutBufferSize) {
Vkadaba	5:0728bde67bdb	2374	ADMW_LOG_ERROR("Insufficient LUT buffer size provided");
Vkadaba	5:0728bde67bdb	2375	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	2376	}
ADIJake	0:85855ecd3257	2377
ADIJake	0:85855ecd3257	2378	/* First initialise the top-level header */
Vkadaba	5:0728bde67bdb	2379	pHdr->signature = ADMW_LUT_SIGNATURE;
ADIJake	0:85855ecd3257	2380	pHdr->version.major = 1;
ADIJake	0:85855ecd3257	2381	pHdr->version.minor = 0;
ADIJake	0:85855ecd3257	2382	pHdr->numTables = 0;
ADIJake	0:85855ecd3257	2383	pHdr->totalLength = 0;
ADIJake	0:85855ecd3257	2384
ADIJake	0:85855ecd3257	2385	/*
ADIJake	0:85855ecd3257	2386	* Walk through the list of table pointers provided, appending the table
ADIJake	0:85855ecd3257	2387	* descriptor+data from each one to the provided LUT buffer
ADIJake	0:85855ecd3257	2388	*/
Vkadaba	23:bb685f35b08b	2389	for (unsigned i = 0; i < nNumTables; i++) {
Vkadaba	5:0728bde67bdb	2390	ADMW1001_LUT_DESCRIPTOR * const pDesc = ppDesc[i];
Vkadaba	5:0728bde67bdb	2391	ADMW1001_LUT_TABLE_DATA * const pData = ppData[i];
Vkadaba	5:0728bde67bdb	2392	ADMW_RESULT res;
ADIJake	0:85855ecd3257	2393	unsigned dataLength = 0;
ADIJake	0:85855ecd3257	2394
ADIJake	0:85855ecd3257	2395	/* Calculate the length of the table data */
ADIJake	0:85855ecd3257	2396	res = getLutTableSize(pDesc, pData, &dataLength);
Vkadaba	5:0728bde67bdb	2397	if (res != ADMW_SUCCESS)
ADIJake	0:85855ecd3257	2398	return res;
ADIJake	0:85855ecd3257	2399
ADIJake	0:85855ecd3257	2400	/* Fill in the table descriptor length and CRC fields */
ADIJake	0:85855ecd3257	2401	pDesc->length = dataLength;
Vkadaba	5:0728bde67bdb	2402	pDesc->crc16 = admw_crc16_ccitt(pData, dataLength);
ADIJake	0:85855ecd3257	2403
Vkadaba	23:bb685f35b08b	2404	if ((sizeof(pHdr) + pHdr->totalLength + sizeof(pDesc) + dataLength) > nLutBufferSize) {
Vkadaba	5:0728bde67bdb	2405	ADMW_LOG_ERROR("Insufficient LUT buffer size provided");
Vkadaba	5:0728bde67bdb	2406	return ADMW_INVALID_PARAM;
ADIJake	0:85855ecd3257	2407	}
ADIJake	0:85855ecd3257	2408
ADIJake	0:85855ecd3257	2409	/* Append the table to the LUT buffer (desc + data) */
ADIJake	0:85855ecd3257	2410	memcpy(pLutTableData + pHdr->totalLength, pDesc, sizeof(*pDesc));
ADIJake	0:85855ecd3257	2411	pHdr->totalLength += sizeof(*pDesc);
ADIJake	0:85855ecd3257	2412	memcpy(pLutTableData + pHdr->totalLength, pData, dataLength);
ADIJake	0:85855ecd3257	2413	pHdr->totalLength += dataLength;
ADIJake	0:85855ecd3257	2414
ADIJake	0:85855ecd3257	2415	pHdr->numTables++;
ADIJake	0:85855ecd3257	2416	}
ADIJake	0:85855ecd3257	2417
Vkadaba	5:0728bde67bdb	2418	return ADMW_SUCCESS;
ADIJake	0:85855ecd3257	2419	}

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@33:df7a00f1b8e1, 2019-11-14 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning