mylib.c

Keil平台

{
	long flongtemp;
	uint mult;
	uchar tbuf[4];

	tbuf[3] = hex8b(&buf[0]);
	tbuf[2] = hex8b(&buf[2]);
	tbuf[1] = hex8b(&buf[4]);
	tbuf[0] = hex8b(&buf[6]);

    
    mult = b2fix(&tbuf[0],&flongtemp);
    *value = flongtemp;
    return mult;
}
/****************************************************************************/
void i8hex(uint value, uchar *buf)
{
    i2hex(value, buf);
    oppsortbuf(buf, 4);
}
/****************************************************************************/
uint hex8i(uchar *buf)
{
    oppsortbuf(buf, 4);
    return hex2i(buf);
}
/****************************************************************************/
void hex2buf(uchar *buf, int len)
{
    uchar i = 0, j = 0, btemp;
    for (i = 0; i < len; i += 2)
    {
        btemp = hex2b(&buf[i]);
        buf[j++] = btemp;
    }
}
/****************************************************************************/
void buf2hex(uchar *buf, uchar *hexbuf, int buflen)
{
    uchar i = 0, j = 0;
    for (i = 0; i < buflen; i ++)
    {
        hexbuf[j++] = HEXTAB[(buf[i]>>4) &0x0F];
        hexbuf[j++] = HEXTAB[buf[i] &0x0F];
    }
}
/****************************************************************************/
void oppsortbuf(uchar *buf, int len)
{
    uchar btemp;
    uchar head = 0, tail;
    tail = len-1;
    len /= 2;

    while (len--)
    {
        btemp = buf[head];
        buf[head] = buf[tail];
        buf[tail] = btemp;
        head++;
        tail--;
    }
}
/****************************************************************************/
/* 0x2A --> 'A','2'*/
void b8hex(uchar value, uchar *buf)
{
    buf[0] = HEXTAB[value & 0x0F];
    buf[1] = HEXTAB[(value>>4) & 0x0F];
}
/****************************************************************************/
/* 'A','2' --> 0x2A*/
uchar hex8b(uchar *buf)
{
    uchar btemp;
    if ((buf[1] <= '9') && (buf[1] >= '0'))
        btemp = buf[1] - '0';
    else
        btemp = buf[1] - 'A' + 10;
    btemp <<= 4;
    if ((buf[0] <= '9') && (buf[0] >= '0'))
        btemp |= buf[0] - '0';
    else
        btemp |= 10 + buf[0] - 'A';
    return btemp;
}
/****************************************************************************/
/****************************************************************************/
/* 0x2A --> '2','A'*/
void b2hex(uchar value, uchar *buf)
{
    buf[1] = HEXTAB[value & 0x0F];
    buf[0] = HEXTAB[(value>>4) & 0x0F];
}
/****************************************************************************/
/* '2','A' --> 0x2A*/
uchar hex2b(uchar *buf)
{
    uchar btemp;
    if ((buf[0] <= '9') && (buf[0] >= '0'))
        btemp = buf[0] - '0';
    else
        btemp = buf[0] - 'A' + 10;
    btemp <<= 4;
    if ((buf[1] <= '9') && (buf[1] >= '0'))
        btemp |= buf[1] - '0';
    else
        btemp |= 10 + buf[1] - 'A';
    return btemp;
}
/****************************************************************************/
void i2hex(uint value, uchar *buf)
{
    uchar i, btemp;
    for (i = 0; i < 4; i++)
    {
        btemp = (value & 0xF000)>>12;
        buf[i] = HEXTAB[btemp];
        value <<= 4;
    }
}
/****************************************************************************/
uint hex2i(uchar *buf)
{
    uchar i;
    uint value = 0;

    for (i = 0; i < 4; i++)
    {
        value <<= 4;
        if ((buf[i] <= '9') && (buf[i] >= '0'))
            value |= (uint)(buf[i] - '0') & 0x00FF;
        else
            value |= (uint)(buf[i] - 'A' + 10) & 0x00FF;
    }
    return value;
}
/****************************************************************************/
uint b2i(uchar *buf)
{
    return (uint)buf[0] & 0xFF | (uint)(buf[1]<<8);
}
/***************************************************************************/
void i2b(uint value, uchar *buf)
{
    buf[0] = (value & 0xFF);
    buf[1] = (value>>8 & 0xFF);
}
/****************************************************************************/
void i2bcd(uint value, uchar *buf)
{
    buf[1] = (uchar)(value%10) & 0x0F;
    value /= 10;
    buf[1] |= (uchar)( (value%10)<<4 ) & 0xF0;
    value /= 10;
    buf[0] = (uchar)((value%10)) & 0x0F;
    value /= 10;
    buf[0] |= (uchar)((value%10)<<4) & 0xF0;
}
/****************************************************************************/
uint bcd2i(uchar *buf)
{
    uint value;
    value = (int)((buf[0] & 0xF0)>>4);
    value *= 10;
    value += (int)(buf[0] & 0x0F);
    value *= 10;
    value += (int)((buf[1] & 0xF0)>>4);
    value *= 10;
    value += (int)(buf[1] & 0x0F);
    return value;
}
/****************************************************************************/
int fix2s( int value, int format, char *str)
{
    /*  integer to string by format */
    /* vintdigit=integer digits   vdecdigit=decimal digits  */
    int i, len = 0, itemp, vdecdigit, vintdigit;
    vdecdigit = format & 0x000F;
    vintdigit = (format>> 4) & 0x000F;
    len = vdecdigit+vintdigit;

    itemp = value>0 ? value : -value;
    if (vdecdigit == 0)
    {
        
        if ((itemp > 9) && (vintdigit < 2) )
        {
             vintdigit = 2;
        }
    }
    
    for (i = len-1; i >= 0; i--)
    {
        str[i] = itemp%10 + '0';
        itemp/=10;
    }
    if (vdecdigit!=0)
    {
        for (i = len; i>vintdigit; i--)
        {
            str[i] = str[i-1];
        }
        str[vintdigit] = '.';
        len++;
    }
    if (value < 0)
    {
        for (i = len; i > 0; i--)
        {
            str[i] = str[i-1];
        }
        str[0] = '-';
        len++;
    }
    str[len] = '\0';
    return len;
}
/****************************************************************************/
/* str=220.4 value=2204, rt=10    */
int s2fix(char *str, int *value)
{
    int min = 0, max = 0;
    int flag = 1,dot = 0;
    char  ch;
    *value = 0;

    ch = *str;
    if (ch == '\0')
    {
        *value = 0;
        return 1;
    }

    if (ch == '-')
        flag = -1;
    ch = *str++;
    while( ch >= '0' && ch <= '9' )
    {
        *value = *value * 10 + ch - '0';
        ch = *str++;
    }
    if( ch == '.' )
    {
        ch = *str++;
        while( ch >= '0' && ch <= '9' )
        {
            *value = *value * 10 + ch - '0';
            dot *= 10;
            ch = *str++;
        }
    }
    *value = *value*flag;
    return dot;
}
/****************************************************************************/
/* string option function*/
/****************************************************************************/
char *scpy(char  *s1, char  *s2)
{
    uchar *os1;

    os1 = s1;
    while (*s1++ = *s2++)
        ;
    return(os1);
}
/****************************************************************************/
int slen(char  *s)
{
    int i;
    for (i = 0; i < 255; i++)
    {
        if (s[i] == '\0')
            return i;
    }
    return 0;
}
/***************************************************************************/
char *scat(char  *s1, char  *s2)
{
	char *os1;

	os1 = s1;
	while (*s1++)
		;
	--s1;
	while (*s1++ = *s2++)
		;
	return(os1);
}
/****************************************************************************/
void sfixlen(char  *str, int len)         /*fixed length*/
{
    uchar i;
    for (i = slen(str); i < len; i++)
    {
        str[i] = ' ';
    }
    str[len] = '\0';
}
/****************************************************************************/
void sleftalign(char  *str, int len)
{
    uchar i, j = 0;
    sfixlen(str, len);
    if (str[0] != ' ')
        return;
    for (i = 0; i < len; i++)
    {
        if (str[i] != ' ')
            break;
    }
    for (j = 0; i < len; i++)
    {
        str[j++] = str[i];
    }
}
/****************************************************************************/
void srightalign(char  *str, int len)
{
    char i, j = 0;
    sfixlen(str, len);
    i = len;
    while (--i)
    {
        if (str[i] != ' ')
            break;
    }
    j = len;
    while (--j)
    {
        str[j] = str[j-i];
    }
    for (i = len-1; i > 0; i--)
    {
        if (str[i] != ' ')
            break;
    }
}
/****************************************************************************/
int scomp(char  *s1, char  *s2)
{
    while (*s1 == *s2)
    {
        if (*s1=='\0')
            return(0);
        s2++;
        s1++;
    }
    return((int)(*s1 - *s2));
}

