#include <stdlib.h>
div_t dtmp;
char str_tmp[6];
str_tmp[5] = 0;  
  OborotiZaMin = (OborotiZaMinConst + (PPeriod >> 1)) / PPeriod;

#if   0

  dtmp = div(OborotiZaMin, 10);
  str_tmp[4] = dtmp.rem + '0';  
  dtmp = div(dtmp.quot, 10);
  str_tmp[3] = dtmp.rem + '0';  
  dtmp = div(dtmp.quot, 10);
  str_tmp[2] = dtmp.rem + '0';  
  dtmp = div(dtmp.quot, 10);
  str_tmp[1] = dtmp.rem + '0';  
  str_tmp[0] = dtmp.quot + '0';  
// Гашение незначащих нулей
  for (i = 0; i < 4; ++i)
    if (str_tmp[i] == '0')
      str_tmp[i] = ' ';
    else
      break;

#else
  
  i = 0;
  dtmp = div(OborotiZaMin, 10000);
  if (dtmp.quot != 0)
    str_tmp[i++] = dtmp.quot + '0';

  dtmp = div(dtmp.rem, 1000);
  if (i || (dtmp.quot != 0))
    str_tmp[i++] = dtmp.quot + '0';
    
  dtmp = div(dtmp.rem, 100);
  if (i || (dtmp.quot != 0))
    str_tmp[i++] = dtmp.quot + '0';
    
  dtmp = div(dtmp.rem, 10);
  if (i || (dtmp.quot != 0))
    str_tmp[i++] = dtmp.quot + '0';
    
  str_tmp[i++] = dtmp.rem + '0';
  str_tmp[i] = 0;
    
#endif
    // LCD_Write

char* itoa(unsigned int val, char *s)
{
  register unsigned int temp;
  register char n=0, atemp=0;
  
  atemp=0; temp=10000; if(val >= temp) {n=1; while(val >= temp) {atemp++; val-=temp;} *s++ = atemp+'0';}  
  atemp=0; temp=1000; if((val >= temp)||(n)) {n=1; while(val >= temp) {atemp++; val-=temp;} *s++ = atemp+'0';}  
  atemp=0; temp=100; if((val >= temp)||(n)) {n=1; while(val >= temp) {atemp++; val-=temp;} *s++ = atemp+'0';}  
  atemp=0; temp=10; if((val >= temp)||(n)) {while(val >= temp) {atemp++; val-=temp;} *s++ = atemp+'0';}
  *s++ = (char)val+'0';                                                                      

  *s = '\0';
  
  return s;
}

#include <stdlib.h>

{
  char str_tmp[6];
  unsigned int OborotiZaMin;
...
  utoa (OborotiZaMin, str_tmp, 10);
...
}

.global    itoa
    .type    itoa, @function
itoa:
.LFB0:
.LM1:
.LVL0:
    push r16
    push r17
    push r28
    push r29
/* prologue: function */
/* frame size = 0 */
    movw r28,r24
    movw r16,r22
.LM2:
    ldi r18,hi8(10000)
    cpi r24,lo8(10000)
    cpc r25,r18
    brsh .L2
.LVL1:
    ldi r24,lo8(0)
.LVL2:
    rjmp .L3
.LVL3:
.L2:
.LM3:
    movw r30,r24
    subi r30,lo8(-(-10000))
    sbci r31,hi8(-(-10000))
    movw r24,r30
.LVL4:
    ldi r22,lo8(10000)
    ldi r23,hi8(10000)
    call __udivmodhi4
    movw r28,r24
.LM4:
    movw r24,r30
    ldi r22,lo8(10000)
    ldi r23,hi8(10000)
    call __udivmodhi4
    subi r22,lo8(-(49))
    movw r30,r16
    st Z+,r22
    movw r16,r30
    ldi r24,lo8(1)
.LVL5:
.L3:
.LM5:
    ldi r31,hi8(1000)
    cpi r28,lo8(1000)
    cpc r29,r31
    brsh .L4
    tst r24
    breq .L5
.L4:
    movw r24,r28
.LVL6:
    ldi r22,lo8(1000)
    ldi r23,hi8(1000)
    call __udivmodhi4
    mov r18,r22
    movw r24,r28
    ldi r22,lo8(1000)
    ldi r23,hi8(1000)
    call __udivmodhi4
    movw r28,r24
    subi r18,lo8(-(48))
    movw r30,r16
    st Z+,r18
    movw r16,r30
    ldi r24,lo8(1)
