Vybhav Kadaba / Mbed OS EV-PRO-MW1001_MWARE1832

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@6:9d393a9677f4, 2019-06-15 (annotated)

Committer:
Vkadaba
Date:
Sat Jun 15 14:30:49 2019 +0000
Revision:
6:9d393a9677f4
Parent:
5:0728bde67bdb
Child:
10:14954555be2a
Register map is updated and sensor config files are modified

Who changed what in which revision?

UserRevisionLine numberNew contents of line
ADIJake 0:85855ecd3257 1 #include <stdlib.h>
ADIJake 0:85855ecd3257 2
ADIJake 0:85855ecd3257 3 #include "utils.h"
Vkadaba 5:0728bde67bdb 4 #include "admw_log.h"
ADIJake 0:85855ecd3257 5
ADIJake 0:85855ecd3257 6 void utils_printStatus(
Vkadaba 5:0728bde67bdb 7 ADMW_STATUS *pStatus)
ADIJake 0:85855ecd3257 8 {
Vkadaba 5:0728bde67bdb 9 ADMW_LOG_INFO("Status Summary:");
ADIJake 0:85855ecd3257 10
ADIJake 0:85855ecd3257 11 if (pStatus->deviceStatus == 0)
ADIJake 0:85855ecd3257 12 {
Vkadaba 5:0728bde67bdb 13 ADMW_LOG_INFO("\tNo errors detected");
ADIJake 0:85855ecd3257 14 }
ADIJake 0:85855ecd3257 15 else
ADIJake 0:85855ecd3257 16 {
Vkadaba 5:0728bde67bdb 17 if (pStatus->deviceStatus & ADMW_DEVICE_STATUS_BUSY)
Vkadaba 5:0728bde67bdb 18 ADMW_LOG_INFO("\tCommand running");
Vkadaba 5:0728bde67bdb 19 if (pStatus->deviceStatus & ADMW_DEVICE_STATUS_DATAREADY)
Vkadaba 5:0728bde67bdb 20 ADMW_LOG_INFO("\tData ready");
Vkadaba 5:0728bde67bdb 21 if (pStatus->deviceStatus & ADMW_DEVICE_STATUS_ERROR)
Vkadaba 5:0728bde67bdb 22 ADMW_LOG_INFO("\tActive Errors - RESET REQUIRED");
Vkadaba 5:0728bde67bdb 23 if (pStatus->deviceStatus & ADMW_DEVICE_STATUS_FIFO_ERROR)
Vkadaba 5:0728bde67bdb 24 ADMW_LOG_INFO("\tActive FIFO Errors - ATTENTION REQUIRED");
Vkadaba 5:0728bde67bdb 25 if (pStatus->deviceStatus & ADMW_DEVICE_STATUS_CONFIG_ERROR)
Vkadaba 5:0728bde67bdb 26 ADMW_LOG_INFO("\tActive Configuration Errors - ATTENTION REQUIRED");
Vkadaba 5:0728bde67bdb 27 if (pStatus->deviceStatus & ADMW_DEVICE_STATUS_LUT_ERROR)
Vkadaba 5:0728bde67bdb 28 ADMW_LOG_INFO("\tActive Look-Up Table Errors - ATTENTION REQUIRED");
Vkadaba 6:9d393a9677f4 29
ADIJake 0:85855ecd3257 30
Vkadaba 5:0728bde67bdb 31 if (pStatus->deviceStatus & ADMW_DEVICE_STATUS_ERROR)
ADIJake 0:85855ecd3257 32 {
Vkadaba 5:0728bde67bdb 33 ADMW_LOG_INFO("\tActive Errors - ATTENTION REQUIRED");
Vkadaba 5:0728bde67bdb 34 ADMW_LOG_INFO("\t\tLast Error Code: %u (0x%X)",
ADIJake 0:85855ecd3257 35 pStatus->errorCode, pStatus->errorCode);
ADIJake 0:85855ecd3257 36
ADIJake 0:85855ecd3257 37 if (pStatus->diagnosticsStatus == 0)
ADIJake 0:85855ecd3257 38 {
Vkadaba 5:0728bde67bdb 39 ADMW_LOG_INFO("\t\tNo diagnostics faults detected");
ADIJake 0:85855ecd3257 40 }
ADIJake 0:85855ecd3257 41 else
ADIJake 0:85855ecd3257 42 {
Vkadaba 5:0728bde67bdb 43 ADMW_LOG_INFO("\t\tActive diagnostics faults:");
ADIJake 0:85855ecd3257 44
Vkadaba 5:0728bde67bdb 45 if (pStatus->diagnosticsStatus & ADMW_DIAGNOSTICS_STATUS_CHECKSUM_ERROR)
Vkadaba 5:0728bde67bdb 46 ADMW_LOG_INFO("\t\t\tInternal Checksum fault detected");
Vkadaba 6:9d393a9677f4 47
Vkadaba 6:9d393a9677f4 48
Vkadaba 6:9d393a9677f4 49
Vkadaba 5:0728bde67bdb 50 if (pStatus->diagnosticsStatus & ADMW_DIAGNOSTICS_STATUS_CONVERSION_ERROR)
Vkadaba 5:0728bde67bdb 51 ADMW_LOG_INFO("\t\t\tInternal ADC Conversions fault detected");
Vkadaba 5:0728bde67bdb 52 if (pStatus->diagnosticsStatus & ADMW_DIAGNOSTICS_STATUS_CALIBRATION_ERROR)
Vkadaba 5:0728bde67bdb 53 ADMW_LOG_INFO("\t\t\tInternal Device Calibrations fault detected");
ADIJake 0:85855ecd3257 54 }
ADIJake 0:85855ecd3257 55 }
ADIJake 0:85855ecd3257 56
Vkadaba 5:0728bde67bdb 57 if (pStatus->deviceStatus & ADMW_DEVICE_STATUS_ALERT)
ADIJake 0:85855ecd3257 58 {
Vkadaba 5:0728bde67bdb 59 ADMW_LOG_INFO("\tActive Alerts - ATTENTION REQUIRED:");
Vkadaba 5:0728bde67bdb 60 ADMW_LOG_INFO("\t\tLast Alert Code: %u (0x%X)",
ADIJake 0:85855ecd3257 61 pStatus->alertCode, pStatus->alertCode);
ADIJake 0:85855ecd3257 62
Vkadaba 5:0728bde67bdb 63 for (unsigned i = 0; i < ADMW1001_MAX_CHANNELS; i++)
ADIJake 0:85855ecd3257 64 {
ADIJake 0:85855ecd3257 65 if (pStatus->channelAlerts[i] == 0)
ADIJake 0:85855ecd3257 66 continue;
ADIJake 0:85855ecd3257 67
Vkadaba 5:0728bde67bdb 68 ADMW_LOG_INFO("\t\tChannel #%u:", i);
Vkadaba 5:0728bde67bdb 69 ADMW_LOG_INFO("\t\t\tLast Alert Code: %u (0x%X)",
ADIJake 0:85855ecd3257 70 pStatus->channelAlertCodes[i],
ADIJake 0:85855ecd3257 71 pStatus->channelAlertCodes[i]);
Vkadaba 5:0728bde67bdb 72 if (pStatus->channelAlerts[i] & ADMW_CHANNEL_ALERT_TIMEOUT)
Vkadaba 5:0728bde67bdb 73 ADMW_LOG_INFO("\t\t\tTimeout alert detected");
Vkadaba 5:0728bde67bdb 74 if (pStatus->channelAlerts[i] & ADMW_CHANNEL_ALERT_UNDER_RANGE)
Vkadaba 5:0728bde67bdb 75 ADMW_LOG_INFO("\t\t\tUnder Range alert detected");
Vkadaba 5:0728bde67bdb 76 if (pStatus->channelAlerts[i] & ADMW_CHANNEL_ALERT_OVER_RANGE)
Vkadaba 5:0728bde67bdb 77 ADMW_LOG_INFO("\t\t\tOver Range alert detected");
Vkadaba 5:0728bde67bdb 78 if (pStatus->channelAlerts[i] & ADMW_CHANNEL_ALERT_LOW_LIMIT)
Vkadaba 5:0728bde67bdb 79 ADMW_LOG_INFO("\t\t\tLow limit alert detected");
Vkadaba 5:0728bde67bdb 80 if (pStatus->channelAlerts[i] & ADMW_CHANNEL_ALERT_HIGH_LIMIT)
Vkadaba 5:0728bde67bdb 81 ADMW_LOG_INFO("\t\t\tHigh Limit alert detected");
Vkadaba 5:0728bde67bdb 82 if (pStatus->channelAlerts[i] & ADMW_CHANNEL_ALERT_SENSOR_OPEN)
Vkadaba 5:0728bde67bdb 83 ADMW_LOG_INFO("\t\t\tSensor Fault alert detected");
Vkadaba 5:0728bde67bdb 84 if (pStatus->channelAlerts[i] & ADMW_CHANNEL_ALERT_REF_DETECT)
Vkadaba 5:0728bde67bdb 85 ADMW_LOG_INFO("\t\t\tReference Detection alert detected");
Vkadaba 5:0728bde67bdb 86 if (pStatus->channelAlerts[i] & ADMW_CHANNEL_ALERT_CONFIG_ERR)
Vkadaba 5:0728bde67bdb 87 ADMW_LOG_INFO("\t\t\tConfiguration Error alert detected");
Vkadaba 5:0728bde67bdb 88 if (pStatus->channelAlerts[i] & ADMW_CHANNEL_ALERT_LUT_ERR)
Vkadaba 5:0728bde67bdb 89 ADMW_LOG_INFO("\t\t\tLook-Up Table Error alert detected");
Vkadaba 5:0728bde67bdb 90 if (pStatus->channelAlerts[i] & ADMW_CHANNEL_ALERT_SENSOR_NOT_READY)
Vkadaba 5:0728bde67bdb 91 ADMW_LOG_INFO("\t\t\tSensor Not Ready alert detected");
Vkadaba 5:0728bde67bdb 92 if (pStatus->channelAlerts[i] & ADMW_CHANNEL_ALERT_COMP_NOT_READY)
Vkadaba 5:0728bde67bdb 93 ADMW_LOG_INFO("\t\t\tCompensation Channel Not Ready alert detected");
Vkadaba 5:0728bde67bdb 94 if (pStatus->channelAlerts[i] & ADMW_CHANNEL_ALERT_LUT_UNDER_RANGE)
Vkadaba 5:0728bde67bdb 95 ADMW_LOG_INFO("\t\t\tUnder Look-Up Table Range alert detected");
Vkadaba 5:0728bde67bdb 96 if (pStatus->channelAlerts[i] & ADMW_CHANNEL_ALERT_LUT_OVER_RANGE)
Vkadaba 5:0728bde67bdb 97 ADMW_LOG_INFO("\t\t\tOver Look-Up Table Range alert detected");
ADIJake 0:85855ecd3257 98 }
ADIJake 0:85855ecd3257 99 }
ADIJake 0:85855ecd3257 100
Vkadaba 5:0728bde67bdb 101 if ((pStatus->deviceStatus & ADMW_DEVICE_STATUS_ERROR) ||
Vkadaba 5:0728bde67bdb 102 (pStatus->deviceStatus & ADMW_DEVICE_STATUS_ALERT))
ADIJake 0:85855ecd3257 103 {
Vkadaba 5:0728bde67bdb 104 ADMW_LOG_INFO("\t\tLast Debug Code: %u-%u",
ADIJake 0:85855ecd3257 105 (pStatus->debugCode >> 16) & 0xFFFF,
ADIJake 0:85855ecd3257 106 (pStatus->debugCode >> 0) & 0xFFFF);
ADIJake 0:85855ecd3257 107 }
ADIJake 0:85855ecd3257 108 }
ADIJake 0:85855ecd3257 109 }
ADIJake 0:85855ecd3257 110
ADIJake 0:85855ecd3257 111 void utils_printSamples(
Vkadaba 5:0728bde67bdb 112 ADMW_DATA_SAMPLE *pSampleBuffer,
ADIJake 0:85855ecd3257 113 uint32_t nNumSamples,
Vkadaba 5:0728bde67bdb 114 ADMW_MEASUREMENT_MODE eMeasurementMode)
ADIJake 0:85855ecd3257 115 {
Vkadaba 6:9d393a9677f4 116
ADIJake 0:85855ecd3257 117
Vkadaba 6:9d393a9677f4 118
Vkadaba 6:9d393a9677f4 119
Vkadaba 6:9d393a9677f4 120
ADIJake 0:85855ecd3257 121 }
ADIJake 0:85855ecd3257 122
Vkadaba 5:0728bde67bdb 123 static void gpioCallbackFn(ADMW_GPIO_PIN ePinId, void * pArg)
ADIJake 0:85855ecd3257 124 {
ADIJake 0:85855ecd3257 125 volatile bool *pbFlag = (volatile bool *)pArg;
ADIJake 0:85855ecd3257 126 *pbFlag = true;
ADIJake 0:85855ecd3257 127 }
ADIJake 0:85855ecd3257 128
Vkadaba 5:0728bde67bdb 129 ADMW_RESULT utils_registerCallbacks(
Vkadaba 5:0728bde67bdb 130 ADMW_DEVICE_HANDLE hDevice,
ADIJake 0:85855ecd3257 131 volatile bool *pbDataReady,
ADIJake 0:85855ecd3257 132 volatile bool *pbError,
ADIJake 0:85855ecd3257 133 volatile bool *pbAlert)
ADIJake 0:85855ecd3257 134 {
Vkadaba 5:0728bde67bdb 135 ADMW_RESULT res;
ADIJake 0:85855ecd3257 136 bool state;
ADIJake 0:85855ecd3257 137
Vkadaba 5:0728bde67bdb 138 res = admw_RegisterGpioCallback(hDevice, ADMW_GPIO_PIN_DATAREADY,
ADIJake 0:85855ecd3257 139 gpioCallbackFn, (void *)pbDataReady);
Vkadaba 5:0728bde67bdb 140 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 141 {
Vkadaba 5:0728bde67bdb 142 ADMW_LOG_ERROR("Failed to register DATAREADY callback");
ADIJake 0:85855ecd3257 143 return res;
ADIJake 0:85855ecd3257 144 }
ADIJake 0:85855ecd3257 145
Vkadaba 5:0728bde67bdb 146 res = admw_GetGpioState(hDevice, ADMW_GPIO_PIN_ALERT_ERROR, &state);
Vkadaba 5:0728bde67bdb 147 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 148 {
Vkadaba 5:0728bde67bdb 149 ADMW_LOG_ERROR("Failed to get current ERROR state");
ADIJake 0:85855ecd3257 150 return res;
ADIJake 0:85855ecd3257 151 }
ADIJake 0:85855ecd3257 152 if (state)
ADIJake 0:85855ecd3257 153 {
Vkadaba 5:0728bde67bdb 154 ADMW_LOG_ERROR("ERROR signal already asserted");
Vkadaba 5:0728bde67bdb 155 return ADMW_FAILURE;
ADIJake 0:85855ecd3257 156 }
Vkadaba 5:0728bde67bdb 157 res = admw_RegisterGpioCallback(hDevice, ADMW_GPIO_PIN_ALERT_ERROR,
ADIJake 0:85855ecd3257 158 gpioCallbackFn, (void *)pbError);
Vkadaba 5:0728bde67bdb 159 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 160 {
Vkadaba 5:0728bde67bdb 161 ADMW_LOG_ERROR("Failed to register ERROR callback");
ADIJake 0:85855ecd3257 162 return res;
ADIJake 0:85855ecd3257 163 }
ADIJake 0:85855ecd3257 164
Vkadaba 5:0728bde67bdb 165 /*res = admw_GetGpioState(hDevice, ADMW_GPIO_PIN_ALERT, &state);
Vkadaba 5:0728bde67bdb 166 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 167 {
Vkadaba 5:0728bde67bdb 168 ADMW_LOG_ERROR("Failed to get current ALERT state");
ADIJake 0:85855ecd3257 169 return res;
ADIJake 0:85855ecd3257 170 }
ADIJake 0:85855ecd3257 171 if (state)
ADIJake 0:85855ecd3257 172 {
Vkadaba 5:0728bde67bdb 173 ADMW_LOG_ERROR("ALERT signal already asserted");
Vkadaba 5:0728bde67bdb 174 return ADMW_FAILURE;
ADIJake 1:63dd03580de4 175 }*/
Vkadaba 5:0728bde67bdb 176 res = admw_RegisterGpioCallback(hDevice, ADMW_GPIO_PIN_ALERT_ERROR,
ADIJake 0:85855ecd3257 177 gpioCallbackFn, (void *)pbAlert);
Vkadaba 5:0728bde67bdb 178 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 179 {
Vkadaba 5:0728bde67bdb 180 ADMW_LOG_ERROR("Failed to register ALERT callback");
ADIJake 0:85855ecd3257 181 return res;
ADIJake 0:85855ecd3257 182 }
ADIJake 0:85855ecd3257 183
Vkadaba 5:0728bde67bdb 184 return ADMW_SUCCESS;
ADIJake 0:85855ecd3257 185 }
ADIJake 0:85855ecd3257 186
Vkadaba 5:0728bde67bdb 187 ADMW_RESULT utils_deregisterCallbacks(
Vkadaba 5:0728bde67bdb 188 ADMW_DEVICE_HANDLE hDevice)
ADIJake 0:85855ecd3257 189 {
Vkadaba 5:0728bde67bdb 190 ADMW_RESULT res;
ADIJake 0:85855ecd3257 191
Vkadaba 5:0728bde67bdb 192 res = admw_RegisterGpioCallback(hDevice, ADMW_GPIO_PIN_DATAREADY,
ADIJake 0:85855ecd3257 193 NULL, NULL);
Vkadaba 5:0728bde67bdb 194 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 195 {
Vkadaba 5:0728bde67bdb 196 ADMW_LOG_ERROR("Failed to deregister DATAREADY callback");
ADIJake 0:85855ecd3257 197 return res;
ADIJake 0:85855ecd3257 198 }
ADIJake 0:85855ecd3257 199
Vkadaba 5:0728bde67bdb 200 res = admw_RegisterGpioCallback(hDevice, ADMW_GPIO_PIN_ALERT_ERROR,
ADIJake 0:85855ecd3257 201 NULL, NULL);
Vkadaba 5:0728bde67bdb 202 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 203 {
Vkadaba 5:0728bde67bdb 204 ADMW_LOG_ERROR("Failed to deregister ERROR callback");
ADIJake 0:85855ecd3257 205 return res;
ADIJake 0:85855ecd3257 206 }
ADIJake 0:85855ecd3257 207
Vkadaba 5:0728bde67bdb 208 res = admw_RegisterGpioCallback(hDevice, ADMW_GPIO_PIN_ALERT_ERROR,
ADIJake 0:85855ecd3257 209 NULL, NULL);
Vkadaba 5:0728bde67bdb 210 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 211 {
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
ADIJake 0:85855ecd3257 225 volatile bool bDataReady = false;
ADIJake 0:85855ecd3257 226 volatile bool bError = false;
ADIJake 0:85855ecd3257 227 volatile bool bAlert = false;
ADIJake 0:85855ecd3257 228 res = utils_registerCallbacks(hDevice, &bDataReady, &bError, &bAlert);
Vkadaba 5:0728bde67bdb 229 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 230 return res;
ADIJake 0:85855ecd3257 231
ADIJake 0:85855ecd3257 232 /*
ADIJake 0:85855ecd3257 233 * Retrieve the number of samples per cycle, per DATAREADY pulse, etc. for
ADIJake 0:85855ecd3257 234 * this configuration.
ADIJake 0:85855ecd3257 235 */
Vkadaba 5:0728bde67bdb 236 ADMW1001_OPERATING_MODE eOperatingMode;
Vkadaba 5:0728bde67bdb 237 ADMW1001_DATAREADY_MODE eDataReadyMode;
ADIJake 0:85855ecd3257 238 uint32_t nSamplesPerDataready;
ADIJake 0:85855ecd3257 239 uint32_t nSamplesPerCycle;
ADIJake 0:85855ecd3257 240 uint8_t nBytesPerSample;
Vkadaba 5:0728bde67bdb 241 res = admw1001_GetDataReadyModeInfo(hDevice,
ADIJake 0:85855ecd3257 242 eMeasurementMode,
ADIJake 0:85855ecd3257 243 &eOperatingMode,
ADIJake 0:85855ecd3257 244 &eDataReadyMode,
ADIJake 0:85855ecd3257 245 &nSamplesPerDataready,
ADIJake 0:85855ecd3257 246 &nSamplesPerCycle,
ADIJake 0:85855ecd3257 247 &nBytesPerSample);
Vkadaba 5:0728bde67bdb 248 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 249 return res;
ADIJake 0:85855ecd3257 250
ADIJake 0:85855ecd3257 251 /*
ADIJake 0:85855ecd3257 252 * Allocate a buffer to store the samples retrieved on each DATAREADY pulse
ADIJake 0:85855ecd3257 253 */
Vkadaba 5:0728bde67bdb 254 ADMW_DATA_SAMPLE *pSampleBuffer;
Vkadaba 5:0728bde67bdb 255 pSampleBuffer = malloc(sizeof(ADMW_DATA_SAMPLE) *
ADIJake 0:85855ecd3257 256 nSamplesPerDataready);
ADIJake 0:85855ecd3257 257 if (pSampleBuffer == NULL)
ADIJake 0:85855ecd3257 258 {
Vkadaba 5:0728bde67bdb 259 ADMW_LOG_ERROR("Failed to allocate sample buffer");
Vkadaba 5:0728bde67bdb 260 return ADMW_NO_MEM;
ADIJake 0:85855ecd3257 261 }
ADIJake 0:85855ecd3257 262
ADIJake 0:85855ecd3257 263 /*
ADIJake 0:85855ecd3257 264 * Kick off the measurement cycle(s) here
ADIJake 0:85855ecd3257 265 */
Vkadaba 5:0728bde67bdb 266 ADMW_LOG_INFO("Starting measurement");
Vkadaba 5:0728bde67bdb 267 res = admw_StartMeasurement(hDevice, eMeasurementMode);
Vkadaba 5:0728bde67bdb 268 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 269 {
Vkadaba 5:0728bde67bdb 270 ADMW_LOG_ERROR("Failed to start measurement");
ADIJake 0:85855ecd3257 271 return res;
ADIJake 0:85855ecd3257 272 }
ADIJake 0:85855ecd3257 273
ADIJake 0:85855ecd3257 274 /*
ADIJake 0:85855ecd3257 275 * Loop continuously unless operating mode is single-cycle
ADIJake 0:85855ecd3257 276 */
ADIJake 0:85855ecd3257 277 uint32_t nSampleCount = 0;
ADIJake 0:85855ecd3257 278 uint32_t nReturned;
ADIJake 0:85855ecd3257 279 while (true)
ADIJake 0:85855ecd3257 280 {
Vkadaba 5:0728bde67bdb 281 ADMW_STATUS status;
ADIJake 0:85855ecd3257 282
ADIJake 0:85855ecd3257 283 /*
ADIJake 0:85855ecd3257 284 * Wait until the next batch of 1 or more samples is ready, continuously
ADIJake 0:85855ecd3257 285 * checking DATAREADY until it is asserted
ADIJake 0:85855ecd3257 286 */
ADIJake 0:85855ecd3257 287 while (! (bDataReady || bError))
ADIJake 0:85855ecd3257 288 ;
ADIJake 0:85855ecd3257 289
ADIJake 0:85855ecd3257 290 if (!bError)
ADIJake 0:85855ecd3257 291 {
ADIJake 0:85855ecd3257 292 /*
ADIJake 0:85855ecd3257 293 * Get data samples from the measurement cycle, if no error has occurred
ADIJake 0:85855ecd3257 294 */
ADIJake 0:85855ecd3257 295 bDataReady = false;
Vkadaba 5:0728bde67bdb 296 res = admw_GetData(hDevice, eMeasurementMode, pSampleBuffer,
ADIJake 0:85855ecd3257 297 nBytesPerSample, nSamplesPerDataready,
ADIJake 0:85855ecd3257 298 &nReturned);
Vkadaba 5:0728bde67bdb 299 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 300 {
Vkadaba 5:0728bde67bdb 301 if (res == ADMW_INCOMPLETE)
ADIJake 0:85855ecd3257 302 {
ADIJake 0:85855ecd3257 303 /*
ADIJake 0:85855ecd3257 304 * This is expected in cases where cycleSkipCount may
ADIJake 0:85855ecd3257 305 * be non-zero for some channels, resulting in
ADIJake 0:85855ecd3257 306 * variable-length sequences
ADIJake 0:85855ecd3257 307 */
Vkadaba 5:0728bde67bdb 308 ADMW_LOG_DEBUG("Retrieved %u of %u requested data samples",
ADIJake 0:85855ecd3257 309 nReturned, nSamplesPerDataready);
ADIJake 0:85855ecd3257 310 }
ADIJake 0:85855ecd3257 311 else
ADIJake 0:85855ecd3257 312 {
Vkadaba 5:0728bde67bdb 313 ADMW_LOG_WARN("Failed to get data samples from device");
ADIJake 0:85855ecd3257 314 return res;
ADIJake 0:85855ecd3257 315 }
ADIJake 0:85855ecd3257 316 }
ADIJake 0:85855ecd3257 317
ADIJake 0:85855ecd3257 318 /*
ADIJake 0:85855ecd3257 319 * Display the data samples.
ADIJake 0:85855ecd3257 320 *
ADIJake 0:85855ecd3257 321 * NOTE: this requires a sufficient idle time between subsequent
ADIJake 0:85855ecd3257 322 * DATAREADY pulses to allow printing to occur. Otherwise,
ADIJake 0:85855ecd3257 323 * subsequent samples may be missed if not retrieved promptly when
ADIJake 0:85855ecd3257 324 * the next DATAREADY assertion occurs.
ADIJake 0:85855ecd3257 325 */
ADIJake 0:85855ecd3257 326 utils_printSamples(pSampleBuffer, nReturned, eMeasurementMode);
ADIJake 0:85855ecd3257 327 nSampleCount += nReturned;
ADIJake 0:85855ecd3257 328 }
ADIJake 0:85855ecd3257 329
ADIJake 0:85855ecd3257 330 /*
ADIJake 0:85855ecd3257 331 * Check and print device status if errors/alerts have been triggered
ADIJake 0:85855ecd3257 332 */
ADIJake 0:85855ecd3257 333 if (bError || bAlert)
ADIJake 0:85855ecd3257 334 {
Vkadaba 5:0728bde67bdb 335 res = admw_GetStatus(hDevice, &status);
Vkadaba 5:0728bde67bdb 336 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 337 {
Vkadaba 5:0728bde67bdb 338 ADMW_LOG_ERROR("Failed to retrieve device status");
ADIJake 0:85855ecd3257 339 return res;
ADIJake 0:85855ecd3257 340 }
ADIJake 0:85855ecd3257 341
ADIJake 0:85855ecd3257 342 if (status.deviceStatus &
Vkadaba 5:0728bde67bdb 343 (ADMW_DEVICE_STATUS_ERROR | ADMW_DEVICE_STATUS_ALERT))
ADIJake 0:85855ecd3257 344 {
ADIJake 0:85855ecd3257 345 utils_printStatus(&status);
ADIJake 0:85855ecd3257 346
ADIJake 0:85855ecd3257 347 /* Break out of the loop if any errors are raised */
ADIJake 0:85855ecd3257 348 if (bError)
ADIJake 0:85855ecd3257 349 break;
ADIJake 0:85855ecd3257 350 }
ADIJake 0:85855ecd3257 351 }
ADIJake 0:85855ecd3257 352
Vkadaba 5:0728bde67bdb 353 if (eOperatingMode == ADMW1001_OPERATING_MODE_SINGLECYCLE)
ADIJake 0:85855ecd3257 354 {
ADIJake 0:85855ecd3257 355 /*
ADIJake 0:85855ecd3257 356 * In this mode, break out of the loop when the measurement command
ADIJake 0:85855ecd3257 357 * has completed.
ADIJake 0:85855ecd3257 358 *
ADIJake 0:85855ecd3257 359 * One option is to check for the expected number of samples to be
ADIJake 0:85855ecd3257 360 * returned for the cycle. However, cycles may have variable-length
ADIJake 0:85855ecd3257 361 * sequences if the cycleSkipCount option is non-zero for any of the
ADIJake 0:85855ecd3257 362 * channels.
ADIJake 0:85855ecd3257 363 *
ADIJake 0:85855ecd3257 364 * So, instead, we check for the command-running status, which
ADIJake 0:85855ecd3257 365 * will de-assert in this mode when the measurement command has
ADIJake 0:85855ecd3257 366 * completed a single cycle.
ADIJake 0:85855ecd3257 367 */
ADIJake 0:85855ecd3257 368 bool bCommandRunning;
Vkadaba 5:0728bde67bdb 369 res = admw_GetCommandRunningState(hDevice, &bCommandRunning);
Vkadaba 5:0728bde67bdb 370 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 371 {
Vkadaba 5:0728bde67bdb 372 ADMW_LOG_ERROR("Failed to get command-running status");
ADIJake 0:85855ecd3257 373 return res;
ADIJake 0:85855ecd3257 374 }
ADIJake 0:85855ecd3257 375
ADIJake 0:85855ecd3257 376 if (!bCommandRunning && !bDataReady)
ADIJake 0:85855ecd3257 377 break;
ADIJake 0:85855ecd3257 378 }
ADIJake 0:85855ecd3257 379 }
ADIJake 0:85855ecd3257 380
Vkadaba 5:0728bde67bdb 381 ADMW_LOG_INFO("Stopping measurement");
Vkadaba 5:0728bde67bdb 382 res = admw_StopMeasurement(hDevice);
Vkadaba 5:0728bde67bdb 383 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 384 {
Vkadaba 5:0728bde67bdb 385 ADMW_LOG_ERROR("Failed to send stop measurement");
ADIJake 0:85855ecd3257 386 return res;
ADIJake 0:85855ecd3257 387 }
ADIJake 0:85855ecd3257 388
ADIJake 0:85855ecd3257 389 free(pSampleBuffer);
ADIJake 0:85855ecd3257 390
ADIJake 0:85855ecd3257 391 res = utils_deregisterCallbacks(hDevice);
Vkadaba 5:0728bde67bdb 392 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 393 return res;
ADIJake 0:85855ecd3257 394
Vkadaba 5:0728bde67bdb 395 return ADMW_SUCCESS;
ADIJake 0:85855ecd3257 396 }
ADIJake 0:85855ecd3257 397