Начинающиму Эмбдебберу. Работа со строками

Программирование на микроконтроллере многим отличается от программирования на ПС.
Первый пункт отличия — это ограничение ресурсов. Таких, как оперативная память, частота процессора (ядра микроконтроллера), количества периферии, количества сред и языков программирования и наличие и стабильность компиляторов. Если с первыми пунктами последнее время становится легче, то в стабильности и правильности работ компилятора всегда есть вопросы (или недопонимание со стороны программиста).

Таким образом, имея опыт работ по 2 микроконтролерам, делаю следующие выводы:

1. Программировать под микроконтроллер лучше на си и ассемблере;
2. При программировании желательно не пользоваться глобальными переменными;
3. Не пользоваться стандартными библиотеками си;
4. Если есть возможность писать все самому.

Если с первыми пунктами все более менее понятно, то с последним все правильно, не считая, что все самому написать жизни не хватит. Поэтому пользоваться чужим кодом придется, а значит, как минимум и пункт третий тоже придется писать самому.

При работе с модемом необходимым условием выходят на первый план функции работы со строками, такие как сравнение, определение длины строки, перевода из числового в текстовый и обратно.

Можно переворачивать интернет или поискать на хабре, тем более что сейчас вышла эта статья и вопросы по работе со строковыми переменными в некоторой части решены. Представляю помощь начинающим, а также на обсуждение гуру небольшой сборник функций для работы со строковыми переменными для эмбдеббера.

int strlen (char*p)
     { int i=0;
     while( *p++ ) i++;
     return i;//отлажено
     }


//----------------------------------------------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------//
/////сравнивает две стороки одинаковой ///////////////////
int CP(char *buf ,char *subbuf)
     {
      int i = 0;
      while( buf[i] == subbuf[i]) i++;
      //  i--;
      // if (i f) ) i=0;
      return (i) ; // отлажено
     }

//----------------------------------------------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------//
////выдает первую  позицию вхожденя  подстроки в строку
int Pos(char *buf,char *subbuf)
     {   int i=0;
     while(*buf)
          { if (i=CP(buf,subbuf)) break;
          *buf++;;
          } 
     return(i);//  отлажено
     }



//----------------------------------------------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------//


//----------------------------------------------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------//
*/
unsigned int  TextToWord(char* s, int s_l) // string to word
     {	double r = 0;
     while(s_l-- > 0)
          {	if(*s < '0' || *s > '9') break;
          r = r * 10 + (*s - '0');
          s++;
          }
     return r;
     }
//----------------------------------------------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------//

double TextToDWodr(char* s, int s_l) // string to dword
     {	double r = 0;
     while(s_l-- > 0)
          {	if(*s < '0' || *s > '9') break;
          r = r * 10 + (*s - '0');
          s++;
          }
     return r;
     }
//----------------------------------------------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------//
char l_case_table[256];
#define fast_l_case(c) l_case_table[(unsigned char)c]

double HexToDWord(char* s, int s_l) // hex string to dword
     {	double r = 0;
     while(s_l-- > 0)
      
          {	char c = fast_l_case(*s);
          if(c >= '0' && c <= '9')
               {	r = r * 16 + (c - '0');
               }
          else if(c >= 'a' && c <= 'f')
               {	r = r * 16 + (c - 'a' + 10);
               }
          else break;
          s++;
          }
     return r;
     }
//----------------------------------------------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------//

int HexToInt13(const char* s)          // HEX TO INT
     {
      int r = 0;
      char c;
      
      while( (c = *s++) )
           {	if(c >= '0' && c <= '9') r = r * 16 + (c - '0');
           else if(c >= 'a' && c <= 'f') r = r * 16 + (c - 'a' + 10);
           else if(c >= 'A' && c <= 'F') r = r * 16 + (c - 'A' + 10);
           else break;
           }
      return r;
     }
//----------------------------------------------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------//

int HexToChar( char* s,char *buf)          // HEX TO INT
     {
      int r = 0;
      char c;
      int i=0;
      
      while( (c = *s++) )
           {	if(c >= '0' && c <= '9') r = r * 16 + (c - '0');
           else if(c >= 'a' && c <= 'f') r = r * 16 + (c - 'a' + 10);
           else if(c >= 'A' && c <= 'F') r = r * 16 + (c - 'A' + 10);
           else if( r )  { buf[ i++ ] =  r  ; r = 0; }
           } 
      return i;               
     }


char Buf_Hex[]= {'0','1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};

int CharToHex(char *s,int Count,char* buf) // отлажено
     {
      int i=0;
      char hi,lo,c ;
      // Returns hex String representation of char c
      while( Count--  )
           {  c = *s++;
           hi =  c >> 4;
           lo =  c & 0x0f;
           buf[i++]= Buf_Hex[hi];
           buf[i++]= Buf_Hex[lo];
           buf[i++]=' ';
           }
      ;
      buf[--i]=0;     
      return i;
     }
//----------------------------------------------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------//

int strstr1   ( const char * str1, const char * str2  )
{
        char *cp = (char *) str1;
        char *s1, *s2;
        int i=0;
       if ( !*str2 ) // если строка 2 нулевая
                    return 0;
        while (*cp)
        {
                s1 = cp;
                s2 = (char *) str2;

                while ( *s1 && *s2 && !(*s1-*s2) )
                        s1++, s2++,i++;
                if (!*s2)
                     return i;// позиция
                cp++;
        }
       return(0);// если  строка 1 нулевая
}

//----------------------------------------------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------//


void IntToText(long Value,  char *Buf)
     {
      //// Convert value 
      char BCD[4];
      char j=0, i = 0,Count =5 ,c;
      
      bin2bcd32(BCD, Value);
      //  Buf[0]=BCD[0];
      
      while( Count--  )
           {  
            c=BCD[j++];       
            if (i||c>>4) Buf[i++]= (c >> 4  )  + 0x30;
            if (i||c)   Buf[i++]= (c &  0x0f) + 0x30;
           }     
      Buf[i]=0;  
      
     }
//----------------------------------------------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------//

void  Sleep (int mSek )//пауза в мсек отлажено

     {    int h,i,j;
     h = mSek;
     for ( j  = 0; j < h ; j++)
      for (i  = 0; i < 2000 ; i++);
     
     }
#endif
//----------------------------------------------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------//

void Load(char *Buf1,char *Buf2) // загрузить из массива Buf2 в массив Buf1  отлажено
     { int i=0;
     do
          {
           Buf1[i] = Buf2[0];
           i++;
          }
     while( *Buf2++ ) ;
     }

//----------------------------------------------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------//

В общем-то, если добавить к этому printf и get для вашего микроконтроллера, можно полноценно работать и с GPRS модемом и c GPS и любым другим поддерживающими АТ команды.