Rohan Gurav
/
Sean_AdiSense1000_V21
ADISense1000 Version 2.1 code base
Fork of AdiSense1000_V21 by
src/adi_sense_1000.c@16:e4f2689363bb, 2017-12-05 (annotated)
- Committer:
- kevin1990
- Date:
- Tue Dec 05 19:08:53 2017 +0000
- Revision:
- 16:e4f2689363bb
- Child:
- 17:fd5ab3d27b15
v1.0_RC2 Release
Who changed what in which revision?
User | Revision | Line number | New contents of line |
---|---|---|---|
kevin1990 | 16:e4f2689363bb | 1 | /*! |
kevin1990 | 16:e4f2689363bb | 2 | ****************************************************************************** |
kevin1990 | 16:e4f2689363bb | 3 | * @file: adi_sense_1000.c |
kevin1990 | 16:e4f2689363bb | 4 | * @brief: ADI Sense API implementation for ADI Sense 1000 |
kevin1990 | 16:e4f2689363bb | 5 | *----------------------------------------------------------------------------- |
kevin1990 | 16:e4f2689363bb | 6 | */ |
kevin1990 | 16:e4f2689363bb | 7 | |
kevin1990 | 16:e4f2689363bb | 8 | /****************************************************************************** |
kevin1990 | 16:e4f2689363bb | 9 | Copyright (c) 2017 Emutex Ltd. / Analog Devices, Inc. |
kevin1990 | 16:e4f2689363bb | 10 | |
kevin1990 | 16:e4f2689363bb | 11 | All rights reserved. |
kevin1990 | 16:e4f2689363bb | 12 | |
kevin1990 | 16:e4f2689363bb | 13 | Redistribution and use in source and binary forms, with or without modification, |
kevin1990 | 16:e4f2689363bb | 14 | are permitted provided that the following conditions are met: |
kevin1990 | 16:e4f2689363bb | 15 | - Redistributions of source code must retain the above copyright notice, |
kevin1990 | 16:e4f2689363bb | 16 | this list of conditions and the following disclaimer. |
kevin1990 | 16:e4f2689363bb | 17 | - Redistributions in binary form must reproduce the above copyright notice, |
kevin1990 | 16:e4f2689363bb | 18 | this list of conditions and the following disclaimer in the documentation |
kevin1990 | 16:e4f2689363bb | 19 | and/or other materials provided with the distribution. |
kevin1990 | 16:e4f2689363bb | 20 | - Modified versions of the software must be conspicuously marked as such. |
kevin1990 | 16:e4f2689363bb | 21 | - This software is licensed solely and exclusively for use with processors |
kevin1990 | 16:e4f2689363bb | 22 | manufactured by or for Analog Devices, Inc. |
kevin1990 | 16:e4f2689363bb | 23 | - This software may not be combined or merged with other code in any manner |
kevin1990 | 16:e4f2689363bb | 24 | that would cause the software to become subject to terms and conditions |
kevin1990 | 16:e4f2689363bb | 25 | which differ from those listed here. |
kevin1990 | 16:e4f2689363bb | 26 | - Neither the name of Analog Devices, Inc. nor the names of its |
kevin1990 | 16:e4f2689363bb | 27 | contributors may be used to endorse or promote products derived |
kevin1990 | 16:e4f2689363bb | 28 | from this software without specific prior written permission. |
kevin1990 | 16:e4f2689363bb | 29 | - The use of this software may or may not infringe the patent rights of one |
kevin1990 | 16:e4f2689363bb | 30 | or more patent holders. This license does not release you from the |
kevin1990 | 16:e4f2689363bb | 31 | requirement that you obtain separate licenses from these patent holders |
kevin1990 | 16:e4f2689363bb | 32 | to use this software. |
kevin1990 | 16:e4f2689363bb | 33 | |
kevin1990 | 16:e4f2689363bb | 34 | THIS SOFTWARE IS PROVIDED BY ANALOG DEVICES, INC. AND CONTRIBUTORS "AS IS" AND ANY |
kevin1990 | 16:e4f2689363bb | 35 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, NON-INFRINGEMENT, |
kevin1990 | 16:e4f2689363bb | 36 | TITLE, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN |
kevin1990 | 16:e4f2689363bb | 37 | NO EVENT SHALL ANALOG DEVICES, INC. OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, |
kevin1990 | 16:e4f2689363bb | 38 | INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE OR CONSEQUENTIAL DAMAGES |
kevin1990 | 16:e4f2689363bb | 39 | (INCLUDING, BUT NOT LIMITED TO, DAMAGES ARISING OUT OF CLAIMS OF INTELLECTUAL |
kevin1990 | 16:e4f2689363bb | 40 | PROPERTY RIGHTS INFRINGEMENT; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS |
kevin1990 | 16:e4f2689363bb | 41 | OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
kevin1990 | 16:e4f2689363bb | 42 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
kevin1990 | 16:e4f2689363bb | 43 | NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
kevin1990 | 16:e4f2689363bb | 44 | EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
kevin1990 | 16:e4f2689363bb | 45 | * |
kevin1990 | 16:e4f2689363bb | 46 | *****************************************************************************/ |
kevin1990 | 16:e4f2689363bb | 47 | #include <float.h> |
kevin1990 | 16:e4f2689363bb | 48 | #include <math.h> |
kevin1990 | 16:e4f2689363bb | 49 | #include <string.h> |
kevin1990 | 16:e4f2689363bb | 50 | |
kevin1990 | 16:e4f2689363bb | 51 | #include "inc/adi_sense_platform.h" |
kevin1990 | 16:e4f2689363bb | 52 | #include "inc/adi_sense_api.h" |
kevin1990 | 16:e4f2689363bb | 53 | #include "inc/adi_sense_1000/adi_sense_1000_api.h" |
kevin1990 | 16:e4f2689363bb | 54 | |
kevin1990 | 16:e4f2689363bb | 55 | #include "adi_sense_1000/ADISENSE1000_REGISTERS_typedefs.h" |
kevin1990 | 16:e4f2689363bb | 56 | #include "adi_sense_1000/ADISENSE1000_REGISTERS.h" |
kevin1990 | 16:e4f2689363bb | 57 | #include "adi_sense_1000/adi_sense_1000_lut_data.h" |
kevin1990 | 16:e4f2689363bb | 58 | #include "adi_sense_1000/adi_sense_1000_calibration.h" |
kevin1990 | 16:e4f2689363bb | 59 | |
kevin1990 | 16:e4f2689363bb | 60 | #include "crc16.h" |
kevin1990 | 16:e4f2689363bb | 61 | |
kevin1990 | 16:e4f2689363bb | 62 | /* |
kevin1990 | 16:e4f2689363bb | 63 | * The host is expected to transfer a 16-bit command, followed by data bytes, in 2 |
kevin1990 | 16:e4f2689363bb | 64 | * separate transfers delineated by the CS signal and a short delay in between. |
kevin1990 | 16:e4f2689363bb | 65 | * |
kevin1990 | 16:e4f2689363bb | 66 | * The 16-bit command contains a right-justified 11-bit register address (offset), |
kevin1990 | 16:e4f2689363bb | 67 | * and the remaining upper 5 bits are reserved as command bits assigned as follows: |
kevin1990 | 16:e4f2689363bb | 68 | * [15:11] 10000b = write command, 01000b = read command, anything else is invalid |
kevin1990 | 16:e4f2689363bb | 69 | * [10:0] register address (0-2047) |
kevin1990 | 16:e4f2689363bb | 70 | */ |
kevin1990 | 16:e4f2689363bb | 71 | |
kevin1990 | 16:e4f2689363bb | 72 | /* Register address space is limited to 2048 bytes (11 bit address) */ |
kevin1990 | 16:e4f2689363bb | 73 | #define REG_COMMAND_MASK 0xF800 |
kevin1990 | 16:e4f2689363bb | 74 | #define REG_ADDRESS_MASK 0x07FF |
kevin1990 | 16:e4f2689363bb | 75 | |
kevin1990 | 16:e4f2689363bb | 76 | /* |
kevin1990 | 16:e4f2689363bb | 77 | * The following commands are currently supported, anything else is treated |
kevin1990 | 16:e4f2689363bb | 78 | * as an error |
kevin1990 | 16:e4f2689363bb | 79 | */ |
kevin1990 | 16:e4f2689363bb | 80 | #define REG_WRITE_COMMAND 0x8000 |
kevin1990 | 16:e4f2689363bb | 81 | #define REG_READ_COMMAND 0x4000 |
kevin1990 | 16:e4f2689363bb | 82 | |
kevin1990 | 16:e4f2689363bb | 83 | /* |
kevin1990 | 16:e4f2689363bb | 84 | * The following bytes are sent back to the host when a command is recieved, |
kevin1990 | 16:e4f2689363bb | 85 | * to be used by the host to verify that we were ready to receive the command. |
kevin1990 | 16:e4f2689363bb | 86 | */ |
kevin1990 | 16:e4f2689363bb | 87 | #define REG_COMMAND_RESP_0 0xF0 |
kevin1990 | 16:e4f2689363bb | 88 | #define REG_COMMAND_RESP_1 0xE1 |
kevin1990 | 16:e4f2689363bb | 89 | |
kevin1990 | 16:e4f2689363bb | 90 | /* |
kevin1990 | 16:e4f2689363bb | 91 | * The following minimum delay must be inserted after each SPI transfer to allow |
kevin1990 | 16:e4f2689363bb | 92 | * time for it to be processed by the device |
kevin1990 | 16:e4f2689363bb | 93 | */ |
kevin1990 | 16:e4f2689363bb | 94 | #define POST_SPI_TRANSFER_DELAY_USEC (20) |
kevin1990 | 16:e4f2689363bb | 95 | |
kevin1990 | 16:e4f2689363bb | 96 | /* |
kevin1990 | 16:e4f2689363bb | 97 | * The following macros are used to encapsulate the register access code |
kevin1990 | 16:e4f2689363bb | 98 | * to improve readability in the functions further below in this file |
kevin1990 | 16:e4f2689363bb | 99 | */ |
kevin1990 | 16:e4f2689363bb | 100 | #define STRINGIFY(name) #name |
kevin1990 | 16:e4f2689363bb | 101 | |
kevin1990 | 16:e4f2689363bb | 102 | /* Expand the full name of the reset value macro for the specified register */ |
kevin1990 | 16:e4f2689363bb | 103 | #define REG_RESET_VAL(_name) REG_ADISENSE_##_name##_RESET |
kevin1990 | 16:e4f2689363bb | 104 | |
kevin1990 | 16:e4f2689363bb | 105 | /* Checks if a value is outside the bounds of the specified register field */ |
kevin1990 | 16:e4f2689363bb | 106 | #define CHECK_REG_FIELD_VAL(_field, _val) \ |
kevin1990 | 16:e4f2689363bb | 107 | do { \ |
kevin1990 | 16:e4f2689363bb | 108 | uint32_t _mask = BITM_ADISENSE_##_field; \ |
kevin1990 | 16:e4f2689363bb | 109 | uint32_t _shift = BITP_ADISENSE_##_field; \ |
kevin1990 | 16:e4f2689363bb | 110 | if ((((_val) << _shift) & ~(_mask)) != 0) { \ |
kevin1990 | 16:e4f2689363bb | 111 | ADI_SENSE_LOG_ERROR("Value 0x%08X invalid for register field %s", \ |
kevin1990 | 16:e4f2689363bb | 112 | (uint32_t)(_val), \ |
kevin1990 | 16:e4f2689363bb | 113 | STRINGIFY(ADISENSE_##_field)); \ |
kevin1990 | 16:e4f2689363bb | 114 | return ADI_SENSE_INVALID_PARAM; \ |
kevin1990 | 16:e4f2689363bb | 115 | } \ |
kevin1990 | 16:e4f2689363bb | 116 | } while(false) |
kevin1990 | 16:e4f2689363bb | 117 | |
kevin1990 | 16:e4f2689363bb | 118 | /* |
kevin1990 | 16:e4f2689363bb | 119 | * Encapsulates the write to a specified register |
kevin1990 | 16:e4f2689363bb | 120 | * NOTE - this will cause the calling function to return on error |
kevin1990 | 16:e4f2689363bb | 121 | */ |
kevin1990 | 16:e4f2689363bb | 122 | #define WRITE_REG(_hdev, _val, _name, _type) \ |
kevin1990 | 16:e4f2689363bb | 123 | do { \ |
kevin1990 | 16:e4f2689363bb | 124 | ADI_SENSE_RESULT _res; \ |
kevin1990 | 16:e4f2689363bb | 125 | _type _regval = _val; \ |
kevin1990 | 16:e4f2689363bb | 126 | _res = adi_sense_1000_WriteRegister((_hdev), \ |
kevin1990 | 16:e4f2689363bb | 127 | REG_ADISENSE_##_name, \ |
kevin1990 | 16:e4f2689363bb | 128 | &_regval, sizeof(_regval)); \ |
kevin1990 | 16:e4f2689363bb | 129 | if (_res != ADI_SENSE_SUCCESS) \ |
kevin1990 | 16:e4f2689363bb | 130 | return _res; \ |
kevin1990 | 16:e4f2689363bb | 131 | } while(false) |
kevin1990 | 16:e4f2689363bb | 132 | |
kevin1990 | 16:e4f2689363bb | 133 | /* Wrapper macro to write a value to a uint32_t register */ |
kevin1990 | 16:e4f2689363bb | 134 | #define WRITE_REG_U32(_hdev, _val, _name) \ |
kevin1990 | 16:e4f2689363bb | 135 | WRITE_REG(_hdev, _val, _name, uint32_t) |
kevin1990 | 16:e4f2689363bb | 136 | /* Wrapper macro to write a value to a uint16_t register */ |
kevin1990 | 16:e4f2689363bb | 137 | #define WRITE_REG_U16(_hdev, _val, _name) \ |
kevin1990 | 16:e4f2689363bb | 138 | WRITE_REG(_hdev, _val, _name, uint16_t) |
kevin1990 | 16:e4f2689363bb | 139 | /* Wrapper macro to write a value to a uint8_t register */ |
kevin1990 | 16:e4f2689363bb | 140 | #define WRITE_REG_U8(_hdev, _val, _name) \ |
kevin1990 | 16:e4f2689363bb | 141 | WRITE_REG(_hdev, _val, _name, uint8_t) |
kevin1990 | 16:e4f2689363bb | 142 | /* Wrapper macro to write a value to a float32_t register */ |
kevin1990 | 16:e4f2689363bb | 143 | #define WRITE_REG_FLOAT(_hdev, _val, _name) \ |
kevin1990 | 16:e4f2689363bb | 144 | WRITE_REG(_hdev, _val, _name, float32_t) |
kevin1990 | 16:e4f2689363bb | 145 | |
kevin1990 | 16:e4f2689363bb | 146 | /* |
kevin1990 | 16:e4f2689363bb | 147 | * Encapsulates the read from a specified register |
kevin1990 | 16:e4f2689363bb | 148 | * NOTE - this will cause the calling function to return on error |
kevin1990 | 16:e4f2689363bb | 149 | */ |
kevin1990 | 16:e4f2689363bb | 150 | #define READ_REG(_hdev, _val, _name, _type) \ |
kevin1990 | 16:e4f2689363bb | 151 | do { \ |
kevin1990 | 16:e4f2689363bb | 152 | ADI_SENSE_RESULT _res; \ |
kevin1990 | 16:e4f2689363bb | 153 | _type _regval; \ |
kevin1990 | 16:e4f2689363bb | 154 | _res = adi_sense_1000_ReadRegister((_hdev), \ |
kevin1990 | 16:e4f2689363bb | 155 | REG_ADISENSE_##_name, \ |
kevin1990 | 16:e4f2689363bb | 156 | &_regval, sizeof(_regval)); \ |
kevin1990 | 16:e4f2689363bb | 157 | if (_res != ADI_SENSE_SUCCESS) \ |
kevin1990 | 16:e4f2689363bb | 158 | return _res; \ |
kevin1990 | 16:e4f2689363bb | 159 | _val = _regval; \ |
kevin1990 | 16:e4f2689363bb | 160 | } while(false) |
kevin1990 | 16:e4f2689363bb | 161 | |
kevin1990 | 16:e4f2689363bb | 162 | /* Wrapper macro to read a value from a uint32_t register */ |
kevin1990 | 16:e4f2689363bb | 163 | #define READ_REG_U32(_hdev, _val, _name) \ |
kevin1990 | 16:e4f2689363bb | 164 | READ_REG(_hdev, _val, _name, uint32_t) |
kevin1990 | 16:e4f2689363bb | 165 | /* Wrapper macro to read a value from a uint16_t register */ |
kevin1990 | 16:e4f2689363bb | 166 | #define READ_REG_U16(_hdev, _val, _name) \ |
kevin1990 | 16:e4f2689363bb | 167 | READ_REG(_hdev, _val, _name, uint16_t) |
kevin1990 | 16:e4f2689363bb | 168 | /* Wrapper macro to read a value from a uint8_t register */ |
kevin1990 | 16:e4f2689363bb | 169 | #define READ_REG_U8(_hdev, _val, _name) \ |
kevin1990 | 16:e4f2689363bb | 170 | READ_REG(_hdev, _val, _name, uint8_t) |
kevin1990 | 16:e4f2689363bb | 171 | /* Wrapper macro to read a value from a float32_t register */ |
kevin1990 | 16:e4f2689363bb | 172 | #define READ_REG_FLOAT(_hdev, _val, _name) \ |
kevin1990 | 16:e4f2689363bb | 173 | READ_REG(_hdev, _val, _name, float32_t) |
kevin1990 | 16:e4f2689363bb | 174 | |
kevin1990 | 16:e4f2689363bb | 175 | /* |
kevin1990 | 16:e4f2689363bb | 176 | * Wrapper macro to write an array of values to a uint8_t register |
kevin1990 | 16:e4f2689363bb | 177 | * NOTE - this is intended only for writing to a keyhole data register |
kevin1990 | 16:e4f2689363bb | 178 | */ |
kevin1990 | 16:e4f2689363bb | 179 | #define WRITE_REG_U8_ARRAY(_hdev, _arr, _len, _name) \ |
kevin1990 | 16:e4f2689363bb | 180 | do { \ |
kevin1990 | 16:e4f2689363bb | 181 | ADI_SENSE_RESULT _res; \ |
kevin1990 | 16:e4f2689363bb | 182 | _res = adi_sense_1000_WriteRegister(_hdev, \ |
kevin1990 | 16:e4f2689363bb | 183 | REG_ADISENSE_##_name, \ |
kevin1990 | 16:e4f2689363bb | 184 | _arr, _len); \ |
kevin1990 | 16:e4f2689363bb | 185 | if (_res != ADI_SENSE_SUCCESS) \ |
kevin1990 | 16:e4f2689363bb | 186 | return _res; \ |
kevin1990 | 16:e4f2689363bb | 187 | } while(false) |
kevin1990 | 16:e4f2689363bb | 188 | |
kevin1990 | 16:e4f2689363bb | 189 | /* |
kevin1990 | 16:e4f2689363bb | 190 | * Wrapper macro to read an array of values from a uint8_t register |
kevin1990 | 16:e4f2689363bb | 191 | * NOTE - this is intended only for reading from a keyhole data register |
kevin1990 | 16:e4f2689363bb | 192 | */ |
kevin1990 | 16:e4f2689363bb | 193 | #define READ_REG_U8_ARRAY(_hdev, _arr, _len, _name) \ |
kevin1990 | 16:e4f2689363bb | 194 | do { \ |
kevin1990 | 16:e4f2689363bb | 195 | ADI_SENSE_RESULT _res; \ |
kevin1990 | 16:e4f2689363bb | 196 | _res = adi_sense_1000_ReadRegister((_hdev), \ |
kevin1990 | 16:e4f2689363bb | 197 | REG_ADISENSE_##_name, \ |
kevin1990 | 16:e4f2689363bb | 198 | _arr, _len); \ |
kevin1990 | 16:e4f2689363bb | 199 | if (_res != ADI_SENSE_SUCCESS) \ |
kevin1990 | 16:e4f2689363bb | 200 | return _res; \ |
kevin1990 | 16:e4f2689363bb | 201 | } while(false) |
kevin1990 | 16:e4f2689363bb | 202 | |
kevin1990 | 16:e4f2689363bb | 203 | #define ADI_SENSE_1000_CHANNEL_IS_ADC(c) \ |
kevin1990 | 16:e4f2689363bb | 204 | ((c) >= ADI_SENSE_1000_CHANNEL_ID_CJC_0 && (c) <= ADI_SENSE_1000_CHANNEL_ID_CURRENT_0) |
kevin1990 | 16:e4f2689363bb | 205 | |
kevin1990 | 16:e4f2689363bb | 206 | #define ADI_SENSE_1000_CHANNEL_IS_ADC_CJC(c) \ |
kevin1990 | 16:e4f2689363bb | 207 | ((c) >= ADI_SENSE_1000_CHANNEL_ID_CJC_0 && (c) <= ADI_SENSE_1000_CHANNEL_ID_CJC_1) |
kevin1990 | 16:e4f2689363bb | 208 | |
kevin1990 | 16:e4f2689363bb | 209 | #define ADI_SENSE_1000_CHANNEL_IS_ADC_SENSOR(c) \ |
kevin1990 | 16:e4f2689363bb | 210 | ((c) >= ADI_SENSE_1000_CHANNEL_ID_SENSOR_0 && (c) <= ADI_SENSE_1000_CHANNEL_ID_SENSOR_3) |
kevin1990 | 16:e4f2689363bb | 211 | |
kevin1990 | 16:e4f2689363bb | 212 | #define ADI_SENSE_1000_CHANNEL_IS_ADC_VOLTAGE(c) \ |
kevin1990 | 16:e4f2689363bb | 213 | ((c) == ADI_SENSE_1000_CHANNEL_ID_VOLTAGE_0) |
kevin1990 | 16:e4f2689363bb | 214 | |
kevin1990 | 16:e4f2689363bb | 215 | #define ADI_SENSE_1000_CHANNEL_IS_ADC_CURRENT(c) \ |
kevin1990 | 16:e4f2689363bb | 216 | ((c) == ADI_SENSE_1000_CHANNEL_ID_CURRENT_0) |
kevin1990 | 16:e4f2689363bb | 217 | |
kevin1990 | 16:e4f2689363bb | 218 | #define ADI_SENSE_1000_CHANNEL_IS_VIRTUAL(c) \ |
kevin1990 | 16:e4f2689363bb | 219 | ((c) == ADI_SENSE_1000_CHANNEL_ID_SPI_1 || (c) == ADI_SENSE_1000_CHANNEL_ID_SPI_2) |
kevin1990 | 16:e4f2689363bb | 220 | |
kevin1990 | 16:e4f2689363bb | 221 | typedef struct |
kevin1990 | 16:e4f2689363bb | 222 | { |
kevin1990 | 16:e4f2689363bb | 223 | unsigned nDeviceIndex; |
kevin1990 | 16:e4f2689363bb | 224 | ADI_SENSE_SPI_HANDLE hSpi; |
kevin1990 | 16:e4f2689363bb | 225 | ADI_SENSE_GPIO_HANDLE hGpio; |
kevin1990 | 16:e4f2689363bb | 226 | } ADI_SENSE_DEVICE_CONTEXT; |
kevin1990 | 16:e4f2689363bb | 227 | |
kevin1990 | 16:e4f2689363bb | 228 | static ADI_SENSE_DEVICE_CONTEXT gDeviceCtx[ADI_SENSE_PLATFORM_MAX_DEVICES]; |
kevin1990 | 16:e4f2689363bb | 229 | |
kevin1990 | 16:e4f2689363bb | 230 | /* |
kevin1990 | 16:e4f2689363bb | 231 | * Open an ADI Sense device instance. |
kevin1990 | 16:e4f2689363bb | 232 | */ |
kevin1990 | 16:e4f2689363bb | 233 | ADI_SENSE_RESULT adi_sense_Open( |
kevin1990 | 16:e4f2689363bb | 234 | unsigned const nDeviceIndex, |
kevin1990 | 16:e4f2689363bb | 235 | ADI_SENSE_CONNECTION * const pConnectionInfo, |
kevin1990 | 16:e4f2689363bb | 236 | ADI_SENSE_DEVICE_HANDLE * const phDevice) |
kevin1990 | 16:e4f2689363bb | 237 | { |
kevin1990 | 16:e4f2689363bb | 238 | ADI_SENSE_DEVICE_CONTEXT *pCtx; |
kevin1990 | 16:e4f2689363bb | 239 | ADI_SENSE_RESULT eRet; |
kevin1990 | 16:e4f2689363bb | 240 | |
kevin1990 | 16:e4f2689363bb | 241 | if (nDeviceIndex >= ADI_SENSE_PLATFORM_MAX_DEVICES) |
kevin1990 | 16:e4f2689363bb | 242 | return ADI_SENSE_INVALID_DEVICE_NUM; |
kevin1990 | 16:e4f2689363bb | 243 | |
kevin1990 | 16:e4f2689363bb | 244 | pCtx = &gDeviceCtx[nDeviceIndex]; |
kevin1990 | 16:e4f2689363bb | 245 | pCtx->nDeviceIndex = nDeviceIndex; |
kevin1990 | 16:e4f2689363bb | 246 | |
kevin1990 | 16:e4f2689363bb | 247 | eRet = adi_sense_LogOpen(); |
kevin1990 | 16:e4f2689363bb | 248 | if (eRet != ADI_SENSE_SUCCESS) |
kevin1990 | 16:e4f2689363bb | 249 | return eRet; |
kevin1990 | 16:e4f2689363bb | 250 | |
kevin1990 | 16:e4f2689363bb | 251 | eRet = adi_sense_GpioOpen(&pConnectionInfo->gpio, &pCtx->hGpio); |
kevin1990 | 16:e4f2689363bb | 252 | if (eRet != ADI_SENSE_SUCCESS) |
kevin1990 | 16:e4f2689363bb | 253 | return eRet; |
kevin1990 | 16:e4f2689363bb | 254 | |
kevin1990 | 16:e4f2689363bb | 255 | eRet = adi_sense_SpiOpen(&pConnectionInfo->spi, &pCtx->hSpi); |
kevin1990 | 16:e4f2689363bb | 256 | if (eRet != ADI_SENSE_SUCCESS) |
kevin1990 | 16:e4f2689363bb | 257 | return eRet; |
kevin1990 | 16:e4f2689363bb | 258 | |
kevin1990 | 16:e4f2689363bb | 259 | *phDevice = pCtx; |
kevin1990 | 16:e4f2689363bb | 260 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 261 | } |
kevin1990 | 16:e4f2689363bb | 262 | |
kevin1990 | 16:e4f2689363bb | 263 | /* |
kevin1990 | 16:e4f2689363bb | 264 | * Get the current state of the specified GPIO input signal. |
kevin1990 | 16:e4f2689363bb | 265 | */ |
kevin1990 | 16:e4f2689363bb | 266 | ADI_SENSE_RESULT adi_sense_GetGpioState( |
kevin1990 | 16:e4f2689363bb | 267 | ADI_SENSE_DEVICE_HANDLE const hDevice, |
kevin1990 | 16:e4f2689363bb | 268 | ADI_SENSE_GPIO_PIN const ePinId, |
kevin1990 | 16:e4f2689363bb | 269 | bool_t * const pbAsserted) |
kevin1990 | 16:e4f2689363bb | 270 | { |
kevin1990 | 16:e4f2689363bb | 271 | ADI_SENSE_DEVICE_CONTEXT *pCtx = hDevice; |
kevin1990 | 16:e4f2689363bb | 272 | |
kevin1990 | 16:e4f2689363bb | 273 | return adi_sense_GpioGet(pCtx->hGpio, ePinId, pbAsserted); |
kevin1990 | 16:e4f2689363bb | 274 | } |
kevin1990 | 16:e4f2689363bb | 275 | |
kevin1990 | 16:e4f2689363bb | 276 | /* |
kevin1990 | 16:e4f2689363bb | 277 | * Register an application-defined callback function for GPIO interrupts. |
kevin1990 | 16:e4f2689363bb | 278 | */ |
kevin1990 | 16:e4f2689363bb | 279 | ADI_SENSE_RESULT adi_sense_RegisterGpioCallback( |
kevin1990 | 16:e4f2689363bb | 280 | ADI_SENSE_DEVICE_HANDLE const hDevice, |
kevin1990 | 16:e4f2689363bb | 281 | ADI_SENSE_GPIO_PIN const ePinId, |
kevin1990 | 16:e4f2689363bb | 282 | ADI_SENSE_GPIO_CALLBACK const callbackFunction, |
kevin1990 | 16:e4f2689363bb | 283 | void * const pCallbackParam) |
kevin1990 | 16:e4f2689363bb | 284 | { |
kevin1990 | 16:e4f2689363bb | 285 | ADI_SENSE_DEVICE_CONTEXT *pCtx = hDevice; |
kevin1990 | 16:e4f2689363bb | 286 | |
kevin1990 | 16:e4f2689363bb | 287 | if (callbackFunction) |
kevin1990 | 16:e4f2689363bb | 288 | { |
kevin1990 | 16:e4f2689363bb | 289 | return adi_sense_GpioIrqEnable(pCtx->hGpio, ePinId, callbackFunction, |
kevin1990 | 16:e4f2689363bb | 290 | pCallbackParam); |
kevin1990 | 16:e4f2689363bb | 291 | } |
kevin1990 | 16:e4f2689363bb | 292 | else |
kevin1990 | 16:e4f2689363bb | 293 | { |
kevin1990 | 16:e4f2689363bb | 294 | return adi_sense_GpioIrqDisable(pCtx->hGpio, ePinId); |
kevin1990 | 16:e4f2689363bb | 295 | } |
kevin1990 | 16:e4f2689363bb | 296 | } |
kevin1990 | 16:e4f2689363bb | 297 | |
kevin1990 | 16:e4f2689363bb | 298 | /* |
kevin1990 | 16:e4f2689363bb | 299 | * Reset the specified ADI Sense device. |
kevin1990 | 16:e4f2689363bb | 300 | */ |
kevin1990 | 16:e4f2689363bb | 301 | ADI_SENSE_RESULT adi_sense_Reset( |
kevin1990 | 16:e4f2689363bb | 302 | ADI_SENSE_DEVICE_HANDLE const hDevice) |
kevin1990 | 16:e4f2689363bb | 303 | { |
kevin1990 | 16:e4f2689363bb | 304 | ADI_SENSE_DEVICE_CONTEXT *pCtx = hDevice; |
kevin1990 | 16:e4f2689363bb | 305 | ADI_SENSE_RESULT eRet; |
kevin1990 | 16:e4f2689363bb | 306 | |
kevin1990 | 16:e4f2689363bb | 307 | /* Pulse the Reset GPIO pin low for a minimum of 4 microseconds */ |
kevin1990 | 16:e4f2689363bb | 308 | eRet = adi_sense_GpioSet(pCtx->hGpio, ADI_SENSE_GPIO_PIN_RESET, false); |
kevin1990 | 16:e4f2689363bb | 309 | if (eRet != ADI_SENSE_SUCCESS) |
kevin1990 | 16:e4f2689363bb | 310 | return eRet; |
kevin1990 | 16:e4f2689363bb | 311 | |
kevin1990 | 16:e4f2689363bb | 312 | adi_sense_TimeDelayUsec(4); |
kevin1990 | 16:e4f2689363bb | 313 | |
kevin1990 | 16:e4f2689363bb | 314 | eRet = adi_sense_GpioSet(pCtx->hGpio, ADI_SENSE_GPIO_PIN_RESET, true); |
kevin1990 | 16:e4f2689363bb | 315 | if (eRet != ADI_SENSE_SUCCESS) |
kevin1990 | 16:e4f2689363bb | 316 | return eRet; |
kevin1990 | 16:e4f2689363bb | 317 | |
kevin1990 | 16:e4f2689363bb | 318 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 319 | } |
kevin1990 | 16:e4f2689363bb | 320 | |
kevin1990 | 16:e4f2689363bb | 321 | |
kevin1990 | 16:e4f2689363bb | 322 | /*! |
kevin1990 | 16:e4f2689363bb | 323 | * @brief Get general status of ADISense module. |
kevin1990 | 16:e4f2689363bb | 324 | * |
kevin1990 | 16:e4f2689363bb | 325 | * @param[in] |
kevin1990 | 16:e4f2689363bb | 326 | * @param[out] pStatus : Pointer to CORE Status struct. |
kevin1990 | 16:e4f2689363bb | 327 | * |
kevin1990 | 16:e4f2689363bb | 328 | * @return Status |
kevin1990 | 16:e4f2689363bb | 329 | * - #ADI_SENSE_SUCCESS Call completed successfully. |
kevin1990 | 16:e4f2689363bb | 330 | * - #ADI_SENSE_FAILURE If status register read fails. |
kevin1990 | 16:e4f2689363bb | 331 | * |
kevin1990 | 16:e4f2689363bb | 332 | * @details Read the general status register for the ADISense |
kevin1990 | 16:e4f2689363bb | 333 | * module. Indicates Error, Alert conditions, data ready |
kevin1990 | 16:e4f2689363bb | 334 | * and command running. |
kevin1990 | 16:e4f2689363bb | 335 | * |
kevin1990 | 16:e4f2689363bb | 336 | */ |
kevin1990 | 16:e4f2689363bb | 337 | ADI_SENSE_RESULT adi_sense_GetStatus( |
kevin1990 | 16:e4f2689363bb | 338 | ADI_SENSE_DEVICE_HANDLE const hDevice, |
kevin1990 | 16:e4f2689363bb | 339 | ADI_SENSE_STATUS * const pStatus) |
kevin1990 | 16:e4f2689363bb | 340 | { |
kevin1990 | 16:e4f2689363bb | 341 | ADI_ADISENSE_CORE_Status_t statusReg; |
kevin1990 | 16:e4f2689363bb | 342 | READ_REG_U8(hDevice, statusReg.VALUE8, CORE_STATUS); |
kevin1990 | 16:e4f2689363bb | 343 | |
kevin1990 | 16:e4f2689363bb | 344 | memset(pStatus, 0, sizeof(*pStatus)); |
kevin1990 | 16:e4f2689363bb | 345 | |
kevin1990 | 16:e4f2689363bb | 346 | if (!statusReg.Cmd_Running) /* Active-low, so invert it */ |
kevin1990 | 16:e4f2689363bb | 347 | pStatus->deviceStatus |= ADI_SENSE_DEVICE_STATUS_BUSY; |
kevin1990 | 16:e4f2689363bb | 348 | if (statusReg.Drdy) |
kevin1990 | 16:e4f2689363bb | 349 | pStatus->deviceStatus |= ADI_SENSE_DEVICE_STATUS_DATAREADY; |
kevin1990 | 16:e4f2689363bb | 350 | if (statusReg.FIFO_Error) |
kevin1990 | 16:e4f2689363bb | 351 | pStatus->deviceStatus |= ADI_SENSE_DEVICE_STATUS_FIFO_ERROR; |
kevin1990 | 16:e4f2689363bb | 352 | if (statusReg.Alert_Active) |
kevin1990 | 16:e4f2689363bb | 353 | { |
kevin1990 | 16:e4f2689363bb | 354 | pStatus->deviceStatus |= ADI_SENSE_DEVICE_STATUS_ALERT; |
kevin1990 | 16:e4f2689363bb | 355 | |
kevin1990 | 16:e4f2689363bb | 356 | ADI_ADISENSE_CORE_Alert_Code_t alertCodeReg; |
kevin1990 | 16:e4f2689363bb | 357 | READ_REG_U16(hDevice, alertCodeReg.VALUE16, CORE_ALERT_CODE); |
kevin1990 | 16:e4f2689363bb | 358 | pStatus->alertCode = alertCodeReg.Alert_Code; |
kevin1990 | 16:e4f2689363bb | 359 | |
kevin1990 | 16:e4f2689363bb | 360 | ADI_ADISENSE_CORE_Channel_Alert_Status_t channelAlertStatusReg; |
kevin1990 | 16:e4f2689363bb | 361 | READ_REG_U16(hDevice, channelAlertStatusReg.VALUE16, |
kevin1990 | 16:e4f2689363bb | 362 | CORE_CHANNEL_ALERT_STATUS); |
kevin1990 | 16:e4f2689363bb | 363 | |
kevin1990 | 16:e4f2689363bb | 364 | for (unsigned i = 0; i < ADI_SENSE_1000_MAX_CHANNELS; i++) |
kevin1990 | 16:e4f2689363bb | 365 | { |
kevin1990 | 16:e4f2689363bb | 366 | if (channelAlertStatusReg.VALUE16 & (1 << i)) |
kevin1990 | 16:e4f2689363bb | 367 | { |
kevin1990 | 16:e4f2689363bb | 368 | ADI_ADISENSE_CORE_Alert_Code_Ch_t channelAlertCodeReg; |
kevin1990 | 16:e4f2689363bb | 369 | READ_REG_U16(hDevice, channelAlertCodeReg.VALUE16, CORE_ALERT_CODE_CHn(i)); |
kevin1990 | 16:e4f2689363bb | 370 | pStatus->channelAlertCodes[i] = channelAlertCodeReg.Alert_Code_Ch; |
kevin1990 | 16:e4f2689363bb | 371 | |
kevin1990 | 16:e4f2689363bb | 372 | ADI_ADISENSE_CORE_Alert_Detail_Ch_t alertDetailReg; |
kevin1990 | 16:e4f2689363bb | 373 | READ_REG_U16(hDevice, alertDetailReg.VALUE16, |
kevin1990 | 16:e4f2689363bb | 374 | CORE_ALERT_DETAIL_CHn(i)); |
kevin1990 | 16:e4f2689363bb | 375 | |
kevin1990 | 16:e4f2689363bb | 376 | if (alertDetailReg.Time_Out) |
kevin1990 | 16:e4f2689363bb | 377 | pStatus->channelAlerts[i] |= ADI_SENSE_CHANNEL_ALERT_TIMEOUT; |
kevin1990 | 16:e4f2689363bb | 378 | if (alertDetailReg.Under_Range) |
kevin1990 | 16:e4f2689363bb | 379 | pStatus->channelAlerts[i] |= ADI_SENSE_CHANNEL_ALERT_UNDER_RANGE; |
kevin1990 | 16:e4f2689363bb | 380 | if (alertDetailReg.Over_Range) |
kevin1990 | 16:e4f2689363bb | 381 | pStatus->channelAlerts[i] |= ADI_SENSE_CHANNEL_ALERT_OVER_RANGE; |
kevin1990 | 16:e4f2689363bb | 382 | if (alertDetailReg.Low_Limit) |
kevin1990 | 16:e4f2689363bb | 383 | pStatus->channelAlerts[i] |= ADI_SENSE_CHANNEL_ALERT_LOW_LIMIT; |
kevin1990 | 16:e4f2689363bb | 384 | if (alertDetailReg.High_Limit) |
kevin1990 | 16:e4f2689363bb | 385 | pStatus->channelAlerts[i] |= ADI_SENSE_CHANNEL_ALERT_HIGH_LIMIT; |
kevin1990 | 16:e4f2689363bb | 386 | if (alertDetailReg.Sensor_Open) |
kevin1990 | 16:e4f2689363bb | 387 | pStatus->channelAlerts[i] |= ADI_SENSE_CHANNEL_ALERT_SENSOR_OPEN; |
kevin1990 | 16:e4f2689363bb | 388 | if (alertDetailReg.Ref_Detect) |
kevin1990 | 16:e4f2689363bb | 389 | pStatus->channelAlerts[i] |= ADI_SENSE_CHANNEL_ALERT_REF_DETECT; |
kevin1990 | 16:e4f2689363bb | 390 | if (alertDetailReg.Config_Err) |
kevin1990 | 16:e4f2689363bb | 391 | pStatus->channelAlerts[i] |= ADI_SENSE_CHANNEL_ALERT_CONFIG_ERR; |
kevin1990 | 16:e4f2689363bb | 392 | if (alertDetailReg.LUT_Error_Ch) |
kevin1990 | 16:e4f2689363bb | 393 | pStatus->channelAlerts[i] |= ADI_SENSE_CHANNEL_ALERT_LUT_ERR; |
kevin1990 | 16:e4f2689363bb | 394 | if (alertDetailReg.Sensor_Not_Ready) |
kevin1990 | 16:e4f2689363bb | 395 | pStatus->channelAlerts[i] |= ADI_SENSE_CHANNEL_ALERT_SENSOR_NOT_READY; |
kevin1990 | 16:e4f2689363bb | 396 | if (alertDetailReg.Comp_Not_Ready) |
kevin1990 | 16:e4f2689363bb | 397 | pStatus->channelAlerts[i] |= ADI_SENSE_CHANNEL_ALERT_COMP_NOT_READY; |
kevin1990 | 16:e4f2689363bb | 398 | if (alertDetailReg.Under_Voltage) |
kevin1990 | 16:e4f2689363bb | 399 | pStatus->channelAlerts[i] |= ADI_SENSE_CHANNEL_ALERT_UNDER_VOLTAGE; |
kevin1990 | 16:e4f2689363bb | 400 | if (alertDetailReg.Over_Voltage) |
kevin1990 | 16:e4f2689363bb | 401 | pStatus->channelAlerts[i] |= ADI_SENSE_CHANNEL_ALERT_OVER_VOLTAGE; |
kevin1990 | 16:e4f2689363bb | 402 | if (alertDetailReg.Correction_UnderRange) |
kevin1990 | 16:e4f2689363bb | 403 | pStatus->channelAlerts[i] |= ADI_SENSE_CHANNEL_ALERT_LUT_UNDER_RANGE; |
kevin1990 | 16:e4f2689363bb | 404 | if (alertDetailReg.Correction_OverRange) |
kevin1990 | 16:e4f2689363bb | 405 | pStatus->channelAlerts[i] |= ADI_SENSE_CHANNEL_ALERT_LUT_OVER_RANGE; |
kevin1990 | 16:e4f2689363bb | 406 | } |
kevin1990 | 16:e4f2689363bb | 407 | } |
kevin1990 | 16:e4f2689363bb | 408 | |
kevin1990 | 16:e4f2689363bb | 409 | ADI_ADISENSE_CORE_Alert_Status_2_t alert2Reg; |
kevin1990 | 16:e4f2689363bb | 410 | READ_REG_U16(hDevice, alert2Reg.VALUE16, CORE_ALERT_STATUS_2); |
kevin1990 | 16:e4f2689363bb | 411 | if (alert2Reg.Configuration_Error) |
kevin1990 | 16:e4f2689363bb | 412 | pStatus->deviceStatus |= ADI_SENSE_DEVICE_STATUS_CONFIG_ERROR; |
kevin1990 | 16:e4f2689363bb | 413 | if (alert2Reg.LUT_Error) |
kevin1990 | 16:e4f2689363bb | 414 | pStatus->deviceStatus |= ADI_SENSE_DEVICE_STATUS_LUT_ERROR; |
kevin1990 | 16:e4f2689363bb | 415 | } |
kevin1990 | 16:e4f2689363bb | 416 | |
kevin1990 | 16:e4f2689363bb | 417 | if (statusReg.Error) |
kevin1990 | 16:e4f2689363bb | 418 | { |
kevin1990 | 16:e4f2689363bb | 419 | pStatus->deviceStatus |= ADI_SENSE_DEVICE_STATUS_ERROR; |
kevin1990 | 16:e4f2689363bb | 420 | |
kevin1990 | 16:e4f2689363bb | 421 | ADI_ADISENSE_CORE_Error_Code_t errorCodeReg; |
kevin1990 | 16:e4f2689363bb | 422 | READ_REG_U16(hDevice, errorCodeReg.VALUE16, CORE_ERROR_CODE); |
kevin1990 | 16:e4f2689363bb | 423 | pStatus->errorCode = errorCodeReg.Error_Code; |
kevin1990 | 16:e4f2689363bb | 424 | |
kevin1990 | 16:e4f2689363bb | 425 | ADI_ADISENSE_CORE_Diagnostics_Status_t diagStatusReg; |
kevin1990 | 16:e4f2689363bb | 426 | READ_REG_U16(hDevice, diagStatusReg.VALUE16, CORE_DIAGNOSTICS_STATUS); |
kevin1990 | 16:e4f2689363bb | 427 | |
kevin1990 | 16:e4f2689363bb | 428 | if (diagStatusReg.Diag_Checksum_Error) |
kevin1990 | 16:e4f2689363bb | 429 | pStatus->diagnosticsStatus |= ADI_SENSE_DIAGNOSTICS_STATUS_CHECKSUM_ERROR; |
kevin1990 | 16:e4f2689363bb | 430 | if (diagStatusReg.Diag_Comms_Error) |
kevin1990 | 16:e4f2689363bb | 431 | pStatus->diagnosticsStatus |= ADI_SENSE_DIAGNOSTICS_STATUS_COMMS_ERROR; |
kevin1990 | 16:e4f2689363bb | 432 | if (diagStatusReg.Diag_Supply_Monitor_Error) |
kevin1990 | 16:e4f2689363bb | 433 | pStatus->diagnosticsStatus |= ADI_SENSE_DIAGNOSTICS_STATUS_SUPPLY_MONITOR_ERROR; |
kevin1990 | 16:e4f2689363bb | 434 | if (diagStatusReg.Diag_Supply_Cap_Error) |
kevin1990 | 16:e4f2689363bb | 435 | pStatus->diagnosticsStatus |= ADI_SENSE_DIAGNOSTICS_STATUS_SUPPLY_CAP_ERROR; |
kevin1990 | 16:e4f2689363bb | 436 | if (diagStatusReg.Diag_Ainm_UV_Error) |
kevin1990 | 16:e4f2689363bb | 437 | pStatus->diagnosticsStatus |= ADI_SENSE_DIAGNOSTICS_STATUS_AINM_UV_ERROR; |
kevin1990 | 16:e4f2689363bb | 438 | if (diagStatusReg.Diag_Ainm_OV_Error) |
kevin1990 | 16:e4f2689363bb | 439 | pStatus->diagnosticsStatus |= ADI_SENSE_DIAGNOSTICS_STATUS_AINM_OV_ERROR; |
kevin1990 | 16:e4f2689363bb | 440 | if (diagStatusReg.Diag_Ainp_UV_Error) |
kevin1990 | 16:e4f2689363bb | 441 | pStatus->diagnosticsStatus |= ADI_SENSE_DIAGNOSTICS_STATUS_AINP_UV_ERROR; |
kevin1990 | 16:e4f2689363bb | 442 | if (diagStatusReg.Diag_Ainp_OV_Error) |
kevin1990 | 16:e4f2689363bb | 443 | pStatus->diagnosticsStatus |= ADI_SENSE_DIAGNOSTICS_STATUS_AINP_OV_ERROR; |
kevin1990 | 16:e4f2689363bb | 444 | if (diagStatusReg.Diag_Conversion_Error) |
kevin1990 | 16:e4f2689363bb | 445 | pStatus->diagnosticsStatus |= ADI_SENSE_DIAGNOSTICS_STATUS_CONVERSION_ERROR; |
kevin1990 | 16:e4f2689363bb | 446 | if (diagStatusReg.Diag_Calibration_Error) |
kevin1990 | 16:e4f2689363bb | 447 | pStatus->diagnosticsStatus |= ADI_SENSE_DIAGNOSTICS_STATUS_CALIBRATION_ERROR; |
kevin1990 | 16:e4f2689363bb | 448 | } |
kevin1990 | 16:e4f2689363bb | 449 | |
kevin1990 | 16:e4f2689363bb | 450 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 451 | } |
kevin1990 | 16:e4f2689363bb | 452 | |
kevin1990 | 16:e4f2689363bb | 453 | ADI_SENSE_RESULT adi_sense_GetCommandRunningState( |
kevin1990 | 16:e4f2689363bb | 454 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 455 | bool_t *pbCommandRunning) |
kevin1990 | 16:e4f2689363bb | 456 | { |
kevin1990 | 16:e4f2689363bb | 457 | ADI_ADISENSE_CORE_Status_t statusReg; |
kevin1990 | 16:e4f2689363bb | 458 | |
kevin1990 | 16:e4f2689363bb | 459 | READ_REG_U8(hDevice, statusReg.VALUE8, CORE_STATUS); |
kevin1990 | 16:e4f2689363bb | 460 | |
kevin1990 | 16:e4f2689363bb | 461 | /* We should never normally see 0xFF here if the module is operational */ |
kevin1990 | 16:e4f2689363bb | 462 | if (statusReg.VALUE8 == 0xFF) |
kevin1990 | 16:e4f2689363bb | 463 | return ADI_SENSE_ERR_NOT_INITIALIZED; |
kevin1990 | 16:e4f2689363bb | 464 | |
kevin1990 | 16:e4f2689363bb | 465 | *pbCommandRunning = !statusReg.Cmd_Running; /* Active-low, so invert it */ |
kevin1990 | 16:e4f2689363bb | 466 | |
kevin1990 | 16:e4f2689363bb | 467 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 468 | } |
kevin1990 | 16:e4f2689363bb | 469 | |
kevin1990 | 16:e4f2689363bb | 470 | static ADI_SENSE_RESULT executeCommand( |
kevin1990 | 16:e4f2689363bb | 471 | ADI_SENSE_DEVICE_HANDLE const hDevice, |
kevin1990 | 16:e4f2689363bb | 472 | ADI_ADISENSE_CORE_Command_Special_Command const command, |
kevin1990 | 16:e4f2689363bb | 473 | bool_t const bWaitForCompletion) |
kevin1990 | 16:e4f2689363bb | 474 | { |
kevin1990 | 16:e4f2689363bb | 475 | ADI_ADISENSE_CORE_Command_t commandReg; |
kevin1990 | 16:e4f2689363bb | 476 | bool_t bCommandRunning; |
kevin1990 | 16:e4f2689363bb | 477 | ADI_SENSE_RESULT eRet; |
kevin1990 | 16:e4f2689363bb | 478 | |
kevin1990 | 16:e4f2689363bb | 479 | /* |
kevin1990 | 16:e4f2689363bb | 480 | * Don't allow another command to be issued if one is already running, but |
kevin1990 | 16:e4f2689363bb | 481 | * make an exception for ADISENSE_CORE_COMMAND_NOP which can be used to |
kevin1990 | 16:e4f2689363bb | 482 | * request a running command to be stopped (e.g. continuous measurement) |
kevin1990 | 16:e4f2689363bb | 483 | */ |
kevin1990 | 16:e4f2689363bb | 484 | if (command != ADISENSE_CORE_COMMAND_NOP) |
kevin1990 | 16:e4f2689363bb | 485 | { |
kevin1990 | 16:e4f2689363bb | 486 | eRet = adi_sense_GetCommandRunningState(hDevice, &bCommandRunning); |
kevin1990 | 16:e4f2689363bb | 487 | if (eRet) |
kevin1990 | 16:e4f2689363bb | 488 | return eRet; |
kevin1990 | 16:e4f2689363bb | 489 | |
kevin1990 | 16:e4f2689363bb | 490 | if (bCommandRunning) |
kevin1990 | 16:e4f2689363bb | 491 | return ADI_SENSE_IN_USE; |
kevin1990 | 16:e4f2689363bb | 492 | } |
kevin1990 | 16:e4f2689363bb | 493 | |
kevin1990 | 16:e4f2689363bb | 494 | commandReg.Special_Command = command; |
kevin1990 | 16:e4f2689363bb | 495 | WRITE_REG_U8(hDevice, commandReg.VALUE8, CORE_COMMAND); |
kevin1990 | 16:e4f2689363bb | 496 | |
kevin1990 | 16:e4f2689363bb | 497 | if (bWaitForCompletion) |
kevin1990 | 16:e4f2689363bb | 498 | { |
kevin1990 | 16:e4f2689363bb | 499 | do { |
kevin1990 | 16:e4f2689363bb | 500 | /* Allow a minimum 50usec delay for status update before checking */ |
kevin1990 | 16:e4f2689363bb | 501 | adi_sense_TimeDelayUsec(50); |
kevin1990 | 16:e4f2689363bb | 502 | |
kevin1990 | 16:e4f2689363bb | 503 | eRet = adi_sense_GetCommandRunningState(hDevice, &bCommandRunning); |
kevin1990 | 16:e4f2689363bb | 504 | if (eRet) |
kevin1990 | 16:e4f2689363bb | 505 | return eRet; |
kevin1990 | 16:e4f2689363bb | 506 | } while (bCommandRunning); |
kevin1990 | 16:e4f2689363bb | 507 | } |
kevin1990 | 16:e4f2689363bb | 508 | |
kevin1990 | 16:e4f2689363bb | 509 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 510 | } |
kevin1990 | 16:e4f2689363bb | 511 | |
kevin1990 | 16:e4f2689363bb | 512 | ADI_SENSE_RESULT adi_sense_ApplyConfigUpdates( |
kevin1990 | 16:e4f2689363bb | 513 | ADI_SENSE_DEVICE_HANDLE const hDevice) |
kevin1990 | 16:e4f2689363bb | 514 | { |
kevin1990 | 16:e4f2689363bb | 515 | return executeCommand(hDevice, ADISENSE_CORE_COMMAND_LATCH_CONFIG, true); |
kevin1990 | 16:e4f2689363bb | 516 | } |
kevin1990 | 16:e4f2689363bb | 517 | |
kevin1990 | 16:e4f2689363bb | 518 | /*! |
kevin1990 | 16:e4f2689363bb | 519 | * @brief Start a measurement cycle. |
kevin1990 | 16:e4f2689363bb | 520 | * |
kevin1990 | 16:e4f2689363bb | 521 | * @param[out] |
kevin1990 | 16:e4f2689363bb | 522 | * |
kevin1990 | 16:e4f2689363bb | 523 | * @return Status |
kevin1990 | 16:e4f2689363bb | 524 | * - #ADI_SENSE_SUCCESS Call completed successfully. |
kevin1990 | 16:e4f2689363bb | 525 | * - #ADI_SENSE_FAILURE |
kevin1990 | 16:e4f2689363bb | 526 | * |
kevin1990 | 16:e4f2689363bb | 527 | * @details Sends the latch config command. Configuration for channels in |
kevin1990 | 16:e4f2689363bb | 528 | * conversion cycle should be completed before this function. |
kevin1990 | 16:e4f2689363bb | 529 | * Channel enabled bit should be set before this function. |
kevin1990 | 16:e4f2689363bb | 530 | * Starts a conversion and configures the format of the sample. |
kevin1990 | 16:e4f2689363bb | 531 | * |
kevin1990 | 16:e4f2689363bb | 532 | */ |
kevin1990 | 16:e4f2689363bb | 533 | ADI_SENSE_RESULT adi_sense_StartMeasurement( |
kevin1990 | 16:e4f2689363bb | 534 | ADI_SENSE_DEVICE_HANDLE const hDevice, |
kevin1990 | 16:e4f2689363bb | 535 | ADI_SENSE_MEASUREMENT_MODE const eMeasurementMode) |
kevin1990 | 16:e4f2689363bb | 536 | { |
kevin1990 | 16:e4f2689363bb | 537 | switch (eMeasurementMode) |
kevin1990 | 16:e4f2689363bb | 538 | { |
kevin1990 | 16:e4f2689363bb | 539 | case ADI_SENSE_MEASUREMENT_MODE_HEALTHCHECK: |
kevin1990 | 16:e4f2689363bb | 540 | return executeCommand(hDevice, ADISENSE_CORE_COMMAND_SYSTEM_CHECK, false); |
kevin1990 | 16:e4f2689363bb | 541 | case ADI_SENSE_MEASUREMENT_MODE_NORMAL: |
kevin1990 | 16:e4f2689363bb | 542 | return executeCommand(hDevice, ADISENSE_CORE_COMMAND_CONVERT_WITH_RAW, false); |
kevin1990 | 16:e4f2689363bb | 543 | case ADI_SENSE_MEASUREMENT_MODE_OMIT_RAW: |
kevin1990 | 16:e4f2689363bb | 544 | return executeCommand(hDevice, ADISENSE_CORE_COMMAND_CONVERT, false); |
kevin1990 | 16:e4f2689363bb | 545 | default: |
kevin1990 | 16:e4f2689363bb | 546 | ADI_SENSE_LOG_ERROR("Invalid measurement mode %d specified", |
kevin1990 | 16:e4f2689363bb | 547 | eMeasurementMode); |
kevin1990 | 16:e4f2689363bb | 548 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 549 | } |
kevin1990 | 16:e4f2689363bb | 550 | } |
kevin1990 | 16:e4f2689363bb | 551 | |
kevin1990 | 16:e4f2689363bb | 552 | /* |
kevin1990 | 16:e4f2689363bb | 553 | * Store the configuration settings to persistent memory on the device. |
kevin1990 | 16:e4f2689363bb | 554 | * No other command must be running when this is called. |
kevin1990 | 16:e4f2689363bb | 555 | * Do not power down the device while this command is running. |
kevin1990 | 16:e4f2689363bb | 556 | */ |
kevin1990 | 16:e4f2689363bb | 557 | ADI_SENSE_RESULT adi_sense_SaveConfig( |
kevin1990 | 16:e4f2689363bb | 558 | ADI_SENSE_DEVICE_HANDLE const hDevice) |
kevin1990 | 16:e4f2689363bb | 559 | { |
kevin1990 | 16:e4f2689363bb | 560 | return executeCommand(hDevice, ADISENSE_CORE_COMMAND_SAVE_CONFIG, true); |
kevin1990 | 16:e4f2689363bb | 561 | } |
kevin1990 | 16:e4f2689363bb | 562 | |
kevin1990 | 16:e4f2689363bb | 563 | /* |
kevin1990 | 16:e4f2689363bb | 564 | * Restore the configuration settings from persistent memory on the device. |
kevin1990 | 16:e4f2689363bb | 565 | * No other command must be running when this is called. |
kevin1990 | 16:e4f2689363bb | 566 | */ |
kevin1990 | 16:e4f2689363bb | 567 | ADI_SENSE_RESULT adi_sense_RestoreConfig( |
kevin1990 | 16:e4f2689363bb | 568 | ADI_SENSE_DEVICE_HANDLE const hDevice) |
kevin1990 | 16:e4f2689363bb | 569 | { |
kevin1990 | 16:e4f2689363bb | 570 | return executeCommand(hDevice, ADISENSE_CORE_COMMAND_LOAD_CONFIG, true); |
kevin1990 | 16:e4f2689363bb | 571 | } |
kevin1990 | 16:e4f2689363bb | 572 | |
kevin1990 | 16:e4f2689363bb | 573 | /* |
kevin1990 | 16:e4f2689363bb | 574 | * Store the LUT data to persistent memory on the device. |
kevin1990 | 16:e4f2689363bb | 575 | * No other command must be running when this is called. |
kevin1990 | 16:e4f2689363bb | 576 | * Do not power down the device while this command is running. |
kevin1990 | 16:e4f2689363bb | 577 | */ |
kevin1990 | 16:e4f2689363bb | 578 | ADI_SENSE_RESULT adi_sense_SaveLutData( |
kevin1990 | 16:e4f2689363bb | 579 | ADI_SENSE_DEVICE_HANDLE const hDevice) |
kevin1990 | 16:e4f2689363bb | 580 | { |
kevin1990 | 16:e4f2689363bb | 581 | return executeCommand(hDevice, ADISENSE_CORE_COMMAND_SAVE_LUT2, true); |
kevin1990 | 16:e4f2689363bb | 582 | } |
kevin1990 | 16:e4f2689363bb | 583 | |
kevin1990 | 16:e4f2689363bb | 584 | /* |
kevin1990 | 16:e4f2689363bb | 585 | * Restore the LUT data from persistent memory on the device. |
kevin1990 | 16:e4f2689363bb | 586 | * No other command must be running when this is called. |
kevin1990 | 16:e4f2689363bb | 587 | */ |
kevin1990 | 16:e4f2689363bb | 588 | ADI_SENSE_RESULT adi_sense_RestoreLutData( |
kevin1990 | 16:e4f2689363bb | 589 | ADI_SENSE_DEVICE_HANDLE const hDevice) |
kevin1990 | 16:e4f2689363bb | 590 | { |
kevin1990 | 16:e4f2689363bb | 591 | return executeCommand(hDevice, ADISENSE_CORE_COMMAND_LOAD_LUT, true); |
kevin1990 | 16:e4f2689363bb | 592 | } |
kevin1990 | 16:e4f2689363bb | 593 | |
kevin1990 | 16:e4f2689363bb | 594 | /* |
kevin1990 | 16:e4f2689363bb | 595 | * Stop the measurement cycles on the device. |
kevin1990 | 16:e4f2689363bb | 596 | * To be used only if a measurement command is currently running. |
kevin1990 | 16:e4f2689363bb | 597 | */ |
kevin1990 | 16:e4f2689363bb | 598 | ADI_SENSE_RESULT adi_sense_StopMeasurement( |
kevin1990 | 16:e4f2689363bb | 599 | ADI_SENSE_DEVICE_HANDLE const hDevice) |
kevin1990 | 16:e4f2689363bb | 600 | { |
kevin1990 | 16:e4f2689363bb | 601 | return executeCommand(hDevice, ADISENSE_CORE_COMMAND_NOP, true); |
kevin1990 | 16:e4f2689363bb | 602 | } |
kevin1990 | 16:e4f2689363bb | 603 | |
kevin1990 | 16:e4f2689363bb | 604 | /* |
kevin1990 | 16:e4f2689363bb | 605 | * Run built-in diagnostic checks on the device. |
kevin1990 | 16:e4f2689363bb | 606 | * Diagnostics are executed according to the current applied settings. |
kevin1990 | 16:e4f2689363bb | 607 | * No other command must be running when this is called. |
kevin1990 | 16:e4f2689363bb | 608 | */ |
kevin1990 | 16:e4f2689363bb | 609 | ADI_SENSE_RESULT adi_sense_RunDiagnostics( |
kevin1990 | 16:e4f2689363bb | 610 | ADI_SENSE_DEVICE_HANDLE const hDevice) |
kevin1990 | 16:e4f2689363bb | 611 | { |
kevin1990 | 16:e4f2689363bb | 612 | return executeCommand(hDevice, ADISENSE_CORE_COMMAND_RUN_DIAGNOSTICS, true); |
kevin1990 | 16:e4f2689363bb | 613 | } |
kevin1990 | 16:e4f2689363bb | 614 | |
kevin1990 | 16:e4f2689363bb | 615 | /* |
kevin1990 | 16:e4f2689363bb | 616 | * Run self-calibration routines on the device. |
kevin1990 | 16:e4f2689363bb | 617 | * Calibration is executed according to the current applied settings. |
kevin1990 | 16:e4f2689363bb | 618 | * No other command must be running when this is called. |
kevin1990 | 16:e4f2689363bb | 619 | */ |
kevin1990 | 16:e4f2689363bb | 620 | ADI_SENSE_RESULT adi_sense_RunCalibration( |
kevin1990 | 16:e4f2689363bb | 621 | ADI_SENSE_DEVICE_HANDLE const hDevice) |
kevin1990 | 16:e4f2689363bb | 622 | { |
kevin1990 | 16:e4f2689363bb | 623 | return executeCommand(hDevice, ADISENSE_CORE_COMMAND_SELF_CALIBRATION, true); |
kevin1990 | 16:e4f2689363bb | 624 | } |
kevin1990 | 16:e4f2689363bb | 625 | |
kevin1990 | 16:e4f2689363bb | 626 | /* |
kevin1990 | 16:e4f2689363bb | 627 | * Read a set of data samples from the device. |
kevin1990 | 16:e4f2689363bb | 628 | * This may be called at any time. |
kevin1990 | 16:e4f2689363bb | 629 | */ |
kevin1990 | 16:e4f2689363bb | 630 | ADI_SENSE_RESULT adi_sense_GetData( |
kevin1990 | 16:e4f2689363bb | 631 | ADI_SENSE_DEVICE_HANDLE const hDevice, |
kevin1990 | 16:e4f2689363bb | 632 | ADI_SENSE_MEASUREMENT_MODE const eMeasurementMode, |
kevin1990 | 16:e4f2689363bb | 633 | ADI_SENSE_DATA_SAMPLE * const pSamples, |
kevin1990 | 16:e4f2689363bb | 634 | uint32_t const nRequested, |
kevin1990 | 16:e4f2689363bb | 635 | uint32_t * const pnReturned) |
kevin1990 | 16:e4f2689363bb | 636 | { |
kevin1990 | 16:e4f2689363bb | 637 | ADI_SENSE_DEVICE_CONTEXT *pCtx = hDevice; |
kevin1990 | 16:e4f2689363bb | 638 | uint16_t command = REG_READ_COMMAND | |
kevin1990 | 16:e4f2689363bb | 639 | (REG_ADISENSE_CORE_DATA_FIFO & REG_ADDRESS_MASK); |
kevin1990 | 16:e4f2689363bb | 640 | uint8_t commandData[2] = { |
kevin1990 | 16:e4f2689363bb | 641 | command >> 8, |
kevin1990 | 16:e4f2689363bb | 642 | command & 0xFF |
kevin1990 | 16:e4f2689363bb | 643 | }; |
kevin1990 | 16:e4f2689363bb | 644 | uint8_t commandResponse[2]; |
kevin1990 | 16:e4f2689363bb | 645 | unsigned nValidSamples = 0; |
kevin1990 | 16:e4f2689363bb | 646 | ADI_SENSE_RESULT eRet = ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 647 | |
kevin1990 | 16:e4f2689363bb | 648 | do { |
kevin1990 | 16:e4f2689363bb | 649 | eRet = adi_sense_SpiTransfer(pCtx->hSpi, commandData, commandResponse, |
kevin1990 | 16:e4f2689363bb | 650 | sizeof(command), false); |
kevin1990 | 16:e4f2689363bb | 651 | if (eRet) |
kevin1990 | 16:e4f2689363bb | 652 | { |
kevin1990 | 16:e4f2689363bb | 653 | ADI_SENSE_LOG_ERROR("Failed to send read command for FIFO register"); |
kevin1990 | 16:e4f2689363bb | 654 | return eRet; |
kevin1990 | 16:e4f2689363bb | 655 | } |
kevin1990 | 16:e4f2689363bb | 656 | |
kevin1990 | 16:e4f2689363bb | 657 | adi_sense_TimeDelayUsec(POST_SPI_TRANSFER_DELAY_USEC); |
kevin1990 | 16:e4f2689363bb | 658 | } while ((commandResponse[0] != REG_COMMAND_RESP_0) || |
kevin1990 | 16:e4f2689363bb | 659 | (commandResponse[1] != REG_COMMAND_RESP_1)); |
kevin1990 | 16:e4f2689363bb | 660 | |
kevin1990 | 16:e4f2689363bb | 661 | for (unsigned i = 0; i < nRequested; i++) |
kevin1990 | 16:e4f2689363bb | 662 | { |
kevin1990 | 16:e4f2689363bb | 663 | ADI_ADISENSE_CORE_Data_FIFO_t dataFifoReg; |
kevin1990 | 16:e4f2689363bb | 664 | bool_t bHoldCs = true; |
kevin1990 | 16:e4f2689363bb | 665 | unsigned readSampleSize = sizeof(dataFifoReg); |
kevin1990 | 16:e4f2689363bb | 666 | |
kevin1990 | 16:e4f2689363bb | 667 | if (eMeasurementMode == ADI_SENSE_MEASUREMENT_MODE_OMIT_RAW) |
kevin1990 | 16:e4f2689363bb | 668 | readSampleSize -= 3; /* 3B raw value omitted in this case */ |
kevin1990 | 16:e4f2689363bb | 669 | |
kevin1990 | 16:e4f2689363bb | 670 | /* Keep the CS signal asserted for all but the last sample */ |
kevin1990 | 16:e4f2689363bb | 671 | if ((i + 1) == nRequested) |
kevin1990 | 16:e4f2689363bb | 672 | bHoldCs = false; |
kevin1990 | 16:e4f2689363bb | 673 | |
kevin1990 | 16:e4f2689363bb | 674 | eRet = adi_sense_SpiTransfer(pCtx->hSpi, NULL, &dataFifoReg, |
kevin1990 | 16:e4f2689363bb | 675 | readSampleSize, bHoldCs); |
kevin1990 | 16:e4f2689363bb | 676 | if (eRet) |
kevin1990 | 16:e4f2689363bb | 677 | { |
kevin1990 | 16:e4f2689363bb | 678 | ADI_SENSE_LOG_ERROR("Failed to read data from FIFO register"); |
kevin1990 | 16:e4f2689363bb | 679 | return eRet; |
kevin1990 | 16:e4f2689363bb | 680 | } |
kevin1990 | 16:e4f2689363bb | 681 | |
kevin1990 | 16:e4f2689363bb | 682 | if (! dataFifoReg.Ch_Valid) |
kevin1990 | 16:e4f2689363bb | 683 | { |
kevin1990 | 16:e4f2689363bb | 684 | /* |
kevin1990 | 16:e4f2689363bb | 685 | * Reading an invalid sample indicates that there are no |
kevin1990 | 16:e4f2689363bb | 686 | * more samples available or we've lost sync with the device. |
kevin1990 | 16:e4f2689363bb | 687 | * In the latter case, it might be recoverable, but return here |
kevin1990 | 16:e4f2689363bb | 688 | * to let the application check the device status and decide itself. |
kevin1990 | 16:e4f2689363bb | 689 | */ |
kevin1990 | 16:e4f2689363bb | 690 | eRet = ADI_SENSE_INCOMPLETE; |
kevin1990 | 16:e4f2689363bb | 691 | break; |
kevin1990 | 16:e4f2689363bb | 692 | } |
kevin1990 | 16:e4f2689363bb | 693 | |
kevin1990 | 16:e4f2689363bb | 694 | ADI_SENSE_DATA_SAMPLE *pSample = &pSamples[nValidSamples]; |
kevin1990 | 16:e4f2689363bb | 695 | |
kevin1990 | 16:e4f2689363bb | 696 | pSample->status = 0; |
kevin1990 | 16:e4f2689363bb | 697 | if (dataFifoReg.Ch_Error) |
kevin1990 | 16:e4f2689363bb | 698 | pSample->status |= ADI_SENSE_DEVICE_STATUS_ERROR; |
kevin1990 | 16:e4f2689363bb | 699 | if (dataFifoReg.Ch_Alert) |
kevin1990 | 16:e4f2689363bb | 700 | pSample->status |= ADI_SENSE_DEVICE_STATUS_ALERT; |
kevin1990 | 16:e4f2689363bb | 701 | |
kevin1990 | 16:e4f2689363bb | 702 | if (dataFifoReg.Ch_Raw) |
kevin1990 | 16:e4f2689363bb | 703 | pSample->rawValue = dataFifoReg.Raw_Sample; |
kevin1990 | 16:e4f2689363bb | 704 | else |
kevin1990 | 16:e4f2689363bb | 705 | pSample->rawValue = 0; |
kevin1990 | 16:e4f2689363bb | 706 | |
kevin1990 | 16:e4f2689363bb | 707 | pSample->channelId = dataFifoReg.Channel_ID; |
kevin1990 | 16:e4f2689363bb | 708 | pSample->processedValue = dataFifoReg.Sensor_Result; |
kevin1990 | 16:e4f2689363bb | 709 | |
kevin1990 | 16:e4f2689363bb | 710 | nValidSamples++; |
kevin1990 | 16:e4f2689363bb | 711 | } |
kevin1990 | 16:e4f2689363bb | 712 | *pnReturned = nValidSamples; |
kevin1990 | 16:e4f2689363bb | 713 | |
kevin1990 | 16:e4f2689363bb | 714 | adi_sense_TimeDelayUsec(POST_SPI_TRANSFER_DELAY_USEC); |
kevin1990 | 16:e4f2689363bb | 715 | |
kevin1990 | 16:e4f2689363bb | 716 | return eRet; |
kevin1990 | 16:e4f2689363bb | 717 | } |
kevin1990 | 16:e4f2689363bb | 718 | |
kevin1990 | 16:e4f2689363bb | 719 | /* |
kevin1990 | 16:e4f2689363bb | 720 | * Close the given ADI Sense device. |
kevin1990 | 16:e4f2689363bb | 721 | */ |
kevin1990 | 16:e4f2689363bb | 722 | ADI_SENSE_RESULT adi_sense_Close( |
kevin1990 | 16:e4f2689363bb | 723 | ADI_SENSE_DEVICE_HANDLE const hDevice) |
kevin1990 | 16:e4f2689363bb | 724 | { |
kevin1990 | 16:e4f2689363bb | 725 | ADI_SENSE_DEVICE_CONTEXT *pCtx = hDevice; |
kevin1990 | 16:e4f2689363bb | 726 | |
kevin1990 | 16:e4f2689363bb | 727 | adi_sense_GpioClose(pCtx->hGpio); |
kevin1990 | 16:e4f2689363bb | 728 | adi_sense_SpiClose(pCtx->hSpi); |
kevin1990 | 16:e4f2689363bb | 729 | |
kevin1990 | 16:e4f2689363bb | 730 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 731 | } |
kevin1990 | 16:e4f2689363bb | 732 | |
kevin1990 | 16:e4f2689363bb | 733 | ADI_SENSE_RESULT adi_sense_1000_WriteRegister( |
kevin1990 | 16:e4f2689363bb | 734 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 735 | uint16_t nAddress, |
kevin1990 | 16:e4f2689363bb | 736 | void *pData, |
kevin1990 | 16:e4f2689363bb | 737 | unsigned nLength) |
kevin1990 | 16:e4f2689363bb | 738 | { |
kevin1990 | 16:e4f2689363bb | 739 | ADI_SENSE_RESULT eRet; |
kevin1990 | 16:e4f2689363bb | 740 | ADI_SENSE_DEVICE_CONTEXT *pCtx = hDevice; |
kevin1990 | 16:e4f2689363bb | 741 | uint16_t command = REG_WRITE_COMMAND | (nAddress & REG_ADDRESS_MASK); |
kevin1990 | 16:e4f2689363bb | 742 | uint8_t commandData[2] = { |
kevin1990 | 16:e4f2689363bb | 743 | command >> 8, |
kevin1990 | 16:e4f2689363bb | 744 | command & 0xFF |
kevin1990 | 16:e4f2689363bb | 745 | }; |
kevin1990 | 16:e4f2689363bb | 746 | uint8_t commandResponse[2]; |
kevin1990 | 16:e4f2689363bb | 747 | |
kevin1990 | 16:e4f2689363bb | 748 | do { |
kevin1990 | 16:e4f2689363bb | 749 | eRet = adi_sense_SpiTransfer(pCtx->hSpi, commandData, commandResponse, |
kevin1990 | 16:e4f2689363bb | 750 | sizeof(command), false); |
kevin1990 | 16:e4f2689363bb | 751 | if (eRet) |
kevin1990 | 16:e4f2689363bb | 752 | { |
kevin1990 | 16:e4f2689363bb | 753 | ADI_SENSE_LOG_ERROR("Failed to send write command for register %u", |
kevin1990 | 16:e4f2689363bb | 754 | nAddress); |
kevin1990 | 16:e4f2689363bb | 755 | return eRet; |
kevin1990 | 16:e4f2689363bb | 756 | } |
kevin1990 | 16:e4f2689363bb | 757 | |
kevin1990 | 16:e4f2689363bb | 758 | adi_sense_TimeDelayUsec(POST_SPI_TRANSFER_DELAY_USEC); |
kevin1990 | 16:e4f2689363bb | 759 | } while ((commandResponse[0] != REG_COMMAND_RESP_0) || |
kevin1990 | 16:e4f2689363bb | 760 | (commandResponse[1] != REG_COMMAND_RESP_1)); |
kevin1990 | 16:e4f2689363bb | 761 | |
kevin1990 | 16:e4f2689363bb | 762 | eRet = adi_sense_SpiTransfer(pCtx->hSpi, pData, NULL, nLength, false); |
kevin1990 | 16:e4f2689363bb | 763 | if (eRet) |
kevin1990 | 16:e4f2689363bb | 764 | { |
kevin1990 | 16:e4f2689363bb | 765 | ADI_SENSE_LOG_ERROR("Failed to write data (%dB) to register %u", |
kevin1990 | 16:e4f2689363bb | 766 | nLength, nAddress); |
kevin1990 | 16:e4f2689363bb | 767 | return eRet; |
kevin1990 | 16:e4f2689363bb | 768 | } |
kevin1990 | 16:e4f2689363bb | 769 | |
kevin1990 | 16:e4f2689363bb | 770 | adi_sense_TimeDelayUsec(POST_SPI_TRANSFER_DELAY_USEC); |
kevin1990 | 16:e4f2689363bb | 771 | |
kevin1990 | 16:e4f2689363bb | 772 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 773 | } |
kevin1990 | 16:e4f2689363bb | 774 | |
kevin1990 | 16:e4f2689363bb | 775 | ADI_SENSE_RESULT adi_sense_1000_ReadRegister( |
kevin1990 | 16:e4f2689363bb | 776 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 777 | uint16_t nAddress, |
kevin1990 | 16:e4f2689363bb | 778 | void *pData, |
kevin1990 | 16:e4f2689363bb | 779 | unsigned nLength) |
kevin1990 | 16:e4f2689363bb | 780 | { |
kevin1990 | 16:e4f2689363bb | 781 | ADI_SENSE_RESULT eRet; |
kevin1990 | 16:e4f2689363bb | 782 | ADI_SENSE_DEVICE_CONTEXT *pCtx = hDevice; |
kevin1990 | 16:e4f2689363bb | 783 | uint16_t command = REG_READ_COMMAND | (nAddress & REG_ADDRESS_MASK); |
kevin1990 | 16:e4f2689363bb | 784 | uint8_t commandData[2] = { |
kevin1990 | 16:e4f2689363bb | 785 | command >> 8, |
kevin1990 | 16:e4f2689363bb | 786 | command & 0xFF |
kevin1990 | 16:e4f2689363bb | 787 | }; |
kevin1990 | 16:e4f2689363bb | 788 | uint8_t commandResponse[2]; |
kevin1990 | 16:e4f2689363bb | 789 | |
kevin1990 | 16:e4f2689363bb | 790 | do { |
kevin1990 | 16:e4f2689363bb | 791 | eRet = adi_sense_SpiTransfer(pCtx->hSpi, commandData, commandResponse, |
kevin1990 | 16:e4f2689363bb | 792 | sizeof(command), false); |
kevin1990 | 16:e4f2689363bb | 793 | if (eRet) |
kevin1990 | 16:e4f2689363bb | 794 | { |
kevin1990 | 16:e4f2689363bb | 795 | ADI_SENSE_LOG_ERROR("Failed to send read command for register %u", |
kevin1990 | 16:e4f2689363bb | 796 | nAddress); |
kevin1990 | 16:e4f2689363bb | 797 | return eRet; |
kevin1990 | 16:e4f2689363bb | 798 | } |
kevin1990 | 16:e4f2689363bb | 799 | |
kevin1990 | 16:e4f2689363bb | 800 | adi_sense_TimeDelayUsec(POST_SPI_TRANSFER_DELAY_USEC); |
kevin1990 | 16:e4f2689363bb | 801 | } while ((commandResponse[0] != REG_COMMAND_RESP_0) || |
kevin1990 | 16:e4f2689363bb | 802 | (commandResponse[1] != REG_COMMAND_RESP_1)); |
kevin1990 | 16:e4f2689363bb | 803 | |
kevin1990 | 16:e4f2689363bb | 804 | eRet = adi_sense_SpiTransfer(pCtx->hSpi, NULL, pData, nLength, false); |
kevin1990 | 16:e4f2689363bb | 805 | if (eRet) |
kevin1990 | 16:e4f2689363bb | 806 | { |
kevin1990 | 16:e4f2689363bb | 807 | ADI_SENSE_LOG_ERROR("Failed to read data (%uB) from register %u", |
kevin1990 | 16:e4f2689363bb | 808 | nLength, nAddress); |
kevin1990 | 16:e4f2689363bb | 809 | return eRet; |
kevin1990 | 16:e4f2689363bb | 810 | } |
kevin1990 | 16:e4f2689363bb | 811 | |
kevin1990 | 16:e4f2689363bb | 812 | adi_sense_TimeDelayUsec(POST_SPI_TRANSFER_DELAY_USEC); |
kevin1990 | 16:e4f2689363bb | 813 | |
kevin1990 | 16:e4f2689363bb | 814 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 815 | } |
kevin1990 | 16:e4f2689363bb | 816 | |
kevin1990 | 16:e4f2689363bb | 817 | ADI_SENSE_RESULT adi_sense_GetDeviceReadyState( |
kevin1990 | 16:e4f2689363bb | 818 | ADI_SENSE_DEVICE_HANDLE const hDevice, |
kevin1990 | 16:e4f2689363bb | 819 | bool_t * const bReady) |
kevin1990 | 16:e4f2689363bb | 820 | { |
kevin1990 | 16:e4f2689363bb | 821 | ADI_ADISENSE_SPI_Chip_Type_t chipTypeReg; |
kevin1990 | 16:e4f2689363bb | 822 | |
kevin1990 | 16:e4f2689363bb | 823 | READ_REG_U8(hDevice, chipTypeReg.VALUE8, SPI_CHIP_TYPE); |
kevin1990 | 16:e4f2689363bb | 824 | /* If we read this register successfully, assume the device is ready */ |
kevin1990 | 16:e4f2689363bb | 825 | *bReady = (chipTypeReg.VALUE8 == REG_ADISENSE_SPI_CHIP_TYPE_RESET); |
kevin1990 | 16:e4f2689363bb | 826 | |
kevin1990 | 16:e4f2689363bb | 827 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 828 | } |
kevin1990 | 16:e4f2689363bb | 829 | |
kevin1990 | 16:e4f2689363bb | 830 | ADI_SENSE_RESULT adi_sense_1000_GetDataReadyModeInfo( |
kevin1990 | 16:e4f2689363bb | 831 | ADI_SENSE_DEVICE_HANDLE const hDevice, |
kevin1990 | 16:e4f2689363bb | 832 | ADI_SENSE_MEASUREMENT_MODE const eMeasurementMode, |
kevin1990 | 16:e4f2689363bb | 833 | ADI_SENSE_1000_OPERATING_MODE * const peOperatingMode, |
kevin1990 | 16:e4f2689363bb | 834 | ADI_SENSE_1000_DATAREADY_MODE * const peDataReadyMode, |
kevin1990 | 16:e4f2689363bb | 835 | uint32_t * const pnSamplesPerDataready, |
kevin1990 | 16:e4f2689363bb | 836 | uint32_t * const pnSamplesPerCycle) |
kevin1990 | 16:e4f2689363bb | 837 | { |
kevin1990 | 16:e4f2689363bb | 838 | unsigned nChannelsEnabled = 0; |
kevin1990 | 16:e4f2689363bb | 839 | unsigned nSamplesPerCycle = 0; |
kevin1990 | 16:e4f2689363bb | 840 | |
kevin1990 | 16:e4f2689363bb | 841 | for (ADI_SENSE_1000_CHANNEL_ID chId = 0; chId < ADI_SENSE_1000_MAX_CHANNELS; chId++) |
kevin1990 | 16:e4f2689363bb | 842 | { |
kevin1990 | 16:e4f2689363bb | 843 | ADI_ADISENSE_CORE_Sensor_Details_t sensorDetailsReg; |
kevin1990 | 16:e4f2689363bb | 844 | ADI_ADISENSE_CORE_Channel_Count_t channelCountReg; |
kevin1990 | 16:e4f2689363bb | 845 | |
kevin1990 | 16:e4f2689363bb | 846 | if (ADI_SENSE_1000_CHANNEL_IS_VIRTUAL(chId)) |
kevin1990 | 16:e4f2689363bb | 847 | continue; |
kevin1990 | 16:e4f2689363bb | 848 | |
kevin1990 | 16:e4f2689363bb | 849 | READ_REG_U8(hDevice, channelCountReg.VALUE8, CORE_CHANNEL_COUNTn(chId)); |
kevin1990 | 16:e4f2689363bb | 850 | READ_REG_U32(hDevice, sensorDetailsReg.VALUE32, CORE_SENSOR_DETAILSn(chId)); |
kevin1990 | 16:e4f2689363bb | 851 | |
kevin1990 | 16:e4f2689363bb | 852 | if (channelCountReg.Channel_Enable && !sensorDetailsReg.Do_Not_Publish) |
kevin1990 | 16:e4f2689363bb | 853 | { |
kevin1990 | 16:e4f2689363bb | 854 | ADI_ADISENSE_CORE_Sensor_Type_t sensorTypeReg; |
kevin1990 | 16:e4f2689363bb | 855 | unsigned nActualChannels = 1; |
kevin1990 | 16:e4f2689363bb | 856 | |
kevin1990 | 16:e4f2689363bb | 857 | READ_REG_U16(hDevice, sensorTypeReg.VALUE16, CORE_SENSOR_TYPEn(chId)); |
kevin1990 | 16:e4f2689363bb | 858 | |
kevin1990 | 16:e4f2689363bb | 859 | if (chId == ADI_SENSE_1000_CHANNEL_ID_SPI_0) |
kevin1990 | 16:e4f2689363bb | 860 | { |
kevin1990 | 16:e4f2689363bb | 861 | /* Some sensors automatically generate samples on additional "virtual" channels |
kevin1990 | 16:e4f2689363bb | 862 | * so these channels must be counted as active when those sensors are selected |
kevin1990 | 16:e4f2689363bb | 863 | * and we use the count from the corresponding "physical" channel */ |
kevin1990 | 16:e4f2689363bb | 864 | if (sensorTypeReg.Sensor_Type == |
kevin1990 | 16:e4f2689363bb | 865 | ADISENSE_CORE_SENSOR_TYPE_SENSOR_SPI_ACCELEROMETER_1) |
kevin1990 | 16:e4f2689363bb | 866 | nActualChannels += 2; |
kevin1990 | 16:e4f2689363bb | 867 | } |
kevin1990 | 16:e4f2689363bb | 868 | |
kevin1990 | 16:e4f2689363bb | 869 | nChannelsEnabled += nActualChannels; |
kevin1990 | 16:e4f2689363bb | 870 | if (eMeasurementMode == ADI_SENSE_MEASUREMENT_MODE_HEALTHCHECK) |
kevin1990 | 16:e4f2689363bb | 871 | /* Assume a single sample per channel in test mode */ |
kevin1990 | 16:e4f2689363bb | 872 | nSamplesPerCycle += nActualChannels; |
kevin1990 | 16:e4f2689363bb | 873 | else |
kevin1990 | 16:e4f2689363bb | 874 | nSamplesPerCycle += nActualChannels * |
kevin1990 | 16:e4f2689363bb | 875 | (channelCountReg.Channel_Count + 1); |
kevin1990 | 16:e4f2689363bb | 876 | } |
kevin1990 | 16:e4f2689363bb | 877 | } |
kevin1990 | 16:e4f2689363bb | 878 | |
kevin1990 | 16:e4f2689363bb | 879 | if (nChannelsEnabled == 0) |
kevin1990 | 16:e4f2689363bb | 880 | { |
kevin1990 | 16:e4f2689363bb | 881 | *pnSamplesPerDataready = 0; |
kevin1990 | 16:e4f2689363bb | 882 | *pnSamplesPerCycle = 0; |
kevin1990 | 16:e4f2689363bb | 883 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 884 | } |
kevin1990 | 16:e4f2689363bb | 885 | |
kevin1990 | 16:e4f2689363bb | 886 | ADI_ADISENSE_CORE_Mode_t modeReg; |
kevin1990 | 16:e4f2689363bb | 887 | READ_REG_U8(hDevice, modeReg.VALUE8, CORE_MODE); |
kevin1990 | 16:e4f2689363bb | 888 | |
kevin1990 | 16:e4f2689363bb | 889 | *pnSamplesPerCycle = nSamplesPerCycle; |
kevin1990 | 16:e4f2689363bb | 890 | |
kevin1990 | 16:e4f2689363bb | 891 | /* Assume DRDY_PER_CONVERSION behaviour in test mode */ |
kevin1990 | 16:e4f2689363bb | 892 | if ((eMeasurementMode == ADI_SENSE_MEASUREMENT_MODE_HEALTHCHECK) || |
kevin1990 | 16:e4f2689363bb | 893 | (modeReg.Drdy_Mode == ADISENSE_CORE_MODE_DRDY_PER_CONVERSION)) |
kevin1990 | 16:e4f2689363bb | 894 | { |
kevin1990 | 16:e4f2689363bb | 895 | *pnSamplesPerDataready = 1; |
kevin1990 | 16:e4f2689363bb | 896 | } |
kevin1990 | 16:e4f2689363bb | 897 | else if (modeReg.Drdy_Mode == ADISENSE_CORE_MODE_DRDY_PER_CYCLE) |
kevin1990 | 16:e4f2689363bb | 898 | { |
kevin1990 | 16:e4f2689363bb | 899 | *pnSamplesPerDataready = nSamplesPerCycle; |
kevin1990 | 16:e4f2689363bb | 900 | } |
kevin1990 | 16:e4f2689363bb | 901 | else |
kevin1990 | 16:e4f2689363bb | 902 | { |
kevin1990 | 16:e4f2689363bb | 903 | ADI_ADISENSE_CORE_Fifo_Num_Cycles_t fifoNumCyclesReg; |
kevin1990 | 16:e4f2689363bb | 904 | READ_REG_U8(hDevice, fifoNumCyclesReg.VALUE8, CORE_FIFO_NUM_CYCLES); |
kevin1990 | 16:e4f2689363bb | 905 | |
kevin1990 | 16:e4f2689363bb | 906 | *pnSamplesPerDataready = |
kevin1990 | 16:e4f2689363bb | 907 | nSamplesPerCycle * fifoNumCyclesReg.Fifo_Num_Cycles; |
kevin1990 | 16:e4f2689363bb | 908 | } |
kevin1990 | 16:e4f2689363bb | 909 | |
kevin1990 | 16:e4f2689363bb | 910 | /* Assume SINGLECYCLE in test mode */ |
kevin1990 | 16:e4f2689363bb | 911 | if ((eMeasurementMode == ADI_SENSE_MEASUREMENT_MODE_HEALTHCHECK) || |
kevin1990 | 16:e4f2689363bb | 912 | (modeReg.Conversion_Mode == ADISENSE_CORE_MODE_SINGLECYCLE)) |
kevin1990 | 16:e4f2689363bb | 913 | *peOperatingMode = ADI_SENSE_1000_OPERATING_MODE_SINGLECYCLE; |
kevin1990 | 16:e4f2689363bb | 914 | else if (modeReg.Conversion_Mode == ADISENSE_CORE_MODE_MULTICYCLE) |
kevin1990 | 16:e4f2689363bb | 915 | *peOperatingMode = ADI_SENSE_1000_OPERATING_MODE_MULTICYCLE; |
kevin1990 | 16:e4f2689363bb | 916 | else |
kevin1990 | 16:e4f2689363bb | 917 | *peOperatingMode = ADI_SENSE_1000_OPERATING_MODE_CONTINUOUS; |
kevin1990 | 16:e4f2689363bb | 918 | |
kevin1990 | 16:e4f2689363bb | 919 | /* Assume DRDY_PER_CONVERSION behaviour in test mode */ |
kevin1990 | 16:e4f2689363bb | 920 | if ((eMeasurementMode == ADI_SENSE_MEASUREMENT_MODE_HEALTHCHECK) || |
kevin1990 | 16:e4f2689363bb | 921 | (modeReg.Drdy_Mode == ADISENSE_CORE_MODE_DRDY_PER_CONVERSION)) |
kevin1990 | 16:e4f2689363bb | 922 | *peDataReadyMode = ADI_SENSE_1000_DATAREADY_PER_CONVERSION; |
kevin1990 | 16:e4f2689363bb | 923 | else if (modeReg.Drdy_Mode == ADISENSE_CORE_MODE_DRDY_PER_CYCLE) |
kevin1990 | 16:e4f2689363bb | 924 | *peDataReadyMode = ADI_SENSE_1000_DATAREADY_PER_CYCLE; |
kevin1990 | 16:e4f2689363bb | 925 | else |
kevin1990 | 16:e4f2689363bb | 926 | *peDataReadyMode = ADI_SENSE_1000_DATAREADY_PER_MULTICYCLE_BURST; |
kevin1990 | 16:e4f2689363bb | 927 | |
kevin1990 | 16:e4f2689363bb | 928 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 929 | } |
kevin1990 | 16:e4f2689363bb | 930 | |
kevin1990 | 16:e4f2689363bb | 931 | ADI_SENSE_RESULT adi_sense_GetProductID( |
kevin1990 | 16:e4f2689363bb | 932 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 933 | ADI_SENSE_PRODUCT_ID *pProductId) |
kevin1990 | 16:e4f2689363bb | 934 | { |
kevin1990 | 16:e4f2689363bb | 935 | ADI_ADISENSE_SPI_Product_ID_L_t productIdLoReg; |
kevin1990 | 16:e4f2689363bb | 936 | ADI_ADISENSE_SPI_Product_ID_H_t productIdHiReg; |
kevin1990 | 16:e4f2689363bb | 937 | |
kevin1990 | 16:e4f2689363bb | 938 | READ_REG_U8(hDevice, productIdLoReg.VALUE8, SPI_PRODUCT_ID_L); |
kevin1990 | 16:e4f2689363bb | 939 | READ_REG_U8(hDevice, productIdHiReg.VALUE8, SPI_PRODUCT_ID_H); |
kevin1990 | 16:e4f2689363bb | 940 | |
kevin1990 | 16:e4f2689363bb | 941 | *pProductId = (productIdHiReg.VALUE8 << 8) | productIdLoReg.VALUE8; |
kevin1990 | 16:e4f2689363bb | 942 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 943 | } |
kevin1990 | 16:e4f2689363bb | 944 | |
kevin1990 | 16:e4f2689363bb | 945 | static ADI_SENSE_RESULT adi_sense_SetPowerMode( |
kevin1990 | 16:e4f2689363bb | 946 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 947 | ADI_SENSE_1000_POWER_MODE powerMode) |
kevin1990 | 16:e4f2689363bb | 948 | { |
kevin1990 | 16:e4f2689363bb | 949 | ADI_ADISENSE_CORE_Power_Config_t powerConfigReg; |
kevin1990 | 16:e4f2689363bb | 950 | |
kevin1990 | 16:e4f2689363bb | 951 | if (powerMode == ADI_SENSE_1000_POWER_MODE_LOW) |
kevin1990 | 16:e4f2689363bb | 952 | { |
kevin1990 | 16:e4f2689363bb | 953 | powerConfigReg.Power_Mode_ADC = ADISENSE_CORE_POWER_CONFIG_ADC_LOW_POWER; |
kevin1990 | 16:e4f2689363bb | 954 | /* TODO - we need an enum in the register map for the MCU power modes */ |
kevin1990 | 16:e4f2689363bb | 955 | powerConfigReg.Power_Mode_MCU = 0x0; |
kevin1990 | 16:e4f2689363bb | 956 | } |
kevin1990 | 16:e4f2689363bb | 957 | else if (powerMode == ADI_SENSE_1000_POWER_MODE_MID) |
kevin1990 | 16:e4f2689363bb | 958 | { |
kevin1990 | 16:e4f2689363bb | 959 | powerConfigReg.Power_Mode_ADC = ADISENSE_CORE_POWER_CONFIG_ADC_MID_POWER; |
kevin1990 | 16:e4f2689363bb | 960 | powerConfigReg.Power_Mode_MCU = 0x1; |
kevin1990 | 16:e4f2689363bb | 961 | } |
kevin1990 | 16:e4f2689363bb | 962 | else if (powerMode == ADI_SENSE_1000_POWER_MODE_FULL) |
kevin1990 | 16:e4f2689363bb | 963 | { |
kevin1990 | 16:e4f2689363bb | 964 | powerConfigReg.Power_Mode_ADC = ADISENSE_CORE_POWER_CONFIG_ADC_FULL_POWER; |
kevin1990 | 16:e4f2689363bb | 965 | powerConfigReg.Power_Mode_MCU = 0x2; |
kevin1990 | 16:e4f2689363bb | 966 | } |
kevin1990 | 16:e4f2689363bb | 967 | else |
kevin1990 | 16:e4f2689363bb | 968 | { |
kevin1990 | 16:e4f2689363bb | 969 | ADI_SENSE_LOG_ERROR("Invalid power mode %d specified", powerMode); |
kevin1990 | 16:e4f2689363bb | 970 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 971 | } |
kevin1990 | 16:e4f2689363bb | 972 | |
kevin1990 | 16:e4f2689363bb | 973 | WRITE_REG_U8(hDevice, powerConfigReg.VALUE8, CORE_POWER_CONFIG); |
kevin1990 | 16:e4f2689363bb | 974 | |
kevin1990 | 16:e4f2689363bb | 975 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 976 | } |
kevin1990 | 16:e4f2689363bb | 977 | |
kevin1990 | 16:e4f2689363bb | 978 | static ADI_SENSE_RESULT adi_sense_SetVddVoltage( |
kevin1990 | 16:e4f2689363bb | 979 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 980 | float32_t vddVoltage) |
kevin1990 | 16:e4f2689363bb | 981 | { |
kevin1990 | 16:e4f2689363bb | 982 | WRITE_REG_FLOAT(hDevice, vddVoltage, CORE_AVDD_VOLTAGE); |
kevin1990 | 16:e4f2689363bb | 983 | |
kevin1990 | 16:e4f2689363bb | 984 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 985 | } |
kevin1990 | 16:e4f2689363bb | 986 | |
kevin1990 | 16:e4f2689363bb | 987 | ADI_SENSE_RESULT adi_sense_1000_SetPowerConfig( |
kevin1990 | 16:e4f2689363bb | 988 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 989 | ADI_SENSE_1000_POWER_CONFIG *pPowerConfig) |
kevin1990 | 16:e4f2689363bb | 990 | { |
kevin1990 | 16:e4f2689363bb | 991 | ADI_SENSE_RESULT eRet; |
kevin1990 | 16:e4f2689363bb | 992 | |
kevin1990 | 16:e4f2689363bb | 993 | eRet = adi_sense_SetPowerMode(hDevice, pPowerConfig->powerMode); |
kevin1990 | 16:e4f2689363bb | 994 | if (eRet != ADI_SENSE_SUCCESS) |
kevin1990 | 16:e4f2689363bb | 995 | { |
kevin1990 | 16:e4f2689363bb | 996 | ADI_SENSE_LOG_ERROR("Failed to set power mode"); |
kevin1990 | 16:e4f2689363bb | 997 | return eRet; |
kevin1990 | 16:e4f2689363bb | 998 | } |
kevin1990 | 16:e4f2689363bb | 999 | |
kevin1990 | 16:e4f2689363bb | 1000 | eRet = adi_sense_SetVddVoltage(hDevice, pPowerConfig->supplyVoltage); |
kevin1990 | 16:e4f2689363bb | 1001 | if (eRet != ADI_SENSE_SUCCESS) |
kevin1990 | 16:e4f2689363bb | 1002 | { |
kevin1990 | 16:e4f2689363bb | 1003 | ADI_SENSE_LOG_ERROR("Failed to set AVdd voltage"); |
kevin1990 | 16:e4f2689363bb | 1004 | return eRet; |
kevin1990 | 16:e4f2689363bb | 1005 | } |
kevin1990 | 16:e4f2689363bb | 1006 | |
kevin1990 | 16:e4f2689363bb | 1007 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 1008 | } |
kevin1990 | 16:e4f2689363bb | 1009 | |
kevin1990 | 16:e4f2689363bb | 1010 | static ADI_SENSE_RESULT adi_sense_SetMode( |
kevin1990 | 16:e4f2689363bb | 1011 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 1012 | ADI_SENSE_1000_OPERATING_MODE eOperatingMode, |
kevin1990 | 16:e4f2689363bb | 1013 | ADI_SENSE_1000_DATAREADY_MODE eDataReadyMode) |
kevin1990 | 16:e4f2689363bb | 1014 | { |
kevin1990 | 16:e4f2689363bb | 1015 | ADI_ADISENSE_CORE_Mode_t modeReg; |
kevin1990 | 16:e4f2689363bb | 1016 | |
kevin1990 | 16:e4f2689363bb | 1017 | modeReg.VALUE8 = REG_RESET_VAL(CORE_MODE); |
kevin1990 | 16:e4f2689363bb | 1018 | |
kevin1990 | 16:e4f2689363bb | 1019 | if (eOperatingMode == ADI_SENSE_1000_OPERATING_MODE_SINGLECYCLE) |
kevin1990 | 16:e4f2689363bb | 1020 | { |
kevin1990 | 16:e4f2689363bb | 1021 | modeReg.Conversion_Mode = ADISENSE_CORE_MODE_SINGLECYCLE; |
kevin1990 | 16:e4f2689363bb | 1022 | } |
kevin1990 | 16:e4f2689363bb | 1023 | else if (eOperatingMode == ADI_SENSE_1000_OPERATING_MODE_CONTINUOUS) |
kevin1990 | 16:e4f2689363bb | 1024 | { |
kevin1990 | 16:e4f2689363bb | 1025 | modeReg.Conversion_Mode = ADISENSE_CORE_MODE_CONTINUOUS; |
kevin1990 | 16:e4f2689363bb | 1026 | } |
kevin1990 | 16:e4f2689363bb | 1027 | else if (eOperatingMode == ADI_SENSE_1000_OPERATING_MODE_MULTICYCLE) |
kevin1990 | 16:e4f2689363bb | 1028 | { |
kevin1990 | 16:e4f2689363bb | 1029 | modeReg.Conversion_Mode = ADISENSE_CORE_MODE_MULTICYCLE; |
kevin1990 | 16:e4f2689363bb | 1030 | } |
kevin1990 | 16:e4f2689363bb | 1031 | else |
kevin1990 | 16:e4f2689363bb | 1032 | { |
kevin1990 | 16:e4f2689363bb | 1033 | ADI_SENSE_LOG_ERROR("Invalid operating mode %d specified", |
kevin1990 | 16:e4f2689363bb | 1034 | eOperatingMode); |
kevin1990 | 16:e4f2689363bb | 1035 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 1036 | } |
kevin1990 | 16:e4f2689363bb | 1037 | |
kevin1990 | 16:e4f2689363bb | 1038 | if (eDataReadyMode == ADI_SENSE_1000_DATAREADY_PER_CONVERSION) |
kevin1990 | 16:e4f2689363bb | 1039 | { |
kevin1990 | 16:e4f2689363bb | 1040 | modeReg.Drdy_Mode = ADISENSE_CORE_MODE_DRDY_PER_CONVERSION; |
kevin1990 | 16:e4f2689363bb | 1041 | } |
kevin1990 | 16:e4f2689363bb | 1042 | else if (eDataReadyMode == ADI_SENSE_1000_DATAREADY_PER_CYCLE) |
kevin1990 | 16:e4f2689363bb | 1043 | { |
kevin1990 | 16:e4f2689363bb | 1044 | modeReg.Drdy_Mode = ADISENSE_CORE_MODE_DRDY_PER_CYCLE; |
kevin1990 | 16:e4f2689363bb | 1045 | } |
kevin1990 | 16:e4f2689363bb | 1046 | else if (eDataReadyMode == ADI_SENSE_1000_DATAREADY_PER_MULTICYCLE_BURST) |
kevin1990 | 16:e4f2689363bb | 1047 | { |
kevin1990 | 16:e4f2689363bb | 1048 | if (eOperatingMode != ADI_SENSE_1000_OPERATING_MODE_MULTICYCLE) |
kevin1990 | 16:e4f2689363bb | 1049 | { |
kevin1990 | 16:e4f2689363bb | 1050 | ADI_SENSE_LOG_ERROR( |
kevin1990 | 16:e4f2689363bb | 1051 | "Data-ready mode %d cannot be used with operating mode %d", |
kevin1990 | 16:e4f2689363bb | 1052 | eDataReadyMode, eOperatingMode); |
kevin1990 | 16:e4f2689363bb | 1053 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 1054 | } |
kevin1990 | 16:e4f2689363bb | 1055 | else |
kevin1990 | 16:e4f2689363bb | 1056 | { |
kevin1990 | 16:e4f2689363bb | 1057 | modeReg.Drdy_Mode = ADISENSE_CORE_MODE_DRDY_PER_FIFO_FILL; |
kevin1990 | 16:e4f2689363bb | 1058 | } |
kevin1990 | 16:e4f2689363bb | 1059 | } |
kevin1990 | 16:e4f2689363bb | 1060 | else |
kevin1990 | 16:e4f2689363bb | 1061 | { |
kevin1990 | 16:e4f2689363bb | 1062 | ADI_SENSE_LOG_ERROR("Invalid data-ready mode %d specified", eDataReadyMode); |
kevin1990 | 16:e4f2689363bb | 1063 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 1064 | } |
kevin1990 | 16:e4f2689363bb | 1065 | |
kevin1990 | 16:e4f2689363bb | 1066 | WRITE_REG_U8(hDevice, modeReg.VALUE8, CORE_MODE); |
kevin1990 | 16:e4f2689363bb | 1067 | |
kevin1990 | 16:e4f2689363bb | 1068 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 1069 | } |
kevin1990 | 16:e4f2689363bb | 1070 | |
kevin1990 | 16:e4f2689363bb | 1071 | ADI_SENSE_RESULT adi_sense_SetCycleInterval( |
kevin1990 | 16:e4f2689363bb | 1072 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 1073 | uint32_t nCycleInterval) |
kevin1990 | 16:e4f2689363bb | 1074 | { |
kevin1990 | 16:e4f2689363bb | 1075 | ADI_ADISENSE_CORE_Cycle_Control_t cycleControlReg; |
kevin1990 | 16:e4f2689363bb | 1076 | |
kevin1990 | 16:e4f2689363bb | 1077 | cycleControlReg.VALUE16 = REG_RESET_VAL(CORE_CYCLE_CONTROL); |
kevin1990 | 16:e4f2689363bb | 1078 | |
kevin1990 | 16:e4f2689363bb | 1079 | if (nCycleInterval < (1 << 12)) |
kevin1990 | 16:e4f2689363bb | 1080 | { |
kevin1990 | 16:e4f2689363bb | 1081 | cycleControlReg.Cycle_Time_Units = ADISENSE_CORE_CYCLE_CONTROL_MICROSECONDS; |
kevin1990 | 16:e4f2689363bb | 1082 | } |
kevin1990 | 16:e4f2689363bb | 1083 | else if (nCycleInterval < (1000 * (1 << 12))) |
kevin1990 | 16:e4f2689363bb | 1084 | { |
kevin1990 | 16:e4f2689363bb | 1085 | cycleControlReg.Cycle_Time_Units = ADISENSE_CORE_CYCLE_CONTROL_MILLISECONDS; |
kevin1990 | 16:e4f2689363bb | 1086 | nCycleInterval /= 1000; |
kevin1990 | 16:e4f2689363bb | 1087 | } |
kevin1990 | 16:e4f2689363bb | 1088 | else |
kevin1990 | 16:e4f2689363bb | 1089 | { |
kevin1990 | 16:e4f2689363bb | 1090 | cycleControlReg.Cycle_Time_Units = ADISENSE_CORE_CYCLE_CONTROL_SECONDS; |
kevin1990 | 16:e4f2689363bb | 1091 | nCycleInterval /= 1000000; |
kevin1990 | 16:e4f2689363bb | 1092 | } |
kevin1990 | 16:e4f2689363bb | 1093 | |
kevin1990 | 16:e4f2689363bb | 1094 | CHECK_REG_FIELD_VAL(CORE_CYCLE_CONTROL_CYCLE_TIME, nCycleInterval); |
kevin1990 | 16:e4f2689363bb | 1095 | cycleControlReg.Cycle_Time = nCycleInterval; |
kevin1990 | 16:e4f2689363bb | 1096 | |
kevin1990 | 16:e4f2689363bb | 1097 | WRITE_REG_U16(hDevice, cycleControlReg.VALUE16, CORE_CYCLE_CONTROL); |
kevin1990 | 16:e4f2689363bb | 1098 | |
kevin1990 | 16:e4f2689363bb | 1099 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 1100 | } |
kevin1990 | 16:e4f2689363bb | 1101 | |
kevin1990 | 16:e4f2689363bb | 1102 | static ADI_SENSE_RESULT adi_sense_SetMultiCycleConfig( |
kevin1990 | 16:e4f2689363bb | 1103 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 1104 | ADI_SENSE_1000_MULTICYCLE_CONFIG *pMultiCycleConfig) |
kevin1990 | 16:e4f2689363bb | 1105 | { |
kevin1990 | 16:e4f2689363bb | 1106 | CHECK_REG_FIELD_VAL(CORE_FIFO_NUM_CYCLES_FIFO_NUM_CYCLES, |
kevin1990 | 16:e4f2689363bb | 1107 | pMultiCycleConfig->cyclesPerBurst); |
kevin1990 | 16:e4f2689363bb | 1108 | |
kevin1990 | 16:e4f2689363bb | 1109 | WRITE_REG_U8(hDevice, pMultiCycleConfig->cyclesPerBurst, |
kevin1990 | 16:e4f2689363bb | 1110 | CORE_FIFO_NUM_CYCLES); |
kevin1990 | 16:e4f2689363bb | 1111 | |
kevin1990 | 16:e4f2689363bb | 1112 | WRITE_REG_U32(hDevice, pMultiCycleConfig->burstInterval, |
kevin1990 | 16:e4f2689363bb | 1113 | CORE_MULTI_CYCLE_REPEAT_INTERVAL); |
kevin1990 | 16:e4f2689363bb | 1114 | |
kevin1990 | 16:e4f2689363bb | 1115 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 1116 | } |
kevin1990 | 16:e4f2689363bb | 1117 | |
kevin1990 | 16:e4f2689363bb | 1118 | static ADI_SENSE_RESULT adi_sense_SetExternalReferenceValues( |
kevin1990 | 16:e4f2689363bb | 1119 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 1120 | float32_t externalRef1Value, |
kevin1990 | 16:e4f2689363bb | 1121 | float32_t externalRef2Value) |
kevin1990 | 16:e4f2689363bb | 1122 | { |
kevin1990 | 16:e4f2689363bb | 1123 | WRITE_REG_FLOAT(hDevice, externalRef1Value, CORE_EXTERNAL_REFERENCE1); |
kevin1990 | 16:e4f2689363bb | 1124 | WRITE_REG_FLOAT(hDevice, externalRef2Value, CORE_EXTERNAL_REFERENCE2); |
kevin1990 | 16:e4f2689363bb | 1125 | |
kevin1990 | 16:e4f2689363bb | 1126 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 1127 | } |
kevin1990 | 16:e4f2689363bb | 1128 | |
kevin1990 | 16:e4f2689363bb | 1129 | ADI_SENSE_RESULT adi_sense_1000_SetMeasurementConfig( |
kevin1990 | 16:e4f2689363bb | 1130 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 1131 | ADI_SENSE_1000_MEASUREMENT_CONFIG *pMeasConfig) |
kevin1990 | 16:e4f2689363bb | 1132 | { |
kevin1990 | 16:e4f2689363bb | 1133 | ADI_SENSE_RESULT eRet; |
kevin1990 | 16:e4f2689363bb | 1134 | |
kevin1990 | 16:e4f2689363bb | 1135 | eRet = adi_sense_SetMode(hDevice, |
kevin1990 | 16:e4f2689363bb | 1136 | pMeasConfig->operatingMode, |
kevin1990 | 16:e4f2689363bb | 1137 | pMeasConfig->dataReadyMode); |
kevin1990 | 16:e4f2689363bb | 1138 | if (eRet != ADI_SENSE_SUCCESS) |
kevin1990 | 16:e4f2689363bb | 1139 | { |
kevin1990 | 16:e4f2689363bb | 1140 | ADI_SENSE_LOG_ERROR("Failed to set operating mode"); |
kevin1990 | 16:e4f2689363bb | 1141 | return eRet; |
kevin1990 | 16:e4f2689363bb | 1142 | } |
kevin1990 | 16:e4f2689363bb | 1143 | |
kevin1990 | 16:e4f2689363bb | 1144 | if (pMeasConfig->operatingMode != ADI_SENSE_1000_OPERATING_MODE_SINGLECYCLE) |
kevin1990 | 16:e4f2689363bb | 1145 | { |
kevin1990 | 16:e4f2689363bb | 1146 | eRet = adi_sense_SetCycleInterval(hDevice, pMeasConfig->cycleInterval); |
kevin1990 | 16:e4f2689363bb | 1147 | if (eRet != ADI_SENSE_SUCCESS) |
kevin1990 | 16:e4f2689363bb | 1148 | { |
kevin1990 | 16:e4f2689363bb | 1149 | ADI_SENSE_LOG_ERROR("Failed to set cycle interval"); |
kevin1990 | 16:e4f2689363bb | 1150 | return eRet; |
kevin1990 | 16:e4f2689363bb | 1151 | } |
kevin1990 | 16:e4f2689363bb | 1152 | } |
kevin1990 | 16:e4f2689363bb | 1153 | |
kevin1990 | 16:e4f2689363bb | 1154 | if (pMeasConfig->operatingMode == ADI_SENSE_1000_OPERATING_MODE_MULTICYCLE) |
kevin1990 | 16:e4f2689363bb | 1155 | { |
kevin1990 | 16:e4f2689363bb | 1156 | eRet = adi_sense_SetMultiCycleConfig(hDevice, |
kevin1990 | 16:e4f2689363bb | 1157 | &pMeasConfig->multiCycleConfig); |
kevin1990 | 16:e4f2689363bb | 1158 | if (eRet != ADI_SENSE_SUCCESS) |
kevin1990 | 16:e4f2689363bb | 1159 | { |
kevin1990 | 16:e4f2689363bb | 1160 | ADI_SENSE_LOG_ERROR("Failed to set multi-cycle configuration"); |
kevin1990 | 16:e4f2689363bb | 1161 | return eRet; |
kevin1990 | 16:e4f2689363bb | 1162 | } |
kevin1990 | 16:e4f2689363bb | 1163 | } |
kevin1990 | 16:e4f2689363bb | 1164 | |
kevin1990 | 16:e4f2689363bb | 1165 | eRet = adi_sense_SetExternalReferenceValues(hDevice, |
kevin1990 | 16:e4f2689363bb | 1166 | pMeasConfig->externalRef1Value, |
kevin1990 | 16:e4f2689363bb | 1167 | pMeasConfig->externalRef2Value); |
kevin1990 | 16:e4f2689363bb | 1168 | if (eRet != ADI_SENSE_SUCCESS) |
kevin1990 | 16:e4f2689363bb | 1169 | { |
kevin1990 | 16:e4f2689363bb | 1170 | ADI_SENSE_LOG_ERROR("Failed to set external reference values"); |
kevin1990 | 16:e4f2689363bb | 1171 | return eRet; |
kevin1990 | 16:e4f2689363bb | 1172 | } |
kevin1990 | 16:e4f2689363bb | 1173 | |
kevin1990 | 16:e4f2689363bb | 1174 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 1175 | } |
kevin1990 | 16:e4f2689363bb | 1176 | |
kevin1990 | 16:e4f2689363bb | 1177 | ADI_SENSE_RESULT adi_sense_1000_SetDiagnosticsConfig( |
kevin1990 | 16:e4f2689363bb | 1178 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 1179 | ADI_SENSE_1000_DIAGNOSTICS_CONFIG *pDiagnosticsConfig) |
kevin1990 | 16:e4f2689363bb | 1180 | { |
kevin1990 | 16:e4f2689363bb | 1181 | ADI_ADISENSE_CORE_Diagnostics_Control_t diagnosticsControlReg; |
kevin1990 | 16:e4f2689363bb | 1182 | |
kevin1990 | 16:e4f2689363bb | 1183 | diagnosticsControlReg.VALUE16 = REG_RESET_VAL(CORE_DIAGNOSTICS_CONTROL); |
kevin1990 | 16:e4f2689363bb | 1184 | |
kevin1990 | 16:e4f2689363bb | 1185 | if (pDiagnosticsConfig->disableGlobalDiag) |
kevin1990 | 16:e4f2689363bb | 1186 | diagnosticsControlReg.Diag_Global_En = 0; |
kevin1990 | 16:e4f2689363bb | 1187 | else |
kevin1990 | 16:e4f2689363bb | 1188 | diagnosticsControlReg.Diag_Global_En = 1; |
kevin1990 | 16:e4f2689363bb | 1189 | |
kevin1990 | 16:e4f2689363bb | 1190 | if (pDiagnosticsConfig->disableMeasurementDiag) |
kevin1990 | 16:e4f2689363bb | 1191 | diagnosticsControlReg.Diag_Meas_En = 0; |
kevin1990 | 16:e4f2689363bb | 1192 | else |
kevin1990 | 16:e4f2689363bb | 1193 | diagnosticsControlReg.Diag_Meas_En = 1; |
kevin1990 | 16:e4f2689363bb | 1194 | |
kevin1990 | 16:e4f2689363bb | 1195 | switch (pDiagnosticsConfig->osdFrequency) |
kevin1990 | 16:e4f2689363bb | 1196 | { |
kevin1990 | 16:e4f2689363bb | 1197 | case ADI_SENSE_1000_OPEN_SENSOR_DIAGNOSTICS_DISABLED: |
kevin1990 | 16:e4f2689363bb | 1198 | diagnosticsControlReg.Diag_OSD_Freq = ADISENSE_CORE_DIAGNOSTICS_CONTROL_OCD_OFF; |
kevin1990 | 16:e4f2689363bb | 1199 | break; |
kevin1990 | 16:e4f2689363bb | 1200 | case ADI_SENSE_1000_OPEN_SENSOR_DIAGNOSTICS_PER_CYCLE: |
kevin1990 | 16:e4f2689363bb | 1201 | diagnosticsControlReg.Diag_OSD_Freq = ADISENSE_CORE_DIAGNOSTICS_CONTROL_OCD_PER_1_CYCLE; |
kevin1990 | 16:e4f2689363bb | 1202 | break; |
kevin1990 | 16:e4f2689363bb | 1203 | case ADI_SENSE_1000_OPEN_SENSOR_DIAGNOSTICS_PER_100_CYCLES: |
kevin1990 | 16:e4f2689363bb | 1204 | diagnosticsControlReg.Diag_OSD_Freq = ADISENSE_CORE_DIAGNOSTICS_CONTROL_OCD_PER_100_CYCLES; |
kevin1990 | 16:e4f2689363bb | 1205 | break; |
kevin1990 | 16:e4f2689363bb | 1206 | case ADI_SENSE_1000_OPEN_SENSOR_DIAGNOSTICS_PER_1000_CYCLES: |
kevin1990 | 16:e4f2689363bb | 1207 | diagnosticsControlReg.Diag_OSD_Freq = ADISENSE_CORE_DIAGNOSTICS_CONTROL_OCD_PER_1000_CYCLES; |
kevin1990 | 16:e4f2689363bb | 1208 | break; |
kevin1990 | 16:e4f2689363bb | 1209 | default: |
kevin1990 | 16:e4f2689363bb | 1210 | ADI_SENSE_LOG_ERROR("Invalid open-sensor diagnostic frequency %d specified", |
kevin1990 | 16:e4f2689363bb | 1211 | pDiagnosticsConfig->osdFrequency); |
kevin1990 | 16:e4f2689363bb | 1212 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 1213 | } |
kevin1990 | 16:e4f2689363bb | 1214 | |
kevin1990 | 16:e4f2689363bb | 1215 | WRITE_REG_U16(hDevice, diagnosticsControlReg.VALUE16, CORE_DIAGNOSTICS_CONTROL); |
kevin1990 | 16:e4f2689363bb | 1216 | |
kevin1990 | 16:e4f2689363bb | 1217 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 1218 | } |
kevin1990 | 16:e4f2689363bb | 1219 | |
kevin1990 | 16:e4f2689363bb | 1220 | ADI_SENSE_RESULT adi_sense_1000_SetChannelCount( |
kevin1990 | 16:e4f2689363bb | 1221 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 1222 | ADI_SENSE_1000_CHANNEL_ID eChannelId, |
kevin1990 | 16:e4f2689363bb | 1223 | uint32_t nMeasurementsPerCycle) |
kevin1990 | 16:e4f2689363bb | 1224 | { |
kevin1990 | 16:e4f2689363bb | 1225 | ADI_ADISENSE_CORE_Channel_Count_t channelCountReg; |
kevin1990 | 16:e4f2689363bb | 1226 | |
kevin1990 | 16:e4f2689363bb | 1227 | channelCountReg.VALUE8 = REG_RESET_VAL(CORE_CHANNEL_COUNTn); |
kevin1990 | 16:e4f2689363bb | 1228 | |
kevin1990 | 16:e4f2689363bb | 1229 | if (nMeasurementsPerCycle > 0) |
kevin1990 | 16:e4f2689363bb | 1230 | { |
kevin1990 | 16:e4f2689363bb | 1231 | nMeasurementsPerCycle -= 1; |
kevin1990 | 16:e4f2689363bb | 1232 | |
kevin1990 | 16:e4f2689363bb | 1233 | CHECK_REG_FIELD_VAL(CORE_CHANNEL_COUNT_CHANNEL_COUNT, |
kevin1990 | 16:e4f2689363bb | 1234 | nMeasurementsPerCycle); |
kevin1990 | 16:e4f2689363bb | 1235 | |
kevin1990 | 16:e4f2689363bb | 1236 | channelCountReg.Channel_Enable = 1; |
kevin1990 | 16:e4f2689363bb | 1237 | channelCountReg.Channel_Count = nMeasurementsPerCycle; |
kevin1990 | 16:e4f2689363bb | 1238 | } |
kevin1990 | 16:e4f2689363bb | 1239 | else |
kevin1990 | 16:e4f2689363bb | 1240 | { |
kevin1990 | 16:e4f2689363bb | 1241 | channelCountReg.Channel_Enable = 0; |
kevin1990 | 16:e4f2689363bb | 1242 | } |
kevin1990 | 16:e4f2689363bb | 1243 | |
kevin1990 | 16:e4f2689363bb | 1244 | WRITE_REG_U8(hDevice, channelCountReg.VALUE8, CORE_CHANNEL_COUNTn(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1245 | |
kevin1990 | 16:e4f2689363bb | 1246 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 1247 | } |
kevin1990 | 16:e4f2689363bb | 1248 | |
kevin1990 | 16:e4f2689363bb | 1249 | static ADI_SENSE_RESULT adi_sense_SetChannelAdcSensorType( |
kevin1990 | 16:e4f2689363bb | 1250 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 1251 | ADI_SENSE_1000_CHANNEL_ID eChannelId, |
kevin1990 | 16:e4f2689363bb | 1252 | ADI_SENSE_1000_ADC_SENSOR_TYPE sensorType) |
kevin1990 | 16:e4f2689363bb | 1253 | { |
kevin1990 | 16:e4f2689363bb | 1254 | ADI_ADISENSE_CORE_Sensor_Type_t sensorTypeReg; |
kevin1990 | 16:e4f2689363bb | 1255 | |
kevin1990 | 16:e4f2689363bb | 1256 | sensorTypeReg.VALUE16 = REG_RESET_VAL(CORE_SENSOR_TYPEn); |
kevin1990 | 16:e4f2689363bb | 1257 | |
kevin1990 | 16:e4f2689363bb | 1258 | /* Ensure that the sensor type is valid for this channel */ |
kevin1990 | 16:e4f2689363bb | 1259 | switch(sensorType) |
kevin1990 | 16:e4f2689363bb | 1260 | { |
kevin1990 | 16:e4f2689363bb | 1261 | case ADI_SENSE_1000_ADC_SENSOR_THERMOCOUPLE_J_DEF_L1: |
kevin1990 | 16:e4f2689363bb | 1262 | case ADI_SENSE_1000_ADC_SENSOR_THERMOCOUPLE_K_DEF_L1: |
kevin1990 | 16:e4f2689363bb | 1263 | case ADI_SENSE_1000_ADC_SENSOR_THERMOCOUPLE_T_DEF_L1: |
kevin1990 | 16:e4f2689363bb | 1264 | case ADI_SENSE_1000_ADC_SENSOR_THERMOCOUPLE_1_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1265 | case ADI_SENSE_1000_ADC_SENSOR_THERMOCOUPLE_2_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1266 | case ADI_SENSE_1000_ADC_SENSOR_THERMOCOUPLE_3_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1267 | case ADI_SENSE_1000_ADC_SENSOR_THERMOCOUPLE_4_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1268 | case ADI_SENSE_1000_ADC_SENSOR_THERMOCOUPLE_J_ADV_L1: |
kevin1990 | 16:e4f2689363bb | 1269 | case ADI_SENSE_1000_ADC_SENSOR_THERMOCOUPLE_K_ADV_L1: |
kevin1990 | 16:e4f2689363bb | 1270 | case ADI_SENSE_1000_ADC_SENSOR_THERMOCOUPLE_T_ADV_L1: |
kevin1990 | 16:e4f2689363bb | 1271 | case ADI_SENSE_1000_ADC_SENSOR_THERMOCOUPLE_1_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1272 | case ADI_SENSE_1000_ADC_SENSOR_THERMOCOUPLE_2_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1273 | case ADI_SENSE_1000_ADC_SENSOR_THERMOCOUPLE_3_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1274 | case ADI_SENSE_1000_ADC_SENSOR_THERMOCOUPLE_4_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1275 | case ADI_SENSE_1000_ADC_SENSOR_RTD_3WIRE_PT100_DEF_L1: |
kevin1990 | 16:e4f2689363bb | 1276 | case ADI_SENSE_1000_ADC_SENSOR_RTD_3WIRE_PT1000_DEF_L1: |
kevin1990 | 16:e4f2689363bb | 1277 | case ADI_SENSE_1000_ADC_SENSOR_RTD_3WIRE_1_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1278 | case ADI_SENSE_1000_ADC_SENSOR_RTD_3WIRE_2_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1279 | case ADI_SENSE_1000_ADC_SENSOR_RTD_3WIRE_3_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1280 | case ADI_SENSE_1000_ADC_SENSOR_RTD_3WIRE_4_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1281 | case ADI_SENSE_1000_ADC_SENSOR_RTD_3WIRE_PT100_ADV_L1: |
kevin1990 | 16:e4f2689363bb | 1282 | case ADI_SENSE_1000_ADC_SENSOR_RTD_3WIRE_PT1000_ADV_L1: |
kevin1990 | 16:e4f2689363bb | 1283 | case ADI_SENSE_1000_ADC_SENSOR_RTD_3WIRE_1_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1284 | case ADI_SENSE_1000_ADC_SENSOR_RTD_3WIRE_2_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1285 | case ADI_SENSE_1000_ADC_SENSOR_RTD_3WIRE_3_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1286 | case ADI_SENSE_1000_ADC_SENSOR_RTD_3WIRE_4_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1287 | case ADI_SENSE_1000_ADC_SENSOR_RTD_4WIRE_PT100_DEF_L1: |
kevin1990 | 16:e4f2689363bb | 1288 | case ADI_SENSE_1000_ADC_SENSOR_RTD_4WIRE_PT1000_DEF_L1: |
kevin1990 | 16:e4f2689363bb | 1289 | case ADI_SENSE_1000_ADC_SENSOR_RTD_4WIRE_1_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1290 | case ADI_SENSE_1000_ADC_SENSOR_RTD_4WIRE_2_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1291 | case ADI_SENSE_1000_ADC_SENSOR_RTD_4WIRE_3_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1292 | case ADI_SENSE_1000_ADC_SENSOR_RTD_4WIRE_4_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1293 | case ADI_SENSE_1000_ADC_SENSOR_RTD_4WIRE_PT100_ADV_L1: |
kevin1990 | 16:e4f2689363bb | 1294 | case ADI_SENSE_1000_ADC_SENSOR_RTD_4WIRE_PT1000_ADV_L1: |
kevin1990 | 16:e4f2689363bb | 1295 | case ADI_SENSE_1000_ADC_SENSOR_RTD_4WIRE_1_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1296 | case ADI_SENSE_1000_ADC_SENSOR_RTD_4WIRE_2_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1297 | case ADI_SENSE_1000_ADC_SENSOR_RTD_4WIRE_3_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1298 | case ADI_SENSE_1000_ADC_SENSOR_RTD_4WIRE_4_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1299 | case ADI_SENSE_1000_ADC_SENSOR_BRIDGE_4WIRE_1_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1300 | case ADI_SENSE_1000_ADC_SENSOR_BRIDGE_4WIRE_2_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1301 | case ADI_SENSE_1000_ADC_SENSOR_BRIDGE_4WIRE_3_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1302 | case ADI_SENSE_1000_ADC_SENSOR_BRIDGE_4WIRE_4_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1303 | case ADI_SENSE_1000_ADC_SENSOR_BRIDGE_4WIRE_1_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1304 | case ADI_SENSE_1000_ADC_SENSOR_BRIDGE_4WIRE_2_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1305 | case ADI_SENSE_1000_ADC_SENSOR_BRIDGE_4WIRE_3_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1306 | case ADI_SENSE_1000_ADC_SENSOR_BRIDGE_4WIRE_4_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1307 | case ADI_SENSE_1000_ADC_SENSOR_BRIDGE_6WIRE_1_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1308 | case ADI_SENSE_1000_ADC_SENSOR_BRIDGE_6WIRE_2_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1309 | case ADI_SENSE_1000_ADC_SENSOR_BRIDGE_6WIRE_3_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1310 | case ADI_SENSE_1000_ADC_SENSOR_BRIDGE_6WIRE_4_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1311 | case ADI_SENSE_1000_ADC_SENSOR_BRIDGE_6WIRE_1_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1312 | case ADI_SENSE_1000_ADC_SENSOR_BRIDGE_6WIRE_2_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1313 | case ADI_SENSE_1000_ADC_SENSOR_BRIDGE_6WIRE_3_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1314 | case ADI_SENSE_1000_ADC_SENSOR_BRIDGE_6WIRE_4_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1315 | case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_A_10K_DEF_L1: |
kevin1990 | 16:e4f2689363bb | 1316 | case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_B_10K_DEF_L1: |
kevin1990 | 16:e4f2689363bb | 1317 | case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_1_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1318 | case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_2_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1319 | case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_3_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1320 | case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_4_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1321 | case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_A_10K_ADV_L1: |
kevin1990 | 16:e4f2689363bb | 1322 | case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_B_10K_ADV_L1: |
kevin1990 | 16:e4f2689363bb | 1323 | case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_1_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1324 | case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_2_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1325 | case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_3_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1326 | case ADI_SENSE_1000_ADC_SENSOR_THERMISTOR_4_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1327 | if (! ADI_SENSE_1000_CHANNEL_IS_ADC_SENSOR(eChannelId)) |
kevin1990 | 16:e4f2689363bb | 1328 | { |
kevin1990 | 16:e4f2689363bb | 1329 | ADI_SENSE_LOG_ERROR( |
kevin1990 | 16:e4f2689363bb | 1330 | "Invalid ADC sensor type %d specified for channel %d", |
kevin1990 | 16:e4f2689363bb | 1331 | sensorType, eChannelId); |
kevin1990 | 16:e4f2689363bb | 1332 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 1333 | } |
kevin1990 | 16:e4f2689363bb | 1334 | break; |
kevin1990 | 16:e4f2689363bb | 1335 | case ADI_SENSE_1000_ADC_SENSOR_RTD_2WIRE_PT100_DEF_L1: |
kevin1990 | 16:e4f2689363bb | 1336 | case ADI_SENSE_1000_ADC_SENSOR_RTD_2WIRE_PT1000_DEF_L1: |
kevin1990 | 16:e4f2689363bb | 1337 | case ADI_SENSE_1000_ADC_SENSOR_RTD_2WIRE_1_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1338 | case ADI_SENSE_1000_ADC_SENSOR_RTD_2WIRE_2_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1339 | case ADI_SENSE_1000_ADC_SENSOR_RTD_2WIRE_3_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1340 | case ADI_SENSE_1000_ADC_SENSOR_RTD_2WIRE_4_DEF_L2: |
kevin1990 | 16:e4f2689363bb | 1341 | case ADI_SENSE_1000_ADC_SENSOR_RTD_2WIRE_PT100_ADV_L1: |
kevin1990 | 16:e4f2689363bb | 1342 | case ADI_SENSE_1000_ADC_SENSOR_RTD_2WIRE_PT1000_ADV_L1: |
kevin1990 | 16:e4f2689363bb | 1343 | case ADI_SENSE_1000_ADC_SENSOR_RTD_2WIRE_1_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1344 | case ADI_SENSE_1000_ADC_SENSOR_RTD_2WIRE_2_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1345 | case ADI_SENSE_1000_ADC_SENSOR_RTD_2WIRE_3_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1346 | case ADI_SENSE_1000_ADC_SENSOR_RTD_2WIRE_4_ADV_L2: |
kevin1990 | 16:e4f2689363bb | 1347 | if (! (ADI_SENSE_1000_CHANNEL_IS_ADC_SENSOR(eChannelId) || |
kevin1990 | 16:e4f2689363bb | 1348 | ADI_SENSE_1000_CHANNEL_IS_ADC_CJC(eChannelId))) |
kevin1990 | 16:e4f2689363bb | 1349 | { |
kevin1990 | 16:e4f2689363bb | 1350 | ADI_SENSE_LOG_ERROR( |
kevin1990 | 16:e4f2689363bb | 1351 | "Invalid ADC sensor type %d specified for channel %d", |
kevin1990 | 16:e4f2689363bb | 1352 | sensorType, eChannelId); |
kevin1990 | 16:e4f2689363bb | 1353 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 1354 | } |
kevin1990 | 16:e4f2689363bb | 1355 | break; |
kevin1990 | 16:e4f2689363bb | 1356 | case ADI_SENSE_1000_ADC_SENSOR_VOLTAGE: |
kevin1990 | 16:e4f2689363bb | 1357 | case ADI_SENSE_1000_ADC_SENSOR_VOLTAGE_PRESSURE_HONEYWELL_TRUSTABILITY: |
kevin1990 | 16:e4f2689363bb | 1358 | case ADI_SENSE_1000_ADC_SENSOR_VOLTAGE_PRESSURE_AMPHENOL_NPA300X: |
kevin1990 | 16:e4f2689363bb | 1359 | case ADI_SENSE_1000_ADC_SENSOR_VOLTAGE_PRESSURE_3_DEF: |
kevin1990 | 16:e4f2689363bb | 1360 | if (! ADI_SENSE_1000_CHANNEL_IS_ADC_VOLTAGE(eChannelId)) |
kevin1990 | 16:e4f2689363bb | 1361 | { |
kevin1990 | 16:e4f2689363bb | 1362 | ADI_SENSE_LOG_ERROR( |
kevin1990 | 16:e4f2689363bb | 1363 | "Invalid ADC sensor type %d specified for channel %d", |
kevin1990 | 16:e4f2689363bb | 1364 | sensorType, eChannelId); |
kevin1990 | 16:e4f2689363bb | 1365 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 1366 | } |
kevin1990 | 16:e4f2689363bb | 1367 | break; |
kevin1990 | 16:e4f2689363bb | 1368 | case ADI_SENSE_1000_ADC_SENSOR_CURRENT: |
kevin1990 | 16:e4f2689363bb | 1369 | case ADI_SENSE_1000_ADC_SENSOR_CURRENT_PRESSURE_HONEYWELL_PX2: |
kevin1990 | 16:e4f2689363bb | 1370 | case ADI_SENSE_1000_ADC_SENSOR_CURRENT_PRESSURE_2_DEF: |
kevin1990 | 16:e4f2689363bb | 1371 | if (! ADI_SENSE_1000_CHANNEL_IS_ADC_CURRENT(eChannelId)) |
kevin1990 | 16:e4f2689363bb | 1372 | { |
kevin1990 | 16:e4f2689363bb | 1373 | ADI_SENSE_LOG_ERROR( |
kevin1990 | 16:e4f2689363bb | 1374 | "Invalid ADC sensor type %d specified for channel %d", |
kevin1990 | 16:e4f2689363bb | 1375 | sensorType, eChannelId); |
kevin1990 | 16:e4f2689363bb | 1376 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 1377 | } |
kevin1990 | 16:e4f2689363bb | 1378 | break; |
kevin1990 | 16:e4f2689363bb | 1379 | default: |
kevin1990 | 16:e4f2689363bb | 1380 | ADI_SENSE_LOG_ERROR("Invalid/unsupported ADC sensor type %d specified", |
kevin1990 | 16:e4f2689363bb | 1381 | sensorType); |
kevin1990 | 16:e4f2689363bb | 1382 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 1383 | } |
kevin1990 | 16:e4f2689363bb | 1384 | |
kevin1990 | 16:e4f2689363bb | 1385 | sensorTypeReg.Sensor_Type = sensorType; |
kevin1990 | 16:e4f2689363bb | 1386 | |
kevin1990 | 16:e4f2689363bb | 1387 | WRITE_REG_U16(hDevice, sensorTypeReg.VALUE16, CORE_SENSOR_TYPEn(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1388 | |
kevin1990 | 16:e4f2689363bb | 1389 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 1390 | } |
kevin1990 | 16:e4f2689363bb | 1391 | |
kevin1990 | 16:e4f2689363bb | 1392 | static ADI_SENSE_RESULT adi_sense_SetChannelAdcSensorDetails( |
kevin1990 | 16:e4f2689363bb | 1393 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 1394 | ADI_SENSE_1000_CHANNEL_ID eChannelId, |
kevin1990 | 16:e4f2689363bb | 1395 | ADI_SENSE_1000_CHANNEL_CONFIG *pChannelConfig) |
kevin1990 | 16:e4f2689363bb | 1396 | /* |
kevin1990 | 16:e4f2689363bb | 1397 | * TODO - it would be nice if the general- vs. ADC-specific sensor details could be split into separate registers |
kevin1990 | 16:e4f2689363bb | 1398 | * General details: |
kevin1990 | 16:e4f2689363bb | 1399 | * - Measurement_Units |
kevin1990 | 16:e4f2689363bb | 1400 | * - Compensation_Channel |
kevin1990 | 16:e4f2689363bb | 1401 | * - CJC_Publish (if "CJC" was removed from the name) |
kevin1990 | 16:e4f2689363bb | 1402 | * ADC-specific details: |
kevin1990 | 16:e4f2689363bb | 1403 | * - PGA_Gain |
kevin1990 | 16:e4f2689363bb | 1404 | * - Reference_Select |
kevin1990 | 16:e4f2689363bb | 1405 | * - Reference_Buffer_Disable |
kevin1990 | 16:e4f2689363bb | 1406 | * - Vbias |
kevin1990 | 16:e4f2689363bb | 1407 | */ |
kevin1990 | 16:e4f2689363bb | 1408 | { |
kevin1990 | 16:e4f2689363bb | 1409 | ADI_SENSE_1000_ADC_CHANNEL_CONFIG *pAdcChannelConfig = &pChannelConfig->adcChannelConfig; |
kevin1990 | 16:e4f2689363bb | 1410 | ADI_SENSE_1000_ADC_REFERENCE_CONFIG *pRefConfig = &pAdcChannelConfig->reference; |
kevin1990 | 16:e4f2689363bb | 1411 | ADI_ADISENSE_CORE_Sensor_Details_t sensorDetailsReg; |
kevin1990 | 16:e4f2689363bb | 1412 | |
kevin1990 | 16:e4f2689363bb | 1413 | sensorDetailsReg.VALUE32 = REG_RESET_VAL(CORE_SENSOR_DETAILSn); |
kevin1990 | 16:e4f2689363bb | 1414 | |
kevin1990 | 16:e4f2689363bb | 1415 | switch(pChannelConfig->measurementUnit) |
kevin1990 | 16:e4f2689363bb | 1416 | { |
kevin1990 | 16:e4f2689363bb | 1417 | case ADI_SENSE_1000_MEASUREMENT_UNIT_FAHRENHEIT: |
kevin1990 | 16:e4f2689363bb | 1418 | sensorDetailsReg.Measurement_Units = ADISENSE_CORE_SENSOR_DETAILS_UNITS_DEGF; |
kevin1990 | 16:e4f2689363bb | 1419 | break; |
kevin1990 | 16:e4f2689363bb | 1420 | case ADI_SENSE_1000_MEASUREMENT_UNIT_CELSIUS: |
kevin1990 | 16:e4f2689363bb | 1421 | case ADI_SENSE_1000_MEASUREMENT_UNIT_DEFAULT: |
kevin1990 | 16:e4f2689363bb | 1422 | sensorDetailsReg.Measurement_Units = ADISENSE_CORE_SENSOR_DETAILS_UNITS_DEGC; |
kevin1990 | 16:e4f2689363bb | 1423 | break; |
kevin1990 | 16:e4f2689363bb | 1424 | default: |
kevin1990 | 16:e4f2689363bb | 1425 | ADI_SENSE_LOG_ERROR("Invalid measurement unit %d specified", |
kevin1990 | 16:e4f2689363bb | 1426 | pChannelConfig->measurementUnit); |
kevin1990 | 16:e4f2689363bb | 1427 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 1428 | } |
kevin1990 | 16:e4f2689363bb | 1429 | |
kevin1990 | 16:e4f2689363bb | 1430 | sensorDetailsReg.Compensation_Channel = pChannelConfig->compensationChannel; |
kevin1990 | 16:e4f2689363bb | 1431 | |
kevin1990 | 16:e4f2689363bb | 1432 | switch(pRefConfig->type) |
kevin1990 | 16:e4f2689363bb | 1433 | { |
kevin1990 | 16:e4f2689363bb | 1434 | case ADI_SENSE_1000_ADC_REFERENCE_RESISTOR_INTERNAL_1: |
kevin1990 | 16:e4f2689363bb | 1435 | sensorDetailsReg.Reference_Select = ADISENSE_CORE_SENSOR_DETAILS_REF_RINT1; |
kevin1990 | 16:e4f2689363bb | 1436 | break; |
kevin1990 | 16:e4f2689363bb | 1437 | case ADI_SENSE_1000_ADC_REFERENCE_RESISTOR_INTERNAL_2: |
kevin1990 | 16:e4f2689363bb | 1438 | sensorDetailsReg.Reference_Select = ADISENSE_CORE_SENSOR_DETAILS_REF_RINT2; |
kevin1990 | 16:e4f2689363bb | 1439 | break; |
kevin1990 | 16:e4f2689363bb | 1440 | case ADI_SENSE_1000_ADC_REFERENCE_VOLTAGE_INTERNAL: |
kevin1990 | 16:e4f2689363bb | 1441 | sensorDetailsReg.Reference_Select = ADISENSE_CORE_SENSOR_DETAILS_REF_INT; |
kevin1990 | 16:e4f2689363bb | 1442 | break; |
kevin1990 | 16:e4f2689363bb | 1443 | case ADI_SENSE_1000_ADC_REFERENCE_VOLTAGE_AVDD: |
kevin1990 | 16:e4f2689363bb | 1444 | sensorDetailsReg.Reference_Select = ADISENSE_CORE_SENSOR_DETAILS_REF_AVDD; |
kevin1990 | 16:e4f2689363bb | 1445 | break; |
kevin1990 | 16:e4f2689363bb | 1446 | case ADI_SENSE_1000_ADC_REFERENCE_RESISTOR_EXTERNAL_1: |
kevin1990 | 16:e4f2689363bb | 1447 | sensorDetailsReg.Reference_Select = ADISENSE_CORE_SENSOR_DETAILS_REF_REXT1; |
kevin1990 | 16:e4f2689363bb | 1448 | break; |
kevin1990 | 16:e4f2689363bb | 1449 | case ADI_SENSE_1000_ADC_REFERENCE_RESISTOR_EXTERNAL_2: |
kevin1990 | 16:e4f2689363bb | 1450 | sensorDetailsReg.Reference_Select = ADISENSE_CORE_SENSOR_DETAILS_REF_REXT2; |
kevin1990 | 16:e4f2689363bb | 1451 | break; |
kevin1990 | 16:e4f2689363bb | 1452 | case ADI_SENSE_1000_ADC_REFERENCE_VOLTAGE_EXTERNAL_1: |
kevin1990 | 16:e4f2689363bb | 1453 | sensorDetailsReg.Reference_Select = ADISENSE_CORE_SENSOR_DETAILS_REF_VEXT1; |
kevin1990 | 16:e4f2689363bb | 1454 | break; |
kevin1990 | 16:e4f2689363bb | 1455 | case ADI_SENSE_1000_ADC_REFERENCE_VOLTAGE_EXTERNAL_2: |
kevin1990 | 16:e4f2689363bb | 1456 | sensorDetailsReg.Reference_Select = ADISENSE_CORE_SENSOR_DETAILS_REF_VEXT2; |
kevin1990 | 16:e4f2689363bb | 1457 | break; |
kevin1990 | 16:e4f2689363bb | 1458 | case ADI_SENSE_1000_ADC_REFERENCE_BRIDGE_EXCITATION: |
kevin1990 | 16:e4f2689363bb | 1459 | sensorDetailsReg.Reference_Select = ADISENSE_CORE_SENSOR_DETAILS_REF_EXC; |
kevin1990 | 16:e4f2689363bb | 1460 | break; |
kevin1990 | 16:e4f2689363bb | 1461 | default: |
kevin1990 | 16:e4f2689363bb | 1462 | ADI_SENSE_LOG_ERROR("Invalid ADC reference type %d specified", |
kevin1990 | 16:e4f2689363bb | 1463 | pRefConfig->type); |
kevin1990 | 16:e4f2689363bb | 1464 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 1465 | } |
kevin1990 | 16:e4f2689363bb | 1466 | |
kevin1990 | 16:e4f2689363bb | 1467 | switch(pAdcChannelConfig->gain) |
kevin1990 | 16:e4f2689363bb | 1468 | { |
kevin1990 | 16:e4f2689363bb | 1469 | case ADI_SENSE_1000_ADC_GAIN_1X: |
kevin1990 | 16:e4f2689363bb | 1470 | sensorDetailsReg.PGA_Gain = ADISENSE_CORE_SENSOR_DETAILS_PGA_GAIN_1; |
kevin1990 | 16:e4f2689363bb | 1471 | break; |
kevin1990 | 16:e4f2689363bb | 1472 | case ADI_SENSE_1000_ADC_GAIN_2X: |
kevin1990 | 16:e4f2689363bb | 1473 | sensorDetailsReg.PGA_Gain = ADISENSE_CORE_SENSOR_DETAILS_PGA_GAIN_2; |
kevin1990 | 16:e4f2689363bb | 1474 | break; |
kevin1990 | 16:e4f2689363bb | 1475 | case ADI_SENSE_1000_ADC_GAIN_4X: |
kevin1990 | 16:e4f2689363bb | 1476 | sensorDetailsReg.PGA_Gain = ADISENSE_CORE_SENSOR_DETAILS_PGA_GAIN_4; |
kevin1990 | 16:e4f2689363bb | 1477 | break; |
kevin1990 | 16:e4f2689363bb | 1478 | case ADI_SENSE_1000_ADC_GAIN_8X: |
kevin1990 | 16:e4f2689363bb | 1479 | sensorDetailsReg.PGA_Gain = ADISENSE_CORE_SENSOR_DETAILS_PGA_GAIN_8; |
kevin1990 | 16:e4f2689363bb | 1480 | break; |
kevin1990 | 16:e4f2689363bb | 1481 | case ADI_SENSE_1000_ADC_GAIN_16X: |
kevin1990 | 16:e4f2689363bb | 1482 | sensorDetailsReg.PGA_Gain = ADISENSE_CORE_SENSOR_DETAILS_PGA_GAIN_16; |
kevin1990 | 16:e4f2689363bb | 1483 | break; |
kevin1990 | 16:e4f2689363bb | 1484 | case ADI_SENSE_1000_ADC_GAIN_32X: |
kevin1990 | 16:e4f2689363bb | 1485 | sensorDetailsReg.PGA_Gain = ADISENSE_CORE_SENSOR_DETAILS_PGA_GAIN_32; |
kevin1990 | 16:e4f2689363bb | 1486 | break; |
kevin1990 | 16:e4f2689363bb | 1487 | case ADI_SENSE_1000_ADC_GAIN_64X: |
kevin1990 | 16:e4f2689363bb | 1488 | sensorDetailsReg.PGA_Gain = ADISENSE_CORE_SENSOR_DETAILS_PGA_GAIN_64; |
kevin1990 | 16:e4f2689363bb | 1489 | break; |
kevin1990 | 16:e4f2689363bb | 1490 | case ADI_SENSE_1000_ADC_GAIN_128X: |
kevin1990 | 16:e4f2689363bb | 1491 | sensorDetailsReg.PGA_Gain = ADISENSE_CORE_SENSOR_DETAILS_PGA_GAIN_128; |
kevin1990 | 16:e4f2689363bb | 1492 | break; |
kevin1990 | 16:e4f2689363bb | 1493 | default: |
kevin1990 | 16:e4f2689363bb | 1494 | ADI_SENSE_LOG_ERROR("Invalid ADC gain %d specified", |
kevin1990 | 16:e4f2689363bb | 1495 | pAdcChannelConfig->gain); |
kevin1990 | 16:e4f2689363bb | 1496 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 1497 | } |
kevin1990 | 16:e4f2689363bb | 1498 | |
kevin1990 | 16:e4f2689363bb | 1499 | if (pAdcChannelConfig->enableVbias) |
kevin1990 | 16:e4f2689363bb | 1500 | sensorDetailsReg.Vbias = 1; |
kevin1990 | 16:e4f2689363bb | 1501 | else |
kevin1990 | 16:e4f2689363bb | 1502 | sensorDetailsReg.Vbias = 0; |
kevin1990 | 16:e4f2689363bb | 1503 | |
kevin1990 | 16:e4f2689363bb | 1504 | if (pAdcChannelConfig->reference.disableBuffer) |
kevin1990 | 16:e4f2689363bb | 1505 | sensorDetailsReg.Reference_Buffer_Disable = 1; |
kevin1990 | 16:e4f2689363bb | 1506 | else |
kevin1990 | 16:e4f2689363bb | 1507 | sensorDetailsReg.Reference_Buffer_Disable = 0; |
kevin1990 | 16:e4f2689363bb | 1508 | |
kevin1990 | 16:e4f2689363bb | 1509 | if (pChannelConfig->disablePublishing) |
kevin1990 | 16:e4f2689363bb | 1510 | sensorDetailsReg.Do_Not_Publish = 1; |
kevin1990 | 16:e4f2689363bb | 1511 | else |
kevin1990 | 16:e4f2689363bb | 1512 | sensorDetailsReg.Do_Not_Publish = 0; |
kevin1990 | 16:e4f2689363bb | 1513 | |
kevin1990 | 16:e4f2689363bb | 1514 | WRITE_REG_U32(hDevice, sensorDetailsReg.VALUE32, CORE_SENSOR_DETAILSn(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1515 | |
kevin1990 | 16:e4f2689363bb | 1516 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 1517 | } |
kevin1990 | 16:e4f2689363bb | 1518 | |
kevin1990 | 16:e4f2689363bb | 1519 | static ADI_SENSE_RESULT adi_sense_SetChannelAdcFilter( |
kevin1990 | 16:e4f2689363bb | 1520 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 1521 | ADI_SENSE_1000_CHANNEL_ID eChannelId, |
kevin1990 | 16:e4f2689363bb | 1522 | ADI_SENSE_1000_ADC_FILTER_CONFIG *pFilterConfig) |
kevin1990 | 16:e4f2689363bb | 1523 | { |
kevin1990 | 16:e4f2689363bb | 1524 | ADI_ADISENSE_CORE_Filter_Select_t filterSelectReg; |
kevin1990 | 16:e4f2689363bb | 1525 | |
kevin1990 | 16:e4f2689363bb | 1526 | filterSelectReg.VALUE32 = REG_RESET_VAL(CORE_FILTER_SELECTn); |
kevin1990 | 16:e4f2689363bb | 1527 | |
kevin1990 | 16:e4f2689363bb | 1528 | if (pFilterConfig->type == ADI_SENSE_1000_ADC_FILTER_SINC4) |
kevin1990 | 16:e4f2689363bb | 1529 | { |
kevin1990 | 16:e4f2689363bb | 1530 | filterSelectReg.ADC_Filter_Type = ADISENSE_CORE_FILTER_SELECT_FILTER_SINC4; |
kevin1990 | 16:e4f2689363bb | 1531 | filterSelectReg.ADC_FS = pFilterConfig->fs; |
kevin1990 | 16:e4f2689363bb | 1532 | } |
kevin1990 | 16:e4f2689363bb | 1533 | else if (pFilterConfig->type == ADI_SENSE_1000_ADC_FILTER_FIR_20SPS) |
kevin1990 | 16:e4f2689363bb | 1534 | { |
kevin1990 | 16:e4f2689363bb | 1535 | filterSelectReg.ADC_Filter_Type = ADISENSE_CORE_FILTER_SELECT_FILTER_FIR_20SPS; |
kevin1990 | 16:e4f2689363bb | 1536 | } |
kevin1990 | 16:e4f2689363bb | 1537 | else if (pFilterConfig->type == ADI_SENSE_1000_ADC_FILTER_FIR_25SPS) |
kevin1990 | 16:e4f2689363bb | 1538 | { |
kevin1990 | 16:e4f2689363bb | 1539 | filterSelectReg.ADC_Filter_Type = ADISENSE_CORE_FILTER_SELECT_FILTER_FIR_25SPS; |
kevin1990 | 16:e4f2689363bb | 1540 | } |
kevin1990 | 16:e4f2689363bb | 1541 | else |
kevin1990 | 16:e4f2689363bb | 1542 | { |
kevin1990 | 16:e4f2689363bb | 1543 | ADI_SENSE_LOG_ERROR("Invalid ADC filter type %d specified", |
kevin1990 | 16:e4f2689363bb | 1544 | pFilterConfig->type); |
kevin1990 | 16:e4f2689363bb | 1545 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 1546 | } |
kevin1990 | 16:e4f2689363bb | 1547 | |
kevin1990 | 16:e4f2689363bb | 1548 | WRITE_REG_U32(hDevice, filterSelectReg.VALUE32, CORE_FILTER_SELECTn(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1549 | |
kevin1990 | 16:e4f2689363bb | 1550 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 1551 | } |
kevin1990 | 16:e4f2689363bb | 1552 | |
kevin1990 | 16:e4f2689363bb | 1553 | static ADI_SENSE_RESULT adi_sense_SetChannelAdcCurrentConfig( |
kevin1990 | 16:e4f2689363bb | 1554 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 1555 | ADI_SENSE_1000_CHANNEL_ID eChannelId, |
kevin1990 | 16:e4f2689363bb | 1556 | ADI_SENSE_1000_ADC_EXC_CURRENT_CONFIG *pCurrentConfig) |
kevin1990 | 16:e4f2689363bb | 1557 | { |
kevin1990 | 16:e4f2689363bb | 1558 | ADI_ADISENSE_CORE_Channel_Excitation_t channelExcitationReg; |
kevin1990 | 16:e4f2689363bb | 1559 | |
kevin1990 | 16:e4f2689363bb | 1560 | channelExcitationReg.VALUE8 = REG_RESET_VAL(CORE_CHANNEL_EXCITATIONn); |
kevin1990 | 16:e4f2689363bb | 1561 | |
kevin1990 | 16:e4f2689363bb | 1562 | if (pCurrentConfig->outputLevel == ADI_SENSE_1000_ADC_EXC_CURRENT_NONE) |
kevin1990 | 16:e4f2689363bb | 1563 | { |
kevin1990 | 16:e4f2689363bb | 1564 | channelExcitationReg.IOUT0_Disable = 1; |
kevin1990 | 16:e4f2689363bb | 1565 | channelExcitationReg.IOUT1_Disable = 1; |
kevin1990 | 16:e4f2689363bb | 1566 | |
kevin1990 | 16:e4f2689363bb | 1567 | channelExcitationReg.IOUT_Excitation_Current = ADISENSE_CORE_CHANNEL_EXCITATION_IEXC_OFF; |
kevin1990 | 16:e4f2689363bb | 1568 | } |
kevin1990 | 16:e4f2689363bb | 1569 | else |
kevin1990 | 16:e4f2689363bb | 1570 | { |
kevin1990 | 16:e4f2689363bb | 1571 | channelExcitationReg.IOUT0_Disable = 0; |
kevin1990 | 16:e4f2689363bb | 1572 | channelExcitationReg.IOUT1_Disable = 0; |
kevin1990 | 16:e4f2689363bb | 1573 | |
kevin1990 | 16:e4f2689363bb | 1574 | if (pCurrentConfig->outputLevel == ADI_SENSE_1000_ADC_EXC_CURRENT_50uA) |
kevin1990 | 16:e4f2689363bb | 1575 | channelExcitationReg.IOUT_Excitation_Current = ADISENSE_CORE_CHANNEL_EXCITATION_IEXC_50UA; |
kevin1990 | 16:e4f2689363bb | 1576 | else if (pCurrentConfig->outputLevel == ADI_SENSE_1000_ADC_EXC_CURRENT_100uA) |
kevin1990 | 16:e4f2689363bb | 1577 | channelExcitationReg.IOUT_Excitation_Current = ADISENSE_CORE_CHANNEL_EXCITATION_IEXC_100UA; |
kevin1990 | 16:e4f2689363bb | 1578 | else if (pCurrentConfig->outputLevel == ADI_SENSE_1000_ADC_EXC_CURRENT_250uA) |
kevin1990 | 16:e4f2689363bb | 1579 | channelExcitationReg.IOUT_Excitation_Current = ADISENSE_CORE_CHANNEL_EXCITATION_IEXC_250UA; |
kevin1990 | 16:e4f2689363bb | 1580 | else if (pCurrentConfig->outputLevel == ADI_SENSE_1000_ADC_EXC_CURRENT_500uA) |
kevin1990 | 16:e4f2689363bb | 1581 | channelExcitationReg.IOUT_Excitation_Current = ADISENSE_CORE_CHANNEL_EXCITATION_IEXC_500UA; |
kevin1990 | 16:e4f2689363bb | 1582 | else if (pCurrentConfig->outputLevel == ADI_SENSE_1000_ADC_EXC_CURRENT_750uA) |
kevin1990 | 16:e4f2689363bb | 1583 | channelExcitationReg.IOUT_Excitation_Current = ADISENSE_CORE_CHANNEL_EXCITATION_IEXC_750UA; |
kevin1990 | 16:e4f2689363bb | 1584 | else if (pCurrentConfig->outputLevel == ADI_SENSE_1000_ADC_EXC_CURRENT_1000uA) |
kevin1990 | 16:e4f2689363bb | 1585 | channelExcitationReg.IOUT_Excitation_Current = ADISENSE_CORE_CHANNEL_EXCITATION_IEXC_1000UA; |
kevin1990 | 16:e4f2689363bb | 1586 | else |
kevin1990 | 16:e4f2689363bb | 1587 | { |
kevin1990 | 16:e4f2689363bb | 1588 | ADI_SENSE_LOG_ERROR("Invalid ADC excitation current %d specified", |
kevin1990 | 16:e4f2689363bb | 1589 | pCurrentConfig->outputLevel); |
kevin1990 | 16:e4f2689363bb | 1590 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 1591 | } |
kevin1990 | 16:e4f2689363bb | 1592 | |
kevin1990 | 16:e4f2689363bb | 1593 | if (pCurrentConfig->swapOption == ADI_SENSE_1000_ADC_EXC_CURRENT_SWAP_DYNAMIC) |
kevin1990 | 16:e4f2689363bb | 1594 | { |
kevin1990 | 16:e4f2689363bb | 1595 | channelExcitationReg.IOUT_Dont_Swap_3Wire = 0; |
kevin1990 | 16:e4f2689363bb | 1596 | channelExcitationReg.IOUT_Static_Swap_3Wire = 0; |
kevin1990 | 16:e4f2689363bb | 1597 | } |
kevin1990 | 16:e4f2689363bb | 1598 | else if (pCurrentConfig->swapOption == ADI_SENSE_1000_ADC_EXC_CURRENT_SWAP_STATIC) |
kevin1990 | 16:e4f2689363bb | 1599 | { |
kevin1990 | 16:e4f2689363bb | 1600 | channelExcitationReg.IOUT_Dont_Swap_3Wire = 1; |
kevin1990 | 16:e4f2689363bb | 1601 | channelExcitationReg.IOUT_Static_Swap_3Wire = 1; |
kevin1990 | 16:e4f2689363bb | 1602 | } |
kevin1990 | 16:e4f2689363bb | 1603 | else if (pCurrentConfig->swapOption == ADI_SENSE_1000_ADC_EXC_CURRENT_SWAP_NONE) |
kevin1990 | 16:e4f2689363bb | 1604 | { |
kevin1990 | 16:e4f2689363bb | 1605 | channelExcitationReg.IOUT_Dont_Swap_3Wire = 1; |
kevin1990 | 16:e4f2689363bb | 1606 | channelExcitationReg.IOUT_Static_Swap_3Wire = 0; |
kevin1990 | 16:e4f2689363bb | 1607 | } |
kevin1990 | 16:e4f2689363bb | 1608 | else |
kevin1990 | 16:e4f2689363bb | 1609 | { |
kevin1990 | 16:e4f2689363bb | 1610 | ADI_SENSE_LOG_ERROR( |
kevin1990 | 16:e4f2689363bb | 1611 | "Invalid ADC excitation current swap option %d specified", |
kevin1990 | 16:e4f2689363bb | 1612 | pCurrentConfig->swapOption); |
kevin1990 | 16:e4f2689363bb | 1613 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 1614 | } |
kevin1990 | 16:e4f2689363bb | 1615 | } |
kevin1990 | 16:e4f2689363bb | 1616 | |
kevin1990 | 16:e4f2689363bb | 1617 | WRITE_REG_U8(hDevice, channelExcitationReg.VALUE8, CORE_CHANNEL_EXCITATIONn(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1618 | |
kevin1990 | 16:e4f2689363bb | 1619 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 1620 | } |
kevin1990 | 16:e4f2689363bb | 1621 | |
kevin1990 | 16:e4f2689363bb | 1622 | ADI_SENSE_RESULT adi_sense_SetAdcChannelConfig( |
kevin1990 | 16:e4f2689363bb | 1623 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 1624 | ADI_SENSE_1000_CHANNEL_ID eChannelId, |
kevin1990 | 16:e4f2689363bb | 1625 | ADI_SENSE_1000_CHANNEL_CONFIG *pChannelConfig) |
kevin1990 | 16:e4f2689363bb | 1626 | { |
kevin1990 | 16:e4f2689363bb | 1627 | ADI_SENSE_RESULT eRet; |
kevin1990 | 16:e4f2689363bb | 1628 | ADI_SENSE_1000_ADC_CHANNEL_CONFIG *pAdcChannelConfig = |
kevin1990 | 16:e4f2689363bb | 1629 | &pChannelConfig->adcChannelConfig; |
kevin1990 | 16:e4f2689363bb | 1630 | |
kevin1990 | 16:e4f2689363bb | 1631 | eRet = adi_sense_SetChannelAdcSensorType(hDevice, eChannelId, |
kevin1990 | 16:e4f2689363bb | 1632 | pAdcChannelConfig->sensor); |
kevin1990 | 16:e4f2689363bb | 1633 | if (eRet != ADI_SENSE_SUCCESS) |
kevin1990 | 16:e4f2689363bb | 1634 | { |
kevin1990 | 16:e4f2689363bb | 1635 | ADI_SENSE_LOG_ERROR("Failed to set ADC sensor type for channel %d", |
kevin1990 | 16:e4f2689363bb | 1636 | eChannelId); |
kevin1990 | 16:e4f2689363bb | 1637 | return eRet; |
kevin1990 | 16:e4f2689363bb | 1638 | } |
kevin1990 | 16:e4f2689363bb | 1639 | |
kevin1990 | 16:e4f2689363bb | 1640 | eRet = adi_sense_SetChannelAdcSensorDetails(hDevice, eChannelId, |
kevin1990 | 16:e4f2689363bb | 1641 | pChannelConfig); |
kevin1990 | 16:e4f2689363bb | 1642 | if (eRet != ADI_SENSE_SUCCESS) |
kevin1990 | 16:e4f2689363bb | 1643 | { |
kevin1990 | 16:e4f2689363bb | 1644 | ADI_SENSE_LOG_ERROR("Failed to set ADC sensor details for channel %d", |
kevin1990 | 16:e4f2689363bb | 1645 | eChannelId); |
kevin1990 | 16:e4f2689363bb | 1646 | return eRet; |
kevin1990 | 16:e4f2689363bb | 1647 | } |
kevin1990 | 16:e4f2689363bb | 1648 | |
kevin1990 | 16:e4f2689363bb | 1649 | eRet = adi_sense_SetChannelAdcFilter(hDevice, eChannelId, |
kevin1990 | 16:e4f2689363bb | 1650 | &pAdcChannelConfig->filter); |
kevin1990 | 16:e4f2689363bb | 1651 | if (eRet != ADI_SENSE_SUCCESS) |
kevin1990 | 16:e4f2689363bb | 1652 | { |
kevin1990 | 16:e4f2689363bb | 1653 | ADI_SENSE_LOG_ERROR("Failed to set ADC filter for channel %d", |
kevin1990 | 16:e4f2689363bb | 1654 | eChannelId); |
kevin1990 | 16:e4f2689363bb | 1655 | return eRet; |
kevin1990 | 16:e4f2689363bb | 1656 | } |
kevin1990 | 16:e4f2689363bb | 1657 | |
kevin1990 | 16:e4f2689363bb | 1658 | eRet = adi_sense_SetChannelAdcCurrentConfig(hDevice, eChannelId, |
kevin1990 | 16:e4f2689363bb | 1659 | &pAdcChannelConfig->current); |
kevin1990 | 16:e4f2689363bb | 1660 | if (eRet != ADI_SENSE_SUCCESS) |
kevin1990 | 16:e4f2689363bb | 1661 | { |
kevin1990 | 16:e4f2689363bb | 1662 | ADI_SENSE_LOG_ERROR("Failed to set ADC current for channel %d", |
kevin1990 | 16:e4f2689363bb | 1663 | eChannelId); |
kevin1990 | 16:e4f2689363bb | 1664 | return eRet; |
kevin1990 | 16:e4f2689363bb | 1665 | } |
kevin1990 | 16:e4f2689363bb | 1666 | |
kevin1990 | 16:e4f2689363bb | 1667 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 1668 | } |
kevin1990 | 16:e4f2689363bb | 1669 | |
kevin1990 | 16:e4f2689363bb | 1670 | |
kevin1990 | 16:e4f2689363bb | 1671 | static ADI_SENSE_RESULT adi_sense_SetDigitalSensorCommands( |
kevin1990 | 16:e4f2689363bb | 1672 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 1673 | ADI_SENSE_1000_CHANNEL_ID eChannelId, |
kevin1990 | 16:e4f2689363bb | 1674 | ADI_SENSE_1000_DIGITAL_SENSOR_COMMAND *pConfigCommand, |
kevin1990 | 16:e4f2689363bb | 1675 | ADI_SENSE_1000_DIGITAL_SENSOR_COMMAND *pDataRequestCommand) |
kevin1990 | 16:e4f2689363bb | 1676 | { |
kevin1990 | 16:e4f2689363bb | 1677 | ADI_ADISENSE_CORE_Digital_Sensor_Num_Cmds_t numCmdsReg; |
kevin1990 | 16:e4f2689363bb | 1678 | |
kevin1990 | 16:e4f2689363bb | 1679 | numCmdsReg.VALUE8 = REG_RESET_VAL(CORE_DIGITAL_SENSOR_NUM_CMDSn); |
kevin1990 | 16:e4f2689363bb | 1680 | |
kevin1990 | 16:e4f2689363bb | 1681 | CHECK_REG_FIELD_VAL(CORE_DIGITAL_SENSOR_NUM_CMDS_DIGITAL_SENSOR_NUM_CFG_CMDS, |
kevin1990 | 16:e4f2689363bb | 1682 | pConfigCommand->commandLength); |
kevin1990 | 16:e4f2689363bb | 1683 | CHECK_REG_FIELD_VAL(CORE_DIGITAL_SENSOR_NUM_CMDS_DIGITAL_SENSOR_NUM_READ_CMDS, |
kevin1990 | 16:e4f2689363bb | 1684 | pDataRequestCommand->commandLength); |
kevin1990 | 16:e4f2689363bb | 1685 | |
kevin1990 | 16:e4f2689363bb | 1686 | numCmdsReg.Digital_Sensor_Num_Cfg_Cmds = pConfigCommand->commandLength; |
kevin1990 | 16:e4f2689363bb | 1687 | numCmdsReg.Digital_Sensor_Num_Read_Cmds = pDataRequestCommand->commandLength; |
kevin1990 | 16:e4f2689363bb | 1688 | |
kevin1990 | 16:e4f2689363bb | 1689 | WRITE_REG_U8(hDevice, numCmdsReg.VALUE8, |
kevin1990 | 16:e4f2689363bb | 1690 | CORE_DIGITAL_SENSOR_NUM_CMDSn(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1691 | |
kevin1990 | 16:e4f2689363bb | 1692 | switch (pConfigCommand->commandLength) |
kevin1990 | 16:e4f2689363bb | 1693 | { |
kevin1990 | 16:e4f2689363bb | 1694 | /* NOTE - intentional fall-through cases below */ |
kevin1990 | 16:e4f2689363bb | 1695 | case 7: |
kevin1990 | 16:e4f2689363bb | 1696 | WRITE_REG_U8(hDevice, pConfigCommand->command[6], |
kevin1990 | 16:e4f2689363bb | 1697 | CORE_DIGITAL_SENSOR_COMMAND7n(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1698 | case 6: |
kevin1990 | 16:e4f2689363bb | 1699 | WRITE_REG_U8(hDevice, pConfigCommand->command[5], |
kevin1990 | 16:e4f2689363bb | 1700 | CORE_DIGITAL_SENSOR_COMMAND6n(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1701 | case 5: |
kevin1990 | 16:e4f2689363bb | 1702 | WRITE_REG_U8(hDevice, pConfigCommand->command[4], |
kevin1990 | 16:e4f2689363bb | 1703 | CORE_DIGITAL_SENSOR_COMMAND5n(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1704 | case 4: |
kevin1990 | 16:e4f2689363bb | 1705 | WRITE_REG_U8(hDevice, pConfigCommand->command[3], |
kevin1990 | 16:e4f2689363bb | 1706 | CORE_DIGITAL_SENSOR_COMMAND4n(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1707 | case 3: |
kevin1990 | 16:e4f2689363bb | 1708 | WRITE_REG_U8(hDevice, pConfigCommand->command[2], |
kevin1990 | 16:e4f2689363bb | 1709 | CORE_DIGITAL_SENSOR_COMMAND3n(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1710 | case 2: |
kevin1990 | 16:e4f2689363bb | 1711 | WRITE_REG_U8(hDevice, pConfigCommand->command[1], |
kevin1990 | 16:e4f2689363bb | 1712 | CORE_DIGITAL_SENSOR_COMMAND2n(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1713 | case 1: |
kevin1990 | 16:e4f2689363bb | 1714 | WRITE_REG_U8(hDevice, pConfigCommand->command[0], |
kevin1990 | 16:e4f2689363bb | 1715 | CORE_DIGITAL_SENSOR_COMMAND1n(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1716 | case 0: |
kevin1990 | 16:e4f2689363bb | 1717 | default: |
kevin1990 | 16:e4f2689363bb | 1718 | break; |
kevin1990 | 16:e4f2689363bb | 1719 | }; |
kevin1990 | 16:e4f2689363bb | 1720 | |
kevin1990 | 16:e4f2689363bb | 1721 | switch (pDataRequestCommand->commandLength) |
kevin1990 | 16:e4f2689363bb | 1722 | { |
kevin1990 | 16:e4f2689363bb | 1723 | /* NOTE - intentional fall-through cases below */ |
kevin1990 | 16:e4f2689363bb | 1724 | case 7: |
kevin1990 | 16:e4f2689363bb | 1725 | WRITE_REG_U8(hDevice, pDataRequestCommand->command[6], |
kevin1990 | 16:e4f2689363bb | 1726 | CORE_DIGITAL_SENSOR_READ_CMD7n(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1727 | case 6: |
kevin1990 | 16:e4f2689363bb | 1728 | WRITE_REG_U8(hDevice, pDataRequestCommand->command[5], |
kevin1990 | 16:e4f2689363bb | 1729 | CORE_DIGITAL_SENSOR_READ_CMD6n(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1730 | case 5: |
kevin1990 | 16:e4f2689363bb | 1731 | WRITE_REG_U8(hDevice, pDataRequestCommand->command[4], |
kevin1990 | 16:e4f2689363bb | 1732 | CORE_DIGITAL_SENSOR_READ_CMD5n(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1733 | case 4: |
kevin1990 | 16:e4f2689363bb | 1734 | WRITE_REG_U8(hDevice, pDataRequestCommand->command[3], |
kevin1990 | 16:e4f2689363bb | 1735 | CORE_DIGITAL_SENSOR_READ_CMD4n(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1736 | case 3: |
kevin1990 | 16:e4f2689363bb | 1737 | WRITE_REG_U8(hDevice, pDataRequestCommand->command[2], |
kevin1990 | 16:e4f2689363bb | 1738 | CORE_DIGITAL_SENSOR_READ_CMD3n(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1739 | case 2: |
kevin1990 | 16:e4f2689363bb | 1740 | WRITE_REG_U8(hDevice, pDataRequestCommand->command[1], |
kevin1990 | 16:e4f2689363bb | 1741 | CORE_DIGITAL_SENSOR_READ_CMD2n(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1742 | case 1: |
kevin1990 | 16:e4f2689363bb | 1743 | WRITE_REG_U8(hDevice, pDataRequestCommand->command[0], |
kevin1990 | 16:e4f2689363bb | 1744 | CORE_DIGITAL_SENSOR_READ_CMD1n(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1745 | case 0: |
kevin1990 | 16:e4f2689363bb | 1746 | default: |
kevin1990 | 16:e4f2689363bb | 1747 | break; |
kevin1990 | 16:e4f2689363bb | 1748 | }; |
kevin1990 | 16:e4f2689363bb | 1749 | |
kevin1990 | 16:e4f2689363bb | 1750 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 1751 | } |
kevin1990 | 16:e4f2689363bb | 1752 | |
kevin1990 | 16:e4f2689363bb | 1753 | static ADI_SENSE_RESULT adi_sense_SetChannelI2cSensorType( |
kevin1990 | 16:e4f2689363bb | 1754 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 1755 | ADI_SENSE_1000_CHANNEL_ID eChannelId, |
kevin1990 | 16:e4f2689363bb | 1756 | ADI_SENSE_1000_I2C_SENSOR_TYPE sensorType) |
kevin1990 | 16:e4f2689363bb | 1757 | { |
kevin1990 | 16:e4f2689363bb | 1758 | ADI_ADISENSE_CORE_Sensor_Type_t sensorTypeReg; |
kevin1990 | 16:e4f2689363bb | 1759 | |
kevin1990 | 16:e4f2689363bb | 1760 | sensorTypeReg.VALUE16 = REG_RESET_VAL(CORE_SENSOR_TYPEn); |
kevin1990 | 16:e4f2689363bb | 1761 | |
kevin1990 | 16:e4f2689363bb | 1762 | /* Ensure that the sensor type is valid for this channel */ |
kevin1990 | 16:e4f2689363bb | 1763 | switch(sensorType) |
kevin1990 | 16:e4f2689363bb | 1764 | { |
kevin1990 | 16:e4f2689363bb | 1765 | case ADI_SENSE_1000_I2C_SENSOR_HUMIDITY_HONEYWELL_HUMIDICON: |
kevin1990 | 16:e4f2689363bb | 1766 | sensorTypeReg.Sensor_Type = ADISENSE_CORE_SENSOR_TYPE_SENSOR_I2C_HUMIDITY_HONEYWELL_HUMIDICON; |
kevin1990 | 16:e4f2689363bb | 1767 | break; |
kevin1990 | 16:e4f2689363bb | 1768 | case ADI_SENSE_1000_I2C_SENSOR_HUMIDITY_SENSIRION_SHT3X: |
kevin1990 | 16:e4f2689363bb | 1769 | sensorTypeReg.Sensor_Type = ADISENSE_CORE_SENSOR_TYPE_SENSOR_I2C_HUMIDITY_SENSIRION_SHT3X; |
kevin1990 | 16:e4f2689363bb | 1770 | break; |
kevin1990 | 16:e4f2689363bb | 1771 | default: |
kevin1990 | 16:e4f2689363bb | 1772 | /* TODO - add support for custom I2C sensors */ |
kevin1990 | 16:e4f2689363bb | 1773 | ADI_SENSE_LOG_ERROR("Unsupported I2C sensor type %d specified", sensorType); |
kevin1990 | 16:e4f2689363bb | 1774 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 1775 | } |
kevin1990 | 16:e4f2689363bb | 1776 | |
kevin1990 | 16:e4f2689363bb | 1777 | WRITE_REG_U16(hDevice, sensorTypeReg.VALUE16, CORE_SENSOR_TYPEn(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1778 | |
kevin1990 | 16:e4f2689363bb | 1779 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 1780 | } |
kevin1990 | 16:e4f2689363bb | 1781 | |
kevin1990 | 16:e4f2689363bb | 1782 | static ADI_SENSE_RESULT adi_sense_SetChannelI2cSensorAddress( |
kevin1990 | 16:e4f2689363bb | 1783 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 1784 | ADI_SENSE_1000_CHANNEL_ID eChannelId, |
kevin1990 | 16:e4f2689363bb | 1785 | uint32_t deviceAddress) |
kevin1990 | 16:e4f2689363bb | 1786 | { |
kevin1990 | 16:e4f2689363bb | 1787 | CHECK_REG_FIELD_VAL(CORE_DIGITAL_SENSOR_ADDRESS_DIGITAL_SENSOR_ADDRESS, deviceAddress); |
kevin1990 | 16:e4f2689363bb | 1788 | WRITE_REG_U8(hDevice, deviceAddress, CORE_DIGITAL_SENSOR_ADDRESSn(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1789 | |
kevin1990 | 16:e4f2689363bb | 1790 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 1791 | } |
kevin1990 | 16:e4f2689363bb | 1792 | |
kevin1990 | 16:e4f2689363bb | 1793 | ADI_SENSE_RESULT adi_sense_SetI2cChannelConfig( |
kevin1990 | 16:e4f2689363bb | 1794 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 1795 | ADI_SENSE_1000_CHANNEL_ID eChannelId, |
kevin1990 | 16:e4f2689363bb | 1796 | ADI_SENSE_1000_I2C_CHANNEL_CONFIG *pI2cChannelConfig) |
kevin1990 | 16:e4f2689363bb | 1797 | { |
kevin1990 | 16:e4f2689363bb | 1798 | ADI_SENSE_RESULT eRet; |
kevin1990 | 16:e4f2689363bb | 1799 | |
kevin1990 | 16:e4f2689363bb | 1800 | eRet = adi_sense_SetChannelI2cSensorType(hDevice, eChannelId, |
kevin1990 | 16:e4f2689363bb | 1801 | pI2cChannelConfig->sensor); |
kevin1990 | 16:e4f2689363bb | 1802 | if (eRet != ADI_SENSE_SUCCESS) |
kevin1990 | 16:e4f2689363bb | 1803 | { |
kevin1990 | 16:e4f2689363bb | 1804 | ADI_SENSE_LOG_ERROR("Failed to set I2C sensor type for channel %d", |
kevin1990 | 16:e4f2689363bb | 1805 | eChannelId); |
kevin1990 | 16:e4f2689363bb | 1806 | return eRet; |
kevin1990 | 16:e4f2689363bb | 1807 | } |
kevin1990 | 16:e4f2689363bb | 1808 | |
kevin1990 | 16:e4f2689363bb | 1809 | eRet = adi_sense_SetChannelI2cSensorAddress(hDevice, eChannelId, |
kevin1990 | 16:e4f2689363bb | 1810 | pI2cChannelConfig->deviceAddress); |
kevin1990 | 16:e4f2689363bb | 1811 | if (eRet != ADI_SENSE_SUCCESS) |
kevin1990 | 16:e4f2689363bb | 1812 | { |
kevin1990 | 16:e4f2689363bb | 1813 | ADI_SENSE_LOG_ERROR("Failed to set I2C sensor address for channel %d", |
kevin1990 | 16:e4f2689363bb | 1814 | eChannelId); |
kevin1990 | 16:e4f2689363bb | 1815 | return eRet; |
kevin1990 | 16:e4f2689363bb | 1816 | } |
kevin1990 | 16:e4f2689363bb | 1817 | |
kevin1990 | 16:e4f2689363bb | 1818 | eRet = adi_sense_SetDigitalSensorCommands(hDevice, eChannelId, |
kevin1990 | 16:e4f2689363bb | 1819 | &pI2cChannelConfig->configurationCommand, |
kevin1990 | 16:e4f2689363bb | 1820 | &pI2cChannelConfig->dataRequestCommand); |
kevin1990 | 16:e4f2689363bb | 1821 | if (eRet != ADI_SENSE_SUCCESS) |
kevin1990 | 16:e4f2689363bb | 1822 | { |
kevin1990 | 16:e4f2689363bb | 1823 | ADI_SENSE_LOG_ERROR("Failed to set I2C sensor commands for channel %d", |
kevin1990 | 16:e4f2689363bb | 1824 | eChannelId); |
kevin1990 | 16:e4f2689363bb | 1825 | return eRet; |
kevin1990 | 16:e4f2689363bb | 1826 | } |
kevin1990 | 16:e4f2689363bb | 1827 | |
kevin1990 | 16:e4f2689363bb | 1828 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 1829 | } |
kevin1990 | 16:e4f2689363bb | 1830 | |
kevin1990 | 16:e4f2689363bb | 1831 | static ADI_SENSE_RESULT adi_sense_SetChannelSpiSensorType( |
kevin1990 | 16:e4f2689363bb | 1832 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 1833 | ADI_SENSE_1000_CHANNEL_ID eChannelId, |
kevin1990 | 16:e4f2689363bb | 1834 | ADI_SENSE_1000_SPI_SENSOR_TYPE sensorType) |
kevin1990 | 16:e4f2689363bb | 1835 | { |
kevin1990 | 16:e4f2689363bb | 1836 | ADI_ADISENSE_CORE_Sensor_Type_t sensorTypeReg; |
kevin1990 | 16:e4f2689363bb | 1837 | |
kevin1990 | 16:e4f2689363bb | 1838 | sensorTypeReg.VALUE16 = REG_RESET_VAL(CORE_SENSOR_TYPEn); |
kevin1990 | 16:e4f2689363bb | 1839 | |
kevin1990 | 16:e4f2689363bb | 1840 | /* Ensure that the sensor type is valid for this channel */ |
kevin1990 | 16:e4f2689363bb | 1841 | switch(sensorType) |
kevin1990 | 16:e4f2689363bb | 1842 | { |
kevin1990 | 16:e4f2689363bb | 1843 | case ADI_SENSE_1000_SPI_SENSOR_PRESSURE_HONEYWELL_TRUSTABILITY: |
kevin1990 | 16:e4f2689363bb | 1844 | sensorTypeReg.Sensor_Type = ADISENSE_CORE_SENSOR_TYPE_SENSOR_SPI_PRESSURE_HONEYWELL_TRUSTABILITY; |
kevin1990 | 16:e4f2689363bb | 1845 | break; |
kevin1990 | 16:e4f2689363bb | 1846 | case ADI_SENSE_1000_SPI_SENSOR_ACCELEROMETER_ADI_ADXL362: |
kevin1990 | 16:e4f2689363bb | 1847 | sensorTypeReg.Sensor_Type = ADISENSE_CORE_SENSOR_TYPE_SENSOR_SPI_ACCELEROMETER_1; |
kevin1990 | 16:e4f2689363bb | 1848 | break; |
kevin1990 | 16:e4f2689363bb | 1849 | default: |
kevin1990 | 16:e4f2689363bb | 1850 | /* TODO - add support for custom SPI sensors */ |
kevin1990 | 16:e4f2689363bb | 1851 | ADI_SENSE_LOG_ERROR("Unsupported SPI sensor type %d specified", sensorType); |
kevin1990 | 16:e4f2689363bb | 1852 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 1853 | } |
kevin1990 | 16:e4f2689363bb | 1854 | |
kevin1990 | 16:e4f2689363bb | 1855 | WRITE_REG_U16(hDevice, sensorTypeReg.VALUE16, CORE_SENSOR_TYPEn(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1856 | |
kevin1990 | 16:e4f2689363bb | 1857 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 1858 | } |
kevin1990 | 16:e4f2689363bb | 1859 | |
kevin1990 | 16:e4f2689363bb | 1860 | ADI_SENSE_RESULT adi_sense_SetSpiChannelConfig( |
kevin1990 | 16:e4f2689363bb | 1861 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 1862 | ADI_SENSE_1000_CHANNEL_ID eChannelId, |
kevin1990 | 16:e4f2689363bb | 1863 | ADI_SENSE_1000_SPI_CHANNEL_CONFIG *pSpiChannelConfig) |
kevin1990 | 16:e4f2689363bb | 1864 | { |
kevin1990 | 16:e4f2689363bb | 1865 | ADI_SENSE_RESULT eRet; |
kevin1990 | 16:e4f2689363bb | 1866 | |
kevin1990 | 16:e4f2689363bb | 1867 | eRet = adi_sense_SetChannelSpiSensorType(hDevice, eChannelId, |
kevin1990 | 16:e4f2689363bb | 1868 | pSpiChannelConfig->sensor); |
kevin1990 | 16:e4f2689363bb | 1869 | if (eRet != ADI_SENSE_SUCCESS) |
kevin1990 | 16:e4f2689363bb | 1870 | { |
kevin1990 | 16:e4f2689363bb | 1871 | ADI_SENSE_LOG_ERROR("Failed to set SPI sensor type for channel %d", |
kevin1990 | 16:e4f2689363bb | 1872 | eChannelId); |
kevin1990 | 16:e4f2689363bb | 1873 | return eRet; |
kevin1990 | 16:e4f2689363bb | 1874 | } |
kevin1990 | 16:e4f2689363bb | 1875 | |
kevin1990 | 16:e4f2689363bb | 1876 | eRet = adi_sense_SetDigitalSensorCommands(hDevice, eChannelId, |
kevin1990 | 16:e4f2689363bb | 1877 | &pSpiChannelConfig->configurationCommand, |
kevin1990 | 16:e4f2689363bb | 1878 | &pSpiChannelConfig->dataRequestCommand); |
kevin1990 | 16:e4f2689363bb | 1879 | if (eRet != ADI_SENSE_SUCCESS) |
kevin1990 | 16:e4f2689363bb | 1880 | { |
kevin1990 | 16:e4f2689363bb | 1881 | ADI_SENSE_LOG_ERROR("Failed to set SPI sensor commands for channel %d", |
kevin1990 | 16:e4f2689363bb | 1882 | eChannelId); |
kevin1990 | 16:e4f2689363bb | 1883 | return eRet; |
kevin1990 | 16:e4f2689363bb | 1884 | } |
kevin1990 | 16:e4f2689363bb | 1885 | |
kevin1990 | 16:e4f2689363bb | 1886 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 1887 | } |
kevin1990 | 16:e4f2689363bb | 1888 | |
kevin1990 | 16:e4f2689363bb | 1889 | ADI_SENSE_RESULT adi_sense_1000_SetChannelThresholdLimits( |
kevin1990 | 16:e4f2689363bb | 1890 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 1891 | ADI_SENSE_1000_CHANNEL_ID eChannelId, |
kevin1990 | 16:e4f2689363bb | 1892 | float32_t fHighThresholdLimit, |
kevin1990 | 16:e4f2689363bb | 1893 | float32_t fLowThresholdLimit) |
kevin1990 | 16:e4f2689363bb | 1894 | { |
kevin1990 | 16:e4f2689363bb | 1895 | /* |
kevin1990 | 16:e4f2689363bb | 1896 | * If the low/high limits are *both* set to 0 in memory, or NaNs, assume |
kevin1990 | 16:e4f2689363bb | 1897 | * that they are unset, or not required, and use infinity defaults instead |
kevin1990 | 16:e4f2689363bb | 1898 | */ |
kevin1990 | 16:e4f2689363bb | 1899 | if (fHighThresholdLimit == 0.0 && fLowThresholdLimit == 0.0) |
kevin1990 | 16:e4f2689363bb | 1900 | { |
kevin1990 | 16:e4f2689363bb | 1901 | fHighThresholdLimit = INFINITY; |
kevin1990 | 16:e4f2689363bb | 1902 | fLowThresholdLimit = -INFINITY; |
kevin1990 | 16:e4f2689363bb | 1903 | } |
kevin1990 | 16:e4f2689363bb | 1904 | else |
kevin1990 | 16:e4f2689363bb | 1905 | { |
kevin1990 | 16:e4f2689363bb | 1906 | if (isnan(fHighThresholdLimit)) |
kevin1990 | 16:e4f2689363bb | 1907 | fHighThresholdLimit = INFINITY; |
kevin1990 | 16:e4f2689363bb | 1908 | if (isnan(fLowThresholdLimit)) |
kevin1990 | 16:e4f2689363bb | 1909 | fLowThresholdLimit = -INFINITY; |
kevin1990 | 16:e4f2689363bb | 1910 | } |
kevin1990 | 16:e4f2689363bb | 1911 | |
kevin1990 | 16:e4f2689363bb | 1912 | WRITE_REG_FLOAT(hDevice, fHighThresholdLimit, |
kevin1990 | 16:e4f2689363bb | 1913 | CORE_HIGH_THRESHOLD_LIMITn(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1914 | WRITE_REG_FLOAT(hDevice, fLowThresholdLimit, |
kevin1990 | 16:e4f2689363bb | 1915 | CORE_LOW_THRESHOLD_LIMITn(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1916 | |
kevin1990 | 16:e4f2689363bb | 1917 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 1918 | } |
kevin1990 | 16:e4f2689363bb | 1919 | |
kevin1990 | 16:e4f2689363bb | 1920 | ADI_SENSE_RESULT adi_sense_1000_SetOffsetGain( |
kevin1990 | 16:e4f2689363bb | 1921 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 1922 | ADI_SENSE_1000_CHANNEL_ID eChannelId, |
kevin1990 | 16:e4f2689363bb | 1923 | float32_t fOffsetAdjustment, |
kevin1990 | 16:e4f2689363bb | 1924 | float32_t fGainAdjustment) |
kevin1990 | 16:e4f2689363bb | 1925 | { |
kevin1990 | 16:e4f2689363bb | 1926 | /* Replace with default values if NaNs are specified (or 0.0 for gain) */ |
kevin1990 | 16:e4f2689363bb | 1927 | if (isnan(fGainAdjustment) || (fGainAdjustment == 0.0)) |
kevin1990 | 16:e4f2689363bb | 1928 | fGainAdjustment = 1.0; |
kevin1990 | 16:e4f2689363bb | 1929 | if (isnan(fOffsetAdjustment)) |
kevin1990 | 16:e4f2689363bb | 1930 | fOffsetAdjustment = 0.0; |
kevin1990 | 16:e4f2689363bb | 1931 | |
kevin1990 | 16:e4f2689363bb | 1932 | WRITE_REG_FLOAT(hDevice, fGainAdjustment, CORE_SENSOR_GAINn(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1933 | WRITE_REG_FLOAT(hDevice, fOffsetAdjustment, CORE_SENSOR_OFFSETn(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1934 | |
kevin1990 | 16:e4f2689363bb | 1935 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 1936 | } |
kevin1990 | 16:e4f2689363bb | 1937 | |
kevin1990 | 16:e4f2689363bb | 1938 | ADI_SENSE_RESULT adi_sense_1000_SetChannelSettlingTime( |
kevin1990 | 16:e4f2689363bb | 1939 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 1940 | ADI_SENSE_1000_CHANNEL_ID eChannelId, |
kevin1990 | 16:e4f2689363bb | 1941 | uint32_t nSettlingTime) |
kevin1990 | 16:e4f2689363bb | 1942 | { |
kevin1990 | 16:e4f2689363bb | 1943 | CHECK_REG_FIELD_VAL(CORE_SETTLING_TIME_SETTLING_TIME, nSettlingTime); |
kevin1990 | 16:e4f2689363bb | 1944 | |
kevin1990 | 16:e4f2689363bb | 1945 | WRITE_REG_U16(hDevice, nSettlingTime, CORE_SETTLING_TIMEn(eChannelId)); |
kevin1990 | 16:e4f2689363bb | 1946 | |
kevin1990 | 16:e4f2689363bb | 1947 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 1948 | } |
kevin1990 | 16:e4f2689363bb | 1949 | |
kevin1990 | 16:e4f2689363bb | 1950 | ADI_SENSE_RESULT adi_sense_1000_SetChannelConfig( |
kevin1990 | 16:e4f2689363bb | 1951 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 1952 | ADI_SENSE_1000_CHANNEL_ID eChannelId, |
kevin1990 | 16:e4f2689363bb | 1953 | ADI_SENSE_1000_CHANNEL_CONFIG *pChannelConfig) |
kevin1990 | 16:e4f2689363bb | 1954 | { |
kevin1990 | 16:e4f2689363bb | 1955 | ADI_SENSE_RESULT eRet; |
kevin1990 | 16:e4f2689363bb | 1956 | |
kevin1990 | 16:e4f2689363bb | 1957 | if (! ADI_SENSE_1000_CHANNEL_IS_VIRTUAL(eChannelId)) |
kevin1990 | 16:e4f2689363bb | 1958 | { |
kevin1990 | 16:e4f2689363bb | 1959 | /* If the channel is not enabled, disable it and return */ |
kevin1990 | 16:e4f2689363bb | 1960 | if (! pChannelConfig->enableChannel) |
kevin1990 | 16:e4f2689363bb | 1961 | return adi_sense_1000_SetChannelCount(hDevice, eChannelId, 0); |
kevin1990 | 16:e4f2689363bb | 1962 | |
kevin1990 | 16:e4f2689363bb | 1963 | eRet = adi_sense_1000_SetChannelCount(hDevice, eChannelId, |
kevin1990 | 16:e4f2689363bb | 1964 | pChannelConfig->measurementsPerCycle); |
kevin1990 | 16:e4f2689363bb | 1965 | if (eRet != ADI_SENSE_SUCCESS) |
kevin1990 | 16:e4f2689363bb | 1966 | { |
kevin1990 | 16:e4f2689363bb | 1967 | ADI_SENSE_LOG_ERROR("Failed to set measurement count for channel %d", |
kevin1990 | 16:e4f2689363bb | 1968 | eChannelId); |
kevin1990 | 16:e4f2689363bb | 1969 | return eRet; |
kevin1990 | 16:e4f2689363bb | 1970 | } |
kevin1990 | 16:e4f2689363bb | 1971 | |
kevin1990 | 16:e4f2689363bb | 1972 | switch (eChannelId) |
kevin1990 | 16:e4f2689363bb | 1973 | { |
kevin1990 | 16:e4f2689363bb | 1974 | case ADI_SENSE_1000_CHANNEL_ID_CJC_0: |
kevin1990 | 16:e4f2689363bb | 1975 | case ADI_SENSE_1000_CHANNEL_ID_CJC_1: |
kevin1990 | 16:e4f2689363bb | 1976 | case ADI_SENSE_1000_CHANNEL_ID_SENSOR_0: |
kevin1990 | 16:e4f2689363bb | 1977 | case ADI_SENSE_1000_CHANNEL_ID_SENSOR_1: |
kevin1990 | 16:e4f2689363bb | 1978 | case ADI_SENSE_1000_CHANNEL_ID_SENSOR_2: |
kevin1990 | 16:e4f2689363bb | 1979 | case ADI_SENSE_1000_CHANNEL_ID_SENSOR_3: |
kevin1990 | 16:e4f2689363bb | 1980 | case ADI_SENSE_1000_CHANNEL_ID_VOLTAGE_0: |
kevin1990 | 16:e4f2689363bb | 1981 | case ADI_SENSE_1000_CHANNEL_ID_CURRENT_0: |
kevin1990 | 16:e4f2689363bb | 1982 | eRet = adi_sense_SetAdcChannelConfig(hDevice, eChannelId, pChannelConfig); |
kevin1990 | 16:e4f2689363bb | 1983 | break; |
kevin1990 | 16:e4f2689363bb | 1984 | case ADI_SENSE_1000_CHANNEL_ID_I2C_0: |
kevin1990 | 16:e4f2689363bb | 1985 | case ADI_SENSE_1000_CHANNEL_ID_I2C_1: |
kevin1990 | 16:e4f2689363bb | 1986 | eRet = adi_sense_SetI2cChannelConfig(hDevice, eChannelId, |
kevin1990 | 16:e4f2689363bb | 1987 | &pChannelConfig->i2cChannelConfig); |
kevin1990 | 16:e4f2689363bb | 1988 | break; |
kevin1990 | 16:e4f2689363bb | 1989 | case ADI_SENSE_1000_CHANNEL_ID_SPI_0: |
kevin1990 | 16:e4f2689363bb | 1990 | eRet = adi_sense_SetSpiChannelConfig(hDevice, eChannelId, |
kevin1990 | 16:e4f2689363bb | 1991 | &pChannelConfig->spiChannelConfig); |
kevin1990 | 16:e4f2689363bb | 1992 | break; |
kevin1990 | 16:e4f2689363bb | 1993 | default: |
kevin1990 | 16:e4f2689363bb | 1994 | ADI_SENSE_LOG_ERROR("Invalid channel ID %d specified", eChannelId); |
kevin1990 | 16:e4f2689363bb | 1995 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 1996 | } |
kevin1990 | 16:e4f2689363bb | 1997 | |
kevin1990 | 16:e4f2689363bb | 1998 | eRet = adi_sense_1000_SetChannelSettlingTime(hDevice, eChannelId, |
kevin1990 | 16:e4f2689363bb | 1999 | pChannelConfig->extraSettlingTime); |
kevin1990 | 16:e4f2689363bb | 2000 | if (eRet != ADI_SENSE_SUCCESS) |
kevin1990 | 16:e4f2689363bb | 2001 | { |
kevin1990 | 16:e4f2689363bb | 2002 | ADI_SENSE_LOG_ERROR("Failed to set settling time for channel %d", |
kevin1990 | 16:e4f2689363bb | 2003 | eChannelId); |
kevin1990 | 16:e4f2689363bb | 2004 | return eRet; |
kevin1990 | 16:e4f2689363bb | 2005 | } |
kevin1990 | 16:e4f2689363bb | 2006 | } |
kevin1990 | 16:e4f2689363bb | 2007 | |
kevin1990 | 16:e4f2689363bb | 2008 | if (pChannelConfig->enableChannel) |
kevin1990 | 16:e4f2689363bb | 2009 | { |
kevin1990 | 16:e4f2689363bb | 2010 | /* Threshold limits can be configured individually for virtual channels */ |
kevin1990 | 16:e4f2689363bb | 2011 | eRet = adi_sense_1000_SetChannelThresholdLimits(hDevice, eChannelId, |
kevin1990 | 16:e4f2689363bb | 2012 | pChannelConfig->highThreshold, |
kevin1990 | 16:e4f2689363bb | 2013 | pChannelConfig->lowThreshold); |
kevin1990 | 16:e4f2689363bb | 2014 | if (eRet != ADI_SENSE_SUCCESS) |
kevin1990 | 16:e4f2689363bb | 2015 | { |
kevin1990 | 16:e4f2689363bb | 2016 | ADI_SENSE_LOG_ERROR("Failed to set threshold limits for channel %d", |
kevin1990 | 16:e4f2689363bb | 2017 | eChannelId); |
kevin1990 | 16:e4f2689363bb | 2018 | return eRet; |
kevin1990 | 16:e4f2689363bb | 2019 | } |
kevin1990 | 16:e4f2689363bb | 2020 | |
kevin1990 | 16:e4f2689363bb | 2021 | /* Offset and gain can be configured individually for virtual channels */ |
kevin1990 | 16:e4f2689363bb | 2022 | eRet = adi_sense_1000_SetOffsetGain(hDevice, eChannelId, |
kevin1990 | 16:e4f2689363bb | 2023 | pChannelConfig->offsetAdjustment, |
kevin1990 | 16:e4f2689363bb | 2024 | pChannelConfig->gainAdjustment); |
kevin1990 | 16:e4f2689363bb | 2025 | if (eRet != ADI_SENSE_SUCCESS) |
kevin1990 | 16:e4f2689363bb | 2026 | { |
kevin1990 | 16:e4f2689363bb | 2027 | ADI_SENSE_LOG_ERROR("Failed to set offset/gain for channel %d", |
kevin1990 | 16:e4f2689363bb | 2028 | eChannelId); |
kevin1990 | 16:e4f2689363bb | 2029 | return eRet; |
kevin1990 | 16:e4f2689363bb | 2030 | } |
kevin1990 | 16:e4f2689363bb | 2031 | } |
kevin1990 | 16:e4f2689363bb | 2032 | |
kevin1990 | 16:e4f2689363bb | 2033 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 2034 | } |
kevin1990 | 16:e4f2689363bb | 2035 | |
kevin1990 | 16:e4f2689363bb | 2036 | ADI_SENSE_RESULT adi_sense_SetConfig( |
kevin1990 | 16:e4f2689363bb | 2037 | ADI_SENSE_DEVICE_HANDLE const hDevice, |
kevin1990 | 16:e4f2689363bb | 2038 | ADI_SENSE_CONFIG * const pConfig) |
kevin1990 | 16:e4f2689363bb | 2039 | { |
kevin1990 | 16:e4f2689363bb | 2040 | ADI_SENSE_1000_CONFIG *pDeviceConfig; |
kevin1990 | 16:e4f2689363bb | 2041 | ADI_SENSE_PRODUCT_ID productId; |
kevin1990 | 16:e4f2689363bb | 2042 | ADI_SENSE_RESULT eRet; |
kevin1990 | 16:e4f2689363bb | 2043 | |
kevin1990 | 16:e4f2689363bb | 2044 | if (pConfig->productId != ADI_SENSE_PRODUCT_ID_1000) |
kevin1990 | 16:e4f2689363bb | 2045 | { |
kevin1990 | 16:e4f2689363bb | 2046 | ADI_SENSE_LOG_ERROR("Configuration Product ID (0x%X) is not supported (0x%0X)", |
kevin1990 | 16:e4f2689363bb | 2047 | pConfig->productId, ADI_SENSE_PRODUCT_ID_1000); |
kevin1990 | 16:e4f2689363bb | 2048 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 2049 | } |
kevin1990 | 16:e4f2689363bb | 2050 | |
kevin1990 | 16:e4f2689363bb | 2051 | /* Check that the actual Product ID is a match? */ |
kevin1990 | 16:e4f2689363bb | 2052 | eRet = adi_sense_GetProductID(hDevice, &productId); |
kevin1990 | 16:e4f2689363bb | 2053 | if (eRet) |
kevin1990 | 16:e4f2689363bb | 2054 | { |
kevin1990 | 16:e4f2689363bb | 2055 | ADI_SENSE_LOG_ERROR("Failed to read device Product ID register"); |
kevin1990 | 16:e4f2689363bb | 2056 | return eRet; |
kevin1990 | 16:e4f2689363bb | 2057 | } |
kevin1990 | 16:e4f2689363bb | 2058 | if (pConfig->productId != productId) |
kevin1990 | 16:e4f2689363bb | 2059 | { |
kevin1990 | 16:e4f2689363bb | 2060 | ADI_SENSE_LOG_ERROR("Configuration Product ID (0x%X) does not match device (0x%0X)", |
kevin1990 | 16:e4f2689363bb | 2061 | pConfig->productId, productId); |
kevin1990 | 16:e4f2689363bb | 2062 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 2063 | } |
kevin1990 | 16:e4f2689363bb | 2064 | |
kevin1990 | 16:e4f2689363bb | 2065 | pDeviceConfig = &pConfig->adisense1000; |
kevin1990 | 16:e4f2689363bb | 2066 | |
kevin1990 | 16:e4f2689363bb | 2067 | eRet = adi_sense_1000_SetPowerConfig(hDevice, &pDeviceConfig->power); |
kevin1990 | 16:e4f2689363bb | 2068 | if (eRet) |
kevin1990 | 16:e4f2689363bb | 2069 | { |
kevin1990 | 16:e4f2689363bb | 2070 | ADI_SENSE_LOG_ERROR("Failed to set power configuration"); |
kevin1990 | 16:e4f2689363bb | 2071 | return eRet; |
kevin1990 | 16:e4f2689363bb | 2072 | } |
kevin1990 | 16:e4f2689363bb | 2073 | |
kevin1990 | 16:e4f2689363bb | 2074 | eRet = adi_sense_1000_SetMeasurementConfig(hDevice, &pDeviceConfig->measurement); |
kevin1990 | 16:e4f2689363bb | 2075 | if (eRet) |
kevin1990 | 16:e4f2689363bb | 2076 | { |
kevin1990 | 16:e4f2689363bb | 2077 | ADI_SENSE_LOG_ERROR("Failed to set measurement configuration"); |
kevin1990 | 16:e4f2689363bb | 2078 | return eRet; |
kevin1990 | 16:e4f2689363bb | 2079 | } |
kevin1990 | 16:e4f2689363bb | 2080 | |
kevin1990 | 16:e4f2689363bb | 2081 | eRet = adi_sense_1000_SetDiagnosticsConfig(hDevice, &pDeviceConfig->diagnostics); |
kevin1990 | 16:e4f2689363bb | 2082 | if (eRet) |
kevin1990 | 16:e4f2689363bb | 2083 | { |
kevin1990 | 16:e4f2689363bb | 2084 | ADI_SENSE_LOG_ERROR("Failed to set diagnostics configuration"); |
kevin1990 | 16:e4f2689363bb | 2085 | return eRet; |
kevin1990 | 16:e4f2689363bb | 2086 | } |
kevin1990 | 16:e4f2689363bb | 2087 | |
kevin1990 | 16:e4f2689363bb | 2088 | for (ADI_SENSE_1000_CHANNEL_ID id = 0; id < ADI_SENSE_1000_MAX_CHANNELS; id++) |
kevin1990 | 16:e4f2689363bb | 2089 | { |
kevin1990 | 16:e4f2689363bb | 2090 | eRet = adi_sense_1000_SetChannelConfig(hDevice, id, |
kevin1990 | 16:e4f2689363bb | 2091 | &pDeviceConfig->channels[id]); |
kevin1990 | 16:e4f2689363bb | 2092 | if (eRet) |
kevin1990 | 16:e4f2689363bb | 2093 | { |
kevin1990 | 16:e4f2689363bb | 2094 | ADI_SENSE_LOG_ERROR("Failed to set channel %d configuration", id); |
kevin1990 | 16:e4f2689363bb | 2095 | return eRet; |
kevin1990 | 16:e4f2689363bb | 2096 | } |
kevin1990 | 16:e4f2689363bb | 2097 | } |
kevin1990 | 16:e4f2689363bb | 2098 | |
kevin1990 | 16:e4f2689363bb | 2099 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 2100 | } |
kevin1990 | 16:e4f2689363bb | 2101 | |
kevin1990 | 16:e4f2689363bb | 2102 | ADI_SENSE_RESULT adi_sense_1000_SetLutData( |
kevin1990 | 16:e4f2689363bb | 2103 | ADI_SENSE_DEVICE_HANDLE const hDevice, |
kevin1990 | 16:e4f2689363bb | 2104 | ADI_SENSE_1000_LUT * const pLutData) |
kevin1990 | 16:e4f2689363bb | 2105 | { |
kevin1990 | 16:e4f2689363bb | 2106 | ADI_SENSE_1000_LUT_HEADER *pLutHeader = &pLutData->header; |
kevin1990 | 16:e4f2689363bb | 2107 | ADI_SENSE_1000_LUT_TABLE *pLutTable = pLutData->tables; |
kevin1990 | 16:e4f2689363bb | 2108 | unsigned actualLength = 0; |
kevin1990 | 16:e4f2689363bb | 2109 | |
kevin1990 | 16:e4f2689363bb | 2110 | if (pLutData->header.signature != ADI_SENSE_LUT_SIGNATURE) |
kevin1990 | 16:e4f2689363bb | 2111 | { |
kevin1990 | 16:e4f2689363bb | 2112 | ADI_SENSE_LOG_ERROR("LUT signature incorrect (expected 0x%X, actual 0x%X)", |
kevin1990 | 16:e4f2689363bb | 2113 | ADI_SENSE_LUT_SIGNATURE, pLutHeader->signature); |
kevin1990 | 16:e4f2689363bb | 2114 | return ADI_SENSE_INVALID_SIGNATURE; |
kevin1990 | 16:e4f2689363bb | 2115 | } |
kevin1990 | 16:e4f2689363bb | 2116 | |
kevin1990 | 16:e4f2689363bb | 2117 | for (unsigned i = 0; i < pLutHeader->numTables; i++) |
kevin1990 | 16:e4f2689363bb | 2118 | { |
kevin1990 | 16:e4f2689363bb | 2119 | ADI_SENSE_1000_LUT_DESCRIPTOR *pDesc = &pLutTable->descriptor; |
kevin1990 | 16:e4f2689363bb | 2120 | ADI_SENSE_1000_LUT_TABLE_DATA *pData = &pLutTable->data; |
kevin1990 | 16:e4f2689363bb | 2121 | unsigned short calculatedCrc; |
kevin1990 | 16:e4f2689363bb | 2122 | |
kevin1990 | 16:e4f2689363bb | 2123 | switch (pDesc->geometry) |
kevin1990 | 16:e4f2689363bb | 2124 | { |
kevin1990 | 16:e4f2689363bb | 2125 | case ADI_SENSE_1000_LUT_GEOMETRY_COEFFS: |
kevin1990 | 16:e4f2689363bb | 2126 | switch (pDesc->equation) |
kevin1990 | 16:e4f2689363bb | 2127 | { |
kevin1990 | 16:e4f2689363bb | 2128 | case ADI_SENSE_1000_LUT_EQUATION_POLYN: |
kevin1990 | 16:e4f2689363bb | 2129 | case ADI_SENSE_1000_LUT_EQUATION_POLYNEXP: |
kevin1990 | 16:e4f2689363bb | 2130 | case ADI_SENSE_1000_LUT_EQUATION_QUADRATIC: |
kevin1990 | 16:e4f2689363bb | 2131 | case ADI_SENSE_1000_LUT_EQUATION_STEINHART: |
kevin1990 | 16:e4f2689363bb | 2132 | case ADI_SENSE_1000_LUT_EQUATION_LOGARITHMIC: |
kevin1990 | 16:e4f2689363bb | 2133 | case ADI_SENSE_1000_LUT_EQUATION_EXPONENTIAL: |
kevin1990 | 16:e4f2689363bb | 2134 | case ADI_SENSE_1000_LUT_EQUATION_BIVARIATE_POLYN: |
kevin1990 | 16:e4f2689363bb | 2135 | break; |
kevin1990 | 16:e4f2689363bb | 2136 | default: |
kevin1990 | 16:e4f2689363bb | 2137 | ADI_SENSE_LOG_ERROR("Invalid equation %u specified for LUT table %u", |
kevin1990 | 16:e4f2689363bb | 2138 | pDesc->equation, i); |
kevin1990 | 16:e4f2689363bb | 2139 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 2140 | } |
kevin1990 | 16:e4f2689363bb | 2141 | break; |
kevin1990 | 16:e4f2689363bb | 2142 | case ADI_SENSE_1000_LUT_GEOMETRY_NES_1D: |
kevin1990 | 16:e4f2689363bb | 2143 | case ADI_SENSE_1000_LUT_GEOMETRY_NES_2D: |
kevin1990 | 16:e4f2689363bb | 2144 | case ADI_SENSE_1000_LUT_GEOMETRY_ES_1D: |
kevin1990 | 16:e4f2689363bb | 2145 | case ADI_SENSE_1000_LUT_GEOMETRY_ES_2D: |
kevin1990 | 16:e4f2689363bb | 2146 | if (pDesc->equation != ADI_SENSE_1000_LUT_EQUATION_LUT) { |
kevin1990 | 16:e4f2689363bb | 2147 | ADI_SENSE_LOG_ERROR("Invalid equation %u specified for LUT table %u", |
kevin1990 | 16:e4f2689363bb | 2148 | pDesc->equation, i); |
kevin1990 | 16:e4f2689363bb | 2149 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 2150 | } |
kevin1990 | 16:e4f2689363bb | 2151 | break; |
kevin1990 | 16:e4f2689363bb | 2152 | default: |
kevin1990 | 16:e4f2689363bb | 2153 | ADI_SENSE_LOG_ERROR("Invalid geometry %u specified for LUT table %u", |
kevin1990 | 16:e4f2689363bb | 2154 | pDesc->geometry, i); |
kevin1990 | 16:e4f2689363bb | 2155 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 2156 | } |
kevin1990 | 16:e4f2689363bb | 2157 | |
kevin1990 | 16:e4f2689363bb | 2158 | switch (pDesc->dataType) |
kevin1990 | 16:e4f2689363bb | 2159 | { |
kevin1990 | 16:e4f2689363bb | 2160 | case ADI_SENSE_1000_LUT_DATA_TYPE_FLOAT32: |
kevin1990 | 16:e4f2689363bb | 2161 | case ADI_SENSE_1000_LUT_DATA_TYPE_FLOAT64: |
kevin1990 | 16:e4f2689363bb | 2162 | break; |
kevin1990 | 16:e4f2689363bb | 2163 | default: |
kevin1990 | 16:e4f2689363bb | 2164 | ADI_SENSE_LOG_ERROR("Invalid vector format %u specified for LUT table %u", |
kevin1990 | 16:e4f2689363bb | 2165 | pDesc->dataType, i); |
kevin1990 | 16:e4f2689363bb | 2166 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 2167 | } |
kevin1990 | 16:e4f2689363bb | 2168 | |
kevin1990 | 16:e4f2689363bb | 2169 | calculatedCrc = crc16_ccitt(pData, pDesc->length); |
kevin1990 | 16:e4f2689363bb | 2170 | if (calculatedCrc != pDesc->crc16) |
kevin1990 | 16:e4f2689363bb | 2171 | { |
kevin1990 | 16:e4f2689363bb | 2172 | ADI_SENSE_LOG_ERROR("CRC validation failed on LUT table %u (expected 0x%04X, actual 0x%04X)", |
kevin1990 | 16:e4f2689363bb | 2173 | i, pDesc->crc16, calculatedCrc); |
kevin1990 | 16:e4f2689363bb | 2174 | return ADI_SENSE_CRC_ERROR; |
kevin1990 | 16:e4f2689363bb | 2175 | } |
kevin1990 | 16:e4f2689363bb | 2176 | |
kevin1990 | 16:e4f2689363bb | 2177 | actualLength += sizeof(*pDesc) + pDesc->length; |
kevin1990 | 16:e4f2689363bb | 2178 | |
kevin1990 | 16:e4f2689363bb | 2179 | /* Move to the next look-up table */ |
kevin1990 | 16:e4f2689363bb | 2180 | pLutTable = (ADI_SENSE_1000_LUT_TABLE *)((uint8_t *)pLutTable + sizeof(*pDesc) + pDesc->length); |
kevin1990 | 16:e4f2689363bb | 2181 | } |
kevin1990 | 16:e4f2689363bb | 2182 | |
kevin1990 | 16:e4f2689363bb | 2183 | if (actualLength != pLutHeader->totalLength) |
kevin1990 | 16:e4f2689363bb | 2184 | { |
kevin1990 | 16:e4f2689363bb | 2185 | ADI_SENSE_LOG_ERROR("LUT table length mismatch (expected %u, actual %u)", |
kevin1990 | 16:e4f2689363bb | 2186 | pLutHeader->totalLength, actualLength); |
kevin1990 | 16:e4f2689363bb | 2187 | return ADI_SENSE_WRONG_SIZE; |
kevin1990 | 16:e4f2689363bb | 2188 | } |
kevin1990 | 16:e4f2689363bb | 2189 | |
kevin1990 | 16:e4f2689363bb | 2190 | if (sizeof(*pLutHeader) + pLutHeader->totalLength > ADI_SENSE_LUT_MAX_SIZE) |
kevin1990 | 16:e4f2689363bb | 2191 | { |
kevin1990 | 16:e4f2689363bb | 2192 | ADI_SENSE_LOG_ERROR("Maximum LUT table length (%u bytes) exceeded", |
kevin1990 | 16:e4f2689363bb | 2193 | ADI_SENSE_LUT_MAX_SIZE); |
kevin1990 | 16:e4f2689363bb | 2194 | return ADI_SENSE_WRONG_SIZE; |
kevin1990 | 16:e4f2689363bb | 2195 | } |
kevin1990 | 16:e4f2689363bb | 2196 | |
kevin1990 | 16:e4f2689363bb | 2197 | /* Write the LUT data to the device */ |
kevin1990 | 16:e4f2689363bb | 2198 | unsigned lutSize = sizeof(*pLutHeader) + pLutHeader->totalLength; |
kevin1990 | 16:e4f2689363bb | 2199 | WRITE_REG_U16(hDevice, 0, CORE_LUT_OFFSET); |
kevin1990 | 16:e4f2689363bb | 2200 | WRITE_REG_U8_ARRAY(hDevice, (uint8_t *)pLutData, lutSize, CORE_LUT_DATA); |
kevin1990 | 16:e4f2689363bb | 2201 | |
kevin1990 | 16:e4f2689363bb | 2202 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 2203 | } |
kevin1990 | 16:e4f2689363bb | 2204 | |
kevin1990 | 16:e4f2689363bb | 2205 | ADI_SENSE_RESULT adi_sense_1000_SetLutDataRaw( |
kevin1990 | 16:e4f2689363bb | 2206 | ADI_SENSE_DEVICE_HANDLE const hDevice, |
kevin1990 | 16:e4f2689363bb | 2207 | ADI_SENSE_1000_LUT_RAW * const pLutData) |
kevin1990 | 16:e4f2689363bb | 2208 | { |
kevin1990 | 16:e4f2689363bb | 2209 | return adi_sense_1000_SetLutData(hDevice, |
kevin1990 | 16:e4f2689363bb | 2210 | (ADI_SENSE_1000_LUT * const)pLutData); |
kevin1990 | 16:e4f2689363bb | 2211 | } |
kevin1990 | 16:e4f2689363bb | 2212 | |
kevin1990 | 16:e4f2689363bb | 2213 | static ADI_SENSE_RESULT getLutTableSize( |
kevin1990 | 16:e4f2689363bb | 2214 | ADI_SENSE_1000_LUT_DESCRIPTOR * const pDesc, |
kevin1990 | 16:e4f2689363bb | 2215 | ADI_SENSE_1000_LUT_TABLE_DATA * const pData, |
kevin1990 | 16:e4f2689363bb | 2216 | unsigned *pLength) |
kevin1990 | 16:e4f2689363bb | 2217 | { |
kevin1990 | 16:e4f2689363bb | 2218 | switch (pDesc->geometry) |
kevin1990 | 16:e4f2689363bb | 2219 | { |
kevin1990 | 16:e4f2689363bb | 2220 | case ADI_SENSE_1000_LUT_GEOMETRY_COEFFS: |
kevin1990 | 16:e4f2689363bb | 2221 | if (pDesc->equation == ADI_SENSE_1000_LUT_EQUATION_BIVARIATE_POLYN) |
kevin1990 | 16:e4f2689363bb | 2222 | *pLength = ADI_SENSE_1000_LUT_2D_POLYN_COEFF_LIST_SIZE(pData->coeffList2d); |
kevin1990 | 16:e4f2689363bb | 2223 | else |
kevin1990 | 16:e4f2689363bb | 2224 | *pLength = ADI_SENSE_1000_LUT_COEFF_LIST_SIZE(pData->coeffList); |
kevin1990 | 16:e4f2689363bb | 2225 | break; |
kevin1990 | 16:e4f2689363bb | 2226 | case ADI_SENSE_1000_LUT_GEOMETRY_NES_1D: |
kevin1990 | 16:e4f2689363bb | 2227 | *pLength = ADI_SENSE_1000_LUT_1D_NES_SIZE(pData->lut1dNes); |
kevin1990 | 16:e4f2689363bb | 2228 | break; |
kevin1990 | 16:e4f2689363bb | 2229 | case ADI_SENSE_1000_LUT_GEOMETRY_NES_2D: |
kevin1990 | 16:e4f2689363bb | 2230 | *pLength = ADI_SENSE_1000_LUT_2D_NES_SIZE(pData->lut2dNes); |
kevin1990 | 16:e4f2689363bb | 2231 | break; |
kevin1990 | 16:e4f2689363bb | 2232 | case ADI_SENSE_1000_LUT_GEOMETRY_ES_1D: |
kevin1990 | 16:e4f2689363bb | 2233 | *pLength = ADI_SENSE_1000_LUT_1D_ES_SIZE(pData->lut1dEs); |
kevin1990 | 16:e4f2689363bb | 2234 | break; |
kevin1990 | 16:e4f2689363bb | 2235 | case ADI_SENSE_1000_LUT_GEOMETRY_ES_2D: |
kevin1990 | 16:e4f2689363bb | 2236 | *pLength = ADI_SENSE_1000_LUT_2D_ES_SIZE(pData->lut2dEs); |
kevin1990 | 16:e4f2689363bb | 2237 | break; |
kevin1990 | 16:e4f2689363bb | 2238 | default: |
kevin1990 | 16:e4f2689363bb | 2239 | ADI_SENSE_LOG_ERROR("Invalid LUT table geometry %d specified\r\n", |
kevin1990 | 16:e4f2689363bb | 2240 | pDesc->geometry); |
kevin1990 | 16:e4f2689363bb | 2241 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 2242 | } |
kevin1990 | 16:e4f2689363bb | 2243 | |
kevin1990 | 16:e4f2689363bb | 2244 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 2245 | } |
kevin1990 | 16:e4f2689363bb | 2246 | |
kevin1990 | 16:e4f2689363bb | 2247 | ADI_SENSE_RESULT adi_sense_1000_AssembleLutData( |
kevin1990 | 16:e4f2689363bb | 2248 | ADI_SENSE_1000_LUT * pLutBuffer, |
kevin1990 | 16:e4f2689363bb | 2249 | unsigned nLutBufferSize, |
kevin1990 | 16:e4f2689363bb | 2250 | unsigned const nNumTables, |
kevin1990 | 16:e4f2689363bb | 2251 | ADI_SENSE_1000_LUT_DESCRIPTOR * const ppDesc[], |
kevin1990 | 16:e4f2689363bb | 2252 | ADI_SENSE_1000_LUT_TABLE_DATA * const ppData[]) |
kevin1990 | 16:e4f2689363bb | 2253 | { |
kevin1990 | 16:e4f2689363bb | 2254 | ADI_SENSE_1000_LUT_HEADER *pHdr = &pLutBuffer->header; |
kevin1990 | 16:e4f2689363bb | 2255 | uint8_t *pLutTableData = (uint8_t *)pLutBuffer + sizeof(*pHdr); |
kevin1990 | 16:e4f2689363bb | 2256 | |
kevin1990 | 16:e4f2689363bb | 2257 | if (sizeof(*pHdr) > nLutBufferSize) |
kevin1990 | 16:e4f2689363bb | 2258 | { |
kevin1990 | 16:e4f2689363bb | 2259 | ADI_SENSE_LOG_ERROR("Insufficient LUT buffer size provided"); |
kevin1990 | 16:e4f2689363bb | 2260 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 2261 | } |
kevin1990 | 16:e4f2689363bb | 2262 | |
kevin1990 | 16:e4f2689363bb | 2263 | /* First initialise the top-level header */ |
kevin1990 | 16:e4f2689363bb | 2264 | pHdr->signature = ADI_SENSE_LUT_SIGNATURE; |
kevin1990 | 16:e4f2689363bb | 2265 | pHdr->version.major = 1; |
kevin1990 | 16:e4f2689363bb | 2266 | pHdr->version.minor = 0; |
kevin1990 | 16:e4f2689363bb | 2267 | pHdr->numTables = 0; |
kevin1990 | 16:e4f2689363bb | 2268 | pHdr->totalLength = 0; |
kevin1990 | 16:e4f2689363bb | 2269 | |
kevin1990 | 16:e4f2689363bb | 2270 | /* |
kevin1990 | 16:e4f2689363bb | 2271 | * Walk through the list of table pointers provided, appending the table |
kevin1990 | 16:e4f2689363bb | 2272 | * descriptor+data from each one to the provided LUT buffer |
kevin1990 | 16:e4f2689363bb | 2273 | */ |
kevin1990 | 16:e4f2689363bb | 2274 | for (unsigned i = 0; i < nNumTables; i++) |
kevin1990 | 16:e4f2689363bb | 2275 | { |
kevin1990 | 16:e4f2689363bb | 2276 | ADI_SENSE_1000_LUT_DESCRIPTOR * const pDesc = ppDesc[i]; |
kevin1990 | 16:e4f2689363bb | 2277 | ADI_SENSE_1000_LUT_TABLE_DATA * const pData = ppData[i]; |
kevin1990 | 16:e4f2689363bb | 2278 | ADI_SENSE_RESULT res; |
kevin1990 | 16:e4f2689363bb | 2279 | unsigned dataLength = 0; |
kevin1990 | 16:e4f2689363bb | 2280 | |
kevin1990 | 16:e4f2689363bb | 2281 | /* Calculate the length of the table data */ |
kevin1990 | 16:e4f2689363bb | 2282 | res = getLutTableSize(pDesc, pData, &dataLength); |
kevin1990 | 16:e4f2689363bb | 2283 | if (res != ADI_SENSE_SUCCESS) |
kevin1990 | 16:e4f2689363bb | 2284 | return res; |
kevin1990 | 16:e4f2689363bb | 2285 | |
kevin1990 | 16:e4f2689363bb | 2286 | /* Fill in the table descriptor length and CRC fields */ |
kevin1990 | 16:e4f2689363bb | 2287 | pDesc->length = dataLength; |
kevin1990 | 16:e4f2689363bb | 2288 | pDesc->crc16 = crc16_ccitt(pData, dataLength); |
kevin1990 | 16:e4f2689363bb | 2289 | |
kevin1990 | 16:e4f2689363bb | 2290 | if ((sizeof(*pHdr) + pHdr->totalLength + sizeof(*pDesc) + dataLength) > nLutBufferSize) |
kevin1990 | 16:e4f2689363bb | 2291 | { |
kevin1990 | 16:e4f2689363bb | 2292 | ADI_SENSE_LOG_ERROR("Insufficient LUT buffer size provided"); |
kevin1990 | 16:e4f2689363bb | 2293 | return ADI_SENSE_INVALID_PARAM; |
kevin1990 | 16:e4f2689363bb | 2294 | } |
kevin1990 | 16:e4f2689363bb | 2295 | |
kevin1990 | 16:e4f2689363bb | 2296 | /* Append the table to the LUT buffer (desc + data) */ |
kevin1990 | 16:e4f2689363bb | 2297 | memcpy(pLutTableData + pHdr->totalLength, pDesc, sizeof(*pDesc)); |
kevin1990 | 16:e4f2689363bb | 2298 | pHdr->totalLength += sizeof(*pDesc); |
kevin1990 | 16:e4f2689363bb | 2299 | memcpy(pLutTableData + pHdr->totalLength, pData, dataLength); |
kevin1990 | 16:e4f2689363bb | 2300 | pHdr->totalLength += dataLength; |
kevin1990 | 16:e4f2689363bb | 2301 | |
kevin1990 | 16:e4f2689363bb | 2302 | pHdr->numTables++; |
kevin1990 | 16:e4f2689363bb | 2303 | } |
kevin1990 | 16:e4f2689363bb | 2304 | |
kevin1990 | 16:e4f2689363bb | 2305 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 2306 | } |
kevin1990 | 16:e4f2689363bb | 2307 | |
kevin1990 | 16:e4f2689363bb | 2308 | #define CAL_TABLE_ROWS ADI_SENSE_1000_CAL_NUM_TABLES |
kevin1990 | 16:e4f2689363bb | 2309 | #define CAL_TABLE_COLS ADI_SENSE_1000_CAL_NUM_TEMPS |
kevin1990 | 16:e4f2689363bb | 2310 | #define CAL_TABLE_SIZE (sizeof(float) * CAL_TABLE_ROWS * CAL_TABLE_COLS) |
kevin1990 | 16:e4f2689363bb | 2311 | |
kevin1990 | 16:e4f2689363bb | 2312 | ADI_SENSE_RESULT adi_sense_1000_ReadCalTable( |
kevin1990 | 16:e4f2689363bb | 2313 | ADI_SENSE_DEVICE_HANDLE hDevice, |
kevin1990 | 16:e4f2689363bb | 2314 | float *pfBuffer, |
kevin1990 | 16:e4f2689363bb | 2315 | unsigned nMaxLen, |
kevin1990 | 16:e4f2689363bb | 2316 | unsigned *pnDataLen, |
kevin1990 | 16:e4f2689363bb | 2317 | unsigned *pnRows, |
kevin1990 | 16:e4f2689363bb | 2318 | unsigned *pnColumns) |
kevin1990 | 16:e4f2689363bb | 2319 | { |
kevin1990 | 16:e4f2689363bb | 2320 | *pnDataLen = sizeof(float) * CAL_TABLE_ROWS * CAL_TABLE_COLS; |
kevin1990 | 16:e4f2689363bb | 2321 | *pnRows = CAL_TABLE_ROWS; |
kevin1990 | 16:e4f2689363bb | 2322 | *pnColumns = CAL_TABLE_COLS; |
kevin1990 | 16:e4f2689363bb | 2323 | |
kevin1990 | 16:e4f2689363bb | 2324 | if (nMaxLen > *pnDataLen) |
kevin1990 | 16:e4f2689363bb | 2325 | nMaxLen = *pnDataLen; |
kevin1990 | 16:e4f2689363bb | 2326 | |
kevin1990 | 16:e4f2689363bb | 2327 | WRITE_REG_U16(hDevice, 0, CORE_CAL_OFFSET); |
kevin1990 | 16:e4f2689363bb | 2328 | READ_REG_U8_ARRAY(hDevice, (uint8_t *)pfBuffer, nMaxLen, CORE_CAL_DATA); |
kevin1990 | 16:e4f2689363bb | 2329 | |
kevin1990 | 16:e4f2689363bb | 2330 | return ADI_SENSE_SUCCESS; |
kevin1990 | 16:e4f2689363bb | 2331 | } |
kevin1990 | 16:e4f2689363bb | 2332 |