X-Git-Url: https://sigrok.org/gitweb/?p=libsigrok.git;a=blobdiff_plain;f=src%2Fanalog.c;h=4ec724cfde488a0ae4a37a5c2ab0f0b414264da8;hp=a04844d67a7df13040d73aab775b3e053b325f57;hb=f37f11ec6b3b0bc15de0a186dd9ba424635c117e;hpb=bdba362695bd5ee97fca685839a9e90e1e788ecb diff --git a/src/analog.c b/src/analog.c index a04844d6..4ec724cf 100644 --- a/src/analog.c +++ b/src/analog.c @@ -22,6 +22,7 @@ #include #include #include +#include #include #include "libsigrok-internal.h" @@ -62,8 +63,8 @@ static struct unit_mq_string unit_strings[] = { { 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" }, @@ -87,6 +88,9 @@ static struct unit_mq_string unit_strings[] = { { 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 }; @@ -118,6 +122,7 @@ static struct unit_mq_string mq_strings[] = { ALL_ZERO }; +/** @private */ SR_PRIV int sr_analog_init(struct sr_datafeed_analog *analog, struct sr_analog_encoding *encoding, struct sr_analog_meaning *meaning, @@ -155,14 +160,14 @@ SR_PRIV int sr_analog_init(struct sr_datafeed_analog *analog, /** * 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. @@ -172,9 +177,11 @@ SR_PRIV int sr_analog_init(struct sr_datafeed_analog *analog, 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) @@ -187,6 +194,7 @@ SR_API int sr_analog_to_float(const struct sr_datafeed_analog *analog, #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; @@ -257,8 +265,8 @@ SR_API int sr_analog_to_float(const struct sr_datafeed_analog *analog, } 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; @@ -272,36 +280,131 @@ SR_API int sr_analog_to_float(const struct sr_datafeed_analog *analog, /* 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; + } } } return SR_OK; } +/** + * Scale a float value to the appropriate SI prefix. + * + * @param[in,out] value The float value to convert to appropriate SI prefix. + * @param[in,out] digits The number of significant decimal digits in value. + * + * @return The SI prefix to which value was scaled, as a printable string. + * + * @since 0.5.0 + */ +SR_API const char *sr_analog_si_prefix(float *value, int *digits) +{ +/** @cond PRIVATE */ +#define NEG_PREFIX_COUNT 5 /* number of prefixes below unity */ +#define POS_PREFIX_COUNT (int)(ARRAY_SIZE(prefixes) - NEG_PREFIX_COUNT - 1) +/** @endcond */ + static const char *prefixes[] = { "f", "p", "n", "µ", "m", "", "k", "M", "G", "T" }; + + 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; + + *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. * @@ -400,15 +503,15 @@ static void mult_uint64(struct sr_uint128_t *res, const uint64_t a, #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 */ @@ -433,4 +536,121 @@ SR_API int sr_rational_eq(const struct sr_rational *a, const struct sr_rational #endif } +/** + * 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 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 too large. + * + * @since 0.5.0 + */ +SR_API int sr_rational_mult(struct sr_rational *res, const struct sr_rational *a, + const struct sr_rational *b) +{ +#ifdef HAVE___INT128_T + __int128_t p; + __uint128_t q; + + p = (__int128_t)(a->p) * (__int128_t)(b->p); + q = (__uint128_t)(a->q) * (__uint128_t)(b->q); + + if ((p > INT64_MAX) || (p < INT64_MIN) || (q > UINT64_MAX)) { + while (!((p & 1) || (q & 1))) { + p /= 2; + q /= 2; + } + } + + if ((p > INT64_MAX) || (p < INT64_MIN) || (q > UINT64_MAX)) { + // TODO: determine gcd to do further reduction + return SR_ERR_ARG; + } + + res->p = (int64_t)p; + res->q = (uint64_t)q; + + return SR_OK; + +#else + struct sr_int128_t p; + struct sr_uint128_t q; + + mult_int64(&p, a->p, b->p); + mult_uint64(&q, a->q, b->q); + + while (!(p.low & 1) && !(q.low & 1)) { + p.low /= 2; + if (p.high & 1) + p.low |= (1ll << 63); + p.high >>= 1; + q.low /= 2; + if (q.high & 1) + q.low |= (1ll << 63); + q.high >>= 1; + } + + if (q.high) + return SR_ERR_ARG; + if ((p.high >= 0) && (p.low > INT64_MAX)) + return SR_ERR_ARG; + if (p.high < -1) + return SR_ERR_ARG; + + res->p = (int64_t)p.low; + res->q = q.low; + + return SR_OK; +#endif +} + +/** + * 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 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, denominator of divisor too large, + * or resulting value too large. + * + * @since 0.5.0 + */ +SR_API int sr_rational_div(struct sr_rational *res, const struct sr_rational *num, + const struct sr_rational *div) +{ + struct sr_rational t; + + if (div->q > INT64_MAX) + return SR_ERR_ARG; + if (div->p == 0) + return SR_ERR_ARG; + + if (div->p > 0) { + t.p = div->q; + t.q = div->p; + } else { + t.p = -div->q; + t.q = -div->p; + } + + return sr_rational_mult(res, num, &t); +} + /** @} */