src/slave_Silabs_C8051F342/CD_tools.c

/* CD_tools.c
    misc support functions
*/

#include "CD_tools.h"


/****************************************************************************/
/* calculates the numeric value of an hexa digit represented in ASCII
   parameters:
      char -> character to evaluate
      val -> pointer where the conversion is returned
   returns:
      0 -> conversion OK, <>0 fail conversion
   modifies:
      val
*/
unsigned char CD_HexaToNum(char chr, unsigned char *val) {
   if ((chr >= '0') && (chr <= '9')) {
      *val = chr-'0';
      return(0);
   } else if ((chr >= 'A') && (chr <= 'F')) {
      *val = chr-'A'+10;
      return(0);
   } else if ((chr >= 'a') && (chr <= 'f')) {
      *val = chr-'a'+10;
      return(0);
   } else {
      return(1);
   }
}

/****************************************************************************/
/* calculates the numeric value of an ASCII string representing an hexa number
   parameters:
      strx -> ASCII string representing an hexa number
      siz -> number of digits to evaluate
      val -> pointer where the conversion is returned
   returns:
      0 -> conversion OK, <>0 fail conversion
   modifies:
      val
*/
unsigned char CD_HexaStrTo_u8(unsigned char *strx, unsigned char siz, unsigned char *val) large {

   unsigned char tmp;

   if (siz == 1) {
      if (CD_HexaToNum(strx[0], val)) {
         return(1);  // fail
      } else {
         return(0);
      }
   } else if (siz == 2) {
      if (CD_HexaToNum(strx[0], &tmp)) {
         return(1);  // fail
      } else {
         if (CD_HexaToNum(strx[1], val)) {
             return(1);  // fail
          } else {
             tmp <<= 4;
             *val |= tmp;
             return(0);
          }
      }
   } else { /* siz too big */
      return(2);
   }
}

/****************************************************************************/
/* calculates the numeric value of an ASCII string representing an hexa number
   parameters:
      strx -> ASCII string representing an hexa number
      siz -> number of digits to evaluate
      val -> pointer where the conversion is returned
   returns:
      0 -> conversion OK, <>0 fail conversion
   modifies:
      val
*/
unsigned char CD_HexaStrTo_u16(unsigned char *strx, unsigned char siz, unsigned int *val) large{

   unsigned char tmp;
   unsigned char i;
   unsigned int tmp2;

   if (siz <0 || siz >4) {
      return(2);  // number of digits incorrect
   }

   tmp2 = 0;
   for (i=0;i<siz;i++) {
      if (CD_HexaToNum(strx[i], &tmp)) {
         return(1);  // fail
      } else {
         tmp2 <<= 4;
         tmp2 |= tmp;
      }
   }
   *val = tmp2;
   return(0);
}

/****************************************************************************/
/* calculates the numeric value of an ASCII string representing an hexa number
   parameters:
      strx -> ASCII string representing an hexa number
      siz -> number of digits to evaluate
      val -> pointer where the conversion is returned
   returns:
      0 -> conversion OK, <>0 fail conversion
   modifies:
      val
*/
unsigned char CD_HexaStrTo_u32(unsigned char *strx, unsigned char siz, unsigned long *val) large {

   unsigned char tmp;
   unsigned char i;
   unsigned long tmp2;

   if (siz <0 || siz >8) {
      return(2);  // number of digits incorrect
   }

   tmp2 = 0;
   for (i=0;i<siz;i++) {
      if (CD_HexaToNum(strx[i], &tmp)) {
         return(1);  // fail
      } else {
         tmp2 <<= 4;
         tmp2 |= tmp;
      }
   }
   *val = tmp2;
   return(0);
}

/****************************************************************************/
/* calculates the numeric value of an ASCII string representing an hexa number
   parameters:
      strx -> ASCII string representing an hexa number
      siz -> number of digits to evaluate
      val -> pointer where the conversion is returned
   returns:
      0 -> conversion OK, <>0 fail conversion
   modifies:
      val
*/
unsigned char CD_DecStrTo_u16(unsigned char *strd, unsigned char siz, unsigned int *val) large {

   unsigned char chr;
   unsigned char i;
   unsigned int tmp;

   if (siz > 5) {
      return(2);  // number of digits incorrect
   }

   tmp = 0;
   for (i=0;i<siz;i++) {
      tmp *= 10;
      chr = strd[i];
      if ((chr >= '0') && (chr <= '9')) {
        tmp += (chr - '0');
      } else { 
         return(1);  // fail
      }
   }
   *val = tmp;
   return(0);
}

/****************************************************************************/
/* generates an ASCII string representinc a decimal string based on the value recived
   parameters:
      val -> decimal value to be represented
      siz -> number of digits of the resulting string, '0' filled
      strdes -> pointer to the destination string
   returns:
      0 -> conversion OK, <>0 fail conversion
   modifies:
      val
*/
unsigned char CD_u8_ToDecStr(unsigned char val, unsigned char siz, unsigned char *strdest) large { 

    unsigned char *p;
    unsigned char i;

    if (siz > 3) {
        return(1);  
    }

    p = strdest;
    p += siz;

    *p = '\0';

    for (i=0;i<siz;i++) {
        p--;
        *p = (val % 10) + '0';
        val /= 10;
    }

    return(0);
}

/****************************************************************************/
/* generates an ASCII string representing an hexadecimal string based on the value recived
   parameters:
      val -> decimal value to be represented
      siz -> number of digits of the resulting string, '0' filled
      strdes -> pointer to the destination string
   returns:
      0 -> conversion OK, <>0 fail conversion
   modifies:
      val
*/
unsigned char CD_u8_ToHexaStr(unsigned char val, unsigned char siz, unsigned char *strdest) large { 

    unsigned char *p;
    unsigned char i;
    unsigned char digit;

    if (siz > 2) {
        return(1);  
    }

    p = strdest;
    p += siz;

    *p = '\0';

    for (i=0;i<siz;i++) {
        p--;
        digit = val & 0xF;
        if (digit < 10) {
            digit = digit + '0';
        } else {
            digit = digit - 10 + 'A';
        }
        *p = digit;
        val >>= 4;
    }

    return(0);
}

---