#include "ToolFunc.h"
#include"SerialTool/SerialTool.h"
#define TOOLFUNC_C

#include "ToolFunc.h"
#include <QHBoxLayout>

/**
* 查表法
*/
/* CRC 高位字节值表 */
const unsigned char 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
} ;
/* CRC低位字节值表*/
const unsigned char 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
} ;
/********************************************************************************
name:
function: 退出程序
parameter:
return:
remark:   通过调用close 主paraent  ，达到退出程序的目的
*********************************************************************************/
void ToolFunc::shutDown(void)
{
   //qApp->quit();//退出程序

  //GS_mainWin->close();
}

INT16U ToolFunc::crc16(INT8U *puchMsg, INT16U usDataLen)
{
    INT8U  uchCRCHi = 0xFF ; /* 高CRC字节初始化 */
    INT8U  uchCRCLo = 0xFF ; /* 低CRC 字节初始化 */
    INT32U uIndex ; /* CRC循环中的索引 */
    while (usDataLen--) /* 传输消息缓冲区 */
    {
     uIndex = uchCRCHi ^ *puchMsg++ ; /* 计算CRC */
     uchCRCHi = uchCRCLo ^ auchCRCHi[uIndex] ;
     uchCRCLo = auchCRCLo[uIndex] ;
    }
    return ((static_cast<INT16U>(uchCRCHi))<<8 | static_cast<INT16U>(uchCRCLo));
}

void ToolFunc::charArrCopy(INT8S *des, INT8S *src, INT32U length)
{
    for(INT32U i = 0;i<length;i++)
    {
       des[i] =  src[i];
    }
}

void ToolFunc::charArrCopy(INT8U *des, INT8U *src, INT32U length)
{
    for(INT32U i = 0;i<length;i++)
    {
       des[i] =  src[i];
    }
}

void ToolFunc::ByteArrayTocharArrCopy(INT8S *des, QByteArray src, INT32S length)
{
    for(INT32S i = 0;i<length;i++)
    {
       des[i] =  src.at(i);
    }
}

void ToolFunc::ByteArrayTocharArrCopy(INT8U *des, QByteArray src, INT32S length)
{
    for(INT32S i = 0;i<length;i++)
    {
       des[i] = static_cast<INT8U>( src[i]);
    }
}

void ToolFunc::charArrToByteArrayCopy(QByteArray &des, INT8S *src, INT32S length)
{
    for(INT32S i = 0;i<length;i++)
    {
       des[i] =  src[i];
    }
}

void ToolFunc::charArrToByteArrayCopy(QByteArray& des, INT8U *src, INT32S length)
{
    for(INT32S i = 0;i<length;i++)
    {
       des[i] =static_cast<INT8S>(src[i]) ;
    }
}
/*******************************************************
功能: 将输入的字节 输换为 QString 显示
输入：0xaa 0x33
输出:"AA 33 "
备注:此函数用于QDebug或是文本框显示字节内容
********************************************************/
QString ToolFunc::hexToString(INT8U *in, INT32S len)
{
        INT32S i;
        INT8U inChar,hi,lo;
        QString s;
        for (i=0; i<len; i++)
        {
            inChar = in[i];
            hi = (inChar & 0xF0) >> 4;
            if (hi > 9)
                hi = 'A' + (hi - 0x0A);
            else
                hi += 0x30;
            s.append(hi);

            lo = inChar & 0x0F;
            if (lo > 9)
                lo = 'A' + (lo - 0x0A);
            else
                lo += 0x30;
            s.append(lo);

            s.append(0x20);
        }

        return s;
}
/*****************************(**************************************
功能：将QByteArray转为 可显示的QString
输入：0xaa,0xbb,0xcc
输出:"aa bb cc"
备注：
*********************************************************************/
QString ToolFunc::charArrToByteArrayCopy(QByteArray &des)
{
    INT32S i;
    INT8U inChar,hi,lo;
    QString s;
    INT32S len = des.count();
   for (i=0; i<len; i++)
   {
       inChar = static_cast<INT8U>(des[i]);
       hi = (inChar & 0xF0) >> 4;
       if (hi > 9)
           hi = 'A' + (hi - 0x0A);
       else
           hi += 0x30;
       s.append(hi);

       lo = inChar & 0x0F;
       if (lo > 9)
           lo = 'A' + (lo - 0x0A);
       else
           lo += 0x30;
       s.append(lo);

       s.append(0x20);
   }
   return  s;
}

