AVR Freaks

X

void lcd_write_int(unsigned int data)
#define val_lo	r22
#define str_lo	r20
#define rdx_lo	r18
#define rdx_hi	r19

ENTRY	ltoa
ENTRY	__ltoa

	cpi	rdx_lo, 37
	cpc	rdx_hi, __zero_reg__
	brsh	1f
	cpi	rdx_lo, 2
	brlo	1f
	XJMP	_U(__ltoa_ncheck)

1:	X_movw	ZL, str_lo
	st	Z, __zero_reg__
	X_movw	r24, str_lo
	ret

#define val_lo	r22
#define val_hi	r23
#define val_hlo	r24
#define val_hhi	r25
#define str_lo	r20
#define rdx_lo	r18

#define sign	r27	/* Argument for __ultoa_common()	*/

ENTRY	__ltoa_ncheck

	clr	sign
	cpi	rdx_lo, 10
	brne	1f
	tst	val_hhi
	brpl	1f

    ; radix == 10 && val < 0: sign = '-' and val = -val
	ldi	sign, '-'
	com	val_hhi
	com	val_hlo
	com	val_hi
	neg	val_lo
	sbci	val_hi, -1
	sbci	val_hlo, -1
	sbci	val_hhi, -1
1:	XJMP	_U(__ultoa_common)

#define val_lo	r22
#define val_hi	r23
#define val_hlo	r24
#define val_hhi	r25
#define str_lo	r20
#define radix	r18

#define counter	r19
#define digit	r26
#define sign	r27

ENTRY	__ultoa_ncheck
	clr	sign

ENTRY	__ultoa_common
	X_movw	ZL, str_lo

1:  ; Saves one iteration of the digit-loop:
    ; If val < radix we can use the low byte of val as digit
	mov	digit, val_lo
	cp	val_lo, radix
	cpc	val_hi, __zero_reg__
	cpc	val_hlo, __zero_reg__
	cpc	val_hhi, __zero_reg__
    ; now C is set, if val < radix
	sbc	counter, counter
	bst	counter, 0
	brts	4f
    ; counter == 0 here

    ; If val >= radix, then pop one digit from val
	clr	digit

2:  ; Vanilla 32:8 quotient and remainder to pop the digit
    ; digit <- val % radix
    ; val   <- val / radix
	lsl	val_lo
	rol	val_hi
	rol	val_hlo
	rol	val_hhi
	rol	digit
	cp	digit, radix
	brlo	3f
	sub	digit, radix
    ; val |= 1
	inc	val_lo
3:  ; Loop the 32 bits
	subi	counter, 8		; 256 / 8 == 32 loops
	brne	2b

4:  ; Convert the digit to ASCII...
	subi	digit, -'0'
	cpi	digit, '9'+1
	brlo	5f
	subi	digit, '0'-'a'+10
5:  ; ... and store it to the reversed string
	st	Z+, digit

    ; Popped all digits?
	brtc    1b

    ; Yes:  Store the sign (if any)
	cpse	sign, __zero_reg__
	st	Z+, sign

    ; Terminate the string with '\0'
7:	st	Z, __zero_reg__

    ; Reverse the string and return the original string pointer
	X_movw	r24, str_lo
	XJMP	_U(strrev)
#include "macros.inc"

#define str_hi r25
#define str_lo r24
#define ltemp  r23
#define rtemp  r22

    ASSEMBLY_CLIB_SECTION
    .global _U(strrev)
    .type   _U(strrev), @function

_U(strrev):
	X_movw	XL, str_lo	; X is start of string
	X_movw	ZL, str_lo	; Z becomes end of string
  ; find end of string
1:	mov	rtemp, ltemp	; to obtain right nonzero character
	ld	ltemp, Z+
	tst	ltemp
	brne	1b
	sbiw	ZL, 2		; to last nonzero byte
	rjmp	3f
  ; swap bytes
2:	ld	ltemp, X
	st	X+, rtemp
	st	Z, ltemp
	ld	rtemp, -Z
3:	cp	XL, ZL
	cpc	XH, ZH
	brlo	2b

	ret
extern __inline__ __ATTR_GNU_INLINE__
char *ltoa (long __val, char *__s, int __radix)
{
    if (!__builtin_constant_p (__radix)) {
	extern char *__ltoa (long, char *, int);
	return __ltoa (__val, __s, __radix);
    } else if (__radix < 2 || __radix > 36) {
	*__s = 0;
	return __s;
    } else {
	extern char *__ltoa_ncheck (long, char *, unsigned char);
	return __ltoa_ncheck (__val, __s, __radix);
    }
}

