mylib.c

Keil平台

/***************************************************************************/
/* file: MYLIB.C                                                      */
/* data: 20010420                                                           */
/****************************************************************************/

#include "MYLIB.H"
/****************************************************************************/
const uchar HEXTAB[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
//const uchar MaskCode[] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};
const uchar MaskCode[] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x00};
int PidBuf[8];
int PidBuf2[8];

const uchar auchCRCHi[] = {
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 
    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 
    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 
    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 
    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40
}; 

//Low Order Byte Table 
/* Table of CRC values for low-order byte */
const uchar auchCRCLo[] = {
    0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2,
    0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4, 0x04,
    0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E,
    0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09, 0x08, 0xC8,
    0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A,
    0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC,
    0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6,
    0xD2, 0x12, 0x13, 0xD3, 0x11, 0xD1, 0xD0, 0x10,
    0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32,
    0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4,
    0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE,
    0xFA, 0x3A, 0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38,
    0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA,
    0xEE, 0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C,
    0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
    0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0,
    0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2, 0x62,
    0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4,
    0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F, 0x6E, 0xAE,
    0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68,
    0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA,
    0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C,
    0xB4, 0x74, 0x75, 0xB5, 0x77, 0xB7, 0xB6, 0x76,
    0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0,
    0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92,
    0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54,
    0x9C, 0x5C, 0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E,
    0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98,
    0x88, 0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A,
    0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
    0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86,
    0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80, 0x40
} ;

