内存泄露调试心得

　　平常是懒得去写点东西，但是今天，决定写点调试心得，主要是因为这个问题正真用了一周时间才得以解决，记得这几年在我调程序的过程里，因为一个问题，最长的解决周期也就是四天，但是今天这个问题却是打破了自己的记录。
    内存泄露在程序设计中是较难的一个问题，如果在平常的应用程序设计中（PC机），内存泄露相对来说容易点，至少是可以通过一些工具去查找问题，解决问题。但是，在相对低端的嵌入式系统里，可是无法查找，虽说是有硬件仿真工具，可是面对，大量的数据和一些复杂的系统也是很难去仿真的，那么只有一点一点去分析代码，一点点去理解，假设最终找出问题，解决问题。
        在嵌入式内存泄露的问题里，我个人以为，又有一些区别，一种是：因为一次内存泄露导致程序无法运行，这类问题是相对容易解决的；另一种是：一次内存泄露，不太影响整个程序，甚至可以得出正确数据，两次也可以，三次、、、、、，但是达到一定程序时，问题就会出现，那么要解决，必须把每个问题都解决了才能从根本上解决问题，所以首先必须要找到每个问题。对于这个问题也是最难的，因为或许从最开始就不知道是什么引起的问题。很蛋疼的是，第二种情况就是我遇到的。
    下面将详细介绍整个过程，整个系统如下：

硬件系统（第一次做板见笑了）

软件系统

问题描述：

1、能和上位机链接，可以执行上位机给下位机的命令，在读写时钟过程中很正常（20个字节左右）

2、一些较实时的数据，需要经常更新，自然频率很高，读取出现个别错误；

3、从485里读出的数据有140个字节，通过以太网，向上位机发送，最终封装打包后的数据是212个字节，发送时出现out of memory的错误。

解决问题过程：起初还以为给以太网的内存不够，于是扩大之90多K（总128K），但是很奇怪的是依然不能解决。

因此怀疑是在移植的过程中出现问题。所以倒腾了几天还是没解决。

    项目的另一个人说是我的底层驱动出了错，因为从485读的数据，全是零，这点我从一开始就就否定了，因为我单独测试时也是0，指令正确，数据格式，校验都正确，数据就是零，那么必然正确（一定要坚持自己的观点），可是为什么全是0呢？当然是控制器的问题了（我心想），事实证明我说的正确，确实是控制器的问题，当然质量是没问题，是少插了测试模块，这点我不知道，因为刚来公司，对控制器不熟悉，我很惊讶，很大的 一个东西，竟然没发现，在我的提心下也没发现。后来换了一个带模块的控制器，他才发现。

   也因此，我坚持我的看法，对协议栈进行测试，同事继续去研究驱动。

后来经过多次测试发现，在发送212个字节，开辟内存时，used为121，本来used只是内存的标记，只有1和0，怎么会出现这种问题呢？

想到肯定是内存问题于是对协议栈的配置更改，除了内存有所增加，used的还是121.所以认为或许是在初始化时影响到了。

    果不其然，原来在初始化协议栈之前，初始化了一个6K的空表，而且前面有许多无用的全局变量，（这部分代码是同事编写，写了三百多行代码，一行注释都没，纠结的看了2天才弄明白，主要是链表和定义过多，里面又有状态机什么的，所以注释很重要，尤其项目合作中，更重要是后期的维护，时间久了，代码又多就是自己写的，也搞不清，切记）代码如下：

 int16_t AddCmd(char* rev,int len)
{
    int16_t i;
//   int16_t j;    
    if(rev[0]==0&&rev[1]==0xff&&rev[2]==0&&rev[3]==0xff)
    {
        
        for(i=0;i<CMD_QUE;i++)
        {
         if(CmdQue[0][i].used == 0)
         {
             break;
         }
         else if(i==CMD_QUE-1)
         {
             return -1;
         }
        }
        CmdQue[0][i].used = 1;
        CmdQue[0][i].state = 1;
        CmdQue[0][i].pid = rev[4];
        CmdQue[0][i].nCode = rev[7];
        CmdQue[0][i].nFunction = rev[8];
        memcpy(CmdQue[0][i].data,rev+7,len-7);
//         for(j=0;j<64;j++)
//         {
//             printf("CCAA%2X 
",CmdQue[0][i].data[j]);  //  测试使用
//         }
        return 0;
    }
    else
    {
        return -1;
  }

}

