{ SR_UNIT_BOOLEAN, "" },
{ SR_UNIT_SECOND, "s" },
{ SR_UNIT_SIEMENS, "S" },
- { SR_UNIT_DECIBEL_MW, "dBu" },
- { SR_UNIT_DECIBEL_VOLT, "dBv" },
+ { SR_UNIT_DECIBEL_MW, "dBm" },
+ { SR_UNIT_DECIBEL_VOLT, "dBV" },
{ SR_UNIT_UNITLESS, "" },
{ SR_UNIT_DECIBEL_SPL, "dB" },
{ SR_UNIT_CONCENTRATION, "ppm" },
{ SR_UNIT_MOMME, "momme" },
{ SR_UNIT_TOLA, "tola" },
{ SR_UNIT_PIECE, "pcs" },
+ { SR_UNIT_JOULE, "J" },
+ { SR_UNIT_COULOMB, "C" },
+ { SR_UNIT_AMPERE_HOUR, "Ah" },
ALL_ZERO
};
ALL_ZERO
};
+/** @private */
SR_PRIV int sr_analog_init(struct sr_datafeed_analog *analog,
struct sr_analog_encoding *encoding,
struct sr_analog_meaning *meaning,
/**
* Convert an analog datafeed payload to an array of floats.
*
+ * Sufficient memory for outbuf must have been pre-allocated by the caller,
+ * who is also responsible for freeing it when no longer needed.
+ *
* @param[in] analog The analog payload to convert. Must not be NULL.
* analog->data, analog->meaning, and analog->encoding
* must not be NULL.
* @param[out] outbuf Memory where to store the result. Must not be NULL.
*
- * Sufficient memory for outbuf must have been pre-allocated by the caller,
- * who is also responsible for freeing it when no longer needed.
- *
* @retval SR_OK Success.
* @retval SR_ERR Unsupported encoding.
* @retval SR_ERR_ARG Invalid argument.
SR_API int sr_analog_to_float(const struct sr_datafeed_analog *analog,
float *outbuf)
{
- float offset;
- unsigned int b, i, count;
+ unsigned int b, count;
gboolean bigendian;
+ uint8_t conv_buf[sizeof(double)];
+ float *conv_f = (float*)conv_buf;
+ double *conv_d = (double*)conv_buf;
if (!analog || !(analog->data) || !(analog->meaning)
|| !(analog->encoding) || !outbuf)
#else
bigendian = FALSE;
#endif
+
if (!analog->encoding->is_float) {
float offset = analog->encoding->offset.p / (float)analog->encoding->offset.q;
float scale = analog->encoding->scale.p / (float)analog->encoding->scale.q;
}
break;
default:
- sr_err("Unsupported unit size '%d' for analog-to-float conversion.",
- analog->encoding->unitsize);
+ sr_err("Unsupported unit size '%d' for analog-to-float"
+ " conversion.", analog->encoding->unitsize);
return SR_ERR;
}
return SR_OK;
/* The data is already in the right format. */
memcpy(outbuf, analog->data, count * sizeof(float));
} else {
- for (i = 0; i < count; i += analog->encoding->unitsize) {
+ for (unsigned int i = 0; i < count; i++) {
for (b = 0; b < analog->encoding->unitsize; b++) {
if (analog->encoding->is_bigendian == bigendian)
- ((uint8_t *)outbuf)[i + b] =
+ conv_buf[b] =
((uint8_t *)analog->data)[i * analog->encoding->unitsize + b];
else
- ((uint8_t *)outbuf)[i + (analog->encoding->unitsize - b)] =
+ conv_buf[analog->encoding->unitsize - b - 1] =
((uint8_t *)analog->data)[i * analog->encoding->unitsize + b];
}
- if (analog->encoding->scale.p != 1
- || analog->encoding->scale.q != 1)
- outbuf[i] = (outbuf[i] * analog->encoding->scale.p) / analog->encoding->scale.q;
- offset = ((float)analog->encoding->offset.p / (float)analog->encoding->offset.q);
- outbuf[i] += offset;
+
+ if (analog->encoding->unitsize == sizeof(float)) {
+ if (analog->encoding->scale.p != 1
+ || analog->encoding->scale.q != 1)
+ *conv_f = (*conv_f * analog->encoding->scale.p) / analog->encoding->scale.q;
+ float offset = ((float)analog->encoding->offset.p / (float)analog->encoding->offset.q);
+ *conv_f += offset;
+
+ outbuf[i] = *conv_f;
+ }
+ else if (analog->encoding->unitsize == sizeof(double)) {
+ if (analog->encoding->scale.p != 1
+ || analog->encoding->scale.q != 1)
+ *conv_d = (*conv_d * analog->encoding->scale.p) / analog->encoding->scale.q;
+ double offset = ((double)analog->encoding->offset.p / (double)analog->encoding->offset.q);
+ *conv_d += offset;
+
+ outbuf[i] = *conv_d;
+ }
+ else {
+ sr_err("Unsupported floating-point unit size '%d' for analog-to-float"
+ " conversion.", analog->encoding->unitsize);
+ return SR_ERR;
+ }
}
}
*/
SR_API const char *sr_analog_si_prefix(float *value, int *digits)
{
-#define NEG_PREFIX_COUNT 5 /* number of prefixes below unity */
+/** @cond PRIVATE */
+#define NEG_PREFIX_COUNT 5 /* number of prefixes below unity */
#define POS_PREFIX_COUNT (int)(ARRAY_SIZE(prefixes) - NEG_PREFIX_COUNT - 1)
- static const char *prefixes[] = { "f","p","n","µ","m","","k","M","G","T" };
+/** @endcond */
+ static const char *prefixes[] = { "f", "p", "n", "µ", "m", "", "k", "M", "G", "T" };
- if (value == NULL || digits == NULL || isnan(*value))
+ if (!value || !digits || isnan(*value))
return prefixes[NEG_PREFIX_COUNT];
float logval = log10f(fabsf(*value));
int prefix = (logval / 3) - (logval < 1);
- if (prefix < -NEG_PREFIX_COUNT) prefix = -NEG_PREFIX_COUNT;
- if (3 * prefix < -*digits) prefix = (-*digits + 2 * (*digits < 0)) / 3;
- if (prefix > POS_PREFIX_COUNT) prefix = POS_PREFIX_COUNT;
+ if (prefix < -NEG_PREFIX_COUNT)
+ prefix = -NEG_PREFIX_COUNT;
+ if (3 * prefix < -*digits)
+ prefix = (-*digits + 2 * (*digits < 0)) / 3;
+ if (prefix > POS_PREFIX_COUNT)
+ prefix = POS_PREFIX_COUNT;
*value *= powf(10, -3 * prefix);
*digits += 3 * prefix;
+
return prefixes[prefix + NEG_PREFIX_COUNT];
}
+/**
+ * Check if a unit "accepts" an SI prefix.
+ *
+ * E.g. SR_UNIT_VOLT is SI prefix friendly while SR_UNIT_DECIBEL_MW or
+ * SR_UNIT_PERCENTAGE are not.
+ *
+ * @param[in] unit The unit to check for SI prefix "friendliness".
+ *
+ * @return TRUE if the unit "accept" an SI prefix.
+ *
+ * @since 0.5.0
+ */
+SR_API gboolean sr_analog_si_prefix_friendly(enum sr_unit unit)
+{
+ static const enum sr_unit prefix_friendly_units[] = {
+ SR_UNIT_VOLT,
+ SR_UNIT_AMPERE,
+ SR_UNIT_OHM,
+ SR_UNIT_FARAD,
+ SR_UNIT_KELVIN,
+ SR_UNIT_HERTZ,
+ SR_UNIT_SECOND,
+ SR_UNIT_SIEMENS,
+ SR_UNIT_VOLT_AMPERE,
+ SR_UNIT_WATT,
+ SR_UNIT_WATT_HOUR,
+ SR_UNIT_METER_SECOND,
+ SR_UNIT_HENRY,
+ SR_UNIT_GRAM
+ };
+ unsigned int i;
+
+ for (i = 0; i < ARRAY_SIZE(prefix_friendly_units); i++)
+ if (unit == prefix_friendly_units[i])
+ return TRUE;
+
+ return FALSE;
+}
+
/**
* Convert the unit/MQ/MQ flags in the analog struct to a string.
*
+ * The string is allocated by the function and must be freed by the caller
+ * after use by calling g_free().
+ *
* @param[in] analog Struct containing the unit, MQ and MQ flags.
* Must not be NULL. analog->meaning must not be NULL.
* @param[out] result Pointer to store result. Must not be NULL.
*
- * The string is allocated by the function and must be freed by the caller
- * after use by calling g_free().
- *
* @retval SR_OK Success.
* @retval SR_ERR_ARG Invalid argument.
*
#endif
/**
- * Compare two sr_rational for equality
+ * Compare two sr_rational for equality.
*
- * @param[in] a First value
- * @param[in] b Second value
+ * The values are compared for numerical equality, i.e. 2/10 == 1/5.
*
- * The values are compared for numerical equality, i.e. 2/10 == 1/5
+ * @param[in] a First value.
+ * @param[in] b Second value.
*
- * @retval 1 if both values are equal
- * @retval 0 otherwise
+ * @retval 1 if both values are equal.
+ * @retval 0 Otherwise.
*
* @since 0.5.0
*/
}
/**
- * Multiply two sr_rational
- *
- * @param[in] a First value
- * @param[in] b Second value
- * @param[out] res Result
+ * Multiply two sr_rational.
*
* The resulting nominator/denominator are reduced if the result would not fit
* otherwise. If the resulting nominator/denominator are relatively prime,
* this may not be possible.
*
- * It is save to use the same variable for result and input values
+ * It is safe to use the same variable for result and input values.
+ *
+ * @param[in] a First value.
+ * @param[in] b Second value.
+ * @param[out] res Result.
*
* @retval SR_OK Success.
- * @retval SR_ERR_ARG Resulting value to large
+ * @retval SR_ERR_ARG Resulting value too large.
*
* @since 0.5.0
*/
return SR_ERR_ARG;
}
- res->p = (int64_t)(p);
- res->q = (uint64_t)(q);
+ res->p = (int64_t)p;
+ res->q = (uint64_t)q;
return SR_OK;
while (!(p.low & 1) && !(q.low & 1)) {
p.low /= 2;
- if (p.high & 1) p.low |= (1ll << 63);
+ if (p.high & 1)
+ p.low |= (1ll << 63);
p.high >>= 1;
q.low /= 2;
- if (q.high & 1) q.low |= (1ll << 63);
+ if (q.high & 1)
+ q.low |= (1ll << 63);
q.high >>= 1;
}
}
/**
- * Divide rational a by rational b
- *
- * @param[in] num numerator
- * @param[in] div divisor
- * @param[out] res Result
+ * Divide rational a by rational b.
*
* The resulting nominator/denominator are reduced if the result would not fit
* otherwise. If the resulting nominator/denominator are relatively prime,
* this may not be possible.
*
- * It is save to use the same variable for result and input values
+ * It is safe to use the same variable for result and input values.
+ *
+ * @param[in] num Numerator.
+ * @param[in] div Divisor.
+ * @param[out] res Result.
*
* @retval SR_OK Success.
- * @retval SR_ERR_ARG Division by zero
- * @retval SR_ERR_ARG Denominator of divisor to large
- * @retval SR_ERR_ARG Resulting value to large
+ * @retval SR_ERR_ARG Division by zero, denominator of divisor too large,
+ * or resulting value too large.
*
* @since 0.5.0
*/
projects / libsigrok.git / blobdiff