void ToolFunc::charArrdataInit(INT8U *RamDataSE, INT8U setData, INT32U length)
{
    INT32U i=0;
    for(i=0;i<length;i++)
     {
       *(RamDataSE+i)=setData;
    }
}
/******************************************************
函数名：
功能： QString 为unicode码，转为ASCII码
输入：QString str 如"123"  MaxLen转换最大长度，此时实际GB2312Chars[]长度必须是MaxLen+1
输出：INT8U *GB2312Chars
例 str = "1234",MaxLen = 3,转换后，GB2312Chars[0] = 0x31,
                                 GB2312Chars[1] = 0x32,
                                 GB2312Chars[2] = 0x33,
                                 GB2312Chars[3] = 0x00,
*******************************************************/
INT32S ToolFunc::QStringToGB2312Chars(QString str, INT8U *GB2312Chars, INT32S MaxLen)
{
   qDebug()<<"QStringToGB2312Chars";
   QByteArray tt = str.toLocal8Bit();
   INT32S ttLen=tt.size(); //结果不包括0x00
   INT32S i ;
   for (i = 0;(i<ttLen)&&(i< MaxLen);i++)
   {
       GB2312Chars[i] =static_cast<INT8U>( tt.at(i));
   }
   GB2312Chars[i] =  0x00;
   return i;
}

/******************************************************
函数名：
功能：
输入：字符串:GB2312Chars，如
                                 GB2312Chars[0] = 0x31,
                                 GB2312Chars[1] = 0x32,
                                 GB2312Chars[2] = 0x33,
                                 GB2312Chars[3] = 0x00,

输出：QString str("123")
*******************************************************/
void ToolFunc::GB2312CharsToQString(INT8U *GB2312Chars, QString &str)
{
   str = QString::fromLocal8Bit((INT8S *)(GB2312Chars));
}

void ToolFunc::GB2312Chars_ConstToQString(const INT8U *GB2312Chars, QString &str)
{
    str = QString::fromLocal8Bit((INT8S *)(GB2312Chars));
}


/******************************************************
函数名：
功能：计算字符串长度，以0结束 ，不含最后的0x00
输入：字符串
输出：长度(0~255)
*******************************************************/
INT32U ToolFunc::CharsLength(INT8U *charsdata)
{
    INT32U i=0;
    while(1)
      {
        if(*(charsdata+i)==0)
        {
          return i;
        }
        else
        {
          i++;
        }
    }
}
/******************************************************
函数名：
功能：计算QString转为GB2312后的长度，不含最后的0x00
     目的是为了知道Qt控制输入的内容长度（1个汉字占2个字节）
输入：字符串
输出：长度(0~255)
*******************************************************/
INT32U ToolFunc::QStringToGB2312Length(QString str)
{
    QByteArray aa = str.toLocal8Bit();
    return aa.size();
}

void ToolFunc::Numtochars(INT32U Uldata, INT8U *Datachars, INT8U length)
{
    INT8U i,count;
     INT32U L_temp=1;
     for(i=0;i<length;i++)//空间清零
     {
       Datachars[i] = 0;
       L_temp = L_temp*10;
     }
     Datachars[i] = 0;
      //数据转化
      count=0;
      Uldata=Uldata%L_temp;
      if(length>9)
       {
        while(Uldata>=1000000000)
        {
         Uldata=Uldata-1000000000;
         (*(Datachars+count))++;
        }
        count++;
       }
       if(length>8)
       {
        while(Uldata>=100000000)
        {
         Uldata=Uldata-100000000;
         (*(Datachars+count))++;
        }
        count++;
       }
      if(length>7)
       {
        while(Uldata>=10000000)
        {
         Uldata=Uldata-10000000;
         (*(Datachars+count))++;
        }
        count++;
       }
      if(length>6)
       {
        while(Uldata>=1000000)
        {
         Uldata=Uldata-1000000;
         (*(Datachars+count))++;
        }
        count++;
       }
      if(length>5)
       {
        while(Uldata>=100000)
        {
         Uldata=Uldata-100000;
         (*(Datachars+count))++;
        }
        count++;
       }
      if(length>4)
       {
        while(Uldata>=10000)
        {
        Uldata = Uldata-10000;
         (*(Datachars+count))++;
        }
        count++;
       }
      if(length>3)
       {
        while(Uldata>=1000)
        {
         Uldata = Uldata-1000;
         (*(Datachars+count))++;
        }
        count++;
       }
      if(length>2)
       {
        while(Uldata>=100)
        {
          Uldata = Uldata-100;
         (*(Datachars+count))++;
        }
        count++;
       }
      if(length>1)
       {
        while(Uldata>=10)
        {
         Uldata = Uldata-10;
         (*(Datachars+count))++;
        }
        count++;
       }
       *(Datachars+count)=Uldata;
       count++;
       return;
}

