Routines générales


longToAsc( )

Accepte comme premier argument un entier de type unsigned long 'lx'.
Elle retourne dans le second argument une chaine de caractères 'str'
constituée de chiffres décimaux .

  void  longToAsc(unsigned long lx, char *str){
    unsigned long  decimal, reste  ;
    int   i ,len                   ;
  
    decimal = lx                   ;
    len = 0                        ;  // len determine le nombre de chiffres représentatifs de lx
    do{
      len++  ;
      decimal /= 10                ;
    }  while(decimal)              ;
  
    decimal = lx                   ;
    i = len -1                     ;
    do{
      reste = decimal % 10         ;
      *(str+i) = reste + 0x30      ;	// conversion numérique -> ascii
      i--                          ;
      decimal /= 10                ; 
    } while(decimal)               ;
    *(str+ len )  = 0              ;
  }
  

ascToLong()

Accepte comme argument une chaine de chiffres décimaux représentative d'un entier .
Elle retourne la valeur numérique de cet entier.

  unsigned long ascToLong(char * str){
    int   i             ;
    unsigned long p10 , decimal ;
    unsigned long c     ;
 
    decimal = 0         ;
    p10 = 1             ;	// p10 : valeur des puissances de 10 successives
    i = 5               ;
    do{
      c = (unsigned long)(*(str +i) - 0x30)  ;	// conversion ascii -> numérique
      decimal +=  p10*c  ;
      i--                ;
      p10 = 10*p10       ;
    } while( i >= 0)     ;
    return decimal       ;
  } 
  
Les routines ascToUnsigned() et UnsignedToAsc() sont pratiquement identiques à
ascToLong() et LongToAsc() mais qui sont adaptées au type unsigned int.

ascToByte()

Accepte en argument une chaine représentative d'un byte (entier non signé sur 8 bits))
codé par 2 chiffre hexadécimaux .
Retourne la valeur de cet entier.
Cette routine est utilisée pour numériser le checksum lu sur une trame NMEA.
On rappelle que les caractères '0' à '9' sont codés 0x30 à 0x39.
Les caractères 'A' ( 10 en hexa) à 'F' (15 en hexa) sont codés de 0x41 à 0x46 .

  byte ascToByte(char *str){
    byte sum  ;

    sum = 0  ;
    if( *str < 0x3A)       sum += (*str- 0x30)<< 4   ; // poids fort multiplié par 16
    else                   sum += (*str -0x37)<< 4   ;
    
    if( *(str + 1) < 0x3A) sum += *(str+1)- 0x30     ;	// poids faible
    else                   sum += *(str+1) -0x37     ;
    return sum  ;
  }
  

checksum()

Accepte comme argument une chaine commençant par '$' (offset 0 de la chaine) .
Effectue dans la variable 'sum' un ou-exclusifs sur tous les caractères de cette chaine
jusqu'à la rencontre du caractère '*' non inclus.
Retourne la valeur de 'sum' .

  unsigned char checkSum(char *str){
    unsigned char sum   ;
    int i               ;
    
    sum = *(str+1)      ;  // le calcul se fait à compter de l'offset 1 .
    i = 2               ;
    do{
        sum ^= *(str+i) ;
        i++             ;
    } while(*(str+i) != '*');
    return sum          ;
  }

substring()

Extrait de la chaine pointée par le premier argument, une sous chaine pointée par le
second argument.
Cette sous chaine est déterminée par son offset (3 ème argument) et sa longueur (4 ème argument).
  void substring(char *mainstr, char *substr, int origin, int len){
    int i , j   ;
    int fin     ;
    
    j = 0       ;
    fin = origin + len  ;
    for(i=origin; i < fin ; i++){
        *(substr + j) = *(mainstr + i)  ;
        j++             ;
    }
    *(substr + j)= 0    ;
  }

substring2()

Cette variante de substring() permet d'extraire des chaines de longueur variables.
La sous chaine est déterminée par tous les caractères de la chaine primitive à compter
du paramètre d'offset (3 ème argument) jusqu'à rencontre du caractère ',' .
Cette routine est utile pour extraire les champs d'une trame NMEA (séparés par des virgules) .

  void substring2 (char *mainstr, char *substr,int offset ){
    int i , j   ;
    
    j = 0       ;
    i = offset  ;
    do{
        *(substr + j) = *(mainstr + i)  ;
        i++; j++                        ;
    } while(*(mainstr + i) != ',')      ;
    *(substr + j)= 0                    ;
  }

cmpstr()

Effectue la comparaison de deux chaines .
Premier argument : pointeur sur la première chaine .
Deuxième argument : pointeur sur la deuxième chaine .
Un ou-exclusif est effectué sur tous les caractères des 2 chaines de même rang .
Si les deux chaines sont identiques cette routine retourne zéro.

  int cmpstr(char *str1, char *str2){
    int len1, i         ;
    int sum             ;
    
    len1 = strlen(str1) ;
    if(len1 != strlen(str2)) sum = len1 ;  // chaines de longueur inégales
    else{
       sum = 0                           ;
       for(i=0; i< len1 ; i++)
          sum += *(str1+i) ^ *(str2+i))  ;
    }
    return sum                           ;
  }