wayne roberts / libscpi

https://github.com/j123b567/scpi-parser

Dependents:   scpi_sx127x scpi_sx127x_firstTest MLX90418_I2C_master

src/units.c@1:b497f235115a, 2015-08-07 (annotated)

Committer:
dudmuck
Date:
Fri Aug 07 21:54:11 2015 +0000
Revision:
1:b497f235115a
Parent:
0:aad43948c45c 
update from github commit 6e5e3e0e3fc450eaf53feee059824ad85c4f270d

Who changed what in which revision?

UserRevisionLine numberNew contents of line
dudmuck 0:aad43948c45c 1 /*-
dudmuck 0:aad43948c45c 2 * Copyright (c) 2012-2013 Jan Breuer,
dudmuck 0:aad43948c45c 3 *
dudmuck 0:aad43948c45c 4 * All Rights Reserved
dudmuck 0:aad43948c45c 5 *
dudmuck 0:aad43948c45c 6 * Redistribution and use in source and binary forms, with or without
dudmuck 0:aad43948c45c 7 * modification, are permitted provided that the following conditions are
dudmuck 0:aad43948c45c 8 * met:
dudmuck 0:aad43948c45c 9 * 1. Redistributions of source code must retain the above copyright notice,
dudmuck 0:aad43948c45c 10 * this list of conditions and the following disclaimer.
dudmuck 0:aad43948c45c 11 * 2. Redistributions in binary form must reproduce the above copyright
dudmuck 0:aad43948c45c 12 * notice, this list of conditions and the following disclaimer in the
dudmuck 0:aad43948c45c 13 * documentation and/or other materials provided with the distribution.
dudmuck 0:aad43948c45c 14 *
dudmuck 0:aad43948c45c 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
dudmuck 0:aad43948c45c 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
dudmuck 0:aad43948c45c 17 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
dudmuck 0:aad43948c45c 18 * DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
dudmuck 0:aad43948c45c 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
dudmuck 0:aad43948c45c 20 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
dudmuck 0:aad43948c45c 21 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
dudmuck 0:aad43948c45c 22 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
dudmuck 0:aad43948c45c 23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
dudmuck 0:aad43948c45c 24 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
dudmuck 0:aad43948c45c 25 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
dudmuck 0:aad43948c45c 26 */
dudmuck 0:aad43948c45c 27
dudmuck 0:aad43948c45c 28 /**
dudmuck 0:aad43948c45c 29 * @file scpi_units.c
dudmuck 0:aad43948c45c 30 * @date Thu Nov 15 10:58:45 UTC 2012
dudmuck 0:aad43948c45c 31 *
dudmuck 0:aad43948c45c 32 * @brief SCPI units
dudmuck 0:aad43948c45c 33 *
dudmuck 0:aad43948c45c 34 *
dudmuck 0:aad43948c45c 35 */
dudmuck 0:aad43948c45c 36
dudmuck 0:aad43948c45c 37 #include <string.h>
dudmuck 0:aad43948c45c 38 #include "scpi/parser.h"
dudmuck 0:aad43948c45c 39 #include "scpi/units.h"
dudmuck 1:b497f235115a 40 #include "utils_private.h"
dudmuck 1:b497f235115a 41 #include "scpi/utils.h"
dudmuck 0:aad43948c45c 42 #include "scpi/error.h"
dudmuck 1:b497f235115a 43 #include "lexer_private.h"
dudmuck 0:aad43948c45c 44
dudmuck 0:aad43948c45c 45
dudmuck 0:aad43948c45c 46 /*
dudmuck 0:aad43948c45c 47 * multipliers IEEE 488.2-1992 tab 7-2
dudmuck 0:aad43948c45c 48 * 1E18 EX
dudmuck 0:aad43948c45c 49 * 1E15 PE
dudmuck 0:aad43948c45c 50 * 1E12 T
dudmuck 0:aad43948c45c 51 * 1E9 G
dudmuck 0:aad43948c45c 52 * 1E6 MA (use M for OHM and HZ)
dudmuck 0:aad43948c45c 53 * 1E3 K
dudmuck 0:aad43948c45c 54 * 1E-3 M (disaalowed for OHM and HZ)
dudmuck 0:aad43948c45c 55 * 1E-6 U
dudmuck 0:aad43948c45c 56 * 1E-9 N
dudmuck 0:aad43948c45c 57 * 1E-12 P
dudmuck 0:aad43948c45c 58 * 1E-15 F
dudmuck 0:aad43948c45c 59 * 1E-18 A
dudmuck 0:aad43948c45c 60 */
dudmuck 0:aad43948c45c 61
dudmuck 0:aad43948c45c 62 /*
dudmuck 0:aad43948c45c 63 * units definition IEEE 488.2-1992 tab 7-1
dudmuck 0:aad43948c45c 64 */
dudmuck 0:aad43948c45c 65 const scpi_unit_def_t scpi_units_def[] = {
dudmuck 0:aad43948c45c 66 /* voltage */
dudmuck 1:b497f235115a 67 {/* name */ "UV", /* unit */ SCPI_UNIT_VOLT, /* mult */ 1e-6},
dudmuck 1:b497f235115a 68 {/* name */ "MV", /* unit */ SCPI_UNIT_VOLT, /* mult */ 1e-3},
dudmuck 1:b497f235115a 69 {/* name */ "V", /* unit */ SCPI_UNIT_VOLT, /* mult */ 1},
dudmuck 1:b497f235115a 70 {/* name */ "KV", /* unit */ SCPI_UNIT_VOLT, /* mult */ 1e3},
dudmuck 0:aad43948c45c 71
dudmuck 0:aad43948c45c 72 /* current */
dudmuck 1:b497f235115a 73 {/* name */ "UA", /* unit */ SCPI_UNIT_AMPER, /* mult */ 1e-6},
dudmuck 1:b497f235115a 74 {/* name */ "MA", /* unit */ SCPI_UNIT_AMPER, /* mult */ 1e-3},
dudmuck 1:b497f235115a 75 {/* name */ "A", /* unit */ SCPI_UNIT_AMPER, /* mult */ 1},
dudmuck 1:b497f235115a 76 {/* name */ "KA", /* unit */ SCPI_UNIT_AMPER, /* mult */ 1e3},
dudmuck 0:aad43948c45c 77
dudmuck 0:aad43948c45c 78 /* resistance */
dudmuck 1:b497f235115a 79 {/* name */ "OHM", /* unit */ SCPI_UNIT_OHM, /* mult */ 1},
dudmuck 1:b497f235115a 80 {/* name */ "KOHM", /* unit */ SCPI_UNIT_OHM, /* mult */ 1e3},
dudmuck 1:b497f235115a 81 {/* name */ "MOHM", /* unit */ SCPI_UNIT_OHM, /* mult */ 1e6},
dudmuck 0:aad43948c45c 82
dudmuck 0:aad43948c45c 83 /* frequency */
dudmuck 1:b497f235115a 84 {/* name */ "HZ", /* unit */ SCPI_UNIT_HERTZ, /* mult */ 1},
dudmuck 1:b497f235115a 85 {/* name */ "KHZ", /* unit */ SCPI_UNIT_HERTZ, /* mult */ 1e3},
dudmuck 1:b497f235115a 86 {/* name */ "MHZ", /* unit */ SCPI_UNIT_HERTZ, /* mult */ 1e6},
dudmuck 1:b497f235115a 87 {/* name */ "GHZ", /* unit */ SCPI_UNIT_HERTZ, /* mult */ 1e9},
dudmuck 0:aad43948c45c 88
dudmuck 0:aad43948c45c 89 /* temperature */
dudmuck 1:b497f235115a 90 {/* name */ "CEL", /* unit */ SCPI_UNIT_CELSIUS, /* mult */ 1},
dudmuck 0:aad43948c45c 91
dudmuck 0:aad43948c45c 92 /* time */
dudmuck 1:b497f235115a 93 {/* name */ "PS", /* unit */ SCPI_UNIT_SECONDS, /* mult */ 1e-12},
dudmuck 1:b497f235115a 94 {/* name */ "NS", /* unit */ SCPI_UNIT_SECONDS, /* mult */ 1e-9},
dudmuck 1:b497f235115a 95 {/* name */ "US", /* unit */ SCPI_UNIT_SECONDS, /* mult */ 1e-6},
dudmuck 1:b497f235115a 96 {/* name */ "MS", /* unit */ SCPI_UNIT_SECONDS, /* mult */ 1e-3},
dudmuck 1:b497f235115a 97 {/* name */ "S", /* unit */ SCPI_UNIT_SECONDS, /* mult */ 1},
dudmuck 1:b497f235115a 98 {/* name */ "MIN", /* unit */ SCPI_UNIT_SECONDS, /* mult */ 60},
dudmuck 1:b497f235115a 99 {/* name */ "HR", /* unit */ SCPI_UNIT_SECONDS, /* mult */ 3600},
dudmuck 0:aad43948c45c 100
dudmuck 0:aad43948c45c 101 SCPI_UNITS_LIST_END,
dudmuck 0:aad43948c45c 102 };
dudmuck 0:aad43948c45c 103
dudmuck 0:aad43948c45c 104 /*
dudmuck 0:aad43948c45c 105 * Special number values definition
dudmuck 0:aad43948c45c 106 */
dudmuck 1:b497f235115a 107 const scpi_choice_def_t scpi_special_numbers_def[] = {
dudmuck 1:b497f235115a 108 {/* name */ "MINimum", /* type */ SCPI_NUM_MIN},
dudmuck 1:b497f235115a 109 {/* name */ "MAXimum", /* type */ SCPI_NUM_MAX},
dudmuck 1:b497f235115a 110 {/* name */ "DEFault", /* type */ SCPI_NUM_DEF},
dudmuck 1:b497f235115a 111 {/* name */ "UP", /* type */ SCPI_NUM_UP},
dudmuck 1:b497f235115a 112 {/* name */ "DOWN", /* type */ SCPI_NUM_DOWN},
dudmuck 1:b497f235115a 113 {/* name */ "NAN", /* type */ SCPI_NUM_NAN},
dudmuck 1:b497f235115a 114 {/* name */ "INFinity", /* type */ SCPI_NUM_INF},
dudmuck 1:b497f235115a 115 {/* name */ "NINF", /* type */ SCPI_NUM_NINF},
dudmuck 1:b497f235115a 116 {/* name */ "AUTO", /* type */ SCPI_NUM_AUTO},
dudmuck 1:b497f235115a 117 SCPI_CHOICE_LIST_END,
dudmuck 0:aad43948c45c 118 };
dudmuck 0:aad43948c45c 119
dudmuck 0:aad43948c45c 120 /**
dudmuck 0:aad43948c45c 121 * Convert string describing unit to its representation
dudmuck 0:aad43948c45c 122 * @param units units patterns
dudmuck 0:aad43948c45c 123 * @param unit text representation of unknown unit
dudmuck 0:aad43948c45c 124 * @param len length of text representation
dudmuck 0:aad43948c45c 125 * @return pointer of related unit definition or NULL
dudmuck 0:aad43948c45c 126 */
dudmuck 0:aad43948c45c 127 static const scpi_unit_def_t * translateUnit(const scpi_unit_def_t * units, const char * unit, size_t len) {
dudmuck 0:aad43948c45c 128 int i;
dudmuck 1:b497f235115a 129
dudmuck 0:aad43948c45c 130 if (units == NULL) {
dudmuck 0:aad43948c45c 131 return NULL;
dudmuck 0:aad43948c45c 132 }
dudmuck 1:b497f235115a 133
dudmuck 0:aad43948c45c 134 for (i = 0; units[i].name != NULL; i++) {
dudmuck 0:aad43948c45c 135 if (compareStr(unit, len, units[i].name, strlen(units[i].name))) {
dudmuck 0:aad43948c45c 136 return &units[i];
dudmuck 0:aad43948c45c 137 }
dudmuck 0:aad43948c45c 138 }
dudmuck 0:aad43948c45c 139
dudmuck 0:aad43948c45c 140 return NULL;
dudmuck 0:aad43948c45c 141 }
dudmuck 0:aad43948c45c 142
dudmuck 0:aad43948c45c 143 /**
dudmuck 0:aad43948c45c 144 * Convert unit definition to string
dudmuck 0:aad43948c45c 145 * @param units units definitions (patterns)
dudmuck 0:aad43948c45c 146 * @param unit type of unit
dudmuck 0:aad43948c45c 147 * @return string representation of unit
dudmuck 0:aad43948c45c 148 */
dudmuck 0:aad43948c45c 149 static const char * translateUnitInverse(const scpi_unit_def_t * units, const scpi_unit_t unit) {
dudmuck 0:aad43948c45c 150 int i;
dudmuck 1:b497f235115a 151
dudmuck 0:aad43948c45c 152 if (units == NULL) {
dudmuck 0:aad43948c45c 153 return NULL;
dudmuck 0:aad43948c45c 154 }
dudmuck 1:b497f235115a 155
dudmuck 0:aad43948c45c 156 for (i = 0; units[i].name != NULL; i++) {
dudmuck 0:aad43948c45c 157 if ((units[i].unit == unit) && (units[i].mult == 1)) {
dudmuck 0:aad43948c45c 158 return units[i].name;
dudmuck 0:aad43948c45c 159 }
dudmuck 0:aad43948c45c 160 }
dudmuck 0:aad43948c45c 161
dudmuck 0:aad43948c45c 162 return NULL;
dudmuck 0:aad43948c45c 163 }
dudmuck 0:aad43948c45c 164
dudmuck 0:aad43948c45c 165 /**
dudmuck 0:aad43948c45c 166 * Transform number to base units
dudmuck 0:aad43948c45c 167 * @param context
dudmuck 0:aad43948c45c 168 * @param unit text representation of unit
dudmuck 0:aad43948c45c 169 * @param len length of text representation
dudmuck 0:aad43948c45c 170 * @param value preparsed numeric value
dudmuck 0:aad43948c45c 171 * @return TRUE if value parameter was converted to base units
dudmuck 0:aad43948c45c 172 */
dudmuck 0:aad43948c45c 173 static scpi_bool_t transformNumber(scpi_t * context, const char * unit, size_t len, scpi_number_t * value) {
dudmuck 0:aad43948c45c 174 size_t s;
dudmuck 0:aad43948c45c 175 const scpi_unit_def_t * unitDef;
dudmuck 0:aad43948c45c 176 s = skipWhitespace(unit, len);
dudmuck 0:aad43948c45c 177
dudmuck 0:aad43948c45c 178 if (s == len) {
dudmuck 0:aad43948c45c 179 value->unit = SCPI_UNIT_NONE;
dudmuck 0:aad43948c45c 180 return TRUE;
dudmuck 0:aad43948c45c 181 }
dudmuck 0:aad43948c45c 182
dudmuck 0:aad43948c45c 183 unitDef = translateUnit(context->units, unit + s, len - s);
dudmuck 0:aad43948c45c 184
dudmuck 0:aad43948c45c 185 if (unitDef == NULL) {
dudmuck 0:aad43948c45c 186 SCPI_ErrorPush(context, SCPI_ERROR_INVALID_SUFFIX);
dudmuck 0:aad43948c45c 187 return FALSE;
dudmuck 0:aad43948c45c 188 }
dudmuck 0:aad43948c45c 189
dudmuck 0:aad43948c45c 190 value->value *= unitDef->mult;
dudmuck 0:aad43948c45c 191 value->unit = unitDef->unit;
dudmuck 0:aad43948c45c 192
dudmuck 0:aad43948c45c 193 return TRUE;
dudmuck 0:aad43948c45c 194 }
dudmuck 0:aad43948c45c 195
dudmuck 0:aad43948c45c 196 /**
dudmuck 0:aad43948c45c 197 * Parse parameter as number, number with unit or special value (min, max, default, ...)
dudmuck 0:aad43948c45c 198 * @param context
dudmuck 0:aad43948c45c 199 * @param value return value
dudmuck 0:aad43948c45c 200 * @param mandatory if the parameter is mandatory
dudmuck 0:aad43948c45c 201 * @return
dudmuck 0:aad43948c45c 202 */
dudmuck 1:b497f235115a 203 scpi_bool_t SCPI_ParamNumber(scpi_t * context, const scpi_choice_def_t * special, scpi_number_t * value, scpi_bool_t mandatory)
dudmuck 1:b497f235115a 204 {
dudmuck 1:b497f235115a 205 scpi_token_t token;
dudmuck 1:b497f235115a 206 lex_state_t state;
dudmuck 1:b497f235115a 207 scpi_parameter_t param;
dudmuck 0:aad43948c45c 208 scpi_bool_t result;
dudmuck 1:b497f235115a 209 int32_t tag;
dudmuck 0:aad43948c45c 210
dudmuck 0:aad43948c45c 211 if (!value) {
dudmuck 1:b497f235115a 212 SCPI_ErrorPush(context, SCPI_ERROR_SYSTEM_ERROR);
dudmuck 0:aad43948c45c 213 return FALSE;
dudmuck 0:aad43948c45c 214 }
dudmuck 0:aad43948c45c 215
dudmuck 1:b497f235115a 216 result = SCPI_Parameter(context, &param, mandatory);
dudmuck 1:b497f235115a 217
dudmuck 1:b497f235115a 218 if (!result) {
dudmuck 1:b497f235115a 219 return result;
dudmuck 1:b497f235115a 220 }
dudmuck 1:b497f235115a 221
dudmuck 1:b497f235115a 222 state.buffer = param.ptr;
dudmuck 1:b497f235115a 223 state.pos = state.buffer;
dudmuck 1:b497f235115a 224 state.len = param.len;
dudmuck 0:aad43948c45c 225
dudmuck 1:b497f235115a 226 switch(param.type) {
dudmuck 1:b497f235115a 227 case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA:
dudmuck 1:b497f235115a 228 case SCPI_TOKEN_HEXNUM:
dudmuck 1:b497f235115a 229 case SCPI_TOKEN_OCTNUM:
dudmuck 1:b497f235115a 230 case SCPI_TOKEN_BINNUM:
dudmuck 1:b497f235115a 231 case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA_WITH_SUFFIX:
dudmuck 1:b497f235115a 232 case SCPI_TOKEN_PROGRAM_MNEMONIC:
dudmuck 1:b497f235115a 233 value->unit = SCPI_UNIT_NONE;
dudmuck 1:b497f235115a 234 value->special = FALSE;
dudmuck 1:b497f235115a 235 result = TRUE;
dudmuck 1:b497f235115a 236 break;
dudmuck 0:aad43948c45c 237 }
dudmuck 0:aad43948c45c 238
dudmuck 1:b497f235115a 239 switch(param.type) {
dudmuck 1:b497f235115a 240 case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA:
dudmuck 1:b497f235115a 241 case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA_WITH_SUFFIX:
dudmuck 1:b497f235115a 242 case SCPI_TOKEN_PROGRAM_MNEMONIC:
dudmuck 1:b497f235115a 243 value->base = 10;
dudmuck 1:b497f235115a 244 break;
dudmuck 1:b497f235115a 245 case SCPI_TOKEN_BINNUM:
dudmuck 1:b497f235115a 246 value->base = 2;
dudmuck 1:b497f235115a 247 break;
dudmuck 1:b497f235115a 248 case SCPI_TOKEN_HEXNUM:
dudmuck 1:b497f235115a 249 value->base = 16;
dudmuck 1:b497f235115a 250 break;
dudmuck 1:b497f235115a 251 case SCPI_TOKEN_OCTNUM:
dudmuck 1:b497f235115a 252 value->base = 8;
dudmuck 1:b497f235115a 253 break;
dudmuck 0:aad43948c45c 254 }
dudmuck 0:aad43948c45c 255
dudmuck 1:b497f235115a 256 switch(param.type) {
dudmuck 1:b497f235115a 257 case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA:
dudmuck 1:b497f235115a 258 SCPI_ParamToDouble(context, &param, &(value->value));
dudmuck 1:b497f235115a 259 break;
dudmuck 1:b497f235115a 260 case SCPI_TOKEN_HEXNUM:
dudmuck 1:b497f235115a 261 SCPI_ParamToDouble(context, &param, &(value->value));
dudmuck 1:b497f235115a 262 break;
dudmuck 1:b497f235115a 263 case SCPI_TOKEN_OCTNUM:
dudmuck 1:b497f235115a 264 SCPI_ParamToDouble(context, &param, &(value->value));
dudmuck 1:b497f235115a 265 break;
dudmuck 1:b497f235115a 266 case SCPI_TOKEN_BINNUM:
dudmuck 1:b497f235115a 267 SCPI_ParamToDouble(context, &param, &(value->value));
dudmuck 1:b497f235115a 268 break;
dudmuck 1:b497f235115a 269 case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA_WITH_SUFFIX:
dudmuck 1:b497f235115a 270 scpiLex_DecimalNumericProgramData(&state, &token);
dudmuck 1:b497f235115a 271 scpiLex_WhiteSpace(&state, &token);
dudmuck 1:b497f235115a 272 scpiLex_SuffixProgramData(&state, &token);
dudmuck 0:aad43948c45c 273
dudmuck 1:b497f235115a 274 SCPI_ParamToDouble(context, &param, &(value->value));
dudmuck 1:b497f235115a 275
dudmuck 1:b497f235115a 276 result = transformNumber(context, token.ptr, token.len, value);
dudmuck 1:b497f235115a 277 break;
dudmuck 1:b497f235115a 278 case SCPI_TOKEN_PROGRAM_MNEMONIC:
dudmuck 1:b497f235115a 279 scpiLex_WhiteSpace(&state, &token);
dudmuck 1:b497f235115a 280 scpiLex_CharacterProgramData(&state, &token);
dudmuck 1:b497f235115a 281
dudmuck 1:b497f235115a 282 /* convert string to special number type */
dudmuck 1:b497f235115a 283 SCPI_ParamToChoice(context, &token, special, &tag);
dudmuck 1:b497f235115a 284
dudmuck 1:b497f235115a 285 value->special = TRUE;
dudmuck 1:b497f235115a 286 value->tag = tag;
dudmuck 1:b497f235115a 287
dudmuck 1:b497f235115a 288 break;
dudmuck 1:b497f235115a 289 default:
dudmuck 1:b497f235115a 290 result = FALSE;
dudmuck 0:aad43948c45c 291 }
dudmuck 0:aad43948c45c 292
dudmuck 1:b497f235115a 293 return result;
dudmuck 0:aad43948c45c 294 }
dudmuck 0:aad43948c45c 295
dudmuck 0:aad43948c45c 296 /**
dudmuck 0:aad43948c45c 297 * Convert scpi_number_t to string
dudmuck 0:aad43948c45c 298 * @param context
dudmuck 0:aad43948c45c 299 * @param value number value
dudmuck 0:aad43948c45c 300 * @param str target string
dudmuck 0:aad43948c45c 301 * @param len max length of string
dudmuck 0:aad43948c45c 302 * @return number of chars written to string
dudmuck 0:aad43948c45c 303 */
dudmuck 1:b497f235115a 304 size_t SCPI_NumberToStr(scpi_t * context, const scpi_choice_def_t * special, scpi_number_t * value, char * str, size_t len) {
dudmuck 0:aad43948c45c 305 const char * type;
dudmuck 0:aad43948c45c 306 const char * unit;
dudmuck 0:aad43948c45c 307 size_t result;
dudmuck 0:aad43948c45c 308
dudmuck 0:aad43948c45c 309 if (!value || !str) {
dudmuck 0:aad43948c45c 310 return 0;
dudmuck 0:aad43948c45c 311 }
dudmuck 0:aad43948c45c 312
dudmuck 1:b497f235115a 313 if (value->special) {
dudmuck 1:b497f235115a 314 if (SCPI_ChoiceToName(special, value->tag, &type)) {
dudmuck 1:b497f235115a 315 strncpy(str, type, len);
dudmuck 1:b497f235115a 316 return min(strlen(type), len);
dudmuck 1:b497f235115a 317 } else {
dudmuck 1:b497f235115a 318 str[0] = 0;
dudmuck 1:b497f235115a 319 return 0;
dudmuck 1:b497f235115a 320 }
dudmuck 0:aad43948c45c 321 }
dudmuck 0:aad43948c45c 322
dudmuck 1:b497f235115a 323 result = SCPI_DoubleToStr(value->value, str, len);
dudmuck 0:aad43948c45c 324
dudmuck 0:aad43948c45c 325 unit = translateUnitInverse(context->units, value->unit);
dudmuck 0:aad43948c45c 326
dudmuck 0:aad43948c45c 327 if (unit) {
dudmuck 0:aad43948c45c 328 strncat(str, " ", len);
dudmuck 0:aad43948c45c 329 strncat(str, unit, len);
dudmuck 0:aad43948c45c 330 result += strlen(unit) + 1;
dudmuck 0:aad43948c45c 331 }
dudmuck 0:aad43948c45c 332
dudmuck 0:aad43948c45c 333 return result;
dudmuck 0:aad43948c45c 334 }