int16_t FindACmd(int8_t* num, int8_t state)
{
  int i;
    for(i=0;i<CMD_QUE;i++)
    {
        if(CmdQue[0][i].state == state)
        {
            *num = i;
            return state;
        }
    }
    return 0;  
}

  把这些搞完，下载程序查看，used虽不是1或0，但是变为30,121,55等等一些数据，有希望了，必然是内存的原因。

     就这样纠结了几天依旧没解决，有种无能为力的感觉。

    所以看底层的代码， 突然发现定义了这样一个sbuf[ ]，起初在没有联机时，以为接收的数据是不定长的，所以没给具体的值，现在至少可以确定其最大值，因此将sbuf[ ]改为sbuf[256 ]，同样的其他几个也改正。（C语言仍需加强）    下载程序，一看，很神奇的问题终于没了 ，呜呼，终于解决了！真的很激动！

 

写到这里，不知道再写点什么了，平常感觉在技术上有许多想写的，可是正真要写时，感觉很难下笔，可是当真正写下整个过程时，发现对其理解更深了一层，所以做技术，写博客是很好的一种学习途径！

     行百里者半九十，需要做的还很多，尤其项目的完善还需要一个过程！

    写的有点乱，想等项目结了好好的写点整个项目由电路图的设计，PCB板的设计，驱动代码的设计，以及整个系统的调试过程，以此来对整个项目有个更深的了解。

   特别感谢在这个过程中鼓励和技术上帮助我的朋友和网友！

不足之处仍有许多，希望大家多多指正！

附MODBUS协议：

#include "modbus.h"
#include "usart.h"
#include "delay.h"

//********************************************************************************/     
//modbus协议支持485总线
//修改日期:2013/12/9
//版本：V1.0
//Copyright(C) 象牙塔 All rights reserved
//Email：cronus_skl@163.com QQ:374199080
//********************************************************************************/
u8 MODBUS_SEND_SBUF[64];
u8 MODBUS_RECEIVE_SBUF[256];

 u8 Defaultspec=0;
 u8 baseAddress=0;




//字地址 0 - 255 (只取低8位)
//位地址 0 - 255 (只取低8位)

/* CRC 高位字节值表 */ 
const u8  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 u8  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 
};

/***************************CRC校验码生成函数 ********************************
*函数功能：生成CRC校验码
*本代码中使用查表法，以提高运算速度
****************************************************************************/
u16 crc16(u8 *puchMsg, u16 usDataLen) 
{ 
u8 uchCRCHi = 0xFF ; /* 高CRC字节初始化 */ 
u8 uchCRCLo = 0xFF ; /* 低CRC 字节初始化 */ 
u16 uIndex ; /* CRC循环中的索引 */ 
while (usDataLen--) /* 传输消息缓冲区 */ 
{ 
  uIndex = uchCRCHi ^ *puchMsg++ ; /* 计算CRC */ 
  uchCRCHi = uchCRCLo ^ auchCRCHi[uIndex] ; 
  uchCRCLo = auchCRCLo[uIndex] ; 
} 
return (uchCRCLo << 8 | uchCRCHi) ; 
}

/********************************读写线圈*********************************/
/***************主要功能码：读线圈，写单个线圈，写多个线圈****************/
/*************************************************************************
*SendReadCoilCommand();读线圈（0X01）：最多读256个线圈
*SD:地址(1)+功能码(1)+起始地址(2)+线圈数量(2)+CRC 发送读线圈命令
*RD:地址(1)+功能码(1)+字节数N(1)+状态(N)+CRC            接受读线圈数据
*输入：StartingAddress：起始地址;CoilNumber：线圈数量
*输出：无
**************************************************************************/

