void lcd_menu_value(
    unsigned long freq,
    uint_least8_t width,    // full width
    uint_least8_t comma,        // comma position (from right, inside width)
    uint_least8_t rj        // right truncated
    )
{
    static const prog_uint32_t vals [] =
    {
        100000000,
        10000000,
        1000000,
        100000,
        10000,
        1000,
        100,
        10,
        1,
    };
    const unsigned  char j = (sizeof vals /sizeof vals [0]) - rj;
    unsigned  char i = (j - width);
    unsigned  char z = 1;    // only zeroes


    for (; i < j; ++ i)
    {
        ldiv_t res = ldiv(freq, pgm_read_dword(& vals [i]));

        if (comma == (j - i))
        {
            z = 0;
            ws1602_wrdata('.');
        }
        if (z == 1 && (i + 1) < j && res.quot == 0)
            ws1602_wrdata(' ');    // supress zero
        else
        {
            z = 0;
            ws1602_wrdata('0' + res.quot);
        }
        freq = res.rem;
    }
}

void si16toad (int16_t Number, char * StrBuf)
{
  char Sign = ' ';
  if (Number > 0) Sign = '+';
  if (Number < 0) {
    Sign = '-';
    Number = -Number;
  }
  StrBuf[6] = '\0';
  signed char i = 5;
  do {
    StrBuf[i--] = Number % 10 + '0';
    Number /= 10;
  } while (Number);
  StrBuf[i] = Sign;
  for (i--; i >= 0; i--) StrBuf[i] = ' ';
}

unsigned int short2str(char *str, unsigned short v, unsigned int slz)
{
    unsigned int a, b, n = 0;
    unsigned long vi;

    vi = v * 26844UL;
    if(v >= 57074) vi -= 13422;    // Вдруг кто скопипастит без проверки
    for(a = 0; a < 5; a++)
    {
        b = vi >> 28;
        if(b || !slz)
        {
            *str++ = b + '0';
            n++;
            slz = 0;
        }
        vi &= ~(0x0f << 28);
        vi *= 10;
    }
    if(!n)
    {
        *str++ = '0';
        n = 1;
    }
    *str++ = 0;
    return n;
}

"     0"
"   -12"
"+32767"

//-----------Функция преобразования числа в строку----------//
void decbin_5dgt(uint8_t* x, uchar8* buffer)
{
   uint8_t i;
   uint8_t buff[DSPL_BUFF_SIZE]; //промежуточный интовый буфер
  
        for (i=0; i<DSPL_BUFF_SIZE;i++)buff[i]=0; //зануляем
        //разлаживаем
        for (i=*x; i>=10000; i-=10000)buff[0]++;
        for (i=*x-10000*buff[0]; i>=1000; i-=1000)buff[1]++;
        for (i=*x-10000*buff[0]-1000*buff[1]; i>=100; i-=100)buff[2]++;
        for (i=*x-10000*buff[0]-1000*buff[1]-100*buff[2]; i>=10; i-=10)buff[3]++;
        for (i=*x-10000*buff[0]-1000*buff[1]-100*buff[2]-10*buff[3]; i>=1; i-=1)buff[4]++;
    
      
        for (i=0; i<DSPL_BUFF_SIZE;i++)buffer[i]=(uchar8)buff[i]; //переписываем в наш массив                                                }
      
}
//==========================================================//

// 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;
}

/* __divmodhi4 and __divmodsi4 from libgcc.a */
extern div_t div(int __num, int __denom) __asm__("__divmodhi4") __ATTR_CONST__;
extern ldiv_t ldiv(long __num, long __denom) __asm__("__divmodsi4") __ATTR_CONST__;

