ADMW1001_Mbed_FW / Mbed OS EV-PRO-MW1001_Development

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@73:cae0c514bea6, 2020-04-24 (annotated)

Committer:
rfinnert
Date:
Fri Apr 24 11:51:13 2020 +0000
Revision:
73:cae0c514bea6
Parent:
71:7b5ebd969aa7
Child:
74:27a28f452d71
Bytesnap updated project

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