Vybhav Kadaba
/
EV-PRO-MW1001_Development_code_cleaup
Removed unwanted enums and unused functions
common/utils.c@64:d89d9728ba95, 2020-04-09 (annotated)
- Committer:
- Vkadaba
- Date:
- Thu Apr 09 12:39:43 2020 +0000
- Revision:
- 64:d89d9728ba95
- Parent:
- 63:6d048b2f3f32
code clean up part-2
Who changed what in which revision?
User | Revision | Line number | New contents of line |
---|---|---|---|
Vkadaba | 15:b5d57daeb7c0 | 1 | /* |
Vkadaba | 15:b5d57daeb7c0 | 2 | Copyright 2019 (c) Analog Devices, Inc. |
Vkadaba | 15:b5d57daeb7c0 | 3 | |
Vkadaba | 15:b5d57daeb7c0 | 4 | All rights reserved. |
Vkadaba | 15:b5d57daeb7c0 | 5 | |
Vkadaba | 15:b5d57daeb7c0 | 6 | Redistribution and use in source and binary forms, with or without |
Vkadaba | 15:b5d57daeb7c0 | 7 | modification, are permitted provided that the following conditions are met: |
Vkadaba | 15:b5d57daeb7c0 | 8 | - Redistributions of source code must retain the above copyright |
Vkadaba | 15:b5d57daeb7c0 | 9 | notice, this list of conditions and the following disclaimer. |
Vkadaba | 15:b5d57daeb7c0 | 10 | - Redistributions in binary form must reproduce the above copyright |
Vkadaba | 15:b5d57daeb7c0 | 11 | notice, this list of conditions and the following disclaimer in |
Vkadaba | 15:b5d57daeb7c0 | 12 | the documentation and/or other materials provided with the |
Vkadaba | 15:b5d57daeb7c0 | 13 | distribution. |
Vkadaba | 15:b5d57daeb7c0 | 14 | - Neither the name of Analog Devices, Inc. nor the names of its |
Vkadaba | 15:b5d57daeb7c0 | 15 | contributors may be used to endorse or promote products derived |
Vkadaba | 15:b5d57daeb7c0 | 16 | from this software without specific prior written permission. |
Vkadaba | 15:b5d57daeb7c0 | 17 | - The use of this software may or may not infringe the patent rights |
Vkadaba | 15:b5d57daeb7c0 | 18 | of one or more patent holders. This license does not release you |
Vkadaba | 15:b5d57daeb7c0 | 19 | from the requirement that you obtain separate licenses from these |
Vkadaba | 15:b5d57daeb7c0 | 20 | patent holders to use this software. |
Vkadaba | 15:b5d57daeb7c0 | 21 | - Use of the software either in source or binary form, must be run |
Vkadaba | 15:b5d57daeb7c0 | 22 | on or directly connected to an Analog Devices Inc. component. |
Vkadaba | 15:b5d57daeb7c0 | 23 | |
Vkadaba | 15:b5d57daeb7c0 | 24 | THIS SOFTWARE IS PROVIDED BY ANALOG DEVICES "AS IS" AND ANY EXPRESS OR |
Vkadaba | 15:b5d57daeb7c0 | 25 | IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, NON-INFRINGEMENT, |
Vkadaba | 15:b5d57daeb7c0 | 26 | MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
Vkadaba | 15:b5d57daeb7c0 | 27 | IN NO EVENT SHALL ANALOG DEVICES BE LIABLE FOR ANY DIRECT, INDIRECT, |
Vkadaba | 15:b5d57daeb7c0 | 28 | INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
Vkadaba | 15:b5d57daeb7c0 | 29 | LIMITED TO, INTELLECTUAL PROPERTY RIGHTS, PROCUREMENT OF SUBSTITUTE GOODS OR |
Vkadaba | 15:b5d57daeb7c0 | 30 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
Vkadaba | 15:b5d57daeb7c0 | 31 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
Vkadaba | 15:b5d57daeb7c0 | 32 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
Vkadaba | 15:b5d57daeb7c0 | 33 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
Vkadaba | 15:b5d57daeb7c0 | 34 | */ |
Vkadaba | 15:b5d57daeb7c0 | 35 | |
Vkadaba | 15:b5d57daeb7c0 | 36 | /*! |
Vkadaba | 15:b5d57daeb7c0 | 37 | ****************************************************************************** |
Vkadaba | 15:b5d57daeb7c0 | 38 | * @file: utils.c |
Vkadaba | 15:b5d57daeb7c0 | 39 | * @brief: Interface Utilities for ADMW1001 |
Vkadaba | 15:b5d57daeb7c0 | 40 | *----------------------------------------------------------------------------- |
Vkadaba | 15:b5d57daeb7c0 | 41 | */ |
ADIJake | 0:85855ecd3257 | 42 | #include <stdlib.h> |
ADIJake | 0:85855ecd3257 | 43 | |
ADIJake | 0:85855ecd3257 | 44 | #include "utils.h" |
Vkadaba | 5:0728bde67bdb | 45 | #include "admw_log.h" |
ADIJake | 0:85855ecd3257 | 46 | |
ADIJake | 0:85855ecd3257 | 47 | void utils_printStatus( |
Vkadaba | 5:0728bde67bdb | 48 | ADMW_STATUS *pStatus) |
ADIJake | 0:85855ecd3257 | 49 | { |
Vkadaba | 5:0728bde67bdb | 50 | ADMW_LOG_INFO("Status Summary:"); |
ADIJake | 0:85855ecd3257 | 51 | |
Vkadaba | 23:bb685f35b08b | 52 | if (pStatus->deviceStatus == 0) { |
Vkadaba | 5:0728bde67bdb | 53 | ADMW_LOG_INFO("\tNo errors detected"); |
Vkadaba | 23:bb685f35b08b | 54 | } else { |
Vkadaba | 5:0728bde67bdb | 55 | if (pStatus->deviceStatus & ADMW_DEVICE_STATUS_BUSY) |
Vkadaba | 5:0728bde67bdb | 56 | ADMW_LOG_INFO("\tCommand running"); |
Vkadaba | 5:0728bde67bdb | 57 | if (pStatus->deviceStatus & ADMW_DEVICE_STATUS_DATAREADY) |
Vkadaba | 5:0728bde67bdb | 58 | ADMW_LOG_INFO("\tData ready"); |
Vkadaba | 5:0728bde67bdb | 59 | if (pStatus->deviceStatus & ADMW_DEVICE_STATUS_ERROR) |
Vkadaba | 5:0728bde67bdb | 60 | ADMW_LOG_INFO("\tActive Errors - RESET REQUIRED"); |
Vkadaba | 5:0728bde67bdb | 61 | if (pStatus->deviceStatus & ADMW_DEVICE_STATUS_FIFO_ERROR) |
Vkadaba | 5:0728bde67bdb | 62 | ADMW_LOG_INFO("\tActive FIFO Errors - ATTENTION REQUIRED"); |
Vkadaba | 5:0728bde67bdb | 63 | if (pStatus->deviceStatus & ADMW_DEVICE_STATUS_CONFIG_ERROR) |
Vkadaba | 5:0728bde67bdb | 64 | ADMW_LOG_INFO("\tActive Configuration Errors - ATTENTION REQUIRED"); |
Vkadaba | 5:0728bde67bdb | 65 | if (pStatus->deviceStatus & ADMW_DEVICE_STATUS_LUT_ERROR) |
Vkadaba | 5:0728bde67bdb | 66 | ADMW_LOG_INFO("\tActive Look-Up Table Errors - ATTENTION REQUIRED"); |
Vkadaba | 23:bb685f35b08b | 67 | |
ADIJake | 0:85855ecd3257 | 68 | |
Vkadaba | 23:bb685f35b08b | 69 | if (pStatus->deviceStatus & ADMW_DEVICE_STATUS_ERROR) { |
Vkadaba | 5:0728bde67bdb | 70 | ADMW_LOG_INFO("\tActive Errors - ATTENTION REQUIRED"); |
Vkadaba | 5:0728bde67bdb | 71 | ADMW_LOG_INFO("\t\tLast Error Code: %u (0x%X)", |
Vkadaba | 23:bb685f35b08b | 72 | pStatus->errorCode, pStatus->errorCode); |
ADIJake | 0:85855ecd3257 | 73 | |
Vkadaba | 63:6d048b2f3f32 | 74 | } |
Vkadaba | 63:6d048b2f3f32 | 75 | } |
Vkadaba | 23:bb685f35b08b | 76 | |
Vkadaba | 63:6d048b2f3f32 | 77 | if (pStatus->deviceStatus & ADMW_DEVICE_STATUS_ALERT) { |
Vkadaba | 63:6d048b2f3f32 | 78 | ADMW_LOG_INFO("\tActive Alerts - ATTENTION REQUIRED:"); |
Vkadaba | 63:6d048b2f3f32 | 79 | ADMW_LOG_INFO("\t\tLast Alert Code: %u (0x%X)", |
Vkadaba | 63:6d048b2f3f32 | 80 | pStatus->alertCode, pStatus->alertCode); |
ADIJake | 0:85855ecd3257 | 81 | |
Vkadaba | 63:6d048b2f3f32 | 82 | for (unsigned i = 0; i < ADMW1001_MAX_CHANNELS; i++) { |
Vkadaba | 63:6d048b2f3f32 | 83 | if (pStatus->channelAlerts[i] == 0) |
Vkadaba | 63:6d048b2f3f32 | 84 | continue; |
ADIJake | 0:85855ecd3257 | 85 | |
Vkadaba | 63:6d048b2f3f32 | 86 | ADMW_LOG_INFO("\t\tChannel #%u:", i); |
Vkadaba | 63:6d048b2f3f32 | 87 | ADMW_LOG_INFO("\t\t\tLast Alert Code: %u (0x%X)", |
Vkadaba | 63:6d048b2f3f32 | 88 | pStatus->channelAlertCodes[i], |
Vkadaba | 63:6d048b2f3f32 | 89 | pStatus->channelAlertCodes[i]); |
Vkadaba | 63:6d048b2f3f32 | 90 | if (pStatus->channelAlerts[i] & ADMW_ALERT_DETAIL_CH_ADC_NEAR_OVERRANGE) |
Vkadaba | 63:6d048b2f3f32 | 91 | ADMW_LOG_INFO("\t\t\ADC near overrange detected"); |
Vkadaba | 63:6d048b2f3f32 | 92 | if (pStatus->channelAlerts[i] & ADMW_ALERT_DETAIL_CH_SENSOR_UNDERRANGE) |
Vkadaba | 63:6d048b2f3f32 | 93 | ADMW_LOG_INFO("\t\t\tSensor underrange detected"); |
Vkadaba | 63:6d048b2f3f32 | 94 | if (pStatus->channelAlerts[i] & ADMW_ALERT_DETAIL_CH_SENSOR_OVERRANGE) |
Vkadaba | 63:6d048b2f3f32 | 95 | ADMW_LOG_INFO("\t\t\tSensor overrange detected"); |
Vkadaba | 63:6d048b2f3f32 | 96 | if (pStatus->channelAlerts[i] & ADMW_ALERT_DETAIL_CH_CJ_SOFT_FAULT) |
Vkadaba | 63:6d048b2f3f32 | 97 | ADMW_LOG_INFO("\t\t\tCJC soft fault alert detected"); |
Vkadaba | 63:6d048b2f3f32 | 98 | if (pStatus->channelAlerts[i] & ADMW_ALERT_DETAIL_CH_CJ_HARD_FAULT) |
Vkadaba | 63:6d048b2f3f32 | 99 | ADMW_LOG_INFO("\t\t\tCJC hard fault alert detected"); |
Vkadaba | 63:6d048b2f3f32 | 100 | if (pStatus->channelAlerts[i] & ADMW_ALERT_DETAIL_CH_ADC_INPUT_OVERRANGE) |
Vkadaba | 63:6d048b2f3f32 | 101 | ADMW_LOG_INFO("\t\t\tADC input overranage alert detected"); |
Vkadaba | 63:6d048b2f3f32 | 102 | if (pStatus->channelAlerts[i] & ADMW_ALERT_DETAIL_CH_SENSOR_HARDFAULT) |
Vkadaba | 63:6d048b2f3f32 | 103 | ADMW_LOG_INFO("\t\t\tChannel sensor hardfault alert detected"); |
ADIJake | 0:85855ecd3257 | 104 | } |
Vkadaba | 63:6d048b2f3f32 | 105 | } |
ADIJake | 0:85855ecd3257 | 106 | |
Vkadaba | 63:6d048b2f3f32 | 107 | if ((pStatus->deviceStatus & ADMW_DEVICE_STATUS_ERROR) || |
Vkadaba | 63:6d048b2f3f32 | 108 | (pStatus->deviceStatus & ADMW_DEVICE_STATUS_ALERT)) { |
Vkadaba | 63:6d048b2f3f32 | 109 | ADMW_LOG_INFO("\t\tLast Debug Code: %u-%u", |
Vkadaba | 63:6d048b2f3f32 | 110 | (pStatus->debugCode >> 16) & 0xFFFF, |
Vkadaba | 63:6d048b2f3f32 | 111 | (pStatus->debugCode >> 0) & 0xFFFF); |
ADIJake | 0:85855ecd3257 | 112 | } |
ADIJake | 0:85855ecd3257 | 113 | } |
ADIJake | 0:85855ecd3257 | 114 | |
ADIJake | 0:85855ecd3257 | 115 | void utils_printSamples( |
Vkadaba | 5:0728bde67bdb | 116 | ADMW_DATA_SAMPLE *pSampleBuffer, |
ADIJake | 0:85855ecd3257 | 117 | uint32_t nNumSamples, |
Vkadaba | 5:0728bde67bdb | 118 | ADMW_MEASUREMENT_MODE eMeasurementMode) |
ADIJake | 0:85855ecd3257 | 119 | { |
Vkadaba | 23:bb685f35b08b | 120 | for (uint32_t i = 0; i < nNumSamples; i++) { |
Vkadaba | 56:38b36e947602 | 121 | ADMW_LOG_INFO("Sample # %2d Channel # %2d :: Raw %f :: Processed %f :: flags: ERROR:%X , ALERT:%X", |
Vkadaba | 23:bb685f35b08b | 122 | i+1, |
Vkadaba | 23:bb685f35b08b | 123 | pSampleBuffer[i].channelId, |
Vkadaba | 56:38b36e947602 | 124 | pSampleBuffer[i].rawValue, |
Vkadaba | 23:bb685f35b08b | 125 | pSampleBuffer[i].processedValue, |
Vkadaba | 56:38b36e947602 | 126 | pSampleBuffer[i].status & ADMW_DEVICE_STATUS_ERROR, |
Vkadaba | 56:38b36e947602 | 127 | pSampleBuffer[i].status & ADMW_DEVICE_STATUS_ALERT ); |
Vkadaba | 10:14954555be2a | 128 | } |
ADIJake | 0:85855ecd3257 | 129 | } |
ADIJake | 0:85855ecd3257 | 130 | |
Vkadaba | 5:0728bde67bdb | 131 | static void gpioCallbackFn(ADMW_GPIO_PIN ePinId, void * pArg) |
ADIJake | 0:85855ecd3257 | 132 | { |
ADIJake | 0:85855ecd3257 | 133 | volatile bool *pbFlag = (volatile bool *)pArg; |
ADIJake | 0:85855ecd3257 | 134 | *pbFlag = true; |
ADIJake | 0:85855ecd3257 | 135 | } |
ADIJake | 0:85855ecd3257 | 136 | |
Vkadaba | 5:0728bde67bdb | 137 | ADMW_RESULT utils_registerCallbacks( |
Vkadaba | 5:0728bde67bdb | 138 | ADMW_DEVICE_HANDLE hDevice, |
ADIJake | 0:85855ecd3257 | 139 | volatile bool *pbDataReady, |
ADIJake | 0:85855ecd3257 | 140 | volatile bool *pbError, |
ADIJake | 0:85855ecd3257 | 141 | volatile bool *pbAlert) |
ADIJake | 0:85855ecd3257 | 142 | { |
Vkadaba | 5:0728bde67bdb | 143 | ADMW_RESULT res; |
ADIJake | 0:85855ecd3257 | 144 | bool state; |
ADIJake | 0:85855ecd3257 | 145 | |
Vkadaba | 5:0728bde67bdb | 146 | res = admw_RegisterGpioCallback(hDevice, ADMW_GPIO_PIN_DATAREADY, |
Vkadaba | 23:bb685f35b08b | 147 | gpioCallbackFn, (void *)pbDataReady); |
Vkadaba | 23:bb685f35b08b | 148 | if (res != ADMW_SUCCESS) { |
Vkadaba | 5:0728bde67bdb | 149 | ADMW_LOG_ERROR("Failed to register DATAREADY callback"); |
ADIJake | 0:85855ecd3257 | 150 | return res; |
ADIJake | 0:85855ecd3257 | 151 | } |
ADIJake | 0:85855ecd3257 | 152 | |
Vkadaba | 5:0728bde67bdb | 153 | res = admw_GetGpioState(hDevice, ADMW_GPIO_PIN_ALERT_ERROR, &state); |
Vkadaba | 23:bb685f35b08b | 154 | if (res != ADMW_SUCCESS) { |
Vkadaba | 5:0728bde67bdb | 155 | ADMW_LOG_ERROR("Failed to get current ERROR state"); |
ADIJake | 0:85855ecd3257 | 156 | return res; |
ADIJake | 0:85855ecd3257 | 157 | } |
Vkadaba | 23:bb685f35b08b | 158 | if (state) { |
Vkadaba | 5:0728bde67bdb | 159 | ADMW_LOG_ERROR("ERROR signal already asserted"); |
Vkadaba | 5:0728bde67bdb | 160 | return ADMW_FAILURE; |
ADIJake | 0:85855ecd3257 | 161 | } |
Vkadaba | 5:0728bde67bdb | 162 | res = admw_RegisterGpioCallback(hDevice, ADMW_GPIO_PIN_ALERT_ERROR, |
Vkadaba | 23:bb685f35b08b | 163 | gpioCallbackFn, (void *)pbError); |
Vkadaba | 23:bb685f35b08b | 164 | if (res != ADMW_SUCCESS) { |
Vkadaba | 5:0728bde67bdb | 165 | ADMW_LOG_ERROR("Failed to register ERROR callback"); |
ADIJake | 0:85855ecd3257 | 166 | return res; |
ADIJake | 0:85855ecd3257 | 167 | } |
ADIJake | 0:85855ecd3257 | 168 | |
Vkadaba | 5:0728bde67bdb | 169 | /*res = admw_GetGpioState(hDevice, ADMW_GPIO_PIN_ALERT, &state); |
Vkadaba | 5:0728bde67bdb | 170 | if (res != ADMW_SUCCESS) |
ADIJake | 0:85855ecd3257 | 171 | { |
Vkadaba | 5:0728bde67bdb | 172 | ADMW_LOG_ERROR("Failed to get current ALERT state"); |
ADIJake | 0:85855ecd3257 | 173 | return res; |
ADIJake | 0:85855ecd3257 | 174 | } |
ADIJake | 0:85855ecd3257 | 175 | if (state) |
ADIJake | 0:85855ecd3257 | 176 | { |
Vkadaba | 5:0728bde67bdb | 177 | ADMW_LOG_ERROR("ALERT signal already asserted"); |
Vkadaba | 5:0728bde67bdb | 178 | return ADMW_FAILURE; |
ADIJake | 1:63dd03580de4 | 179 | }*/ |
Vkadaba | 5:0728bde67bdb | 180 | res = admw_RegisterGpioCallback(hDevice, ADMW_GPIO_PIN_ALERT_ERROR, |
Vkadaba | 23:bb685f35b08b | 181 | gpioCallbackFn, (void *)pbAlert); |
Vkadaba | 23:bb685f35b08b | 182 | if (res != ADMW_SUCCESS) { |
Vkadaba | 5:0728bde67bdb | 183 | ADMW_LOG_ERROR("Failed to register ALERT callback"); |
ADIJake | 0:85855ecd3257 | 184 | return res; |
ADIJake | 0:85855ecd3257 | 185 | } |
ADIJake | 0:85855ecd3257 | 186 | |
Vkadaba | 5:0728bde67bdb | 187 | return ADMW_SUCCESS; |
ADIJake | 0:85855ecd3257 | 188 | } |
ADIJake | 0:85855ecd3257 | 189 | |
Vkadaba | 5:0728bde67bdb | 190 | ADMW_RESULT utils_deregisterCallbacks( |
Vkadaba | 5:0728bde67bdb | 191 | ADMW_DEVICE_HANDLE hDevice) |
ADIJake | 0:85855ecd3257 | 192 | { |
Vkadaba | 5:0728bde67bdb | 193 | ADMW_RESULT res; |
ADIJake | 0:85855ecd3257 | 194 | |
Vkadaba | 5:0728bde67bdb | 195 | res = admw_RegisterGpioCallback(hDevice, ADMW_GPIO_PIN_DATAREADY, |
Vkadaba | 23:bb685f35b08b | 196 | NULL, NULL); |
Vkadaba | 23:bb685f35b08b | 197 | if (res != ADMW_SUCCESS) { |
Vkadaba | 5:0728bde67bdb | 198 | ADMW_LOG_ERROR("Failed to deregister DATAREADY callback"); |
ADIJake | 0:85855ecd3257 | 199 | return res; |
ADIJake | 0:85855ecd3257 | 200 | } |
ADIJake | 0:85855ecd3257 | 201 | |
Vkadaba | 5:0728bde67bdb | 202 | res = admw_RegisterGpioCallback(hDevice, ADMW_GPIO_PIN_ALERT_ERROR, |
Vkadaba | 23:bb685f35b08b | 203 | NULL, NULL); |
Vkadaba | 23:bb685f35b08b | 204 | if (res != ADMW_SUCCESS) { |
Vkadaba | 5:0728bde67bdb | 205 | ADMW_LOG_ERROR("Failed to deregister ERROR callback"); |
ADIJake | 0:85855ecd3257 | 206 | return res; |
ADIJake | 0:85855ecd3257 | 207 | } |
ADIJake | 0:85855ecd3257 | 208 | |
Vkadaba | 5:0728bde67bdb | 209 | res = admw_RegisterGpioCallback(hDevice, ADMW_GPIO_PIN_ALERT_ERROR, |
Vkadaba | 23:bb685f35b08b | 210 | NULL, NULL); |
Vkadaba | 23:bb685f35b08b | 211 | if (res != ADMW_SUCCESS) { |
Vkadaba | 5:0728bde67bdb | 212 | ADMW_LOG_INFO("Failed to deregister ALERT callback"); |
ADIJake | 0:85855ecd3257 | 213 | return res; |
ADIJake | 0:85855ecd3257 | 214 | } |
ADIJake | 0:85855ecd3257 | 215 | |
Vkadaba | 5:0728bde67bdb | 216 | return ADMW_SUCCESS; |
ADIJake | 0:85855ecd3257 | 217 | } |
ADIJake | 0:85855ecd3257 | 218 | |
Vkadaba | 5:0728bde67bdb | 219 | ADMW_RESULT utils_runMeasurement( |
Vkadaba | 5:0728bde67bdb | 220 | ADMW_DEVICE_HANDLE hDevice, |
Vkadaba | 5:0728bde67bdb | 221 | ADMW_MEASUREMENT_MODE eMeasurementMode) |
ADIJake | 0:85855ecd3257 | 222 | { |
Vkadaba | 5:0728bde67bdb | 223 | ADMW_RESULT res; |
ADIJake | 0:85855ecd3257 | 224 | volatile bool bDataReady = false; |
ADIJake | 0:85855ecd3257 | 225 | volatile bool bError = false; |
ADIJake | 0:85855ecd3257 | 226 | volatile bool bAlert = false; |
ADIJake | 0:85855ecd3257 | 227 | res = utils_registerCallbacks(hDevice, &bDataReady, &bError, &bAlert); |
Vkadaba | 5:0728bde67bdb | 228 | if (res != ADMW_SUCCESS) |
ADIJake | 0:85855ecd3257 | 229 | return res; |
ADIJake | 0:85855ecd3257 | 230 | |
ADIJake | 0:85855ecd3257 | 231 | /* |
ADIJake | 0:85855ecd3257 | 232 | * Retrieve the number of samples per cycle, per DATAREADY pulse, etc. for |
ADIJake | 0:85855ecd3257 | 233 | * this configuration. |
ADIJake | 0:85855ecd3257 | 234 | */ |
Vkadaba | 5:0728bde67bdb | 235 | ADMW1001_OPERATING_MODE eOperatingMode; |
Vkadaba | 5:0728bde67bdb | 236 | ADMW1001_DATAREADY_MODE eDataReadyMode; |
ADIJake | 0:85855ecd3257 | 237 | uint32_t nSamplesPerDataready; |
ADIJake | 0:85855ecd3257 | 238 | uint32_t nSamplesPerCycle; |
ADIJake | 0:85855ecd3257 | 239 | uint8_t nBytesPerSample; |
Vkadaba | 5:0728bde67bdb | 240 | res = admw1001_GetDataReadyModeInfo(hDevice, |
Vkadaba | 23:bb685f35b08b | 241 | eMeasurementMode, |
Vkadaba | 23:bb685f35b08b | 242 | &eOperatingMode, |
Vkadaba | 23:bb685f35b08b | 243 | &eDataReadyMode, |
Vkadaba | 23:bb685f35b08b | 244 | &nSamplesPerDataready, |
Vkadaba | 23:bb685f35b08b | 245 | &nSamplesPerCycle, |
Vkadaba | 23:bb685f35b08b | 246 | &nBytesPerSample); |
Vkadaba | 5:0728bde67bdb | 247 | if (res != ADMW_SUCCESS) |
ADIJake | 0:85855ecd3257 | 248 | return res; |
ADIJake | 0:85855ecd3257 | 249 | |
ADIJake | 0:85855ecd3257 | 250 | /* |
ADIJake | 0:85855ecd3257 | 251 | * Allocate a buffer to store the samples retrieved on each DATAREADY pulse |
ADIJake | 0:85855ecd3257 | 252 | */ |
Vkadaba | 5:0728bde67bdb | 253 | ADMW_DATA_SAMPLE *pSampleBuffer; |
Vkadaba | 5:0728bde67bdb | 254 | pSampleBuffer = malloc(sizeof(ADMW_DATA_SAMPLE) * |
ADIJake | 0:85855ecd3257 | 255 | nSamplesPerDataready); |
Vkadaba | 23:bb685f35b08b | 256 | if (pSampleBuffer == NULL) { |
Vkadaba | 5:0728bde67bdb | 257 | ADMW_LOG_ERROR("Failed to allocate sample buffer"); |
Vkadaba | 5:0728bde67bdb | 258 | return ADMW_NO_MEM; |
ADIJake | 0:85855ecd3257 | 259 | } |
ADIJake | 0:85855ecd3257 | 260 | |
ADIJake | 0:85855ecd3257 | 261 | /* |
ADIJake | 0:85855ecd3257 | 262 | * Kick off the measurement cycle(s) here |
ADIJake | 0:85855ecd3257 | 263 | */ |
Vkadaba | 5:0728bde67bdb | 264 | ADMW_LOG_INFO("Starting measurement"); |
Vkadaba | 5:0728bde67bdb | 265 | res = admw_StartMeasurement(hDevice, eMeasurementMode); |
Vkadaba | 23:bb685f35b08b | 266 | if (res != ADMW_SUCCESS) { |
Vkadaba | 5:0728bde67bdb | 267 | ADMW_LOG_ERROR("Failed to start measurement"); |
ADIJake | 0:85855ecd3257 | 268 | return res; |
ADIJake | 0:85855ecd3257 | 269 | } |
ADIJake | 0:85855ecd3257 | 270 | |
ADIJake | 0:85855ecd3257 | 271 | /* |
ADIJake | 0:85855ecd3257 | 272 | * Loop continuously unless operating mode is single-cycle |
ADIJake | 0:85855ecd3257 | 273 | */ |
ADIJake | 0:85855ecd3257 | 274 | uint32_t nSampleCount = 0; |
ADIJake | 0:85855ecd3257 | 275 | uint32_t nReturned; |
Vkadaba | 23:bb685f35b08b | 276 | while (true) { |
Vkadaba | 5:0728bde67bdb | 277 | ADMW_STATUS status; |
ADIJake | 0:85855ecd3257 | 278 | |
ADIJake | 0:85855ecd3257 | 279 | /* |
ADIJake | 0:85855ecd3257 | 280 | * Wait until the next batch of 1 or more samples is ready, continuously |
ADIJake | 0:85855ecd3257 | 281 | * checking DATAREADY until it is asserted |
ADIJake | 0:85855ecd3257 | 282 | */ |
Vkadaba | 39:e255f52072fc | 283 | while (! (bDataReady || bError)); |
ADIJake | 0:85855ecd3257 | 284 | |
Vkadaba | 63:6d048b2f3f32 | 285 | if (!bError) { |
Vkadaba | 63:6d048b2f3f32 | 286 | /* |
Vkadaba | 63:6d048b2f3f32 | 287 | * Get data samples from the measurement cycle, if no error has occurred |
Vkadaba | 63:6d048b2f3f32 | 288 | */ |
Vkadaba | 63:6d048b2f3f32 | 289 | bDataReady = false; |
Vkadaba | 63:6d048b2f3f32 | 290 | res = admw_GetData(hDevice, eMeasurementMode, pSampleBuffer, |
Vkadaba | 63:6d048b2f3f32 | 291 | nBytesPerSample, nSamplesPerDataready, |
Vkadaba | 63:6d048b2f3f32 | 292 | &nReturned); |
Vkadaba | 63:6d048b2f3f32 | 293 | if (res != ADMW_SUCCESS) { |
Vkadaba | 63:6d048b2f3f32 | 294 | if (res == ADMW_INCOMPLETE) { |
Vkadaba | 63:6d048b2f3f32 | 295 | /* |
Vkadaba | 63:6d048b2f3f32 | 296 | * This is expected in cases where cycleSkipCount may |
Vkadaba | 63:6d048b2f3f32 | 297 | * be non-zero for some channels, resulting in |
Vkadaba | 63:6d048b2f3f32 | 298 | * variable-length sequences |
Vkadaba | 63:6d048b2f3f32 | 299 | */ |
Vkadaba | 63:6d048b2f3f32 | 300 | |
Vkadaba | 63:6d048b2f3f32 | 301 | ADMW_LOG_DEBUG("Retrieved %u of %u requested data samples", |
Vkadaba | 63:6d048b2f3f32 | 302 | nReturned, nSamplesPerDataready); |
Vkadaba | 63:6d048b2f3f32 | 303 | continue; |
Vkadaba | 63:6d048b2f3f32 | 304 | } else { |
Vkadaba | 63:6d048b2f3f32 | 305 | ADMW_LOG_WARN("Failed to get data samples from device"); |
Vkadaba | 63:6d048b2f3f32 | 306 | return res; |
ADIJake | 0:85855ecd3257 | 307 | } |
Vkadaba | 63:6d048b2f3f32 | 308 | } |
Vkadaba | 39:e255f52072fc | 309 | |
Vkadaba | 63:6d048b2f3f32 | 310 | /* |
Vkadaba | 63:6d048b2f3f32 | 311 | * Display the data samples. |
Vkadaba | 63:6d048b2f3f32 | 312 | * |
Vkadaba | 63:6d048b2f3f32 | 313 | * NOTE: this requires a sufficient idle time between subsequent |
Vkadaba | 63:6d048b2f3f32 | 314 | * DATAREADY pulses to allow printing to occur. Otherwise, |
Vkadaba | 63:6d048b2f3f32 | 315 | * subsequent samples may be missed if not retrieved promptly when |
Vkadaba | 63:6d048b2f3f32 | 316 | * the next DATAREADY assertion occurs. |
Vkadaba | 63:6d048b2f3f32 | 317 | */ |
Vkadaba | 63:6d048b2f3f32 | 318 | utils_printSamples(pSampleBuffer, nReturned, eMeasurementMode); |
Vkadaba | 63:6d048b2f3f32 | 319 | nSampleCount += nReturned; |
Vkadaba | 63:6d048b2f3f32 | 320 | } |
ADIJake | 0:85855ecd3257 | 321 | |
ADIJake | 0:85855ecd3257 | 322 | /* |
ADIJake | 0:85855ecd3257 | 323 | * Check and print device status if errors/alerts have been triggered |
ADIJake | 0:85855ecd3257 | 324 | */ |
Vkadaba | 23:bb685f35b08b | 325 | if (bError || bAlert) { |
Vkadaba | 5:0728bde67bdb | 326 | res = admw_GetStatus(hDevice, &status); |
Vkadaba | 23:bb685f35b08b | 327 | if (res != ADMW_SUCCESS) { |
Vkadaba | 5:0728bde67bdb | 328 | ADMW_LOG_ERROR("Failed to retrieve device status"); |
ADIJake | 0:85855ecd3257 | 329 | return res; |
ADIJake | 0:85855ecd3257 | 330 | } |
ADIJake | 0:85855ecd3257 | 331 | |
ADIJake | 0:85855ecd3257 | 332 | if (status.deviceStatus & |
Vkadaba | 23:bb685f35b08b | 333 | (ADMW_DEVICE_STATUS_ERROR | ADMW_DEVICE_STATUS_ALERT)) { |
ADIJake | 0:85855ecd3257 | 334 | utils_printStatus(&status); |
ADIJake | 0:85855ecd3257 | 335 | |
ADIJake | 0:85855ecd3257 | 336 | /* Break out of the loop if any errors are raised */ |
ADIJake | 0:85855ecd3257 | 337 | if (bError) |
ADIJake | 0:85855ecd3257 | 338 | break; |
ADIJake | 0:85855ecd3257 | 339 | } |
ADIJake | 0:85855ecd3257 | 340 | } |
ADIJake | 0:85855ecd3257 | 341 | |
Vkadaba | 23:bb685f35b08b | 342 | if (eOperatingMode == ADMW1001_OPERATING_MODE_SINGLECYCLE) { |
ADIJake | 0:85855ecd3257 | 343 | /* |
ADIJake | 0:85855ecd3257 | 344 | * In this mode, break out of the loop when the measurement command |
ADIJake | 0:85855ecd3257 | 345 | * has completed. |
ADIJake | 0:85855ecd3257 | 346 | * |
ADIJake | 0:85855ecd3257 | 347 | * One option is to check for the expected number of samples to be |
ADIJake | 0:85855ecd3257 | 348 | * returned for the cycle. However, cycles may have variable-length |
ADIJake | 0:85855ecd3257 | 349 | * sequences if the cycleSkipCount option is non-zero for any of the |
ADIJake | 0:85855ecd3257 | 350 | * channels. |
ADIJake | 0:85855ecd3257 | 351 | * |
ADIJake | 0:85855ecd3257 | 352 | * So, instead, we check for the command-running status, which |
ADIJake | 0:85855ecd3257 | 353 | * will de-assert in this mode when the measurement command has |
ADIJake | 0:85855ecd3257 | 354 | * completed a single cycle. |
ADIJake | 0:85855ecd3257 | 355 | */ |
ADIJake | 0:85855ecd3257 | 356 | bool bCommandRunning; |
Vkadaba | 5:0728bde67bdb | 357 | res = admw_GetCommandRunningState(hDevice, &bCommandRunning); |
Vkadaba | 23:bb685f35b08b | 358 | if (res != ADMW_SUCCESS) { |
Vkadaba | 5:0728bde67bdb | 359 | ADMW_LOG_ERROR("Failed to get command-running status"); |
ADIJake | 0:85855ecd3257 | 360 | return res; |
ADIJake | 0:85855ecd3257 | 361 | } |
ADIJake | 0:85855ecd3257 | 362 | |
ADIJake | 0:85855ecd3257 | 363 | if (!bCommandRunning && !bDataReady) |
ADIJake | 0:85855ecd3257 | 364 | break; |
ADIJake | 0:85855ecd3257 | 365 | } |
ADIJake | 0:85855ecd3257 | 366 | } |
ADIJake | 0:85855ecd3257 | 367 | |
Vkadaba | 5:0728bde67bdb | 368 | ADMW_LOG_INFO("Stopping measurement"); |
Vkadaba | 5:0728bde67bdb | 369 | res = admw_StopMeasurement(hDevice); |
Vkadaba | 23:bb685f35b08b | 370 | if (res != ADMW_SUCCESS) { |
Vkadaba | 5:0728bde67bdb | 371 | ADMW_LOG_ERROR("Failed to send stop measurement"); |
ADIJake | 0:85855ecd3257 | 372 | return res; |
ADIJake | 0:85855ecd3257 | 373 | } |
ADIJake | 0:85855ecd3257 | 374 | |
ADIJake | 0:85855ecd3257 | 375 | free(pSampleBuffer); |
ADIJake | 0:85855ecd3257 | 376 | |
ADIJake | 0:85855ecd3257 | 377 | res = utils_deregisterCallbacks(hDevice); |
Vkadaba | 5:0728bde67bdb | 378 | if (res != ADMW_SUCCESS) |
ADIJake | 0:85855ecd3257 | 379 | return res; |
ADIJake | 0:85855ecd3257 | 380 | |
Vkadaba | 5:0728bde67bdb | 381 | return ADMW_SUCCESS; |
ADIJake | 0:85855ecd3257 | 382 | } |
ADIJake | 0:85855ecd3257 | 383 |