Contiki 3.0（RPL协议环境）浮点数计算异常及字符串转换解决方案咨询

Great question! Let's break this down into two clear parts: fixing your calculation accuracy first, then refining your float-to-string conversion for Contiki's embedded environment.

1. Getting Accurate Floating-Point Results #

The issue with 5/2 returning 2 instead of 2.5 is integer division—C automatically truncates decimal results when both operands are integers. To get a floating-point result, you just need to ensure at least one operand is a float or double. Here are your options:

• Explicitly use a floating-point literal:

  float result = 5.0 / 2;   // Returns 2.5
  float result = 5 / 2.0;   // Also returns 2.5
  

• Cast one operand to float/double:

  float result = (float)5 / 2;  // 5 is cast to float first, so division is floating-point
  

Just make sure you're assigning the result to a float or double variable—don't store it back in an integer, or you'll lose the decimal part again!

2. Improving Float-to-String Conversion #

Your existing ftoa function works, but it has a few edge cases that can cause issues in embedded systems like Contiki. Let's fix those, plus add support for negatives and proper rounding:

Key Issues in Your Current Code #

• No support for negative floating-point numbers
• Floating-point precision errors (e.g., 0.2999999 * 100 becomes 29.99999, which truncates to 29 instead of rounding to 30)
• Dependence on powf, which may require linking the math library (and can have precision quirks)
• Doesn't handle zero properly in the integer part

Optimized ftoa Implementation #

Here's a revised version that addresses all these issues:

#include <string.h>

// Reverses a string 'str' of length 'len'
void reverse(char* str, int len) {
    int i = 0, j = len - 1, temp;
    while (i < j) {
        temp = str[i];
        str[i] = str[j];
        str[j] = temp;
        i++;
        j--;
    }
}

// Converts an integer to string, handles zeros and negatives
int intToStr(int x, char str[], int d) {
    int i = 0;

    // Handle zero explicitly to avoid empty output
    if (x == 0) {
        str[i++] = '0';
    } else {
        // Track negative integers
        int is_negative = x < 0;
        if (is_negative) {
            x = -x;
        }

        // Convert digits
        while (x > 0) {
            str[i++] = (x % 10) + '0';
            x = x / 10;
        }

        // Add negative sign if needed
        if (is_negative) {
            str[i++] = '-';
        }
    }

    // Pad with leading zeros if required
    while (i < d) {
        str[i++] = '0';
    }

    reverse(str, i);
    str[i] = '\0';
    return i;
}

// Simple integer power function (avoids powf dependency)
long long power10(int exponent) {
    long long result = 1;
    for (int i = 0; i < exponent; i++) {
        result *= 10;
    }
    return result;
}

// Converts float to string with proper rounding and negative support
void ftoa(float n, char* res, int afterpoint) {
    int i = 0;
    int is_negative = n < 0.0f;

    // Handle negative numbers
    if (is_negative) {
        n = -n;
        res[i++] = '-';
    }

    // Extract integer and fractional parts
    int ipart = (int)n;
    float fpart = n - (float)ipart;

    // Convert integer part to string
    i += intToStr(ipart, res + i, 0);

    // Handle decimal point and fractional part if needed
    if (afterpoint > 0) {
        res[i++] = '.';

        // Scale fractional part and add 0.5 to round correctly
        long long fpart_scaled = (long long)(fpart * power10(afterpoint) + 0.5f);

        // Handle carryover if scaling causes overflow (e.g., 0.999999 * 100 + 0.5 = 100)
        if (fpart_scaled >= power10(afterpoint)) {
            ipart += 1;
            // Re-convert integer part to account for carryover
            i = is_negative ? 1 : 0;
            i += intToStr(ipart, res + i, 0);
            res[i++] = '.';
            fpart_scaled = 0;
        }

        // Convert scaled fractional part, pad with zeros if needed
        i += intToStr((int)fpart_scaled, res + i, afterpoint);
    }

    // Null-terminate the string
    res[i] = '\0';
}

What This Fixes #

• Negative numbers: Properly prepends a - sign for negative floats
• Rounding: Adds 0.5 before truncating to avoid precision-related truncation errors
• Carryover handling: If the fractional part rounds up to a full integer (e.g., 2.999 with afterpoint=2 becomes 3.00), it updates the integer part correctly
• No powf dependency: Uses a custom power10 function to avoid linking the math library (which can be tricky on some Contiki targets)
• Zero handling: Ensures 0.0 converts to "0" (or "0.00" with afterpoint=2) instead of an empty string

Compilation Note #

If you do choose to use powf instead of the custom power10 function, make sure to add the math library to your Contiki Makefile:

LDLIBS += -lm

Testing Tips #

Try these edge cases to verify your implementation:

• ftoa(-3.1415, buf, 2) should return "-3.14"
• ftoa(2.9999, buf, 3) should return "3.000"
• ftoa(5.0, buf, 2) should return "5.00"

内容的提问来源于stack exchange，提问作者H. Almutairi