Vybhav Kadaba / Mbed OS EV-PRO-MW1001_Development_MWARE2390

Important changes to repositories hosted on mbed.com

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

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

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

common/utils.c@70:420fac5132f5, 2020-04-23 (annotated)

Committer:
Vkadaba
Date:
Thu Apr 23 08:30:42 2020 +0000
Revision:
70:420fac5132f5
Parent:
69:4305ac772a66
Child:
71:7b5ebd969aa7
sensor result structure modified

Who changed what in which revision?

UserRevisionLine numberNew 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:");
Vkadaba 70:420fac5132f5 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 70:420fac5132f5 62 {
Vkadaba 5:0728bde67bdb 63 ADMW_LOG_INFO("\tActive FIFO Errors - ATTENTION REQUIRED");
Vkadaba 67:d36977cbfe90 64 ADMW_LOG_INFO("\tFIFO buffer full");
Vkadaba 70:420fac5132f5 65 }
Vkadaba 5:0728bde67bdb 66 if (pStatus->deviceStatus & ADMW_DEVICE_STATUS_CONFIG_ERROR)
Vkadaba 5:0728bde67bdb 67 ADMW_LOG_INFO("\tActive Configuration Errors - ATTENTION REQUIRED");
Vkadaba 23:bb685f35b08b 68 if (pStatus->deviceStatus & ADMW_DEVICE_STATUS_ALERT) {
Vkadaba 5:0728bde67bdb 69 ADMW_LOG_INFO("\tActive Alerts - ATTENTION REQUIRED:");
ADIJake 0:85855ecd3257 70
Vkadaba 23:bb685f35b08b 71 for (unsigned i = 0; i < ADMW1001_MAX_CHANNELS; i++) {
ADIJake 0:85855ecd3257 72 if (pStatus->channelAlerts[i] == 0)
ADIJake 0:85855ecd3257 73 continue;
ADIJake 0:85855ecd3257 74
Vkadaba 5:0728bde67bdb 75 ADMW_LOG_INFO("\t\tChannel #%u:", i);
Vkadaba 32:52445bef314d 76 if (pStatus->channelAlerts[i] & ADMW_ALERT_DETAIL_CH_ADC_NEAR_OVERRANGE)
Vkadaba 32:52445bef314d 77 ADMW_LOG_INFO("\t\t\ADC near overrange detected");
Vkadaba 32:52445bef314d 78 if (pStatus->channelAlerts[i] & ADMW_ALERT_DETAIL_CH_SENSOR_UNDERRANGE)
Vkadaba 32:52445bef314d 79 ADMW_LOG_INFO("\t\t\tSensor underrange detected");
Vkadaba 32:52445bef314d 80 if (pStatus->channelAlerts[i] & ADMW_ALERT_DETAIL_CH_SENSOR_OVERRANGE)
Vkadaba 32:52445bef314d 81 ADMW_LOG_INFO("\t\t\tSensor overrange detected");
Vkadaba 32:52445bef314d 82 if (pStatus->channelAlerts[i] & ADMW_ALERT_DETAIL_CH_CJ_SOFT_FAULT)
Vkadaba 32:52445bef314d 83 ADMW_LOG_INFO("\t\t\tCJC soft fault alert detected");
Vkadaba 32:52445bef314d 84 if (pStatus->channelAlerts[i] & ADMW_ALERT_DETAIL_CH_CJ_HARD_FAULT)
Vkadaba 32:52445bef314d 85 ADMW_LOG_INFO("\t\t\tCJC hard fault alert detected");
Vkadaba 32:52445bef314d 86 if (pStatus->channelAlerts[i] & ADMW_ALERT_DETAIL_CH_ADC_INPUT_OVERRANGE)
Vkadaba 32:52445bef314d 87 ADMW_LOG_INFO("\t\t\tADC input overranage alert detected");
Vkadaba 32:52445bef314d 88 if (pStatus->channelAlerts[i] & ADMW_ALERT_DETAIL_CH_SENSOR_HARDFAULT)
Vkadaba 32:52445bef314d 89 ADMW_LOG_INFO("\t\t\tChannel sensor hardfault alert detected");
ADIJake 0:85855ecd3257 90 }
ADIJake 0:85855ecd3257 91 }
Vkadaba 70:420fac5132f5 92
Vkadaba 70:420fac5132f5 93 if ((pStatus->deviceStatus & ADMW_DEVICE_STATUS_ERROR) ||
Vkadaba 70:420fac5132f5 94 (pStatus->deviceStatus & ADMW_DEVICE_STATUS_ALERT)) {
Vkadaba 70:420fac5132f5 95 ADMW_LOG_INFO("\t\tLast Debug Code: %u-%u",
Vkadaba 70:420fac5132f5 96 (pStatus->debugCode >> 16) & 0xFFFF,
Vkadaba 70:420fac5132f5 97 (pStatus->debugCode >> 0) & 0xFFFF);
Vkadaba 70:420fac5132f5 98 }
ADIJake 0:85855ecd3257 99 }
ADIJake 0:85855ecd3257 100 }
ADIJake 0:85855ecd3257 101
ADIJake 0:85855ecd3257 102 void utils_printSamples(
Vkadaba 5:0728bde67bdb 103 ADMW_DATA_SAMPLE *pSampleBuffer,
ADIJake 0:85855ecd3257 104 uint32_t nNumSamples,
Vkadaba 5:0728bde67bdb 105 ADMW_MEASUREMENT_MODE eMeasurementMode)
ADIJake 0:85855ecd3257 106 {
Vkadaba 23:bb685f35b08b 107 for (uint32_t i = 0; i < nNumSamples; i++) {
Vkadaba 65:d91e1d63153d 108 ADMW_LOG_INFO("Sample # %2d Channel_ID # %2d :: Raw_Sample %f :: processedValue %f :: flags: ERROR:%X , ALERT:%X",
Vkadaba 23:bb685f35b08b 109 i+1,
Vkadaba 65:d91e1d63153d 110 pSampleBuffer[i].Channel_ID,
Vkadaba 65:d91e1d63153d 111 pSampleBuffer[i].Raw_Sample,
Vkadaba 23:bb685f35b08b 112 pSampleBuffer[i].processedValue,
Vkadaba 65:d91e1d63153d 113 pSampleBuffer[i].Ch_Error,
Vkadaba 65:d91e1d63153d 114 pSampleBuffer[i].Ch_Alert);
Vkadaba 10:14954555be2a 115 }
ADIJake 0:85855ecd3257 116 }
ADIJake 0:85855ecd3257 117
Vkadaba 5:0728bde67bdb 118 static void gpioCallbackFn(ADMW_GPIO_PIN ePinId, void * pArg)
ADIJake 0:85855ecd3257 119 {
ADIJake 0:85855ecd3257 120 volatile bool *pbFlag = (volatile bool *)pArg;
ADIJake 0:85855ecd3257 121 *pbFlag = true;
ADIJake 0:85855ecd3257 122 }
ADIJake 0:85855ecd3257 123
Vkadaba 5:0728bde67bdb 124 ADMW_RESULT utils_registerCallbacks(
Vkadaba 5:0728bde67bdb 125 ADMW_DEVICE_HANDLE hDevice,
ADIJake 0:85855ecd3257 126 volatile bool *pbDataReady,
ADIJake 0:85855ecd3257 127 volatile bool *pbError,
ADIJake 0:85855ecd3257 128 volatile bool *pbAlert)
ADIJake 0:85855ecd3257 129 {
Vkadaba 5:0728bde67bdb 130 ADMW_RESULT res;
ADIJake 0:85855ecd3257 131 bool state;
ADIJake 0:85855ecd3257 132
Vkadaba 5:0728bde67bdb 133 res = admw_RegisterGpioCallback(hDevice, ADMW_GPIO_PIN_DATAREADY,
Vkadaba 23:bb685f35b08b 134 gpioCallbackFn, (void *)pbDataReady);
Vkadaba 23:bb685f35b08b 135 if (res != ADMW_SUCCESS) {
Vkadaba 5:0728bde67bdb 136 ADMW_LOG_ERROR("Failed to register DATAREADY callback");
ADIJake 0:85855ecd3257 137 return res;
ADIJake 0:85855ecd3257 138 }
ADIJake 0:85855ecd3257 139
Vkadaba 5:0728bde67bdb 140 res = admw_GetGpioState(hDevice, ADMW_GPIO_PIN_ALERT_ERROR, &state);
Vkadaba 23:bb685f35b08b 141 if (res != ADMW_SUCCESS) {
Vkadaba 5:0728bde67bdb 142 ADMW_LOG_ERROR("Failed to get current ERROR state");
ADIJake 0:85855ecd3257 143 return res;
ADIJake 0:85855ecd3257 144 }
Vkadaba 23:bb685f35b08b 145 if (state) {
Vkadaba 5:0728bde67bdb 146 ADMW_LOG_ERROR("ERROR signal already asserted");
Vkadaba 5:0728bde67bdb 147 return ADMW_FAILURE;
ADIJake 0:85855ecd3257 148 }
Vkadaba 5:0728bde67bdb 149 res = admw_RegisterGpioCallback(hDevice, ADMW_GPIO_PIN_ALERT_ERROR,
Vkadaba 23:bb685f35b08b 150 gpioCallbackFn, (void *)pbError);
Vkadaba 23:bb685f35b08b 151 if (res != ADMW_SUCCESS) {
Vkadaba 5:0728bde67bdb 152 ADMW_LOG_ERROR("Failed to register ERROR callback");
ADIJake 0:85855ecd3257 153 return res;
ADIJake 0:85855ecd3257 154 }
ADIJake 0:85855ecd3257 155
Vkadaba 5:0728bde67bdb 156 /*res = admw_GetGpioState(hDevice, ADMW_GPIO_PIN_ALERT, &state);
Vkadaba 5:0728bde67bdb 157 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 158 {
Vkadaba 5:0728bde67bdb 159 ADMW_LOG_ERROR("Failed to get current ALERT state");
ADIJake 0:85855ecd3257 160 return res;
ADIJake 0:85855ecd3257 161 }
ADIJake 0:85855ecd3257 162 if (state)
ADIJake 0:85855ecd3257 163 {
Vkadaba 5:0728bde67bdb 164 ADMW_LOG_ERROR("ALERT signal already asserted");
Vkadaba 5:0728bde67bdb 165 return ADMW_FAILURE;
ADIJake 1:63dd03580de4 166 }*/
Vkadaba 5:0728bde67bdb 167 res = admw_RegisterGpioCallback(hDevice, ADMW_GPIO_PIN_ALERT_ERROR,
Vkadaba 23:bb685f35b08b 168 gpioCallbackFn, (void *)pbAlert);
Vkadaba 23:bb685f35b08b 169 if (res != ADMW_SUCCESS) {
Vkadaba 5:0728bde67bdb 170 ADMW_LOG_ERROR("Failed to register ALERT callback");
ADIJake 0:85855ecd3257 171 return res;
ADIJake 0:85855ecd3257 172 }
ADIJake 0:85855ecd3257 173
Vkadaba 5:0728bde67bdb 174 return ADMW_SUCCESS;
ADIJake 0:85855ecd3257 175 }
ADIJake 0:85855ecd3257 176
Vkadaba 5:0728bde67bdb 177 ADMW_RESULT utils_deregisterCallbacks(
Vkadaba 5:0728bde67bdb 178 ADMW_DEVICE_HANDLE hDevice)
ADIJake 0:85855ecd3257 179 {
Vkadaba 5:0728bde67bdb 180 ADMW_RESULT res;
ADIJake 0:85855ecd3257 181
Vkadaba 5:0728bde67bdb 182 res = admw_RegisterGpioCallback(hDevice, ADMW_GPIO_PIN_DATAREADY,
Vkadaba 23:bb685f35b08b 183 NULL, NULL);
Vkadaba 23:bb685f35b08b 184 if (res != ADMW_SUCCESS) {
Vkadaba 5:0728bde67bdb 185 ADMW_LOG_ERROR("Failed to deregister DATAREADY callback");
ADIJake 0:85855ecd3257 186 return res;
ADIJake 0:85855ecd3257 187 }
ADIJake 0:85855ecd3257 188
Vkadaba 5:0728bde67bdb 189 res = admw_RegisterGpioCallback(hDevice, ADMW_GPIO_PIN_ALERT_ERROR,
Vkadaba 23:bb685f35b08b 190 NULL, NULL);
Vkadaba 23:bb685f35b08b 191 if (res != ADMW_SUCCESS) {
Vkadaba 5:0728bde67bdb 192 ADMW_LOG_ERROR("Failed to deregister ERROR callback");
ADIJake 0:85855ecd3257 193 return res;
ADIJake 0:85855ecd3257 194 }
ADIJake 0:85855ecd3257 195
Vkadaba 5:0728bde67bdb 196 res = admw_RegisterGpioCallback(hDevice, ADMW_GPIO_PIN_ALERT_ERROR,
Vkadaba 23:bb685f35b08b 197 NULL, NULL);
Vkadaba 23:bb685f35b08b 198 if (res != ADMW_SUCCESS) {
Vkadaba 5:0728bde67bdb 199 ADMW_LOG_INFO("Failed to deregister ALERT callback");
ADIJake 0:85855ecd3257 200 return res;
ADIJake 0:85855ecd3257 201 }
ADIJake 0:85855ecd3257 202
Vkadaba 5:0728bde67bdb 203 return ADMW_SUCCESS;
ADIJake 0:85855ecd3257 204 }
ADIJake 0:85855ecd3257 205
Vkadaba 5:0728bde67bdb 206 ADMW_RESULT utils_runMeasurement(
Vkadaba 5:0728bde67bdb 207 ADMW_DEVICE_HANDLE hDevice,
Vkadaba 5:0728bde67bdb 208 ADMW_MEASUREMENT_MODE eMeasurementMode)
ADIJake 0:85855ecd3257 209 {
Vkadaba 5:0728bde67bdb 210 ADMW_RESULT res;
ADIJake 0:85855ecd3257 211 volatile bool bDataReady = false;
ADIJake 0:85855ecd3257 212 volatile bool bError = false;
ADIJake 0:85855ecd3257 213 volatile bool bAlert = false;
ADIJake 0:85855ecd3257 214 res = utils_registerCallbacks(hDevice, &bDataReady, &bError, &bAlert);
Vkadaba 5:0728bde67bdb 215 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 216 return res;
ADIJake 0:85855ecd3257 217
ADIJake 0:85855ecd3257 218 /*
ADIJake 0:85855ecd3257 219 * Retrieve the number of samples per cycle, per DATAREADY pulse, etc. for
ADIJake 0:85855ecd3257 220 * this configuration.
ADIJake 0:85855ecd3257 221 */
Vkadaba 5:0728bde67bdb 222 ADMW1001_OPERATING_MODE eOperatingMode;
Vkadaba 5:0728bde67bdb 223 ADMW1001_DATAREADY_MODE eDataReadyMode;
ADIJake 0:85855ecd3257 224 uint32_t nSamplesPerDataready;
ADIJake 0:85855ecd3257 225 uint32_t nSamplesPerCycle;
ADIJake 0:85855ecd3257 226 uint8_t nBytesPerSample;
Vkadaba 5:0728bde67bdb 227 res = admw1001_GetDataReadyModeInfo(hDevice,
Vkadaba 23:bb685f35b08b 228 eMeasurementMode,
Vkadaba 23:bb685f35b08b 229 &eOperatingMode,
Vkadaba 23:bb685f35b08b 230 &eDataReadyMode,
Vkadaba 23:bb685f35b08b 231 &nSamplesPerDataready,
Vkadaba 23:bb685f35b08b 232 &nSamplesPerCycle,
Vkadaba 23:bb685f35b08b 233 &nBytesPerSample);
Vkadaba 5:0728bde67bdb 234 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 235 return res;
ADIJake 0:85855ecd3257 236
ADIJake 0:85855ecd3257 237 /*
ADIJake 0:85855ecd3257 238 * Allocate a buffer to store the samples retrieved on each DATAREADY pulse
ADIJake 0:85855ecd3257 239 */
Vkadaba 5:0728bde67bdb 240 ADMW_DATA_SAMPLE *pSampleBuffer;
Vkadaba 5:0728bde67bdb 241 pSampleBuffer = malloc(sizeof(ADMW_DATA_SAMPLE) *
ADIJake 0:85855ecd3257 242 nSamplesPerDataready);
Vkadaba 23:bb685f35b08b 243 if (pSampleBuffer == NULL) {
Vkadaba 5:0728bde67bdb 244 ADMW_LOG_ERROR("Failed to allocate sample buffer");
Vkadaba 5:0728bde67bdb 245 return ADMW_NO_MEM;
ADIJake 0:85855ecd3257 246 }
ADIJake 0:85855ecd3257 247
ADIJake 0:85855ecd3257 248 /*
ADIJake 0:85855ecd3257 249 * Kick off the measurement cycle(s) here
ADIJake 0:85855ecd3257 250 */
Vkadaba 5:0728bde67bdb 251 ADMW_LOG_INFO("Starting measurement");
Vkadaba 5:0728bde67bdb 252 res = admw_StartMeasurement(hDevice, eMeasurementMode);
Vkadaba 23:bb685f35b08b 253 if (res != ADMW_SUCCESS) {
Vkadaba 5:0728bde67bdb 254 ADMW_LOG_ERROR("Failed to start measurement");
ADIJake 0:85855ecd3257 255 return res;
ADIJake 0:85855ecd3257 256 }
ADIJake 0:85855ecd3257 257
ADIJake 0:85855ecd3257 258 /*
ADIJake 0:85855ecd3257 259 * Loop continuously unless operating mode is single-cycle
ADIJake 0:85855ecd3257 260 */
ADIJake 0:85855ecd3257 261 uint32_t nSampleCount = 0;
ADIJake 0:85855ecd3257 262 uint32_t nReturned;
Vkadaba 23:bb685f35b08b 263 while (true) {
Vkadaba 70:420fac5132f5 264 ADMW_STATUS status;
ADIJake 0:85855ecd3257 265
ADIJake 0:85855ecd3257 266 /*
ADIJake 0:85855ecd3257 267 * Wait until the next batch of 1 or more samples is ready, continuously
ADIJake 0:85855ecd3257 268 * checking DATAREADY until it is asserted
ADIJake 0:85855ecd3257 269 */
Vkadaba 70:420fac5132f5 270 res = admw_GetStatus(hDevice, &status);
Vkadaba 70:420fac5132f5 271 if (res != ADMW_SUCCESS) {
Vkadaba 70:420fac5132f5 272 ADMW_LOG_ERROR("Failed to retrieve device status");
Vkadaba 70:420fac5132f5 273 }
Vkadaba 70:420fac5132f5 274 if (status.deviceStatus & ADMW_DEVICE_STATUS_FIFO_ERROR)
Vkadaba 70:420fac5132f5 275 {
Vkadaba 70:420fac5132f5 276 utils_printStatus(&status);
Vkadaba 70:420fac5132f5 277 break;
Vkadaba 70:420fac5132f5 278 }
Vkadaba 70:420fac5132f5 279 while (! (bDataReady || bError));
Vkadaba 39:e255f52072fc 280 if (!bError) {
Vkadaba 39:e255f52072fc 281 /*
Vkadaba 39:e255f52072fc 282 * Get data samples from the measurement cycle, if no error has occurred
Vkadaba 39:e255f52072fc 283 */
Vkadaba 39:e255f52072fc 284 bDataReady = false;
Vkadaba 39:e255f52072fc 285 res = admw_GetData(hDevice, eMeasurementMode, pSampleBuffer,
Vkadaba 39:e255f52072fc 286 nBytesPerSample, nSamplesPerDataready,
Vkadaba 39:e255f52072fc 287 &nReturned);
Vkadaba 39:e255f52072fc 288 if (res != ADMW_SUCCESS) {
Vkadaba 39:e255f52072fc 289 if (res == ADMW_INCOMPLETE) {
Vkadaba 39:e255f52072fc 290 /*
Vkadaba 39:e255f52072fc 291 * This is expected in cases where cycleSkipCount may
Vkadaba 39:e255f52072fc 292 * be non-zero for some channels, resulting in
Vkadaba 39:e255f52072fc 293 * variable-length sequences
Vkadaba 39:e255f52072fc 294 */
Vkadaba 55:215da406282b 295
Vkadaba 39:e255f52072fc 296 ADMW_LOG_DEBUG("Retrieved %u of %u requested data samples",
Vkadaba 56:38b36e947602 297 nReturned, nSamplesPerDataready);
Vkadaba 39:e255f52072fc 298 continue;
Vkadaba 39:e255f52072fc 299 } else {
Vkadaba 39:e255f52072fc 300 ADMW_LOG_WARN("Failed to get data samples from device");
Vkadaba 39:e255f52072fc 301 return res;
Vkadaba 39:e255f52072fc 302 }
ADIJake 0:85855ecd3257 303 }
Vkadaba 39:e255f52072fc 304
Vkadaba 39:e255f52072fc 305 /*
Vkadaba 39:e255f52072fc 306 * Display the data samples.
Vkadaba 39:e255f52072fc 307 *
Vkadaba 39:e255f52072fc 308 * NOTE: this requires a sufficient idle time between subsequent
Vkadaba 39:e255f52072fc 309 * DATAREADY pulses to allow printing to occur. Otherwise,
Vkadaba 39:e255f52072fc 310 * subsequent samples may be missed if not retrieved promptly when
Vkadaba 39:e255f52072fc 311 * the next DATAREADY assertion occurs.
Vkadaba 39:e255f52072fc 312 */
Vkadaba 39:e255f52072fc 313 utils_printSamples(pSampleBuffer, nReturned, eMeasurementMode);
Vkadaba 39:e255f52072fc 314 nSampleCount += nReturned;
ADIJake 0:85855ecd3257 315 }
ADIJake 0:85855ecd3257 316
ADIJake 0:85855ecd3257 317 /*
ADIJake 0:85855ecd3257 318 * Check and print device status if errors/alerts have been triggered
ADIJake 0:85855ecd3257 319 */
Vkadaba 23:bb685f35b08b 320 if (bError || bAlert) {
Vkadaba 5:0728bde67bdb 321 res = admw_GetStatus(hDevice, &status);
Vkadaba 23:bb685f35b08b 322 if (res != ADMW_SUCCESS) {
Vkadaba 5:0728bde67bdb 323 ADMW_LOG_ERROR("Failed to retrieve device status");
ADIJake 0:85855ecd3257 324 return res;
ADIJake 0:85855ecd3257 325 }
ADIJake 0:85855ecd3257 326
ADIJake 0:85855ecd3257 327 if (status.deviceStatus &
Vkadaba 23:bb685f35b08b 328 (ADMW_DEVICE_STATUS_ERROR | ADMW_DEVICE_STATUS_ALERT)) {
ADIJake 0:85855ecd3257 329 utils_printStatus(&status);
ADIJake 0:85855ecd3257 330
ADIJake 0:85855ecd3257 331 /* Break out of the loop if any errors are raised */
ADIJake 0:85855ecd3257 332 if (bError)
ADIJake 0:85855ecd3257 333 break;
ADIJake 0:85855ecd3257 334 }
ADIJake 0:85855ecd3257 335 }
ADIJake 0:85855ecd3257 336
Vkadaba 23:bb685f35b08b 337 if (eOperatingMode == ADMW1001_OPERATING_MODE_SINGLECYCLE) {
ADIJake 0:85855ecd3257 338 /*
ADIJake 0:85855ecd3257 339 * In this mode, break out of the loop when the measurement command
ADIJake 0:85855ecd3257 340 * has completed.
ADIJake 0:85855ecd3257 341 *
ADIJake 0:85855ecd3257 342 * One option is to check for the expected number of samples to be
ADIJake 0:85855ecd3257 343 * returned for the cycle. However, cycles may have variable-length
ADIJake 0:85855ecd3257 344 * sequences if the cycleSkipCount option is non-zero for any of the
ADIJake 0:85855ecd3257 345 * channels.
ADIJake 0:85855ecd3257 346 *
ADIJake 0:85855ecd3257 347 * So, instead, we check for the command-running status, which
ADIJake 0:85855ecd3257 348 * will de-assert in this mode when the measurement command has
ADIJake 0:85855ecd3257 349 * completed a single cycle.
ADIJake 0:85855ecd3257 350 */
ADIJake 0:85855ecd3257 351 bool bCommandRunning;
Vkadaba 5:0728bde67bdb 352 res = admw_GetCommandRunningState(hDevice, &bCommandRunning);
Vkadaba 23:bb685f35b08b 353 if (res != ADMW_SUCCESS) {
Vkadaba 5:0728bde67bdb 354 ADMW_LOG_ERROR("Failed to get command-running status");
ADIJake 0:85855ecd3257 355 return res;
ADIJake 0:85855ecd3257 356 }
ADIJake 0:85855ecd3257 357
ADIJake 0:85855ecd3257 358 if (!bCommandRunning && !bDataReady)
ADIJake 0:85855ecd3257 359 break;
ADIJake 0:85855ecd3257 360 }
ADIJake 0:85855ecd3257 361 }
ADIJake 0:85855ecd3257 362
Vkadaba 5:0728bde67bdb 363 ADMW_LOG_INFO("Stopping measurement");
Vkadaba 5:0728bde67bdb 364 res = admw_StopMeasurement(hDevice);
Vkadaba 23:bb685f35b08b 365 if (res != ADMW_SUCCESS) {
Vkadaba 5:0728bde67bdb 366 ADMW_LOG_ERROR("Failed to send stop measurement");
ADIJake 0:85855ecd3257 367 return res;
ADIJake 0:85855ecd3257 368 }
ADIJake 0:85855ecd3257 369
ADIJake 0:85855ecd3257 370 free(pSampleBuffer);
ADIJake 0:85855ecd3257 371
ADIJake 0:85855ecd3257 372 res = utils_deregisterCallbacks(hDevice);
Vkadaba 5:0728bde67bdb 373 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 374 return res;
ADIJake 0:85855ecd3257 375
Vkadaba 5:0728bde67bdb 376 return ADMW_SUCCESS;
ADIJake 0:85855ecd3257 377 }
ADIJake 0:85855ecd3257 378