求助modbus---51单片机通讯

gdqxp

想请教下大神们，用modbus协议写485通讯，其中的变量可以设置成xdata区吗？目前我写的程序，用串口助手可以正常收发，但是用死活都调不出。unsigned char xdata RecvBuf[32];                 //串口接收32个字节
unsigned char xdata SendBuf[32];                 //串口发送32个字节
unsigned char  RS485RecvCnt = 0;//接收
unsigned char  RS485SendCnt = 0;//发送
signed short xdata Address,Kp,Ki,Kd;//设置变量
signed short xdata*ModbusHoldReg[6];//寄存器映射地址
unsigned short StartRegAddress, RegisterNum;//寄存器首地址，和寄存器数量
unsigned char xdata Registerbuff[22];//
unsigned char xdata *pSendBuf = SendBuf;       //串口发送指针

/* 串口配置函数，baud-通信波特率 */void ConfigUART()
{
  RS485_DIR = 0; //RS485设置为接收方向
//        SCON=0x50; //[bit6:5]SM1 SM2 = 1 0;[bit4]REN=1
//  AUXR=0x11; //[bit4]BRTR=1,允许独立波特率发生器运行;[bit0]SIBRS=1,独立波特率作为串口1的波特率发生器，此时定时器1释放
//  BRT=0XFD;   //独特波特率发生器定时器（产生波特率9600）
//          EA=1;
//    ES=1;
        S2CON = 0x50;   //串口2工作在方式1  10位异步收发 S2REN=1允许接收
        AUXR = 0x10;    //BRTR=1 独立波特率发生器开始计数
        AUXR1 = 0x10;//从P1口切换到P4口
  BRT = 0xFD;           //独立波特率发生器初值     
  IE2 =0x01;        //开串口2中断  ES2=1
  EA =1;        //开总中断

}
/* 软件延时函数，延时时间(t*10)us */
void DelayX10us(unsigned char t)
{
    do {
        _nop_();
        _nop_();
        _nop_();
        _nop_();
        _nop_();
        _nop_();
        _nop_();
        _nop_();
    } while (--t);
}
/* 串口数据写入，即串口发送函数，buf-待发送数据的指针，len-指定的发送长度 */
void UartWrite(unsigned char  *pSendBuf, unsigned char  RS485SendCnt)
{
          RS485_DIR = 1;  //RS485设置为发送
    while (RS485SendCnt--)   //循环发送所有字节//停止位去除
    {
        flagTxd = 0;      //清零发送标志
        S2BUF = *pSendBuf++;    //发送一个字节数据
        while (!flagTxd); //等待该字节发送完成
    }
    DelayX10us(5);  //等待最后的停止位完成，延时时间由波特率决定
    RS485_DIR = 0;  //RS485设置为接收
}
/* 串口数据读取函数，buf-接收指针，len-指定的读取长度，返回值-实际读到的长度 */

