Diaz George / Mbed OS EV-PRO-MW1001_EXT_REF_VLTG

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

src/admw_1001.c@32:57d6dc184906, 2019-11-14 (annotated)

Committer:
diazdgeorge
Date:
Thu Nov 14 13:33:58 2019 +0000
Revision:
32:57d6dc184906
Parent:
31:38f9097982c7 
Added support for External Voltage Reference

Who changed what in which revision?

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