//发送命令
//最多可读256个线圈
void SendReadCoilCommand(u8 StartingAddress,u8 CoilNumber)
{
    u16 crcData;
    MODBUS_SEND_SBUF[0] = baseAddress;//地址
    MODBUS_SEND_SBUF[1] = 0X01;//功能码
    MODBUS_SEND_SBUF[2] = 0X00;//读地址只有48个0X2C，远小于0XFF个
    MODBUS_SEND_SBUF[3] = StartingAddress;
    MODBUS_SEND_SBUF[4] = 0X00;
    MODBUS_SEND_SBUF[5] = CoilNumber;
    crcData = crc16(MODBUS_SEND_SBUF,6);
  MODBUS_SEND_SBUF[6] = crcData & 0xff;   // CRC代码低位在前
  MODBUS_SEND_SBUF[7] = crcData >> 8;       //高位在后
    RS485_Send_Data(MODBUS_SEND_SBUF,8);
    // MODBUS_SEND_SBUF[]=0; 需不需要清零
}
//返回数据
u8 ReceiveReadCoilData(void)
{
    u8 result=0;
    u16 crcData;
    RS485_Receive_Data(MODBUS_RECEIVE_SBUF,&RS485_RX_CNT);
    crcData = crc16(MODBUS_RECEIVE_SBUF,RS485_RX_CNT-1);
    if(MODBUS_RECEIVE_SBUF[RS485_RX_CNT-1] == ( crcData&0xff ) || MODBUS_RECEIVE_SBUF[RS485_RX_CNT] == ( crcData >> 8 ))
    {
        RS485_RX_CNT=0; //长度清零
        return result=0;
    }
    else
    {
        RS485_RX_CNT=0; //长度清零
        printf("读线圈出错！");
        result=0X01;    
        return result;
        
    }

}