.LVL7:
.L5:
.LM6:
    cpi r28,100
    cpc r29,__zero_reg__
    brsh .L6
    tst r24
    breq .L7
.L6:
    movw r24,r28
.LVL8:
    ldi r22,lo8(100)
    ldi r23,hi8(100)
    call __udivmodhi4
    mov r18,r22
    movw r24,r28
    ldi r22,lo8(100)
    ldi r23,hi8(100)
    call __udivmodhi4
    movw r28,r24
    subi r18,lo8(-(48))
    movw r30,r16
    st Z+,r18
    movw r16,r30
    ldi r24,lo8(1)
.LVL9:
.L7:
.LM7:
    cpi r28,10
    cpc r29,__zero_reg__
    brsh .L8
    tst r24
    breq .L9
.L8:
    movw r24,r28
.LVL10:
    ldi r22,lo8(10)
    ldi r23,hi8(10)
    call __udivmodhi4
    mov r18,r22
    movw r24,r28
    ldi r22,lo8(10)
    ldi r23,hi8(10)
    call __udivmodhi4
    movw r28,r24
    subi r18,lo8(-(48))
    movw r30,r16
    st Z+,r18
    movw r16,r30
.LVL11:
.L9:
.LM8:
    movw r18,r28
    subi r18,lo8(-(48))
    movw r30,r16
    st Z+,r18
.LM9:
    movw r28,r16
.LVL12:
    std Y+1,__zero_reg__
.LM10:
    movw r24,r30
.LVL13:
/* epilogue start */
    pop r29
    pop r28
    pop r17
    pop r16
.LVL14:
    ret
.LFE0:

    X_movw    ZL, r_str_lo; &string
    X_movw    r_lstr_lo, ZL; save &string
    cpi    r_radix, 2; no radix < 2
    brlt    99f
    cpi    r_radix, 37; no radix > 36
    brge    99f    
1:
    mov    r22, r_radix; radix
    clr    r23;  dividend in r25:r24,   divisor in r23:r22
    XCALL    _U(__udivmodhi4);  quotient in r23:r22, remainder in r25:r24
    ;  clobbered: r0, r21, r26, r27
    ;  call-used but preserved: r18,r19,r20,r30,r31
    subi    r24, 0xd0; + '0'
    cpi    r24, 0x3a; > '9' ?
    brlt    10f
    subi    r24, 0xd9; + 'a' - 10 - '0'
10:
    st    Z+, r24; write char to string in reverse order!
    X_movw    r_val_lo,r22; quotient -> dividend
    sbiw    r_val_lo,0; value == 0 ?
    brne    1b
99:
    st    Z, __zero_reg__; terminate string
    X_movw    r_val_lo, r_lstr_lo; restore &string as return value
    XJMP    _U(strrev); reverse string

    RSEG CODE:CODE:NOROOT(1)
    PUBLIC _i2a
//   13 __z void i2a(char *s, UINT16 v)
_i2a:
//   14 {
//   15   UINT8 m0; //R16
//   16   UINT8 m1; //R17
//R18-R20 - 24bit fmul result
//R21 - c,b,a ->06 8D B9
//R22 - zero reg
    CLR    R22
    LDI    R21,0x06
//  v=__multiply_unsigned(m0,0x06)+3;
    MUL    R16,R21
    MOVW    R19:R18,R1:R0
    SUBI    R18,0xFD
    SBCI    R19,0xFF
//  v+=__multiply_unsigned(m1,0x06)<<8;
    MUL    R17,R21
    MOV    R20,R1
    ADD    R19,R0
    ADC    R20,R22
//  v+=__multiply_unsigned(m1,0x8D);
        LDI     R21, 0x8D
        MUL     R17, R21
        ADD     R18, R0
        ADC     R19, R1
    ADC    R20, R22
//  v+=__multiply_unsigned(m0,0x8D)>>8;
        MUL     R16, R21
        ADD     R18, R1
        ADC     R19, R22
    ADC    R20, R22
