PoC_Team / Mbed OS ADMW1001v0510002

Host API Example for the ADMW1001

common/utils.c@11:8e6023d2e584, 2019-07-15 (annotated)

Committer:
Vkadaba
Date:
Mon Jul 15 13:04:34 2019 +0000
Revision:
11:8e6023d2e584
Parent:
10:14954555be2a 
sensor2_bridge_4w_load_cell_config.c file is updated and able to download the bin file .

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 10:14954555be2a 116
Vkadaba 10:14954555be2a 117 for (uint32_t i = 0; i < nNumSamples; i++)
Vkadaba 10:14954555be2a 118 {
Vkadaba 10:14954555be2a 119 ADMW_LOG_INFO("Sample # %2d Channel # %2d :: Raw %0X %f :: Processed %f :: flags:%s%s",
Vkadaba 10:14954555be2a 120 i+1,
Vkadaba 10:14954555be2a 121 pSampleBuffer[i].channelId,
Vkadaba 10:14954555be2a 122 pSampleBuffer[i].rawValue, (pSampleBuffer[i].rawValue/1024.0),
Vkadaba 10:14954555be2a 123 pSampleBuffer[i].processedValue,
Vkadaba 10:14954555be2a 124 pSampleBuffer[i].status & ADMW_DEVICE_STATUS_ERROR ? " ERROR" : "",
Vkadaba 10:14954555be2a 125 pSampleBuffer[i].status & ADMW_DEVICE_STATUS_ALERT ? " ALERT" : "");
Vkadaba 10:14954555be2a 126 }
ADIJake 0:85855ecd3257 127 }
ADIJake 0:85855ecd3257 128
Vkadaba 5:0728bde67bdb 129 static void gpioCallbackFn(ADMW_GPIO_PIN ePinId, void * pArg)
ADIJake 0:85855ecd3257 130 {
ADIJake 0:85855ecd3257 131 volatile bool *pbFlag = (volatile bool *)pArg;
ADIJake 0:85855ecd3257 132 *pbFlag = true;
ADIJake 0:85855ecd3257 133 }
ADIJake 0:85855ecd3257 134
Vkadaba 5:0728bde67bdb 135 ADMW_RESULT utils_registerCallbacks(
Vkadaba 5:0728bde67bdb 136 ADMW_DEVICE_HANDLE hDevice,
ADIJake 0:85855ecd3257 137 volatile bool *pbDataReady,
ADIJake 0:85855ecd3257 138 volatile bool *pbError,
ADIJake 0:85855ecd3257 139 volatile bool *pbAlert)
ADIJake 0:85855ecd3257 140 {
Vkadaba 5:0728bde67bdb 141 ADMW_RESULT res;
ADIJake 0:85855ecd3257 142 bool state;
ADIJake 0:85855ecd3257 143
Vkadaba 5:0728bde67bdb 144 res = admw_RegisterGpioCallback(hDevice, ADMW_GPIO_PIN_DATAREADY,
ADIJake 0:85855ecd3257 145 gpioCallbackFn, (void *)pbDataReady);
Vkadaba 5:0728bde67bdb 146 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 147 {
Vkadaba 5:0728bde67bdb 148 ADMW_LOG_ERROR("Failed to register DATAREADY callback");
ADIJake 0:85855ecd3257 149 return res;
ADIJake 0:85855ecd3257 150 }
ADIJake 0:85855ecd3257 151
Vkadaba 5:0728bde67bdb 152 res = admw_GetGpioState(hDevice, ADMW_GPIO_PIN_ALERT_ERROR, &state);
Vkadaba 5:0728bde67bdb 153 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 154 {
Vkadaba 5:0728bde67bdb 155 ADMW_LOG_ERROR("Failed to get current ERROR state");
ADIJake 0:85855ecd3257 156 return res;
ADIJake 0:85855ecd3257 157 }
ADIJake 0:85855ecd3257 158 if (state)
ADIJake 0:85855ecd3257 159 {
Vkadaba 5:0728bde67bdb 160 ADMW_LOG_ERROR("ERROR signal already asserted");
Vkadaba 5:0728bde67bdb 161 return ADMW_FAILURE;
ADIJake 0:85855ecd3257 162 }
Vkadaba 5:0728bde67bdb 163 res = admw_RegisterGpioCallback(hDevice, ADMW_GPIO_PIN_ALERT_ERROR,
ADIJake 0:85855ecd3257 164 gpioCallbackFn, (void *)pbError);
Vkadaba 5:0728bde67bdb 165 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 166 {
Vkadaba 5:0728bde67bdb 167 ADMW_LOG_ERROR("Failed to register ERROR callback");
ADIJake 0:85855ecd3257 168 return res;
ADIJake 0:85855ecd3257 169 }
ADIJake 0:85855ecd3257 170
Vkadaba 5:0728bde67bdb 171 /*res = admw_GetGpioState(hDevice, ADMW_GPIO_PIN_ALERT, &state);
Vkadaba 5:0728bde67bdb 172 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 173 {
Vkadaba 5:0728bde67bdb 174 ADMW_LOG_ERROR("Failed to get current ALERT state");
ADIJake 0:85855ecd3257 175 return res;
ADIJake 0:85855ecd3257 176 }
ADIJake 0:85855ecd3257 177 if (state)
ADIJake 0:85855ecd3257 178 {
Vkadaba 5:0728bde67bdb 179 ADMW_LOG_ERROR("ALERT signal already asserted");
Vkadaba 5:0728bde67bdb 180 return ADMW_FAILURE;
ADIJake 1:63dd03580de4 181 }*/
Vkadaba 5:0728bde67bdb 182 res = admw_RegisterGpioCallback(hDevice, ADMW_GPIO_PIN_ALERT_ERROR,
ADIJake 0:85855ecd3257 183 gpioCallbackFn, (void *)pbAlert);
Vkadaba 5:0728bde67bdb 184 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 185 {
Vkadaba 5:0728bde67bdb 186 ADMW_LOG_ERROR("Failed to register ALERT callback");
ADIJake 0:85855ecd3257 187 return res;
ADIJake 0:85855ecd3257 188 }
ADIJake 0:85855ecd3257 189
Vkadaba 5:0728bde67bdb 190 return ADMW_SUCCESS;
ADIJake 0:85855ecd3257 191 }
ADIJake 0:85855ecd3257 192
Vkadaba 5:0728bde67bdb 193 ADMW_RESULT utils_deregisterCallbacks(
Vkadaba 5:0728bde67bdb 194 ADMW_DEVICE_HANDLE hDevice)
ADIJake 0:85855ecd3257 195 {
Vkadaba 5:0728bde67bdb 196 ADMW_RESULT res;
ADIJake 0:85855ecd3257 197
Vkadaba 5:0728bde67bdb 198 res = admw_RegisterGpioCallback(hDevice, ADMW_GPIO_PIN_DATAREADY,
ADIJake 0:85855ecd3257 199 NULL, NULL);
Vkadaba 5:0728bde67bdb 200 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 201 {
Vkadaba 5:0728bde67bdb 202 ADMW_LOG_ERROR("Failed to deregister DATAREADY callback");
ADIJake 0:85855ecd3257 203 return res;
ADIJake 0:85855ecd3257 204 }
ADIJake 0:85855ecd3257 205
Vkadaba 5:0728bde67bdb 206 res = admw_RegisterGpioCallback(hDevice, ADMW_GPIO_PIN_ALERT_ERROR,
ADIJake 0:85855ecd3257 207 NULL, NULL);
Vkadaba 5:0728bde67bdb 208 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 209 {
Vkadaba 5:0728bde67bdb 210 ADMW_LOG_ERROR("Failed to deregister ERROR callback");
ADIJake 0:85855ecd3257 211 return res;
ADIJake 0:85855ecd3257 212 }
ADIJake 0:85855ecd3257 213
Vkadaba 5:0728bde67bdb 214 res = admw_RegisterGpioCallback(hDevice, ADMW_GPIO_PIN_ALERT_ERROR,
ADIJake 0:85855ecd3257 215 NULL, NULL);
Vkadaba 5:0728bde67bdb 216 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 217 {
Vkadaba 5:0728bde67bdb 218 ADMW_LOG_INFO("Failed to deregister ALERT callback");
ADIJake 0:85855ecd3257 219 return res;
ADIJake 0:85855ecd3257 220 }
ADIJake 0:85855ecd3257 221
Vkadaba 5:0728bde67bdb 222 return ADMW_SUCCESS;
ADIJake 0:85855ecd3257 223 }
ADIJake 0:85855ecd3257 224
Vkadaba 5:0728bde67bdb 225 ADMW_RESULT utils_runMeasurement(
Vkadaba 5:0728bde67bdb 226 ADMW_DEVICE_HANDLE hDevice,
Vkadaba 5:0728bde67bdb 227 ADMW_MEASUREMENT_MODE eMeasurementMode)
ADIJake 0:85855ecd3257 228 {
Vkadaba 5:0728bde67bdb 229 ADMW_RESULT res;
ADIJake 0:85855ecd3257 230
ADIJake 0:85855ecd3257 231 volatile bool bDataReady = false;
ADIJake 0:85855ecd3257 232 volatile bool bError = false;
ADIJake 0:85855ecd3257 233 volatile bool bAlert = false;
ADIJake 0:85855ecd3257 234 res = utils_registerCallbacks(hDevice, &bDataReady, &bError, &bAlert);
Vkadaba 5:0728bde67bdb 235 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 236 return res;
ADIJake 0:85855ecd3257 237
ADIJake 0:85855ecd3257 238 /*
ADIJake 0:85855ecd3257 239 * Retrieve the number of samples per cycle, per DATAREADY pulse, etc. for
ADIJake 0:85855ecd3257 240 * this configuration.
ADIJake 0:85855ecd3257 241 */
Vkadaba 5:0728bde67bdb 242 ADMW1001_OPERATING_MODE eOperatingMode;
Vkadaba 5:0728bde67bdb 243 ADMW1001_DATAREADY_MODE eDataReadyMode;
ADIJake 0:85855ecd3257 244 uint32_t nSamplesPerDataready;
ADIJake 0:85855ecd3257 245 uint32_t nSamplesPerCycle;
ADIJake 0:85855ecd3257 246 uint8_t nBytesPerSample;
Vkadaba 5:0728bde67bdb 247 res = admw1001_GetDataReadyModeInfo(hDevice,
ADIJake 0:85855ecd3257 248 eMeasurementMode,
ADIJake 0:85855ecd3257 249 &eOperatingMode,
ADIJake 0:85855ecd3257 250 &eDataReadyMode,
ADIJake 0:85855ecd3257 251 &nSamplesPerDataready,
ADIJake 0:85855ecd3257 252 &nSamplesPerCycle,
ADIJake 0:85855ecd3257 253 &nBytesPerSample);
Vkadaba 5:0728bde67bdb 254 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 255 return res;
ADIJake 0:85855ecd3257 256
ADIJake 0:85855ecd3257 257 /*
ADIJake 0:85855ecd3257 258 * Allocate a buffer to store the samples retrieved on each DATAREADY pulse
ADIJake 0:85855ecd3257 259 */
Vkadaba 5:0728bde67bdb 260 ADMW_DATA_SAMPLE *pSampleBuffer;
Vkadaba 5:0728bde67bdb 261 pSampleBuffer = malloc(sizeof(ADMW_DATA_SAMPLE) *
ADIJake 0:85855ecd3257 262 nSamplesPerDataready);
ADIJake 0:85855ecd3257 263 if (pSampleBuffer == NULL)
ADIJake 0:85855ecd3257 264 {
Vkadaba 5:0728bde67bdb 265 ADMW_LOG_ERROR("Failed to allocate sample buffer");
Vkadaba 5:0728bde67bdb 266 return ADMW_NO_MEM;
ADIJake 0:85855ecd3257 267 }
ADIJake 0:85855ecd3257 268
ADIJake 0:85855ecd3257 269 /*
ADIJake 0:85855ecd3257 270 * Kick off the measurement cycle(s) here
ADIJake 0:85855ecd3257 271 */
Vkadaba 5:0728bde67bdb 272 ADMW_LOG_INFO("Starting measurement");
Vkadaba 5:0728bde67bdb 273 res = admw_StartMeasurement(hDevice, eMeasurementMode);
Vkadaba 5:0728bde67bdb 274 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 275 {
Vkadaba 5:0728bde67bdb 276 ADMW_LOG_ERROR("Failed to start measurement");
ADIJake 0:85855ecd3257 277 return res;
ADIJake 0:85855ecd3257 278 }
ADIJake 0:85855ecd3257 279
ADIJake 0:85855ecd3257 280 /*
ADIJake 0:85855ecd3257 281 * Loop continuously unless operating mode is single-cycle
ADIJake 0:85855ecd3257 282 */
ADIJake 0:85855ecd3257 283 uint32_t nSampleCount = 0;
ADIJake 0:85855ecd3257 284 uint32_t nReturned;
ADIJake 0:85855ecd3257 285 while (true)
ADIJake 0:85855ecd3257 286 {
Vkadaba 5:0728bde67bdb 287 ADMW_STATUS status;
ADIJake 0:85855ecd3257 288
ADIJake 0:85855ecd3257 289 /*
ADIJake 0:85855ecd3257 290 * Wait until the next batch of 1 or more samples is ready, continuously
ADIJake 0:85855ecd3257 291 * checking DATAREADY until it is asserted
ADIJake 0:85855ecd3257 292 */
ADIJake 0:85855ecd3257 293 while (! (bDataReady || bError))
ADIJake 0:85855ecd3257 294 ;
ADIJake 0:85855ecd3257 295
ADIJake 0:85855ecd3257 296 if (!bError)
ADIJake 0:85855ecd3257 297 {
ADIJake 0:85855ecd3257 298 /*
ADIJake 0:85855ecd3257 299 * Get data samples from the measurement cycle, if no error has occurred
ADIJake 0:85855ecd3257 300 */
ADIJake 0:85855ecd3257 301 bDataReady = false;
Vkadaba 5:0728bde67bdb 302 res = admw_GetData(hDevice, eMeasurementMode, pSampleBuffer,
ADIJake 0:85855ecd3257 303 nBytesPerSample, nSamplesPerDataready,
ADIJake 0:85855ecd3257 304 &nReturned);
Vkadaba 5:0728bde67bdb 305 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 306 {
Vkadaba 5:0728bde67bdb 307 if (res == ADMW_INCOMPLETE)
ADIJake 0:85855ecd3257 308 {
ADIJake 0:85855ecd3257 309 /*
ADIJake 0:85855ecd3257 310 * This is expected in cases where cycleSkipCount may
ADIJake 0:85855ecd3257 311 * be non-zero for some channels, resulting in
ADIJake 0:85855ecd3257 312 * variable-length sequences
ADIJake 0:85855ecd3257 313 */
Vkadaba 5:0728bde67bdb 314 ADMW_LOG_DEBUG("Retrieved %u of %u requested data samples",
ADIJake 0:85855ecd3257 315 nReturned, nSamplesPerDataready);
ADIJake 0:85855ecd3257 316 }
ADIJake 0:85855ecd3257 317 else
ADIJake 0:85855ecd3257 318 {
Vkadaba 5:0728bde67bdb 319 ADMW_LOG_WARN("Failed to get data samples from device");
ADIJake 0:85855ecd3257 320 return res;
ADIJake 0:85855ecd3257 321 }
ADIJake 0:85855ecd3257 322 }
ADIJake 0:85855ecd3257 323
ADIJake 0:85855ecd3257 324 /*
ADIJake 0:85855ecd3257 325 * Display the data samples.
ADIJake 0:85855ecd3257 326 *
ADIJake 0:85855ecd3257 327 * NOTE: this requires a sufficient idle time between subsequent
ADIJake 0:85855ecd3257 328 * DATAREADY pulses to allow printing to occur. Otherwise,
ADIJake 0:85855ecd3257 329 * subsequent samples may be missed if not retrieved promptly when
ADIJake 0:85855ecd3257 330 * the next DATAREADY assertion occurs.
ADIJake 0:85855ecd3257 331 */
ADIJake 0:85855ecd3257 332 utils_printSamples(pSampleBuffer, nReturned, eMeasurementMode);
ADIJake 0:85855ecd3257 333 nSampleCount += nReturned;
ADIJake 0:85855ecd3257 334 }
ADIJake 0:85855ecd3257 335
ADIJake 0:85855ecd3257 336 /*
ADIJake 0:85855ecd3257 337 * Check and print device status if errors/alerts have been triggered
ADIJake 0:85855ecd3257 338 */
ADIJake 0:85855ecd3257 339 if (bError || bAlert)
ADIJake 0:85855ecd3257 340 {
Vkadaba 5:0728bde67bdb 341 res = admw_GetStatus(hDevice, &status);
Vkadaba 5:0728bde67bdb 342 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 343 {
Vkadaba 5:0728bde67bdb 344 ADMW_LOG_ERROR("Failed to retrieve device status");
ADIJake 0:85855ecd3257 345 return res;
ADIJake 0:85855ecd3257 346 }
ADIJake 0:85855ecd3257 347
ADIJake 0:85855ecd3257 348 if (status.deviceStatus &
Vkadaba 5:0728bde67bdb 349 (ADMW_DEVICE_STATUS_ERROR | ADMW_DEVICE_STATUS_ALERT))
ADIJake 0:85855ecd3257 350 {
ADIJake 0:85855ecd3257 351 utils_printStatus(&status);
ADIJake 0:85855ecd3257 352
ADIJake 0:85855ecd3257 353 /* Break out of the loop if any errors are raised */
ADIJake 0:85855ecd3257 354 if (bError)
ADIJake 0:85855ecd3257 355 break;
ADIJake 0:85855ecd3257 356 }
ADIJake 0:85855ecd3257 357 }
ADIJake 0:85855ecd3257 358
Vkadaba 5:0728bde67bdb 359 if (eOperatingMode == ADMW1001_OPERATING_MODE_SINGLECYCLE)
ADIJake 0:85855ecd3257 360 {
ADIJake 0:85855ecd3257 361 /*
ADIJake 0:85855ecd3257 362 * In this mode, break out of the loop when the measurement command
ADIJake 0:85855ecd3257 363 * has completed.
ADIJake 0:85855ecd3257 364 *
ADIJake 0:85855ecd3257 365 * One option is to check for the expected number of samples to be
ADIJake 0:85855ecd3257 366 * returned for the cycle. However, cycles may have variable-length
ADIJake 0:85855ecd3257 367 * sequences if the cycleSkipCount option is non-zero for any of the
ADIJake 0:85855ecd3257 368 * channels.
ADIJake 0:85855ecd3257 369 *
ADIJake 0:85855ecd3257 370 * So, instead, we check for the command-running status, which
ADIJake 0:85855ecd3257 371 * will de-assert in this mode when the measurement command has
ADIJake 0:85855ecd3257 372 * completed a single cycle.
ADIJake 0:85855ecd3257 373 */
ADIJake 0:85855ecd3257 374 bool bCommandRunning;
Vkadaba 5:0728bde67bdb 375 res = admw_GetCommandRunningState(hDevice, &bCommandRunning);
Vkadaba 5:0728bde67bdb 376 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 377 {
Vkadaba 5:0728bde67bdb 378 ADMW_LOG_ERROR("Failed to get command-running status");
ADIJake 0:85855ecd3257 379 return res;
ADIJake 0:85855ecd3257 380 }
ADIJake 0:85855ecd3257 381
ADIJake 0:85855ecd3257 382 if (!bCommandRunning && !bDataReady)
ADIJake 0:85855ecd3257 383 break;
ADIJake 0:85855ecd3257 384 }
ADIJake 0:85855ecd3257 385 }
ADIJake 0:85855ecd3257 386
Vkadaba 5:0728bde67bdb 387 ADMW_LOG_INFO("Stopping measurement");
Vkadaba 5:0728bde67bdb 388 res = admw_StopMeasurement(hDevice);
Vkadaba 5:0728bde67bdb 389 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 390 {
Vkadaba 5:0728bde67bdb 391 ADMW_LOG_ERROR("Failed to send stop measurement");
ADIJake 0:85855ecd3257 392 return res;
ADIJake 0:85855ecd3257 393 }
ADIJake 0:85855ecd3257 394
ADIJake 0:85855ecd3257 395 free(pSampleBuffer);
ADIJake 0:85855ecd3257 396
ADIJake 0:85855ecd3257 397 res = utils_deregisterCallbacks(hDevice);
Vkadaba 5:0728bde67bdb 398 if (res != ADMW_SUCCESS)
ADIJake 0:85855ecd3257 399 return res;
ADIJake 0:85855ecd3257 400
Vkadaba 5:0728bde67bdb 401 return ADMW_SUCCESS;
ADIJake 0:85855ecd3257 402 }
ADIJake 0:85855ecd3257 403