unsigned char UartRead(unsigned char xdata *buf, unsigned char len)
{
    unsigned char i;
    if (len > RS485RecvCnt)  //指定读取长度大于实际接收到的数据长度时，
    {                  //读取长度设置为实际接收到的数据长度
        len = RS485RecvCnt;
    }
    for (i=0; i<len; i++)  //拷贝接收到的数据到接收指针上
    {
        *buf++ = RecvBuf;
    }
    RS485RecvCnt = 0;  //RS485RecvCnt = 0;  //接收计数器清零

    return len;  //返回实际读取长度
}
/* 串口接收监控，由空闲时间判定帧结束，需在定时中断中调用，ms-定时间隔 */
void UartRxMonitor(unsigned char ms)
{
    static unsigned char cntbkp = 0;
    static unsigned char idletmr = 0;
    if (RS485RecvCnt> 0)  //接收计数器大于零时，监控总线空闲时间
    {
        if (cntbkp != RS485RecvCnt)  //接收计数器改变，即刚接收到数据时，清零空闲计时
        {
            cntbkp = RS485RecvCnt;
            idletmr = 0;
        }
        else                   //接收计数器未改变，即总线空闲时，累积空闲时间
        {
            if (idletmr < 30)  //空闲计时小于30ms时，持续累加
            {
                idletmr += ms;
                if (idletmr >= 30)  //空闲时间达到30ms时，即判定为一帧接收完毕
                {
                    flagFrame = 1;  //设置帧接收完成标志
                }
            }
        }
    }
    else
    {
        cntbkp = 0;
    }
}
/* 串口驱动函数，监测数据帧的接收，调度功能函数，需在主循环中调用 */
void UartDriver()
{
    unsigned char len;
    unsigned char xdata buf[40];

    if (flagFrame) //有命令到达时，读取处理该命令
    {
        flagFrame = 0;
        len = UartRead(buf, sizeof(buf)-2); //将接收到的命令读取到缓冲区中
        UartAction();  //传递数据帧，调用动作执行函数
    }
}
/* 串口中断服务函数 */
void InterruptUART2() interrupt 8//interrupt 4
{
         if (S2CON&S2RI)  //接收到新字节
    {
        S2CON&=~S2RI ;  //S2RI = 0;  //清零接收中断标志位
        if (RS485RecvCnt < sizeof(RecvBuf)) //接收缓冲区尚未用完时，
        {                            //保存接收字节，并递增计数器
            RecvBuf[RS485RecvCnt++] = S2BUF;
        }
    }
    if (S2CON&S2TI)  //字节发送完毕
    {
        S2CON&=~S2TI;     //S2TI=0 //S2TI = 0;   //清零发送中断标志位
        flagTxd = 1;  //设置字节发送完成标志
    }
}
这些是我的部分代码能否帮看看是哪里的问题

gdqxp

用modbus调试精灵死活通讯不成功

gdqxp

没人肯回答吗，我用串口通讯助手进行modbus通讯没误，但用modbus调试精灵就不能通讯成功，查了资料xdata是片外rom，不知道这个会不会有影响，因为data去太小了，所有用的xdata,请求大虾们帮看看啊

LcwSwust

单片机啥型号？
编译结果data有多少？idata有多少？code有多少？
截图看看

gdqxp

STC12C5A08S2     Program Size: data=9.2 xdata=700 code=3138
creating hex file from "lesson18_2"...
"lesson18_2" - 0 Error(s), 0 Warning(s).
Build Time Elapsed:  00:00:01

gdqxp

帮我看看呢，xdata区使用需要注意什么吗？

gdqxp

没有大神回答吗

LcwSwust

gdqxp 发表于 2021-6-9 15:56
STC12C5A08S2     Program Size: data=9.2 xdata=700 code=3138
creating hex file from "lesson18_2"...
...

点击楼层左下角的“回复”，我才能收到通知。

xdata用法无误，详细说明可参考单片机的PDF手册中3.2.2节。


你所说“死活都调不出”,
不知你做了哪些调试？比如检查接收到的数据是否存入了数组？字节数对不对？
程序中，检查下这一句看有什么问题：   *buf++ = RecvBuf;
可能是网页对代码显示有问题，有些东西未显示出来，以后发代码要点击<>添加代码文字，或把C文件（或工程）作为附件发上来。


modbus调试精灵我不了解，也许它有检查CRC校验，但你的这段代码未能体现出有校验。

我更信任串口调试助手，如sscom5.13.1，直接看原始数据。

gdqxp

首先非常感谢大神的解答，你那个贴中指出的 *buf++ = RecvBuf;是这样写的，复制的过程中可能复制漏了，下面这个是串口助手发送的modbus码，是可以接收到的，但是调试精灵不行，调试精灵不行后就无法和昆仑通态的屏通讯

，还麻烦帮看下啊，

gdqxp

*buf++ = RecvBuf;这个写的是这个，复制的时候复制错了，不知道为什么图片上传不了，好像问题在这里 UartWrite( SendBuf,(SendCnt));//
原函数是/* 串口数据写入，即串口发送函数，buf-待发送数据的指针，len-指定的发送长度 */

1. void UartWrite(unsigned char  *pSendBuf, unsigned char  RS485SendCnt)
   
