Integer to ASCII in C18

Question

I'm writing code for a PIC18F46K22 using the C18 compiler. I want to write the value of an integer \$n\$ in ASCII over the USART to my PC.

For \$n<10\$, it's easy:

Write1USART(n + 0x30); // 0x30 = '0'

This would work for \$10\le{}n\le100\$:

Write1USART((n/10) + 0x30);
Write1USART((n%10) + 0x30);

But this isn't the fastest possible way, probably.

So is there a built-in function or a function somewhere out there that I could just use instead of rolling my own?

Answer 1

The C18 compiler supports the number-to-ascii family of standard C functions in stdlib.h: itoa(), ltoa(), ultoa() et cetera.

Depending on which compiler / stdlib.h you have, the relevant function prototype would be:

extern char *   itoa(char * buf, int val, int base); // signed int
extern char *   utoa(char * buf, unsigned val, int base); // unsigned int

or

extern char *   itoa(char * buf, int val); // signed int
extern char *   utoa(char * buf, unsigned val); // unsigned int

If you were looking for a relatively robust built-in "standard" C way for converting your numbers to ASCII strings, these xtoa() functions would be the ones to use.

If on the other hand you are constrained to squeeze a few extra cycles or bytes of memory out of the final code, then several of the other answers to your question are the way to go.

Answer 2

I have made a function myself:

void writeInteger(unsigned long input) {
    unsigned long start = 1;
    unsigned long counter;
    while (start*10 <= input)
        start *= 10;
    for (counter = start; counter >= 1; counter /= 10)
        Write1USART(((input / counter) % 10) + 0x30);
}

Answer 3

You could try a function that uses brute-force method to convert to string. Below function does not use modulus operator nor multiplication. It returns a string.

/*
 *  Create a function that will return a string.
 *  It accepts 'inputValue' that is up to 255, but you can make it an int or longint...
 *  ...after you make some edits in the function.
 *  inputValue:   5       7       6
 *  Digits:      1st     2nd     3rd
 */
unsigned char* returnString(unsigned char inputValue)
{
    static unsigned char processedString[4]; // Return a string of 3 digits.
    unsigned char firstDigitCounter = 0; // Brute-force counter for first digit.
    unsigned char secondDigitCounter = 0; // Brute-force counter for second digit.
    if (inputValue > 99) // If we have a 3 digit number,
    {
        while (inputValue > 99) // Until our number is 3 digits, i.e. bigger than 99,
        {
            inputValue -= 100; // Subtract 100 and..
            firstDigitCounter++; //.. increment first digit.
        }
        while (inputValue > 9) // Until our number is 3 digits, i.e. bigger than 9,
        {
            inputValue -= 10; // Subtract 10 and..
            secondDigitCounter++; //.. increment second digit.
        }

        // Now, we have left the 'inputValue' as a single digit.

        processedString[0] = firstDigitCounter + 0x30; // First digit
        processedString[1] = secondDigitCounter + 0x30; // Second digit
        processedString[2] = inputValue + 0x30; // Third digit
        processedString[3] = '\0'; // String terminator.
    }
    else // If we have a 2 digit number,
    {
        while (inputValue > 9) // Until our number is 3 digits, i.e. bigger than 99,
        {
            inputValue -= 10; // Subtract 10 and..
            secondDigitCounter++; //.. increment second digit.
        }
        processedString[0] = secondDigitCounter + 0x30; // Second digit
        processedString[1] = inputValue + 0x30; // Third digit
        processedString[2] = '\0'; // String terminator.
    }
    return processedString; // Return the processed string.
}

Pastebin of the above code.

Answer 4

I have used sprintf(); before. Apart from it being convenient with formatting, I'm not entirely sure if it is fast and has a small footprint. It comes with .

#include <stdio.h>
const uint8_t stringLength = 16;
char string[ stringLength ] = { 0 };

volatile uint32_t measurement = 12345;
sprintf( string , "Measured: %lu milliseconds\n" , measurement );

uint8_t charCounter = 0;
while ( ( charCounter < stringLength ) and ( string[ charCounter ] != 0x00 ) ) {
    serialByteOut( string[ charCounter ] );                         // Send a single character
    charCounter++;
}

Where measurement is a 32bit integer updated in an ISR, which I want to print and string is the output buffer. %lu indicates a long unsigned integer is to be printed and \n is a newline.

The use is largely the same as for printf(); Documentation is extensive and can easily be found on Internet on various websites: http://linux.die.net/man/3/sprintf

Answer 5

You could try this:

void writeInteger(unsigned i)
{
   if (i > 9)
     writeInteger(i/10);
   write1USART(i % 10 + '0');
}