How to convert an int to a series of characters

Question

I'm trying to break down an integer with C on an 8-bit microcontroller (a PIC) into its ASCII equivalent characters.

For example: convert 982 to '9','8','2'

Everything I've come up with so far seems pretty brute force. This is the main idea of what I'm basically doing right now:

if( (10 <= n) && (n < 100) ) {
// isolate and update the first order of magnitude
digit_0 = (n % 10);
// isolate and update the second order of magnitude
switch( n - (n % 10) ) {
  case 0:
    digit_1 = 0;
    break;
  case 10:
    digit_1 = 1;
    break;

...

And then I have another function to just add 0b00110000 (48decimal) to each of my digits.

I've been having trouble finding any C function to do this for me or doing it well myself.

Thanks in advance for any help!

score 4 · Answer 1 · answered Jul 14 '11 at 01:40

4

If sprintf isn't suitable for some reason, something simple like this would work:

char digits[MAX_DIGITS];
int count = 0;
do {
    digits[count++] = n % 10;
    n /= 10;
} while (n > 0);

There'll be count digits, with digits[0] being the least significant.

answered Jul 14 '11 at 01:40

MRAB

20,356
6
40
33

+1 That is exactly what he need! I have posted the same function made in assembler. – GJ. Jul 14 '11 at 14:07

phoxis · Accepted Answer · 2011-07-14T01:52:10.083

To do it yourself you need to perform the operations which are demonstrated with the sample code below:

#include <stdio.h>

int main (void)
{
  unsigned int x = 512;
  int base_val = 10, digit, i = 0, n = 0;
  char x_str[32], t;

  printf ("\nEnter an unsigned number: ");
  scanf ("%u", &x);

  printf ("\nEnter base: ");
  scanf ("%d", &base_val);

  /* Chop the digits in reverse order and store in `x_arr`
   * the interpretation of the digits are made in base value
   * denoted by `base_val`
   */

  while (x)
  {
    digit = x % base_val;
    x /= base_val;
    if (digit < 10)
      x_str[n++] = digit + '0';
    else
      x_str[n++] = digit + 'A' - 10;  /* handle base > 9 */
  }

  /* Terminate string */
  x_str[n] = '\0';

  /* Reverse string */
  for (i=0; i<n/2; i++)
  {
    t = x_str[i];
    x_str[i] = x_str[n-i-1];
    x_str[n-i-1] = t;
  }
  printf ("\n%s\n", x_str);

  return 0;
}

The while loop will chop out the digits from the integer in a given base and feed the digits in reverse order in an array. The inner if - else handles base more than 9, and places uppercase alphabets when a digit value is greater than 10. The for loop reverses the string and gets the chopped number into string in forward order.

You need to adjust the size of x_str array as per your max capability. Define a macro for it. Note the above code is only for unsigned integers. For signed integers you need to first check if it is below 0, then add a '-' sign in x_str and then print the magnitude ie. apply the above code with -x . This can also be done by checking the sign bit, by masking, but will make the process dependent on storage of integer.

The base_val is the base in which you want to interpret the numbers.

it is a microcontroller. your code is valid, but printf and scanf are probably not avaliable. — Vinicius Kamakura, Jul 14 '11 at 01:46
the above code is just a demo to demonstrate the while loop and the for loop work. — phoxis, Jul 14 '11 at 01:53

GJ. · Answer 3 · 2011-07-14T21:49:08.060

If you are compatible with PIC16 RISC assembler than this is very simple, fast, short and efective. Here you have 16 bit unsigned 16 bit division by 10 rutine to see how to do it.

To get first lowest char of number in WREG put 16 bit unsigned number to Reg1 and Reg2 and call rutine. To get next char call rutine again and so on until Reg1 and Reg2 are 0.

RegAE       res 1
RegA0       res 1
RegA1       res 1
RegA2       res 1



    divR16by_c10
    ;{
    ;//Input: 16 bit unsigned number as RegA1,2 (RegA2 low byte, RegA1 High byte)
    ;//Division result: Reg1 and Reg2 and reminder as char in WREG
            clrf    RegA0
            movlw   16             ;//init loop counter
            movwf   RegAE
            lslf    RegA2, f
    divI16by_c10_        
            rlf     RegA1, f
            rlf     RegA0, f       
            movlw   10
            subwf   RegA0, f
            btfsc   Carry
            bra     divI16by_c10_OK
            addwfc  RegA0, f
            bcf     Carry
    divI16by_c10_OK        
            rlf     RegA2, f
            decfsz  RegAE, f
            bra     divI16by_c10_
    ;//result= W from 0..9
            addlw   0x30        ;//convert to char
            return 
    ;}

EDIT:

If you want to convert signed 16 bit value then check the 15th bit first, to determine sign number. If negative than write - sign and negate the number in RegA1,2. After that is the procedure the same a for positive number. To negate number you can use the following asm rutine:

             comf    RegA2, f
             comf    RegA1, f
             movlw   0
             bsf     STATUS, 0      ;//set carry flag
             addwfc  RegA2, f
             addwfc  RegA1, f

score 1 · Answer 4 · edited May 23 '17 at 12:11

1

I answered a question like this a long time ago.

Implementing ftoa

I hope this helps. This applies to both integers and floating point numbers. The concept is simple.

Determine number of digits (for base 10, you use log base 10)
Grab the msb digit by taking the floor of (num/digit_weight)
Subtract digit * weight from number and decrease weight by 1
Do it again until number == 0 for integers or num > 0 + tolerance for fp numbers

Since the algorithm process a digit with every iteration, its O(logn) time so it's pretty reasonable.

edited May 23 '17 at 12:11

Community

1
1

answered Jul 14 '11 at 11:01

Sophy Pal

435
2
7

Tarabyte use a small 8 bit MCPU with few kilo words of FLASH program memory, so using log function in this case isn't reasonable. My function use only 17 words of program memory and is fast, short and efective and it is simple to include in c or any other language. – GJ. Jul 14 '11 at 14:01

How to convert an int to a series of characters

4 Answers4

Linked