2. {
   
3.           RS485_DIR = 1;  //RS485设置为发送
   
4.     while (RS485SendCnt--)   //循环发送所有字节//停止位去除
   
5.     {
   
6.         flagTxd = 0;      //清零发送标志
   
7.         S2BUF = *pSendBuf++;    //发送一个字节数据
   
8.         while (!flagTxd); //等待该字节发送完成
   
9.     }
   
10.     DelayX10us(5);  //等待最后的停止位完成，延时时间由波特率决定
    
11.     RS485_DIR = 0;  //RS485设置为接收
    
12. }

复制代码

把这个应用到modbus协议里面的；STM32里面是这样写的 USART_SendData(USART_485, *pSendBuf++);可以正常通讯，我把这句改到51里面UartWrite( SendBuf,(SendCnt));用这个替代，不知道有没有影响啊

gdqxp

还麻烦大神帮看看啊！调试精灵里面发送 05 06 0004 0007 88 4D接收到07 88 4D;发送05 03 0002 0001 24 4E 接收89 87 4D，麻烦帮我看下啊，STM32程序是这样的

1. 
   

复制代码

//改成51是这样的

1. * 串口数据写入，即串口发送函数，buf-待发送数据的指针，len-指定的发送长度 */
   
2. void UartWrite(unsigned char  *pSendBuf, unsigned char  RS485SendCnt)
   
3. {
   
4.           RS485_DIR = 1;  //RS485设置为发送
   
5.     while (RS485SendCnt--)   //循环发送所有字节//停止位去除
   
6.     {
   
7.         flagTxd = 0;      //清零发送标志
   
8.         S2BUF = *pSendBuf++;    //发送一个字节数据
   
9.         while (!flagTxd); //等待该字节发送完成
   
10.     }
    
11.     DelayX10us(5);  //等待最后的停止位完成，延时时间由波特率决定
    
12.     RS485_DIR = 0;  //RS485设置为接收
    
13. }
    
14. /* 串口数据读取函数，buf-接收指针，len-指定的读取长度，返回值-实际读到的长度 */
    
15. 
    
16. unsigned char UartRead(unsigned char xdata *buf, unsigned char len)
    
17. {
    
18.     unsigned char i;
    
19.     if (len > RecvCnt)  //指定读取长度大于实际接收到的数据长度时，
    
20.     {                  //读取长度设置为实际接收到的数据长度
    
21.         len = RecvCnt;
    
22.     }
    
23.     for (i=0; i<len; i++)  //拷贝接收到的数据到接收指针上
    
24.     {
    
25.         *buf++ = RecvBuf[i];
    
26.     }
    
27.     RecvCnt = 0;  //RS485RecvCnt = 0;  //接收计数器清零
    
28.    
    
29.     return len;  //返回实际读取长度
    
30. }
    
31. 
    
32. /* 串口中断服务函数 */
    
33. void InterruptUART2() interrupt 8//interrupt 4
    
34. {
    
35.          if (S2CON&S2RI)  //接收到新字节
    
36.     {
    
37.         S2CON&=~S2RI ;  //S2RI = 0;  //清零接收中断标志位
    
38.         if (RecvCnt < sizeof(RecvBuf)) //接收缓冲区尚未用完时，
    
39.         {                            //保存接收字节，并递增计数器
    
40.             RecvBuf[RecvCnt++] = S2BUF;
    
41.         }
    
42.     }
    
43.     if (S2CON&S2TI)  //字节发送完毕
    
44.     {
    
45.         S2CON&=~S2TI;     //S2TI=0 //S2TI = 0;   //清零发送中断标志位
    
46.         flagTxd = 1;  //设置字节发送完成标志
    
47.     }
    
48. }

复制代码

会不会程序的错误在写的51函数的接收函数里啊，还麻烦大神帮看下啊

gdqxp

大神在吗？我的用串助手就可以发送：比如发送050600050003D84E接收到050600050003D84E；比如发送050300030001758E接收到05 03 02 65 A3 22 AD 、、个人感觉没有任何问题，但是用modbus调试精灵调试就像上面发的，连昆仑通态的屏也毫无反应。特别的急，我已经在这个死循环里好多天了

gdqxp

3397372037这个是我qq可以加我，能解决这个问题可以有偿回报的，非常感谢

LcwSwust