void ToolFunc::longdataTochars(INT32U Uldata, INT8U *Datas)
{
    INT8U i,count;
    INT8U C_temps[11];
    count=0;
    for(i=0;i<11;i++)//空间清零
    {
      C_temps[i] = 0;
    }
     //数据转化
     if(Uldata>=1000000000)
      {
       while(Uldata>=1000000000)
       {
        Uldata=Uldata-1000000000;
        (*(C_temps+count))++;
       }
       count++;
      }
      if((Uldata>=100000000)||(count!=0))
      {
       while(Uldata>=100000000)
       {
        Uldata=Uldata-100000000;
        (*(C_temps+count))++;
       }
       count++;
      }
     if((Uldata>=10000000)||(count!=0))
      {
       while(Uldata>=10000000)
       {
        Uldata=Uldata-10000000;
        (*(C_temps+count))++;
       }
       count++;
      }
     if((Uldata>=1000000)||(count!=0))
      {
       while(Uldata>=1000000)
       {
        Uldata=Uldata-1000000;
        (*(C_temps+count))++;
       }
       count++;
      }
     if((Uldata>=100000)||(count!=0))
      {
       while(Uldata>=100000)
       {
        Uldata=Uldata-100000;
        (*(C_temps+count))++;
       }
       count++;
      }
     if((Uldata>=10000)||(count!=0))
      {
       while(Uldata>=10000)
       {
        Uldata = Uldata-10000;
        (*(C_temps+count))++;
       }
       count++;
      }
     if((Uldata>=1000)||(count!=0))
      {
       while(Uldata>=1000)
       {
        Uldata = Uldata-1000;
        (*(C_temps+count))++;
       }
       count++;
      }
     if((Uldata>=100)||(count!=0))
      {
       while(Uldata>=100)
       {
         Uldata = Uldata-100;
         (*(C_temps+count))++;
       }
       count++;
      }
     if((Uldata>=10)||(count!=0))
      {
       while(Uldata>=10)
       {
         Uldata = Uldata-10;
         (*(C_temps+count))++;
       }
       count++;
      }
      (*(C_temps+count))=Uldata;
      count++;
     for(i=0;i<count;i++)
      {
       (*(Datas+i))=(*(C_temps+i))+'0';
      }
      *(Datas+i)=0;
     return;
}
/******************************************************
函数名:void CharsMoveRight(INT8U *Datas,INT8U Length)
功能: 将字符串在指定长度的空间内左移
输入'123'    6
输出: '   123'
*******************************************************/
void ToolFunc::CharsMoveRight(INT8U *Datas, INT8U Length)
{
    INT8U OriginalDataslength;
    INT8U i;
    INT8U j = Length;
    INT8U C_temps[11];
     for(i=0;i<11;i++)
     {
        C_temps[i]= *(Datas+i);
     }
    //获取原始字符串的长度
    OriginalDataslength = CharacterStringLength(Datas);
    if(j>OriginalDataslength)
      {
        j = OriginalDataslength;
      }
    for(i=0;i<j;i++)
     {
        *(Datas+Length-1-i) = *(C_temps+OriginalDataslength-1-i);
     }
    if(Length>j)
    {
     for(i=0;i<Length-j;i++)
     {
        *(Datas+i) = ' ';
     }
    }
    *(Datas+Length) = 0;
}
/******************************************************
函数名：INT8U CharacterStringLength(INT8U *charsdata)
功能：计算字符串长度，以0结束
输入：字符串
输出：长度(0~255)
*******************************************************/
INT8U ToolFunc::CharacterStringLength(INT8U *charsdata)
{
    INT8U i=0;
    while(1)
      {
        if(*(charsdata+i)==0)
        {
          return i;
        }
        else
        {
          i++;
        }
    }
}
/******************************************************
函数名:void CharsMoveRight(INT8U *Datas,INT8U Length)
功能: 将字符串在指定长度的空间内右移
输入'   123'
输出: '123'
*******************************************************/
void ToolFunc::CharsMoveLeft(INT8U *Datas)
{
    INT8U j=0;
    INT8U i=0;
    //获取原始字符串的长度
    while(Datas[i]!=0)
      {
        if(Datas[i]==' ')
        {
         Datas[j]=Datas[i];
         j++;
        }
        i++;
      }
    Datas[j]= 0;
}
/********************************************
函数名：signed long fdata_to_SLdata(float F_data)
功能:
输入：float
输出：signed long
********************************************/
INT32S ToolFunc::fdata_to_SLdata(FP32 F_data)
{
    INT32S SL_temp0;
    if(F_data>0)
     {
        SL_temp0=static_cast<INT32S>(F_data+static_cast<FP32>(0.5));
     }
    else
     {
        SL_temp0=static_cast<INT32S>(F_data-static_cast<FP32>(0.5));
     }
    return SL_temp0;
}
/********************************************
函数名：void DatasToPointDatas(INT8U *Datas,INT8U point)
功能:字符串增加小数点，并清零  "123",2	 //向后多移1位
输入：Datas
输出："1.23"
********************************************/
void ToolFunc::DatasToPointDatas(INT8U *Datas, INT8U point)
{
    INT8U i;
     INT8U length;
     length = CharacterStringLength(Datas);
     //向后移1位
     if(length>point)
       {//不必移位
         CharsMoveRight(Datas,length+1);
         for(i=0;i<(length-point);i++)
         {
           *(Datas+i)=*(Datas+i+1);
         }
         *(Datas+i)='.';
       }
     else
       {//需移位，移位数按小数点确定
         CharsMoveRight(Datas,point+2);
         //
         for(i=0;i<(point+2-length);i++)
         {
           if(i==1)
           {
             *(Datas+i)='.';
           }
           else
           {
             *(Datas+i)='0';
           }
         }
     }
}
/********************************************
函数名：signed long fdata_to_SLdata()
功能:字符串增加小数点，并清零  主要用于数码管显示
输入：Datas
输出："1.23"
********************************************/
void ToolFunc::DatasToClrPointDatas(INT8U *Datas, INT8U point)
{
    INT8U i,j;
    DatasToPointDatas(Datas,point);//"00.123"
    i=0;
    j=0;
    while(*(Datas+j)!=0)
      {
        if(*(Datas+j)=='.')
          {

          }
        else
          {
           *(Datas+i)=*(Datas+j);
           i++;
          }
        j++;
      }
    *(Datas+i)=0;
}
/******************************************************
函数名:void SLData_to_chars(INT32S SLdata,INT8U *Datas,INT8U length,INT8U point)
功能:将带符号型数据转化为指定长度的字符串,并与小数点位置有关的显示，但不显示小数点(数码管)
输入:INT32S SLdata,INT8U *Datas,INT8U length,INT8U point
输出: "-   1.23"
*******************************************************/
void ToolFunc::SLData_to_chars(INT32S SLdata, INT8U *Datas, INT8U length, INT8U point)
{
    INT8U mark;
    INT32S SL_temp;
    mark=0;//正数
    if(SLdata<0)
     {
       mark = 1;
       SL_temp = -SLdata;
     }
    else
     {
       SL_temp = SLdata;
     }
    longdataTochars(static_cast<INT32U>(SL_temp), Datas); //转化为"123"
    DatasToClrPointDatas(Datas,point);//根据小数点清零
    CharsMoveRight(Datas,length);//显示数据左对齐“   1.23”
    if(mark==1)
     {
       *(Datas)='-';
    }
}
/******************************************************
函数名:void SLData_to_chars(INT32S SLdata,INT8U *Datas,INT8U length,INT8U point)
功能:将带符号型数据转化为指定长度的字符串,并与小数点位置有关的显示，显示小数点(数码管)
输入:INT32S SLdata,INT8U *Datas,INT8U length,INT8U point
输出: "-   1.23"
*******************************************************/
void ToolFunc::SLData_to_charsPoint(INT32S SLdata, INT8U *Datas, INT8U length, INT8U point)
{
    INT8U i;
    SLData_to_chars(SLdata,Datas,length,point);
    if(point != 0)
    {
        if(Datas[0] == 45)
        {//负号
            i=1;
        }
        else
        {
            i=0 ;
        }
       for(;i<(length-point-1);i++)
       {
         *(Datas+i)=*(Datas+i+1);
       }
       *(Datas+i)='.';
    }
}
/******************************************************
函数名:void ULData_to_Datas(signed long ULdata,unsigned char *Datas)
功能: 将长整型变为一个字符串
输入
输出:
*******************************************************/
void ToolFunc::longdataTocharsLength(INT32U Uldata, unsigned char *Datas, INT8U length)
{
    INT8U C_temps[20];
    INT8U i;
    longdataTochars(Uldata,C_temps);
    CharsMoveRight(C_temps,length);//显示数据左对齐“   1.23”
    for(i=0;i<=length;i++)
     {
        if(C_temps[i]==' ')
        {
           *(Datas+i)='0';
        }
        else
        {
          *(Datas+i)=C_temps[i];
        }
    }
}
/******************************************************
函数名:void ULData_to_Datas(signed long ULdata,unsigned char *Datas)
功能: 将长整型变为一个字符串 000123
输入
输出:
*******************************************************/
void ToolFunc::longdataTocharsLengthWithSpace(INT32U Uldata, unsigned char *Datas, INT8U length)
{
    INT8U C_temps[20];
    INT8U i;
    longdataTochars(Uldata,C_temps);
    CharsMoveRight(C_temps,length);//显示数据左对齐“   1.23”
    for(i=0;i<=length;i++)
     {
          *(Datas+i)=C_temps[i];
    }
}
/******************************************************
函数名:FP32 absoluteDataTurn(FP32 F_data)
功能: 取绝值
输入
输出:
*******************************************************/
FP32 ToolFunc::absoluteDataTurn(FP32 F_data)
{
    if(F_data<0)//稳定判定
    {
      F_data = -F_data;
    }
    return F_data;
}