const uchar BCHTAB[256]={
  0x00,0x07,0x0E,0x09,0x1C,0x1B,0x12,0x15, /* 000-007 */
  0x38,0x3F,0x36,0x31,0x24,0x23,0x2A,0x2D, /* 008-015 */
  0x70,0x77,0x7E,0x79,0x6C,0x6B,0x62,0x65, /* 016-023 */
  0x48,0x4F,0x46,0x41,0x54,0x53,0x5A,0x5D, /* 024-031 */
  0xE0,0xE7,0xEE,0xE9,0xFC,0xFB,0xF2,0xF5, /* 032-039 */
  0xD8,0xDF,0xD6,0xD1,0xC4,0xC3,0xCA,0xCD, /* 040-047 */
  0x90,0x97,0x9E,0x99,0x8C,0x8B,0x82,0x85, /* 048-055 */
  0xA8,0xAF,0xA6,0xA1,0xB4,0xB3,0xBA,0xBD, /* 056-063 */
  0xC7,0xC0,0xC9,0xCE,0xDB,0xDC,0xD5,0xD2, /* 064-071 */
  0xFF,0xF8,0xF1,0xF6,0xE3,0xE4,0xED,0xEA, /* 072-079 */
  0xB7,0xB0,0xB9,0xBE,0xAB,0xAC,0xA5,0xA2, /* 080-087 */
  0x8F,0x88,0x81,0x86,0x93,0x94,0x9D,0x9A, /* 088-095 */
  0x27,0x20,0x29,0x2E,0x3B,0x3C,0x35,0x32, /* 096-103 */
  0x1F,0x18,0x11,0x16,0x03,0x04,0x0D,0x0A, /* 104-111 */
  0x57,0x50,0x59,0x5E,0x4B,0x4C,0x45,0x42, /* 112-119 */
  0x6F,0x68,0x61,0x66,0x73,0x74,0x7D,0x7A, /* 120-127 */
  0x89,0x8E,0x87,0x80,0x95,0x92,0x9B,0x9C, /* 128-135 */
  0xB1,0xB6,0xBF,0xB8,0xAD,0xAA,0xA3,0xA4, /* 136-143 */
  0xF9,0xFE,0xF7,0xF0,0xE5,0xE2,0xEB,0xEC, /* 144-151 */
  0xC1,0xC6,0xCF,0xC8,0xDD,0xDA,0xD3,0xD4, /* 152-159 */
  0x69,0x6E,0x67,0x60,0x75,0x72,0x7B,0x7C, /* 160-167 */
  0x51,0x56,0x5F,0x58,0x4D,0x4A,0x43,0x44, /* 168-175 */
  0x19,0x1E,0x17,0x10,0x05,0x02,0x0B,0x0C, /* 176-183 */
  0x21,0x26,0x2F,0x28,0x3D,0x3A,0x33,0x34, /* 184-191 */
  0x4E,0x49,0x40,0x47,0x52,0x55,0x5C,0x5B, /* 192-199 */
  0x76,0x71,0x78,0x7F,0x6A,0x6D,0x64,0x63, /* 200-207 */
  0x3E,0x39,0x30,0x37,0x22,0x25,0x2C,0x2B, /* 208-215 */
  0x06,0x01,0x08,0x0F,0x1A,0x1D,0x14,0x13, /* 216-223 */
  0xAE,0xA9,0xA0,0xA7,0xB2,0xB5,0xBC,0xBB, /* 224-231 */
  0x96,0x91,0x98,0x9F,0x8A,0x8D,0x84,0x83, /* 232-239 */
  0xDE,0xD9,0xD0,0xD7,0xC2,0xC5,0xCC,0xCB, /* 240-247 */
  0xE6,0xE1,0xE8,0xEF,0xFA,0xFD,0xF4,0xF3, /* 248-255 */
};
/****************************************************************************/
uchar BCH(uchar *pBuf)
{
  uchar i, temp = 0;

  for(i = 0; i < 5; i++)
  {
      temp ^= pBuf[i];
      temp = BCHTAB[temp];
  }
  return ~temp;
}
/****************************************************************************/
uchar CDTCRC(uchar *buf)
{
    uchar i, j, crc = 0;

    for (i = 0; i < 5; i++)
    {
        crc ^= buf[i];
        for (j = 0; j < 8; j++ )
        {
            crc <<= 1;
            if (crc & 0x100)
                crc ^= 0x107;
        }
    }
    return (~crc);
}
/****************************************************************************/
uint CRC12(uchar *buf, int len)
{
    int i, j;
    uint crc = 0;

    for (i = 0; i < len; i++)
    {
        crc ^= (uint)buf[i];
        for (j = 0; j < 8; j++ )
        {
            crc <<= 1;
            if (crc & 0x1000)
                crc ^= 0x180D;
        }
    }
    for (j = 0; j < 4; j++ )
    {
        crc <<= 1;
        if (crc & 0x1000)
            crc ^= 0x180D;
    }
    return (crc);
}
/****************************************************************************/
uint CRC12B(uint crc, uchar buf)
{
    int i;

    crc ^= (uint)buf;
    for (i = 0; i < 8; i++ )
    {
        crc <<= 1;
        if (crc & 0x1000)
            crc ^= 0x180D;
    }
    return (crc);
}
/****************************************************************************/
uint CRC12BEnd(uint crc)
{
    int j;

    for (j = 0; j < 4; j++ )
    {
        crc <<= 1;
        if (crc & 0x1000)
            crc ^= 0x180D;
    }
    return (crc);
}
/****************************************************************************/
uint CRC16(uchar *pBuf, int len)
{
    uchar uchCRCHi = 0xFF ; /* high CRC byte initialized */
    uchar uchCRCLo = 0xFF ; /* low CRC byte initialized */
    uint uIndex ;           /* will index into CRC lookup*/
                            /* table                   */
    while (len--)           /* pass through message buffer*/
    {
        uIndex = uchCRCHi ^ *pBuf++ ;	/* calculate the CRC  */
        uchCRCHi = uchCRCLo ^ auchCRCHi[uIndex] ;
        uchCRCLo = auchCRCLo[uIndex] ;
    }
    return (uchCRCHi << 8 | uchCRCLo) ;
}

/****************************************************************************/
void Set_SM2(uchar *value)              /* odd check set SM2 = 1    */
{
    uchar i, sum = 0;

    *value &= 0x7F;
    for(i = 0; i < 7; i++)
    {
        if(*value & (0x01<<i))
            sum++;
    }
    if ((sum & 0x01) == 1)
        *value |= 0x80;
}
/****************************************************************************/
void Cls_SM2(uchar *value)              /* odd check set SM2 = 0    */
{
    uchar i, sum = 0;

    *value &= 0x7F;
    for(i = 0; i < 7; i++)
    {
        if(*value & (0x01<<i))
            sum++;
    }
    if ((sum & 0x01) == 0)
        *value |= 0x80;
}
/****************************************************************************/