再次提醒，点击我所在楼层的左下方“回复”我才能收到通知，一闪一闪的通知。
你在最底下“发表回复”就如同别人回复了你的帖，我是不知道的，需找到你的帖子点开来看才能看到。
modbus是有CRC校验的，此事你可知晓？你这些代码未能体现CRC。

LcwSwust

我的一段代码，添加了CRC，仅供参考：

1. //--------------------------------------------------
   
2. //CRC16计算
   
3. //nbyte为字节数
   
4. //多项式=X16+X15+X2+1
   
5. 
   
6. //--------------------------------------------------
   
7. U16 crc16(U8 *p,U8 nbyte)   
   
8. {  
   
9.         U16 crc=0xffff;
   
10.         U8 i,d;
    
11.         while(nbyte--)   
    
12.         {  
    
13.                 d=*(p++);
    
14.                 for(i=0x01;i;i<<=1)               
    
15.                 {      
    
16.                         if(crc&0x1){crc>>=1;crc^=0xA001;}
    
17.                         else crc>>=1;                        //数据同CRC最低位相异或
    
18.                         if(d&i)crc^=0xA001;                //数据都是低位在前
    
19.                 }               
    
20.         }
    
21.         return(crc);
    
22. }
    
23. //--------------------------------------------------
    
24. //串口4发送一串数据
    
25. //--------------------------------------------------
    
26. void uart4sendframe(U8 s[],U8 size)//发送一帧
    
27. {
    
28.         U16 i,crc;
    
29.         U8        chk=0;
    
30.         crc=crc16(s,size);
    
31.         for(i=0;i<size;i++)                //数据区
    
32.         {
    
33.                 uart4_sendbyte(s[i]);
    
34.         }
    
35.         uart4_sendbyte(crc);        //校验
    
36.         uart4_sendbyte(crc>>8);
    
37. }
    
38. //读取寄存器
    
39. void mod_GetReg(U16 add)
    
40. {
    
41.         uart4buf_tx[0] =0x01;//ADD
    
42.         uart4buf_tx[1] =0x03;//CMD
    
43.         uart4buf_tx[2] =add>>8;//reg addr_h
    
44.         uart4buf_tx[3] =add;//reg addr_l
    
45.         uart4buf_tx[4] =0x00;//reg cnt_h
    
46.         uart4buf_tx[5] =0x01;//reg cnt_l
    
47.         uart4sendframe(uart4buf_tx,6);
    
48. }

复制代码

gdqxp

我的一段代码，添加了CRC，仅供参考：

//变量寄存器地址映射，从0开始
void Modbus_RegMap()
{
  ModbusHoldReg[0] = (signed short*)&Address;                       //设备地址
  ModbusHoldReg[1] = (signed short*)&frequency;                     //频率
  ModbusHoldReg[2] = (signed short*)&duty_3;                        //占空比
  ModbusHoldReg[3] = (signed short*)&Kp;                           
  ModbusHoldReg[4] = (signed short*)&Ki;               
  ModbusHoldReg[5] = (signed short*)&Kd;                    
}

gdqxp

LcwSwust 发表于 2021-6-10 19:58
我的一段代码，添加了CRC，仅供参考：

大神我的modbus协议//变量寄存器地址映射，从0开始

gdqxp

我的一段代码，添加了CRC，仅供参考：

//变量寄存器地址映射，从0开始
void Modbus_RegMap()
{
  ModbusHoldReg[0] = (signed short*)&Address;                       //设备地址
  ModbusHoldReg[1] = (signed short*)&frequency;                     //频率
  ModbusHoldReg[2] = (signed short*)&duty_3;                        //占空比
  ModbusHoldReg[3] = (signed short*)&Kp;                           
  ModbusHoldReg[4] = (signed short*)&Ki;               
  ModbusHoldReg[5] = (signed short*)&Kd;                    
}

gdqxp

LcwSwust 发表于 2021-6-10 19:58
我的一段代码，添加了CRC，仅供参考：

能看到我的回复吗

gdqxp

现在我把程序贴上啊：

1. 
   
2. void Modbus_RegMap()
   