/**
* "Указатель" на тетраду байта (обертка над указателем и признаком первая\вторая тетрада)
*/
struct TBCDLocation
{
byte *buf;
bool isFH;

TBCDLocation(byte *buf = 0, bool isFH = true) { this->buf = buf; this->isFH = isFH; }

TBCDLocation& operator++();
TBCDLocation& operator--();
TBCDLocation& operator+=(byte b );
TBCDLocation& operator-=(byte b );
uint_fast16_t operator-(const TBCDLocation& b ) const;
uint_fast16_t operator-(byte *b ) const;
TBCDLocation operator-(uint_fast8_t b ) const;
TBCDLocation operator+(uint_fast8_t b ) const;
bool operator==(const TBCDLocation& b ) const;
bool operator!=(const TBCDLocation& b ) const;
bool operator>(const TBCDLocation& b ) const;

void put(byte val);
void putAndInc(byte val);
void putAndDec(byte val);
byte get();
byte getAndInc();
byte getAndDec();
};

struct TBINtoBCDres
{
TBCDLocation loc; //!< Указатель на цифру перед первой результата
bool isOverflow : 1; //!< признак переполнения
bool isMinus : 1; //!< знак
TBINtoBCDres (TBCDLocation loc, bool isOverflow, bool isMinus) : loc(loc), isOverflow(isOverflow), isMinus(isMinus) {}
};

/**
* Преобразование двоичного числа произвольной длины в десятичное число произвольной длины
* (две цифры в байте). Результат выравнивается по правому краю.
* Заполнение ведущими нулями НЕ производится (в частности, при преобразовании числа 0
* целевой массив НЕ ИЗМЕНИТСЯ вообще и будет возвращен lsBCD).\n
* Если десяичное число не влезает в указанное число разрядов,
* старшие разряды будут потеряны (т.е. 0xffff при преобразовании
* в три разряда даст 535)\n
* Двоичное число лежит младшим байтом вперед. Десятичное - старшей цифрой вперед.
*
* @param lsBCD указатель на младшую цифру результата (самую последнюю)
* @param bin указатель на младший байт двоичного числа (самый первый)
* @param halfbyteCnt
* число тетрад в двоичном числе
* @param bcdDigCnt число цифр в десятичном числе
*
* @return Указатель на цифру перед первой результата и признак переполнения
*/
TBINtoBCDres BINtoBCD(TBCDLocation lsBCD, void const *bin, uint_fast8_t halfbyteCnt, uint_fast8_t bcdDigCnt)
{
// используется сдвиговый алгоритм (полубайты выдвигаются из двоичного регистра и вдвигаются
// в десятичный, при этом произодится коррекция) Число итераций = (число байт) * (число дес цифр)
TBCDLocation msBCD = lsBCD;
bool isOverflow = false;
byte *pbin = ((byte*)bin) + (halfbyteCnt/2)-1;
bool binIsFH = true;
uint_fast8_t tmp;
while(halfbyteCnt--)
{
uint_fast8_t sdv; // выдвинутый полубайт
if (binIsFH)
{
tmp = *pbin--;
sdv = HIGHPART(tmp);
binIsFH = false;
}
else
{
sdv = LOWPART(tmp);
binIsFH = true;
}
TBCDLocation bcd(lsBCD);
while(true) // вдвигаем полубайт в десятичный регистр
{
bool isLim = msBCD == bcd; // признак достижения старшей цифры
if(isLim && sdv == 0) break;

uint_fast8_t cur = isLim ? 0 : bcd.get();
uint_fast8_t tmp = tableBINtoBCD[(cur<<4) | sdv];
cur = HIGHPART(tmp);
sdv = LOWPART(tmp);
if (isLim)
{
if (cur || sdv)
{
if (bcdDigCnt)
{
bcd.putAndDec(cur);
--bcdDigCnt;
msBCD = bcd;
}
else
{
isOverflow = true;
break;
}
}
else
break;
}
else
bcd.putAndDec(cur);
}
}
return TBINtoBCDres(msBCD, isOverflow, false);
}

void  itoa(int16_t Number, uint8_t *String)
{
  uint8_t  Sign = ' ';
  if (Number > 0) Sign = '+';
  if (Number < 0) {
    Sign = '-';
    Number = - Number;
  }
  String[6] = '\0';
  int8_t i = 5;
  div_t QR = {Number, 0};
  do {
    QR = div(QR.quot, 10);
    String[i--] = QR.rem + '0';
  } while (QR.quot);
  String[i] = Sign;
  for (i--; i >= 0; i--)
    String[i] = ' ';
}