char *sword(char  *buf, char  *wordstr)
{
    uchar i;
    for (i = 0; i < 20; i++)
    {
        if ( (buf[i] == ' ') || (buf[i] == '\0')||(buf[i] == '\n') )
            break;
        wordstr[i] = buf[i];
    }
    wordstr[i] = '\0';
    return wordstr;
}

/****************************************************************************/
/*我虽不同意你的所说的每一句话，但誓死捍卫你说话的权利*/
/****************************************************************************/
char *timestr(uchar* tbuf, char* str)
{
    str[0] = (tbuf[5]/10)%10 + '0';
    str[1] = tbuf[5]%10 + '0';
    str[2] = '-';
    str[3] = (tbuf[4]/10)%10 + '0';
    str[4] = tbuf[4]%10 + '0';
    str[5] = '-';
    str[6] = (tbuf[3]/10)%10 + '0';
    str[7] = tbuf[3]%10 + '0';
    str[8] = ' ';
    str[9] = (tbuf[2]/10)%10 + '0';
    str[10] = tbuf[2]%10 + '0';
    str[11] = ':';
    str[12] = (tbuf[1]/10)%10 + '0';
    str[13] = tbuf[1]%10 + '0';
    str[14] = ':';
    str[15] = (tbuf[0]/10)%10 + '0';
    str[16] = tbuf[0]%10 + '0';
    str[17] = '\0';
}
/****************************************************************************/
char *time2s(int hh, int mm, int ss, char *str)
{
    str[0] = (hh/10)%10 + '0';
    str[1] = hh%10 + '0';
    str[3] = (mm/10)%10 + '0';
    str[4] = mm%10 + '0';
    str[6] = (ss/10)%10 + '0';
    str[7] = ss%10 + '0';
    str[2] = str[5] = ':';
    str[8] = '\0';
    return str;
}
/****************************************************************************/
char *date2s(int yy, int mm, int dd, char *str)
{
    if (yy > 100)
    {
        str[0] = yy/1000 + '0';