3. {
   
4.   ModbusHoldReg[0] = (signed short*)&Address;                       //设备地址
   
5.   ModbusHoldReg[1] = (signed short*)&frequency;                     //频率
   
6.   ModbusHoldReg[2] = (signed short*)&duty_3;                        //占空比
   
7.   ModbusHoldReg[3] = (signed short*)&Kp;                           
   
8.   ModbusHoldReg[4] = (signed short*)&Ki;               
   
9.   ModbusHoldReg[5] = (signed short*)&Kd;                    
   
10. }
    
11. void Modbus_Backup_RegMap(void)
    
12. {
    
13.         //备份寄存器
    
14.   Backup_ModbusHoldReg[0] = (signed short*)&Backup_Address;         
    
15.   Backup_ModbusHoldReg[1] = (signed short*)&Backup_frequency;      
    
16.   Backup_ModbusHoldReg[2] = (signed short*)&Backup_duty_3;   
    
17.   Backup_ModbusHoldReg[3] = (signed short*)&Backup_Kp;        
    
18.   Backup_ModbusHoldReg[4] = (signed short*)&Backup_Ki;  
    
19.   Backup_ModbusHoldReg[5] = (signed short*)&Backup_Kd;      
    
20. }//CRC效验
    
21. unsigned short CRCData(unsigned char xdata *ptr,unsigned char len)
    
22. {
    
23.   unsigned char CRCDataH = 0xFF;
    
24.         unsigned char CRCDataL = 0xFF;
    
25.         unsigned char Index=0;
    
26.         unsigned short         CRCResult=0;
    
27.         while(len--)
    
28.         {
    
29.                 Index = CRCDataH ^ *ptr++;
    
30.                 CRCDataH = CRCDataL ^ RevCRC16H[Index];
    
31.                 CRCDataL = RevCRC16L[Index];
    
32.         }
    
33.         CRCResult = (((unsigned short)CRCDataL)<<8)|CRCDataH;
    
34.         return(CRCResult);
    
35. } /* 串口动作函数，根据接收到的命令帧执行响应的动作
    
36.    buf-接收到的命令帧指针，len-命令帧长度 */
    
37. void UartAction()
    