//  v+=__multiply_unsigned(m1,0xB9)>>8;
    LDI    R16,0x10    ; Counter & flags
    LDI    R21,0xB9
        MUL     R17, R21
        LDI     R21, 10        ; Next multiplicand
        ADD     R18, R1
        ADC     R19, R22
    ADC    R20, R22
    BREQ    ??i2a_0
    SUBI    R20,208
    ST    Z+,R20
    INC    R16
??i2a_0:
//   39     UINT16 hv;
//   40     UINT8 bv;
//   41     bv=v>>8;
        MOV     R17, R19
//   42     v=__multiply_unsigned(v,10);
        MUL     R18, R21
        MOVW    R19:R18, R1:R0
//   43     hv=__multiply_unsigned(bv,10);
        MUL     R17, R21
//   44     v+=(hv&0xFF)<<8;
        ADD     R19, R0
//   45     if (SREG_Bit0) hv+=0x100;
    ADC    R1, R22
//   46     bv=hv>>8;
        MOV     R17, R1
//   47     if ((i|bv)&0x8F)
        MOV     R20, R1
        OR      R20, R16
        ANDI    R20, 0x8F
        BREQ    ??i2a_1
//   48     {
//   49       *s++=bv+'0';
    SUBI    R17,208
    ST    Z+,R17
//   50       i|=1;
//        ORI     R18, 0x01
??i2a_1:
//   51     }
//   52     i<<=1;
    ROL    R16
//   54   while(!SREG_Bit0);
        BRBC    0, ??i2a_0
//   55   *s=0;
        ST      Z, R22
//   56 }
        RET

// convert and output decimal value
int IntToStrPrint( S32 val )
{
    U8  c, len = 0;
    U8  buf[ 10 ]; // max size for text representation of S32 value

    if (val < 0)
    {
        putchar('-');
        val =  -val;
    }

    do {
        c = val % 10 + '0';
        val /= 10;
        buf[ len++ ] = c;
    } while (val != 0);
    
    while (len)
        putchar(buf[ --len ]);
    return SUCCESS;
}

#include <stdio.h>
#include <lcd.h>

int lcd_file_putc(char ch, FILE * stream)
{
    (void) stream;
    lcd_putchar(ch);
    return 0;
}

FILE lcd_file = FDEV_SETUP_STREAM(lcd_file_putc, 0, _FDEV_SETUP_WRITE);
#define flcd (&lcd_file)

...
    // тут и с гашением, и без гашения, и с фиксированной шириной поля, и с переменной
    // - как угодно
    fprintf_P( flcd, PSTR("%d 0x%04X"), -20121, 0xBEEF);

int console_putc(char ch, FILE * stream)
{
    (void) stream;
    uart_putchar(ch);
    return 0;
}

int console_getc(FILE * stream)
{
    (void) stream;
    return uart_getchar();
}

FILE console_file = FDEV_SETUP_STREAM(console_putc, console_getc, _FDEV_SETUP_RW);
#define fconsole (&console_file)

void report_ex_time(const prog_char *header, const prog_char *comment, uint32_t cpu_ticks)
{
    uint32_t ex_time = (cpu_ticks * CPU_TICK_SCALE + 128) / 256;    // CPU ticks to us
    if (comment)
        fprintf_P(fconsole, PSTR("%-38S = %6luus (%S)\n"), header, ex_time, comment);
    else
        fprintf_P(fconsole,  PSTR("%-38S = %6luus\n"), header, ex_time);
}

//
// Перекодировка в 7-сегментные цифры
//
// Input:
// R24:R25 - указатель на массив цифр (6 байт)
// R22 - признак гашения ведущих нулей
//
// используются:
// R18
//

BCDto7Segm:ldi r18, 6
mov r26, r24
mov r27, r25
clt
sbrc r22, 0
set ; уст. T - гашение ведущих нулей
conv: ldi r30, lo8(SegmTable)
ldi r31, hi8(SegmTable)
ld r0, X
brtc addx ; если не гасим нули, то получить 7-сегментный код
tst r0 ; если 0
breq cont ; то продолжить
clt ; иначе - прекратить гашение нулей
sub r24, r26
neg r24
dec r24 ; в r24 - позиция последнего погашенного символа
addx: add r30, r0
adc r31, r1
lpm
st X, r0
cont: adiw r26, 1
dec r18
brne conv
brtc exit ; если все нули
sbiw r26, 1
ldi r18, 0x3f; то последний не гасить
st X, r18
ldi r24, 4

exit: ret