When you don't have access to snprintf() and other string functions, and you wish to build a fixed-size string, you may find that it is easiest to build the string from right to left.
For example, if you have room for 16 characters, and you want it to have contents
±#.##A ###B ###C
from variables avalue (signed integer multiplied by 100, so 100 = +1.00), bvalue (unsigned integer), and cvalue, with # signifying a decimal digit:
Code:
char buffer[17]; /* For testing; 16 should do on a microcontroller */
unsigned int temp;
buffer[16] = '\0'; /* For testing, so you can print this */
buffer[15] = 'C';
if (cvalue > 999) {
buffer[12] = 'M';
buffer[13] = 'A';
buffer[14] = 'X';
} else {
buffer[14] = '0' + (cvalue % 10);
buffer[13] = (cvalue > 9) ? '0' + ((cvalue / 10) % 10) : ' ';
buffer[12] = (cvalue > 99) ? '0' + ((cvalue / 100) % 10) : ' ';
}
buffer[11] = ' ';
buffer[10] = 'B';
if (bvalue > 999) {
buffer[7] = 'M';
buffer[8] = 'A';
buffer[9] = 'X';
} else {
buffer[9] = '0' + (bvalue % 10);
buffer[8] = (bvalue > 9) ? '0' + ((bvalue / 10) % 10) : ' ';
buffer[7] = (bvalue > 99) ? '0' + ((bvalue / 100) % 10) : ' ';
}
buffer[6] = ' ';
buffer[5] = 'A';
if (avalue < -999) {
buffer[0] = '-';
buffer[1] = 'M';
buffer[2] = 'A';
buffer[3] = 'X';
buffer[4] = '!';
} else
if (avalue > 999) {
buffer[0] = '+';
buffer[1] = 'M';
buffer[2] = 'A';
buffer[3] = 'X';
buffer[4] = '!';
} else {
if (avalue > 0) {
temp = avalue;
buffer[0] = '+';
} else
if (avalue < 0) {
temp = -avalue;
buffer[0] = '-';
} else {
temp = 0;
buffer[0] = ' ';
}
buffer[4] = '0' + (temp % 10);
buffer[3] = '0' + ((temp / 10) % 10);
buffer[2] = '.';
buffer[1] = '0' + ((temp / 100) % 10);
}
Extracting the rightmost digit is easy, so depending on your display formatting needs, you can often do it with a simple loop or two. For example, if you just want the first eight digits of buffer to show a number, you can do
Code:
char buffer[17];
int number; /* Show this number */
unsigned int temp;
unsigned char i;
if (number < -9999999) {
temp = 9999999;
buffer[0] = '-';
} else
if (number < 0) {
temp = -number;
buffer[0] = '-';
} else
if (number > 99999999) {
temp = 99999999;
buffer[0] = ' ';
} else {
temp = number;
buffer[0] = ' ';
}
i = 8;
do {
buffer[--i] = '0' + (temp % 10);
temp /= 10;
} while (temp > 0);
while (i-->1)
buffer[i] = ' ';
The do .. while loop constructs the unsigned number (which should not overflow the buffer, that's why the checks are needed). If there were fewer than seven digits, the last while snippet fills spaces leftwards, but keeps the initial character intact (which was already set in the range checking if clauses). Note that the do .. while loop can assign all 8 digits, in which case the last while snippet does nothing.
In general, I recommend designing the output on paper, and testing it with a small C program (with different inputs). For example, now that I look at the above, I think you could use the two spaces in between for the negative sign, if B or C were negative. (That means that if you have two or more values, and one of them is never negative, it makes sense putting that to the left, because you can then use the separating spaces for the - sign for the others.)
Originally Posted by Nominal Animal