38. {
    
39.   unsigned short RegCRC;
    
40.         unsigned short CalCRC;
    
41. //        if(flagFrame == 1)
    
42. //        {
    
43. //                flagFrame=0;
    
44.         if((RecvBuf[0] == Address)||(RecvBuf[0] == 0))
    
45.   {
    
46.                 if((RecvBuf[1] == 03)||(RecvBuf[1] == 06)||(RecvBuf[1] == 16))//功能码
    
47.                 {
    
48.                         StartRegAddress = ((((unsigned short)RecvBuf[2])<<8)|RecvBuf[3]);//寄存器起始地址
    
49.                   if(StartRegAddress < 100)
    
50.                         {
    
51.                                 CalCRC = CRCData(RecvBuf,(RecvCnt-2));                                      /???CRCD￡?é??           
    
52.                                 RegCRC = (((unsigned short)RecvBuf[RecvCnt-1])<<8)|RecvBuf[RecvCnt-2]; /????óê?μ?μ?CRCD￡?é??
    
53.                                 RegCRC = CalCRC; //*****2aê?íê±?oó′?ì???á?é?3y*****
    
54.                                 if(CalCRC == RegCRC)      
    
55.                                 {
    
56.                                                 switch(RecvBuf[1])
    
57.                                           {
    
58.                                                   case 03: //读多个寄存器
    
59.                                                                ReadManyRegister(RecvBuf,SendBuf);
    
60.                                                          break;
    
61.                                                   case 06: //写单个寄存器
    
62.                                                                WriteOneRegister(RecvBuf,SendBuf);
    
63.                                                          break;
    
64.                                                   case 16: //写多个寄存器
    
65.                                                                WriteManyRegister(RecvBuf,SendBuf);
    
66.                                                                break;
    
67.                                           }
    
68.                                         }
    
69.                                   else                                       //CRCD￡?é′í?ó
    
70.                                   {
    
71.                               SendBuf[0] = RecvBuf[0];
    
72.                               SendBuf[1] = RecvBuf[1]|0x80;
    
73.                               SendBuf[2] = 0x04;                       //′í?ó′ú??0x04:CRCD￡?é??òì3￡
    
74.                                           CalCRC = CRCData(SendBuf,3);        
    
75.                         SendBuf[3] = CalCRC&0xFF;
    
76.                         SendBuf[4] = (CalCRC>>8)&0xFF;               
    
77.                         SendCnt = 6;                //               
    
78.                                   }
    
79.                         }
    
80.                         else//超出范围
    
81.                         {
    
82.                             SendBuf[0] = RecvBuf[0];
    
83.                             SendBuf[1] = RecvBuf[1]|0x80;
    
84.                             SendBuf[2] = 0x02;                           //0x02:寄存器地址超出范围
    
85.                             CalCRC = CRCData(SendBuf,3);               
    
86.                       SendBuf[3] = CalCRC&0xFF;
    
87.                       SendBuf[4] = (CalCRC>>8)&0xFF;               
    
88.                       SendCnt = 6;
    
89.                         }
    
90.          }
    
91.          else  //功能码错误
    
92.          {
    
93.                           SendBuf[0] = RecvBuf[0];
    
94.                           SendBuf[1] = RecvBuf[1]|0x80;
    
95.                           SendBuf[2] = 0x01;                           //0x01:功能码错误
    
96.         CalCRC = CRCData(SendBuf,3);                                
    
97.                     SendBuf[3] = CalCRC&0xFF;
    
98.                     SendBuf[4] = (CalCRC>>8)&0xFF;               
    
99.                     SendCnt = 6;        
    
100.          }
     
101.     RecvCnt = 0;
     
102.                 pSendBuf = SendBuf;
     
103.                 RS485_DIR = 1;//准备发送
     
104.                 UartWrite( SendBuf, (SendCnt-1));
     
105.   }
     
106. //}
     
107. 
     
108. //读多个寄存器地址
     
109. void ReadManyRegister(unsigned char xdata*RecvBuf,unsigned char xdata*SendBuf)            
     
110. {
     
111.         unsigned char  i=0;
     
112.   unsigned short CalCRC;   
     
113.         RegisterNum = (((unsigned short)RecvBuf[4])<<8)|RecvBuf[5];        //获取寄存器数量
     
114.   if((StartRegAddress+RegisterNum)<100)//地址小于100
     
115.         {
     
116.                 SendBuf[0] = RecvBuf[0];
     
117.                 SendBuf[1] = RecvBuf[1];
     
118.                 SendBuf[2] = RegisterNum<<1;//字节数为寄存器的两倍
     
119.                 for(i=0;i<RegisterNum;i++)//把接收到的数据写进去
     
120.                 {
     
121.       SendBuf[3+i*2] = (*ModbusHoldReg[StartRegAddress+i]>>8)&0xFF;  //先发送高字节再发送低字节
     
122.       SendBuf[4+i*2] = (*ModbusHoldReg[StartRegAddress+i])&0xFF;   
     
123.                 }
     
124.                 CalCRC = CRCData(SendBuf,((RegisterNum<<1)+3));
     
125.                 SendBuf[(RegisterNum<<1)+3] = CalCRC&0xFF;
     
126.                 SendBuf[(RegisterNum<<1)+4] = (CalCRC>>8)&0xFF;
     
127.                 SendCnt = SendBuf[2]+6;
     
128.         }
     
129.         else                                                               //寄存器地址+数量超出范围
     
130.         {
     
131.                 SendBuf[0] = RecvBuf[0];
     
132.                 SendBuf[1] = RecvBuf[1]|0x80;
     
133.                 SendBuf[2] = 0x02;                                               //错误代码
     
134.     CalCRC = CRCData(SendBuf,3);        
     
135.                 SendBuf[3] = CalCRC&0xFF;
     
136.                 SendBuf[4] = (CalCRC>>8)&0xFF;               
     
137.                 SendCnt = 6;//
     
138.         }        
     
139.          RecvCnt = 0;
     
140.          pSendBuf = SendBuf;
     
141.          RS485_DIR = 1;//准备发送
     
142.          UartWrite( SendBuf,(SendCnt-1));
     
143. }
     
144. 
     
145. 
     
146. 
     
147. 
     

复制代码