Vybhav Kadaba / Mbed OS EV-PRO-MW1001_Development

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

src/admw_1001.c@52:d32ea3dfc8ac, 2020-02-19 (annotated)

Committer:
Vkadaba
Date:
Wed Feb 19 09:07:35 2020 +0000
Revision:
52:d32ea3dfc8ac
Parent:
50:d84305e5e1c0
Child:
53:644c5f6300da
Adding release notes and mbed FW version

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