/***************************************************************************
*写单个线圈（0X05）:  可写线圈地址0~31
*SD: 地址(1)+功能码(1)+输出地址(2)+输出值(2)+CRC
*RD: 地址(1)+功能码(1)+输出地址(2)+输出值(2)+CRC
*输入：ExportAddress：输出地址；ExportData:输出值
*
***************************************************************************/
//发送命令
//ExportData 只能是0XFF 或 0X00
//地址范围0-31个
void SendWriteSingleCommand(u8 ExportAddress,u8 ExportData)
{
    u16 crcData;
    u8 i;
    MODBUS_SEND_SBUF[0] = baseAddress;//地址
    MODBUS_SEND_SBUF[1] = 0X05;//功能码
    MODBUS_SEND_SBUF[2] = 0X00;//读地址只有48个0X2C，远小于0XFF个
    MODBUS_SEND_SBUF[3] = ExportAddress;
    MODBUS_SEND_SBUF[4]  = ExportData;
    MODBUS_SEND_SBUF[5] = 0X00;
    
    crcData = crc16(MODBUS_SEND_SBUF,6);
  MODBUS_SEND_SBUF[6] = crcData & 0xff;   // CRC代码低位在前
  MODBUS_SEND_SBUF[7] = crcData >> 8 ;       //高位在后
    RS485_Send_Data(MODBUS_SEND_SBUF,8);
    for(i=0;i<8;i++)
    {
        printf("
%2X

",MODBUS_SEND_SBUF[i]);
    }
    
    // MODBUS_SEND_SBUF[]=0; 需不需要清零
}
//返回数据
u8 ReceiveWriteSingleData(void)
{
    u8 result=0;
    u16 crcData;
    RS485_Receive_Data(MODBUS_RECEIVE_SBUF,&RS485_RX_CNT);
    crcData = crc16(MODBUS_RECEIVE_SBUF,RS485_RX_CNT-1);
    if(MODBUS_RECEIVE_SBUF[RS485_RX_CNT-1] == ( crcData&0xff ) || MODBUS_RECEIVE_SBUF[RS485_RX_CNT] == ( crcData >> 8 ))
    {
        RS485_RX_CNT=0; //长度清零
        return result=0;
    }
    else
    {
        RS485_RX_CNT=0; //长度清零
        printf("写单个线圈出错！");
        result=0X05;    
        return result;
    }

}
/***************************************************************************
*写多个线圈（0X0F）:  可写线圈地址0~31
*SD:地址(1)+功能码(1)+起始地址(2)+输出数量(2)+字节数量N(1)+输出值(N字节)+CRC
*RD: 地址(1)+功能码(1)+起始地址(2)+输出数量(2)+CRC
*查询——0X11 0X0F 0X00 0X13 0X00 0X0A 0X02 0XCD 0X01 0XBF 0X0B
*从机地址-功能码-寄存器地址高字节-寄存器地址低字节-寄存器数量高字节-寄存器数量
*低字节-字节数-数据1-数据2-CRC校验高字节-CRC校验低字节
*  001AH  0019H  0018H  0017H  0016H  0015H  0014H 0013H
*    1      1      0      0      1      1      0     1
*  0022H  0021H  0020H  001FH  001EH  001DH  001CH 001BH
*    0      0      0      0      0      0     0     1
*传输的第一个字节CDH对应线圈为0013H到001AH，LSB（最低位）对应0013H
*输入：StartAddress:起始地址 ExportNumber:输出数量 ByteNumber:字节数量
*      ExportData:输出值（本代码里，最多4个字节）
***************************************************************************/
//发送命令
//地址范围0-31个,即最多32个地址，因此字节数是4Bit
void SendWriteMulCoilCommand(u8 StartAddress,u8 ExportNumber,u8 ByteNumber,u32 ExportData)
{
    u16 crcData;
    u8 i;
    MODBUS_SEND_SBUF[0] = baseAddress;//地址
    MODBUS_SEND_SBUF[1] = 0X0F;//功能码
    MODBUS_SEND_SBUF[2] = 0X00;//起始地址高，写地址只有32个0X2C，远小于0XFF个
    MODBUS_SEND_SBUF[3] = StartAddress;//起始地址低位
    MODBUS_SEND_SBUF[4] = 0X00;  //输出数量高位
    MODBUS_SEND_SBUF[5] = ExportNumber;//输出数量低位
    MODBUS_SEND_SBUF[6] = ByteNumber;//字节数
//     if((ByteNumber>=0)&&(ByteNumber<8)){i=1;}
//     else if((8<=ByteNumber)&&(ByteNumber<16)){i=2;}
//     else if((16<=ByteNumber)&&(ByteNumber<24)){i=3;}
//     else if((24<=ByteNumber)&&(ByteNumber<32)){i=4;}
//     else{i=5;}
    switch(ByteNumber)
  {
        case 1:
                     MODBUS_SEND_SBUF[7]=ExportData&0XFF;
                     crcData = crc16(MODBUS_SEND_SBUF,8);
                     MODBUS_SEND_SBUF[8] = crcData & 0xff;   // CRC代码低位在前
                     MODBUS_SEND_SBUF[9] = crcData >> 8 ;       //高位在后
                     RS485_Send_Data(MODBUS_SEND_SBUF,10);    
                    for(i=0;i<10;i++)
                    {
                        printf("
%2X

",MODBUS_SEND_SBUF[i]);
                    }
                    break;
         case 2: 
                    MODBUS_SEND_SBUF[7]=ExportData&0XFF;
                    MODBUS_SEND_SBUF[8]=(ExportData&0XFFFF)>>8;
                    crcData = crc16(MODBUS_SEND_SBUF,9);
                    MODBUS_SEND_SBUF[9] = crcData & 0xff;   // CRC代码低位在前
                    MODBUS_SEND_SBUF[10] = crcData >> 8 ;       //高位在后
                    RS485_Send_Data(MODBUS_SEND_SBUF,11);    
                    for(i=0;i<11;i++)
                    {
                        printf("
%2X

",MODBUS_SEND_SBUF[i]);
                    }
                    break;
            case 3: 
                    MODBUS_SEND_SBUF[7]=ExportData&0XFF;
                    MODBUS_SEND_SBUF[8]=(ExportData&0XFFFF)>>8;
                    MODBUS_SEND_SBUF[9]=(ExportData&0XFFFFFF)>>16;
                    crcData = crc16(MODBUS_SEND_SBUF,10);
                    MODBUS_SEND_SBUF[10] = crcData & 0xff;   // CRC代码低位在前
                    MODBUS_SEND_SBUF[11] = crcData >> 8 ;       //高位在后
                    RS485_Send_Data(MODBUS_SEND_SBUF,12);    
                    for(i=0;i<12;i++)
                    {
                        printf("
%2X

",MODBUS_SEND_SBUF[i]);
                    }
                    break;
             case 4: 
                    MODBUS_SEND_SBUF[7]=ExportData&0XFF;
                    MODBUS_SEND_SBUF[8]=(ExportData&0XFFFF)>>8;
                    MODBUS_SEND_SBUF[9]=(ExportData&0XFFFFFF)>>16;
                    MODBUS_SEND_SBUF[10]=ExportData>>24;
                    crcData = crc16(MODBUS_SEND_SBUF,11);
                    MODBUS_SEND_SBUF[11] = crcData & 0xff;   // CRC代码低位在前
                    MODBUS_SEND_SBUF[12] = crcData >> 8 ;       //高位在后
                    RS485_Send_Data(MODBUS_SEND_SBUF,13);    
                    for(i=0;i<13;i++)
                    {
                        printf("
%2X

",MODBUS_SEND_SBUF[i]);
                    }
                    break;
                case 5:
                    /***********************/
                    break;
        }
    // MODBUS_SEND_SBUF[]=0; 需不需要清零
}
//返回数据
u8 ReceiveWriteMulCoilData(void)
{
    u8 result=0;
    u16 crcData;
    RS485_Receive_Data(MODBUS_RECEIVE_SBUF,&RS485_RX_CNT);
    crcData = crc16(MODBUS_RECEIVE_SBUF,RS485_RX_CNT-1);
    if(MODBUS_RECEIVE_SBUF[RS485_RX_CNT-1] == ( crcData&0xff ) || MODBUS_RECEIVE_SBUF[RS485_RX_CNT] == ( crcData >> 8 ))
    {
        RS485_RX_CNT=0; //长度清零
        return result=0;
    }
    else
    {
        RS485_RX_CNT=0; //长度清零
        printf("写多线圈出错！");
        result=0X0F;    
        return result;
    }

}
/*****************************读写保持寄存器*********************************/
/*********主要功能码：读保持寄存器，写单个寄存器，写多个寄存器***************/
/****************************************************************************
*256套规范，每套规范预留256个寄存器，现有128个参数，每个参数2个字节。
*保持寄存器偏移量=规范号*256+参数号。
*规范号：0~255         参数号：0~127
*0<=保持寄存器偏移量<=255*256+127=65407=0XFF7F
*0XFF7F=65535
*get_MN(),动态定义规范
*****************************************************************************/
//取值范围是0~255
u8 get_MN()
{
/***********测试使用************/
//     printf("
%2X

",Defaultspec);
    return Defaultspec;
    
}
/*****************************************************************************
*读保持寄存器（0X03）: 每次最多读取125个
*SD:地址(1)+功能码(1)+起始地址(2)+寄存器数量(2)+CRC
*RD:地址(1)+功能码(1)+字节数N(1)+寄存器值(N*2)+CRC
*输入：ParameterNum  参数号  RegNumber 寄存器数量
*****************************************************************************/
void SendReadRegCommand(u8 ParameterNum,u8 RegNumber)
{
    u16 crcData,StartAddress;
    u8 i;
    StartAddress=256*mn+ParameterNum;
    MODBUS_SEND_SBUF[0] = baseAddress;//地址
    MODBUS_SEND_SBUF[1] = 0X03;//功能码
    MODBUS_SEND_SBUF[2] = StartAddress>>8;
    MODBUS_SEND_SBUF[3] = StartAddress&0XFF;
    MODBUS_SEND_SBUF[4] = 0X00;
    MODBUS_SEND_SBUF[5] = RegNumber;//不超过 7D（125）
    crcData = crc16(MODBUS_SEND_SBUF,6);
  MODBUS_SEND_SBUF[6] = crcData & 0xff;   // CRC代码低位在前
  MODBUS_SEND_SBUF[7] = crcData >> 8;       //高位在后
    RS485_Send_Data(MODBUS_SEND_SBUF,8);
//   MODBUS_SEND_SBUF[]=0; // 需不需要清零
//     for(i=0;i<8;i++)
//     {
//         printf("
%2X

",MODBUS_SEND_SBUF[i]);
//     }
}
u8 ReceiveReadRegData(void)
{
    u8 result=0;
    u16 crcData;
    RS485_Receive_Data(MODBUS_RECEIVE_SBUF,&RS485_RX_CNT);
    crcData = crc16(MODBUS_RECEIVE_SBUF,RS485_RX_CNT-1);
    if(MODBUS_RECEIVE_SBUF[RS485_RX_CNT-1] == ( crcData&0xff ) || MODBUS_RECEIVE_SBUF[RS485_RX_CNT] == ( crcData >> 8 ))
    {
        RS485_RX_CNT=0; //长度清零
        return result=0;
    }
    else
    {
        RS485_RX_CNT=0; //长度清零
        printf("读寄存器出错！");
        result=0X03;    
        return result;
    }

}

/*************************************************************************
*SendWriteRegisterCommand();写单个寄存器（0X06）: 
*SD:地址(1)+功能码(1)+寄存器地址(2)+寄存器值(2)+CRC
*RD:地址(1)+功能码(1)+寄存器地址(2)+寄存器值(2)+CRC
*输入：ParameterNum：寄存器地址;SinRegswitch：ON或OFF
*输出：无
**************************************************************************/

//发送命令
void SendWriteSinRegCommand(u8 ParameterNum,u8 SinRegswitch)
{
    u16 crcData,RegisterAddress;
    u8 i;
    RegisterAddress=256*mn+ParameterNum;
    MODBUS_SEND_SBUF[0] = baseAddress;//地址
    MODBUS_SEND_SBUF[1] = 0X06;//功能码
    MODBUS_SEND_SBUF[2] = RegisterAddress>>8;
    MODBUS_SEND_SBUF[3] = RegisterAddress&0XFF;
    MODBUS_SEND_SBUF[4] = 0X00;
    MODBUS_SEND_SBUF[5] = SinRegswitch;
    crcData = crc16(MODBUS_SEND_SBUF,6);
  MODBUS_SEND_SBUF[6] = crcData & 0xff;   // CRC代码低位在前
  MODBUS_SEND_SBUF[7] = crcData >> 8;       //高位在后
    RS485_Send_Data(MODBUS_SEND_SBUF,8);
    // MODBUS_SEND_SBUF[]=0; 需不需要清零
    for(i=0;i<8;i++)
    {
        printf("
%2X

",MODBUS_SEND_SBUF[i]);
    }
}
u8 ReceiveWriteSinRegData(void)
{
    u8 result=0;
    u16 crcData;
    RS485_Receive_Data(MODBUS_RECEIVE_SBUF,&RS485_RX_CNT);
    crcData = crc16(MODBUS_RECEIVE_SBUF,RS485_RX_CNT-1);
    if(MODBUS_RECEIVE_SBUF[RS485_RX_CNT-1] == ( crcData&0xff ) || MODBUS_RECEIVE_SBUF[RS485_RX_CNT] == ( crcData >> 8 ))
    {
        RS485_RX_CNT=0; //长度清零
        return result=0;
    }
    else
    {
        RS485_RX_CNT=0; //长度清零
        printf("写单个寄存器出错！");
        result=0X06;    
        return result;
    }

}
/*************************************************************************
*写多个寄存器（0X10）: 每次最多写123个
*SD:地址(1)+功能码(1)+起始地址(2)+寄存器数量(2)+字节数N(1)+寄存器值(2*N)+CRC
*RD:地址(1)+功能码(1)+起始地址(2)+寄存器数量(2)+CRC
*输入：StartAddress：寄存器地址;SinRegswitch：ON或OFF
*输出：无
**************************************************************************/
// void SendWriteMulRegCommand( u8 ParameterNum, )
// {
//     u16 crcData,StartAddress;
//     u8 i;
//     StartAddress=256*mn+ParameterNum;
//     MODBUS_SEND_SBUF[0] = baseAddress;//地址
//     MODBUS_SEND_SBUF[1] = 0X10;//功能码
//     MODBUS_SEND_SBUF[2] = StartAddress>>8;
//     MODBUS_SEND_SBUF[3] = StartAddress&0XFF;
// }
/*************************************************************************
*读输入寄存器（0X04）：读内存
*SD:地址(2)+命令(2)+起始地(2)址+寄存器数量(2)
*RD:地址(2)+命令(2)+字节数N(2)+数据内容(N*2)
*输入：StartAddress：起始地址0X0000~0XFFFF 
*输入：RegisterNum：0X0001~0X007D（125）
*输出：无
**************************************************************************/
void SendReadEnterRegCommand( u16 StartAddress,u8 RegisterNum )
{
    u16 crcData;
    MODBUS_SEND_SBUF[0] = baseAddress;//地址
    MODBUS_SEND_SBUF[1] = 0X04;//功能码
    MODBUS_SEND_SBUF[2] = StartAddress>>8;
    MODBUS_SEND_SBUF[3] = StartAddress&0XFF;
    MODBUS_SEND_SBUF[4] = 0X00;
    MODBUS_SEND_SBUF[5] = RegisterNum;
    crcData = crc16(MODBUS_SEND_SBUF,6);
  MODBUS_SEND_SBUF[6] = crcData & 0xff;   // CRC代码低位在前
  MODBUS_SEND_SBUF[7] = crcData >> 8;       //高位在后
    RS485_Send_Data(MODBUS_SEND_SBUF,8);
}
u8 ReceiveReadEnterRegData(void)
{
    u8 result=0;
    u16 crcData;
    RS485_Receive_Data(MODBUS_RECEIVE_SBUF,&RS485_RX_CNT);
    crcData = crc16(MODBUS_RECEIVE_SBUF,RS485_RX_CNT-1);
    if(MODBUS_RECEIVE_SBUF[RS485_RX_CNT-1] == ( crcData&0xff ) || MODBUS_RECEIVE_SBUF[RS485_RX_CNT] == ( crcData >> 8 ))
    {
        RS485_RX_CNT=0; //长度清零
        return result=0;
    }
    else
    {
        RS485_RX_CNT=0; //长度清零
        printf("读输入寄存器出错！");
        result=0X04;    
        return result;
    }
}
/*************************************************************************
*读焊接历史记录（功能码：0X41）
*焊接记录，最多960条记录；记录读取方式只有0和1，1代表读记录（ 从最早的记录
*开始读），0代表重读记录。每次最多读取3条记录。每个记录体包含64个字节（低
*字节在先）。
*SD: 地址(1)+功能码(1)+读取方式(1)+CRC
*RD: 地址(1)+功能码(1)+读取方式(1)+回复的记录个数(1)+记录体(64）+CRC 
**************************************************************************/
void SendReadWeldingHistoryCommand( u8 ReadMode )
{
    u16 crcData;
//     u8 i;
    MODBUS_SEND_SBUF[0] = baseAddress;//地址
    MODBUS_SEND_SBUF[1] = 0X41;//功能码
    MODBUS_SEND_SBUF[2] = ReadMode;
    crcData = crc16(MODBUS_SEND_SBUF,3);
  MODBUS_SEND_SBUF[3] = crcData & 0xff;   // CRC代码低位在前
  MODBUS_SEND_SBUF[4] = crcData >> 8;       //高位在后
    RS485_Send_Data(MODBUS_SEND_SBUF,5);
//     for(i=0;i<5;i++)
//     {
//         printf("
%d
",MODBUS_SEND_SBUF[i]);
//     }
}

u8 ReceiveWeldingHistoryData(void)
{
    u8 result=0;
    u16 crcData;
    RS485_Receive_Data(MODBUS_RECEIVE_SBUF,&RS485_RX_CNT);
    crcData = crc16(MODBUS_RECEIVE_SBUF,RS485_RX_CNT-1);
    if(MODBUS_RECEIVE_SBUF[RS485_RX_CNT-1] == ( crcData&0xff ) || MODBUS_RECEIVE_SBUF[RS485_RX_CNT] == ( crcData >> 8 ))
    {
        RS485_RX_CNT=0; //长度清零
        return result=0;
    }
    else
    {
        RS485_RX_CNT=0; //长度清零
        printf("读焊接历史记录错误！");
        result=0X41;    
        return result;
    }
}


void SendReadWriteTimeCommand(u8 TimeCommand , u8 TimeNumber[7] )
{
    
    u16 crcData;
    u8 i;
    MODBUS_SEND_SBUF[0] = baseAddress;//地址
    MODBUS_SEND_SBUF[1] = 0X44;//功能码
     MODBUS_SEND_SBUF[2] = TimeCommand;
    if(TimeCommand==0)
    {
        crcData = crc16(MODBUS_SEND_SBUF,3);
    MODBUS_SEND_SBUF[3] = crcData & 0xff;   // CRC代码低位在前
    MODBUS_SEND_SBUF[4] = crcData >> 8;       //高位在后
      RS485_Send_Data(MODBUS_SEND_SBUF,5);
    }
    else
    {

        delay_ms(5);
        for(i=0;i<7;i++)
            {
                MODBUS_SEND_SBUF[3+i] = TimeNumber[i];
//                 printf("

%d

",TimeNumber[i]);
            }
        crcData = crc16(MODBUS_SEND_SBUF,10);
    MODBUS_SEND_SBUF[10] = crcData & 0xff;   // CRC代码低位在前
    MODBUS_SEND_SBUF[11] = crcData >> 8;       //高位在后
      RS485_Send_Data(MODBUS_SEND_SBUF,12);
        
    }
//     MODBUS_SEND_SBUF[3] = RecordPointer&0XFF;
//     MODBUS_SEND_SBUF[4] = RecordNumber;
//     
}

u8 ReceiveReadWriteTimeData( void )
{
    u8 result=0;
    u16 crcData;
    RS485_Receive_Data(MODBUS_RECEIVE_SBUF,&RS485_RX_CNT);
    crcData = crc16(MODBUS_RECEIVE_SBUF,RS485_RX_CNT-1);
    if(MODBUS_RECEIVE_SBUF[RS485_RX_CNT-1] == ( crcData&0xff ) || MODBUS_RECEIVE_SBUF[RS485_RX_CNT] == ( crcData >> 8 ))
    {
        RS485_RX_CNT=0; //长度清零
        return result=0;
    }
    else
    {
        RS485_RX_CNT=0; //长度清零
        printf("读写时钟错误！");
        result=0X44;    
        return result;
    }
}
/*************************************************************************
* 读设备标识(0X2B)
* 表:10：设备标识
* 对象ID    对象名称    类型    　
* 0X00    厂商名称    ASCII字符串    　只读
* 0X01    产品代码    ASCII字符串    　只读
* 0X02    主次版本号    ASCII字符串    　只读
* SD:地址(1)+功能码(1)+MEI类型(1)+读设备ID码(1)+对象ID(1)
  SD:  **+2B+0E+01+00+CRC
* RD:地址(1)+功能码(1)+MEI类型(1)+设备ID码(1)+一致性等级[conformity
* level]（1）+00(1)+下一个设备ID码(1)+对象数量n (1)+对象1 ID(1)+对象1
* 长度N(1)+对象内容（N）+… … +对象n ID(1)+对象n长度M(1)+对象内容(M)+CRC 
*************************************************************************/
void SendReadDeviceIdentifineCommand( void )
{
    
    u16 crcData;
    MODBUS_SEND_SBUF[0] = baseAddress;//地址
    MODBUS_SEND_SBUF[1] = 0X2B;//功能码
     MODBUS_SEND_SBUF[2] = 0X0E;
    MODBUS_SEND_SBUF[3] = 0X01;
    MODBUS_SEND_SBUF[4] = 0X00;
    crcData = crc16(MODBUS_SEND_SBUF,5);
    MODBUS_SEND_SBUF[5] = crcData & 0xff;   // CRC代码低位在前
    MODBUS_SEND_SBUF[6] = crcData >> 8;       //高位在后
    RS485_Send_Data(MODBUS_SEND_SBUF,7);
}

u8 ReceiveDeviceIdentifineData( void )
{
    u8 result=0;
    u16 crcData;
    RS485_Receive_Data(MODBUS_RECEIVE_SBUF,&RS485_RX_CNT);
    crcData = crc16(MODBUS_RECEIVE_SBUF,RS485_RX_CNT-1);
    if(MODBUS_RECEIVE_SBUF[RS485_RX_CNT-1] == ( crcData&0xff ) || MODBUS_RECEIVE_SBUF[RS485_RX_CNT] == ( crcData >> 8 ))
    {
        RS485_RX_CNT=0; //长度清零
        return result=0;
    }
    else
    {
        RS485_RX_CNT=0; //长度清零
        printf("读设备标识错误！");
        result=0X2B;    
        return result;
    }
}