нужна программа перевода DEC. в HEX в CVAVR

[psa07]

I=I+(M[n]+0x30)*a;

Из кода символа надо ВЫЧИТАТЬ 30, чтобы получить цифру числа

[STM32F0]

вот строка фиксированной длины M[3]=('9','9','9')

Если по шагам и на пальцах

uint16_t data = 0;

data = (M[0] - 0x30) * 100;
data += (M[1] - 0x30) * 10;
data += (M[2] - 0x30);

[Paul74s]

Вот так из текста М появится значение в переменной I

char M[10]={'1','2','3','4','5','6','7','8','9','9'};
char n;
int I=0;
for(n=0;n‹10;n++)
{
  I=I*10;
  I=I+(M[n]-0x30);
}

[Paul74s]

А так преобразовываем I=1234567899 к тексту в виде HEX

char I, J;
char H[8], a, n;
J=I; // это на случай сохранения значения в переменной I
for (n=0; n‹8; n++) {
  a=J&0x0F;
  if (a‹10) H[7-n]=a+'0'; else H[7-n]=a+'7';
  J››=4;
}

Результат должен быть "499602DB"

[begun]

доргие друзья,родные,

прежде всего, еще раз огромное спасибо за ваше терпение.
дело было в протеусе.
он не показывал правильно значения переменных и сам cvavr действительно не работает выше 32 бит что меня и путало.

в общем, вроде все выиснил для себя.
еще раз огромное спасибо всем за все.

[begun]

Разрешите особую благодарность высказать Paul74s

[Insector]

#ifndef BCD_H
#define BCD_H

#include "bcd.h"

#include "main_def_func.h"

//==================================================  ======================
extern char num_str_buf [];
extern char tmp_num_str_buf [];
//==================================================  ======================

//==================================================  ======================
void char_to_str (u08 value);
void int_to_str (u16 value);
void long_to_str (u32 value);

u16 str_to_int (void);
u32 str_to_long (void);
//==================================================  ======================

//==================================================  ======================
void clr_tmp_num_str_buf (void);
void clr_num_str_buf (void);
//==================================================  ======================

#endif //BCD_H

//==================================================  ======================
#include "bcd.h"
//==================================================  ======================

//==================================================  ======================
char num_str_buf [11];
char tmp_num_str_buf [11];
//==================================================  ======================

//==================================================  ======================
void clr_tmp_num_str_buf (void)
{
   char *ptr = tmp_num_str_buf;
   u08 cnt = 10;

   while (cnt)
   {
      *ptr++ = ' ';
      cnt--;
   }
   *ptr = 0;
}
//==================================================  ======================

//==================================================  ======================
void clr_num_str_buf (void)
{
   char *ptr = num_str_buf;
   u08 cnt = 10;

   while (cnt)
   {
      *ptr++ = ' ';
      cnt--;
   }
   *ptr = 0;
}
//==================================================  ======================

//==================================================  ======================
u08 __flash tab_10_08 [] =
{
   100U,
   10U,
};
//------------------------------------------------------------------------
void char_to_str (u08 value)
{
   clr_num_str_buf ();

   char *ptr = num_str_buf + 7;

   u08 a;

   u08 cnt_1;
   u08 cnt_2;

   u08 __flash *ptr_f = tab_10_08;

   cnt_1 = 2;

   while (cnt_1)
   {
      a = *ptr_f;
      cnt_2 = 0;

      while (value ›= a)
      {
         value -= a;
         cnt_2++;
      }

      *ptr++ = (cnt_2 | 0x30);

      ptr_f++;
      cnt_1--;
   }
   *ptr++ = (value | 0x30);
   *ptr = 0 | 0x30;
}
//==================================================  ======================

//==================================================  ======================
u16 __flash tab_10_16 [] =
{
   10000U,
   1000U,
   100U,
   10U,
};
//------------------------------------------------------------------------
void int_to_str (u16 value)
{
   clr_num_str_buf ();

   char *ptr = num_str_buf + 5;

   u16 a;

   u08 flags = 0;
   u08 cnt_1;
   u08 cnt_2;

   u16 __flash *ptr_f = tab_10_16;

   cnt_1 = 4;

   while (cnt_1)
   {
      a = *ptr_f;
      cnt_2 = 0;

      while (value ›= a)
      {
         value -= a;
         cnt_2++;
      }

      if (!(flags & (1‹‹0)))
      {
         if (cnt_2 == 0)
         {
            *ptr++ = ' '; // Гашение незначащих нулей.
         }
         else
         {
            *ptr++ = (cnt_2 | 0x30);
            set_bit (flags, 0);
         }
      }
      else
      {
         *ptr++ = (cnt_2 | 0x30);
      }

      ptr_f++;
      cnt_1--;
   }
   *ptr++ = (value | 0x30);
   *ptr = 0;
}
//==================================================  ======================

//==================================================  ======================
u16 str_to_int (void)
{
   char *ptr_num = tmp_num_str_buf + 5;
   u16 __flash *ptr_tab_10 = tab_10_16;
   u16 a;
   u08 cnt = 0;
   u16 tmp_value = 0;

   while (cnt ‹ 4)
   {
      if ((*ptr_num › 0x30) && (*ptr_num ‹ 0x3A))
      {
         a = (*ptr_num - 0x30);

         while (a)
         {
            tmp_value += *ptr_tab_10;
            a--;
         }
      }
      *ptr_num++;
      ptr_tab_10++;
      cnt++;
   }
      return tmp_value += (*ptr_num - 0x30);
}
//==================================================  ======================

//==================================================  ======================
u32 __flash tab_10_32 [] =
{
   1000000000U,
   100000000U,
   10000000U,
   1000000U,
   100000U,
   10000U,
   1000U,
   100U,
   10U,
};
//------------------------------------------------------------------------
void long_to_str (u32 value)
{
   clr_num_str_buf ();

   char *ptr = num_str_buf;

   u32 a;

   u08 flags = 0;
   u08 cnt_1;
   u08 cnt_2;

   u32 __flash *ptr_f = tab_10_32;

   cnt_1 = 9;

   while (cnt_1)
   {
      a = *ptr_f;
      cnt_2 = 0;

      while (value ›=a)
      {
         value -= a;
         cnt_2++;
      }

      if (!(flags & (1‹‹0)))
      {
         if (cnt_2 == 0)
         {
            *ptr++ = ' '; // Гашение незначащих нулей.
         }
         else
         {
            *ptr++ = (cnt_2 | 0x30);
            set_bit (flags, 0);
         }
      }
      else
      {
         *ptr++ = (cnt_2 | 0x30);
      }

      ptr_f++;
      cnt_1--;
   }
   *ptr++ = (value | 0x30);
   *ptr = 0;
}
//==================================================  ======================

//==================================================  ======================
u32 str_to_long (void)
{
   char *ptr_num = tmp_num_str_buf;
   u32 __flash *ptr_tab_10 = tab_10_32;
   u32 a;
   u08 cnt = 0;
   u32 tmp_value = 0;

   while (cnt ‹ 9)
   {
      if ((*ptr_num › 0x30) && (*ptr_num ‹ 0x3A))
      {
         a = (*ptr_num - 0x30);

         while (a)
         {
            tmp_value += *ptr_tab_10;
            a--;
         }
      }
      *ptr_num++;
      ptr_tab_10++;
      cnt++;
   }
      return tmp_value += (*ptr_num - 0x30);
}
//==================================================  ======================