/****************************************************************************/
/* float and fix numer convet function*/
/****************************************************************************/
/* 输出用定点数表示的浮点数 返回定点数比实际值大的倍数  1 10 100 1000 10000 5种 */
//2004/5/18 修改返回倍数错 最后计算倍数前应初始化倍数为1 mult = 1
uint b2fix(uchar *buf, long *value)
{
    int mult, i; //multiple
    uchar exp;

    exp = buf[0] << 1;
    exp |= (buf[1] & 0x80) >> 7;
    *value = (ulong) (buf[1] | 0x80);
    *value <<=8;
    *value |= (ulong) buf[2];
    *value <<=8;
    *value |= (ulong) buf[3];
    if (*value == 0)
        return 1;
    if ((exp & 0x80) != 0)
    {
        exp = exp - 127;
        exp = 23 - exp;
    }
    else
    {
        exp = 127 - exp;
        exp = 23 + exp;
    }

    if (exp > 17)
    {
        if (exp > 21)
        {
            if (exp > 25)
				mult = 5;
            else
                mult = 4;
        }
        else
            mult = 3;
    }
    else
    {
        if (exp > 14)
            mult = 2;
        else
        {
            if (exp > 11)
                mult = 1;
            else
                mult = 0;
        }
    }

    for (i = 0; i < mult; i++)
    {
        *value >>= 5;
        *value *=10;
        exp -= 5;
    }
    *value >>= exp;
    if ((*value & 0x01L))
    {
        *value += 1;
    }
    if (((buf[0] & 0x80) != 0) )
    {
        *value = -(*value);
    }
    mult = 1;
    while(--i >= 0)
    {
        mult *= 10;
    }
//  *value++;
    return mult;
}

/****************************************************************************/
/* 输入用定点数 输入定点数比真实值大的倍数          1 10 100 1000 10000 5种     */
uint fix2b(long value, int mult, uchar *buf)
{
    long mant; //mantissa
    int real_mult = 1;
    uchar exp = 0;

    if (mult <= 0)
    {
        mult = 1;
    }
    if (value == 0)
    {
        buf[0] = buf[1] = buf[2] = buf[3] = 0;
        return 1;
    }
    /* 规格化尾数 用原码表示*/
    mant = value;
    while ((mant & 0x800000L) == 0)
    {
        mant <<= 1;
        exp++;
    };
    while(mult != 1)
    {
        mant /= 10;
        real_mult *= 10;
        mult /= 10;
        while ((mant & 0x800000L) == 0)
        {
            mant <<= 1;
            exp++;
        }
    };
    /* 计算阶码 用移码表示*/
    if (exp < 23)
    {
        exp &= 0x7F;
        exp = 23 - exp;
        exp += 127;
    }
    else
    {
        exp &= 0x7F;
        exp = exp - 23;
        exp = 127 - exp;
    }
    buf[0]  = exp>>1;
    buf[1]  = exp<<7;
    buf[1] |= (uchar)((mant>>16) & 0x7F);
    buf[2]  = (uchar)((mant>>8) & 0xFF);
    buf[3]  = (uchar)(mant&0xFF);
    return real_mult;
}
/****************************************************************************/
void fix8hex(long value, int mult, uchar *buf)
{
	uchar tbuf[4];

    fix2b(value, mult, &tbuf[0]);
	b8hex(tbuf[0], &buf[6]);
	b8hex(tbuf[1], &buf[4]);
	b8hex(tbuf[2], &buf[2]);
	b8hex(tbuf[3], &buf[0]);
}
/****************************************************************************/
int hex8fixEx(uchar *buf,int mult)
{
    long v;
    int m;
    long rt;
    m = hex8fix(buf, &v);
    if (m < mult)
    {
        rt = v * (mult/m);
    }
    else
    {
        rt =  v / (m/mult);
    }
    return (int) rt;

}
/****************************************************************************/
uint hex8fix(uchar *buf, long *value)