INT8U ToolFunc::percentData(INT32U total, INT32U dataTemp)
{
    INT8U C_temp;
    if(total!=0)
    {
       C_temp = floatToSlongWithDiag((dataTemp*100)/total, 1)	;
    }
    else
    {
       C_temp =0;
    }
    return  C_temp;
}
/********************************************
函数名：signed long floatToSlongWithDiag(float weigh,signed char diag)
功能: 将重量值转化为按diag 方式显示的整数
输入loat weigh,signed char diag?输出：signed long
********************************************/
INT32S ToolFunc::floatToSlongWithDiag(FP32 F_data, INT8U diag)
{
    INT32S SL_temp;
    INT32S SL_temp1;
    if(F_data>=0)
    {
      SL_temp1 = static_cast<INT32S>(F_data+static_cast<FP32>(0.05)+static_cast<FP32>(0.5)*(static_cast<FP32>(diag)));
    }
    else
    {
      SL_temp1 =static_cast<INT32S>(F_data-static_cast<FP32>(0.05)-static_cast<FP32>(0.5)*(static_cast<FP32>(diag)));
    }
    SL_temp = SL_temp1%diag;
    SL_temp = SL_temp1-SL_temp;
    return SL_temp;
}
/******************************************************
函数名:void ULData_to_Datas(signed long ULdata,unsigned char *Datas)
功能: 将n个字符串反转
输入
输出:
*******************************************************/
void ToolFunc::charSTurnCharsWithLength(INT8U *Datas, INT8U length)
{
    INT8U i;//转换次数
    INT8U C_temps[10];
    for(i=length;i>0;i--)
    {
      C_temps[i-1] = *(Datas+length-i);
    }
    for(i=0;i<length;i++)
    {
      *(Datas+i) = C_temps[i] ;
    }
}
/******************************************************
函数名:INT16U UserAddressTurnSaveAddress(INT16U TopIndex,INT16U BaseIndex,INT16U num,INT16U UserAddress)
功能: 校验和
输入: temps数据   length长度
输出:
*******************************************************/
INT8U ToolFunc::AddCheckValue(INT8U *temps, INT8U length)
{
    INT8U C_temp;
    INT8U  i;
    if(length==0)
    {
      C_temp=0;
    }
    else
    {
      C_temp = temps[0];
      for(i=1;i<length;i++)
      {
        C_temp +=temps[i];
      }
    }
    return C_temp;
}