_utoa(char *src, char *dst, char fill);
(unsigned int data)
 lsr r24        ;1/2
 mov r25,r24
 lsr r24        ;1/4
 adc r24,r25    ;3/4
 lsr r24        ;3/8
 lsr r24        ;3/16
 lsr r24        ;3/32
 adc r24,r25    ;19/32
 lsr r24        ;19/64
 adc r24,r25    ;51/64
 lsr r24        ;51/128
 lsr r24        ;51/256
 lsr r24        ;51/512

ldi	r17, 164
fmul	r16, r17
adc	r18, r18
add	r1, r1
adc	r18, r18
andi	r18, 3
ldi	r16, 10
mul	r16, r1
mov	r17, r1
mul	r16, r0
mov	r16, r1
#if	!defined (__AVR_TINY__)

#include "asmdef.h"

/* char *__utoa_ncheck (unsigned val, char *s, unsigned char radix)
   This function is the utoa() without checking the radix for 2..36 margins.
 */

#define val_lo	r24
#define val_hi	r25
#define str_lo	r22
#define radix	r20

#define counter	r21
#define digit	r26
#define sign	r27
                                                                // clock cycles
ENTRY	__utoa_ncheck
	clr	sign                                            // 1

ENTRY	__utoa_common
	X_movw	ZL, str_lo                                      // 1
	clr	counter                                         // 1

1:  ; Vanilla 16:8 quotient and remainder to pop the digit
    ; digit <- val % radix
    ; val   <- val / radix
	clr	digit                                           // 1

2:	lsl	val_lo                                          // 1
	rol	val_hi                                          // 1
	rol	digit                                           // 1
	cp	digit, radix                                    // 1
	brlo	3f                                              // 1/2
	sub	digit, radix                                    // 1
	inc	val_lo                                          // 1
3:	subi	counter, 16		; 256 / 16 == 16 loops  // 1
	brne	2b                                              // 1/2

    ; Convert the digit to ASCII...
	subi	digit, -'0'                                     // 1
	cpi	digit, '9'+1                                    // 1
	brlo	4f                                              // 1/2
	subi	digit, '0'-'a'+10                               // 1
4:  ; ... and store it to the reversed string
	st	Z+, digit                                       // 1(tiny/xmega)/2

    ; Iterate until all digits are sucked out of VAL.
	sbiw	val_lo, 0                                       // 2
	brne	1b                                              // 1/2

    ; Store the sign (if any)
	cpse	sign, __zero_reg__                              // 1/2
	st	Z+, sign                                        // 1(tiny/xmega)/2

    ; Terminate the string with '\0'
	st	Z+, __zero_reg__                                // 1(tiny/xmega)/2

    ; Reverse the string and return the original string pointer
	X_movw	r24, str_lo                                     // 1
	XJMP	_U(strrev)                                      // …

ENDFUNC

#endif	/* !__AVR_TINY__ */
/**
 \ingroup avr_stdlib

   \brief Convert an unsigned integer to a string.

   The function utoa() converts the unsigned integer value from \c val into an
   ASCII representation that will be stored under \c s.  The caller
   is responsible for providing sufficient storage in \c s.

   \note The minimal size of the buffer \c s depends on the choice of
   radix. For example, if the radix is 2 (binary), you need to supply a buffer
   with a minimal length of 8 * sizeof (unsigned int) + 1 characters, i.e. one
   character for each bit plus one for the string terminator. Using a larger
   radix will require a smaller minimal buffer size.

   \warning If the buffer is too small, you risk a buffer overflow.

   Conversion is done using the \c radix as base, which may be a
   number between 2 (binary conversion) and up to 36.  If \c radix
   is greater than 10, the next digit after \c '9' will be the letter
   \c 'a'.

   The utoa() function returns the pointer passed as \c s.
*/
#ifdef  __DOXYGEN__
extern char *utoa(unsigned int val, char *s, int radix);
#else
extern __inline__ __ATTR_GNU_INLINE__
char *utoa (unsigned int __val, char *__s, int __radix)
{
    if (!__builtin_constant_p (__radix)) {
	extern char *__utoa (unsigned int, char *, int);
	return __utoa (__val, __s, __radix);
    } else if (__radix < 2 || __radix > 36) {
	*__s = 0;
	return __s;
    } else {
	extern char *__utoa_ncheck (unsigned int, char *, unsigned char);
	return __utoa_ncheck (__val, __s, __radix);
    }
}
#endif

AVR Freaks

integer to string

Pages

Search form

integer to string

Pages

Pages