设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › STC15系列单片机RS-485通讯例程(带CRC校验)
返回列表 发新帖
查看: 18782|回复: 32
打印 上一主题 下一主题
收起左侧

STC15系列单片机RS-485通讯例程(带CRC校验)

  [复制链接]
跳转到指定楼层
楼主
ID:389303 发表于 2018-8-23 15:36 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
STC15系列单片机RS-485通讯例程

单片机源程序如下:
  1. #include <uart.h>


  4. sbit bitCtrl_485Eable = P1^3;//
  5. sbit bitCtrl_485_2Eable = P7^3;//

  7. xdata unsigned char mod_comd[9]={0x01,0x04,0x75,0x31,0x02,0x00,0x00,0x08,0x09};
  8. unsigned char freq = 0;


  11. /****************************************************************************************/
  12. // unsigned char MyDeviceAddr _at_ 0x06000;
  13. // unsigned char PODeviceAddr _at_ 0x05999;
  14. unsigned char MyDeviceAddr;
  15. unsigned char PODeviceAddr;


  18. /*********************************
  19. 串口1变量定义
  20. **********************************/
  21. bit busy1 = 0;
  22. xdata unsigned char u8Uart1TxBuffer[USART1_TX_BUFFER_SIZE];
  23. xdata unsigned char u8Uart1RxBuffer[USART1_RX_BUFFER_SIZE];
  24. unsigned char  u8Rx1Head = 0;
  25. unsigned char  u8Rx1Tail = 0;
  26. unsigned char  u8Tx1Head = 0;
  27. unsigned char  u8Tx1Tail = 0;

  29. unsigned char  mdbs1_stat = 0;
  30. unsigned char  mdbs1_len = 0;
  31. unsigned char  mdbs1_cnt = 0;
  32. unsigned char  mdbs1_maxlen = 0;
  33. xdata unsigned char mdbs1_Rxbuf[16];
  34. xdata unsigned char mdbs1_Txbuf[16];
  35. unsigned char  mdbs1_pos = 0;
  36. unsigned char  mdbs1_timerflag = 0;
  37. unsigned char  mdbs1_overtime = 0;
  38. unsigned char  mdbs1_data_len = 0;
  39. /****************************************************************************************/

  41. /****************************************************************************************/
  42.    

  44. /*********************************
  45. 串口2变量定义
  46. **********************************/

  48. bit busy2 = 0;
  49. xdata unsigned char u8Uart2TxBuffer[USART2_TX_BUFFER_SIZE];
  50. xdata unsigned char u8Uart2RxBuffer[USART2_RX_BUFFER_SIZE];
  51. unsigned char  u8Rx2Head = 0;
  52. unsigned char  u8Rx2Tail = 0;
  53. unsigned char  u8Tx2Head = 0;
  54. unsigned char  u8Tx2Tail = 0;


  57. unsigned char  mdbs2_stat = 0;
  58. unsigned char  mdbs2_len = 0;
  59. unsigned char  mdbs2_cnt = 0;
  60. unsigned char  mdbs2_maxlen = 0;
  61. xdata unsigned char mdbs2_Rxbuf[16];
  62. xdata unsigned char mdbs2_Txbuf[16];
  63. unsigned char  mdbs2_pos = 0;
  64. unsigned char  mdbs2_timerflag = 0;
  65. unsigned char  mdbs2_overtime = 0;
  66. unsigned char  mdbs2_data_len = 0;
  67. /****************************************************************************************/


  70. /*定时器0初始化，采用16位自动重装技术模式*/

  72. void Timer0Init(void)                                //10毫秒@11.0592MHz                          //16位重装计数器
  73. {
  74.         AUXR &= 0x7F;                                        //定时器时钟12T模式
  75.         TMOD &= 0xF0;                                        //设置定时器模式
  76.                                 
  77.         TL0 = -(FOSC/12/100);                        //设置定时初值
  78.         TH0 = -(FOSC/12/100) >> 8;                //设置定时初值
  79. //        RL_TH0


  82.         TF0 = 0;                                                //清除TF0标志
  83.         TR0 = 1;                                                //定时器0开始计时
  84.         Timer0_InterruptFirst();
  85.         ET0 = 1;                                                //enable timer0 interrupt
  86. }
  87. /***定时器0中断服务函数**/
  88. void tm0_isr() interrupt 1  using 1
  89. {

  91.                                                                
  92.     TF0 = 0;                                            //清除TF0标志
  93.         TL0 = -(FOSC/12/100);                    //设置定时初值
  94.         TH0 = -(FOSC/12/100) >> 8;                //设置定时初值
  95.    
  96.          ++freq;  
  97.         

  99. }

  101. /************************************************************************/
  102.   //8位数据   波特率可变    无奇偶检验位    1位起始位  1位停止位
  103.   //使用定时器1作为波特率发生器
  104.    void Uart1Init(void)                                        //9600bps@11.0592MHz
  105. {
  106.         PCON &= 0x3F;                                        //波特率不倍速
  107.         SCON = 0x50;                                        //8位数据,可变波特率
  108.         AUXR &= 0xBF;                                        //定时器1时钟为Fosc/12,即12T  传统51速度
  109.         AUXR &= 0xFE;                                        //串口1选择定时器1为波特率发生器
  110. //        AUXR |=0X01;                                          //串口1选择定时器2为波特率发生器

  112.         TMOD &= 0x0F;                                        //清除定时器1模式位
  113.         TMOD |= 0x20;                                        //设定定时器1为8位自动重装方式

  115. //        TMOD &= 0xF0;                                        //清除定时器2模式位
  116. //        TMOD |= 0x02;                                        //设定定时器2为8位自动重装方式

  118.         TL1 = -(FOSC/12/32/BAUD);                //设定定时初值
  119.         TH1 = -(FOSC/12/32/BAUD);                //设定定时器重装值
  120. /*****

  122. 定时器2工作方式为固定16位自动重装载   装在值需重新计算
  123. */
  124. //        T2L = -(FOSC/12/32/BAUD);                //设定定时初值
  125. //        T2H = -(FOSC/12/32/BAUD);                //设定定时器重装值


  128.         ET1 = 0;                                                //禁止定时器1中断
  129.         TR1 = 1;                                                //启动定时器1
  130. //        S1_USE_P36P37();                        //定义串口1管脚
  131.         UART1_InterruptFirst();                  //中断优先级设定
  132.         ES = 1;                                 //????????


  135.    bitCtrl_485Eable=0;
  136. }
  137. /******************        *****************************************************/
  138. /*************串口2初始化************/
  139. /************************************************************************/

  141. //#define                S3_Int_en()                        IE2   |=  8
  142. void Uart2Init(void)                                //10毫秒@11.0592MHz
  143. {
  144. /*        
  145.         T2MOD = 0;                                                //初始化模式寄存器
  146.         T2CON = 0;                                                //初始化控制寄存器
  147.         TL2 = -(FOSC/12/100);                        //设置定时初值
  148.         TH2 = -(FOSC/12/100) >> 8;                //设置定时初值
  149.         RCAP2L = -(FOSC/12/100);                //设置定时重载值
  150.         RCAP2H = -(FOSC/12/100) >> 8;        //设置定时重载值
  151.         TR2 = 1;                                            //定时器2开始计时
  152.         ET2 = 1;                                                //enable timer2 interrupt
  153. */        
  154.         
  155. //        Timer2_12T();
  156. //        Timer2_AsTimer();
  157. //        T2L = -(FOSC/12/100);                        //设置定时初值
  158. //        T2H = -(FOSC/12/100) >> 8;                //设置定时初值
  159. //        Timer2_Run();
  160. //        Timer2_InterruptEnable();
  161.         //Timer2_InterruptDisable();
  162.         
  163.         S2CON = 0x50;
  164.         Timer2_12T();
  165.         T2L = (65536-(FOSC/4/12/BAUD));
  166.         T2H = (65536-(FOSC/4/12/BAUD))>> 8;
  167.         Timer2_Run();
  168.         Timer2_InterruptDisable();
  169. //        S2_USE_P10P11();//使用默认端口        
  170.         S2_Int_en();        //中断允许
  171.         
  172. //        S3CON = 0x10;
  173. //        Timer2_12T();
  174. //        T2L = -(FOSC/12/4/BAUD);
  175. //        T2H = -(FOSC/12/4/BAUD) >> 8;
  176. //        Timer2_Run();
  177. //        Timer2_InterruptDisable();
  178. //        S3_USE_P50P51();        
  179. //        S3_Int_en();
  180.           bitCtrl_485_2Eable = 0;
  181.         
  182.         InternalRAM_enable();                        ////禁止外部XRAM，允许使用内部1024RAM
  183. }
  184. /****************************************************************************************/


  187.   /****************************************************************************************/
  188.   /**串口1中断服务函数！！！！！！！！！！！！！！！
  189.   ！！！！！！！！！！！！*/
  190.   /*******************************
  191.   接收数据缓存区满时，丢弃接收到的数据，数据处理后释放数据缓存区
  192.   ********************************/

  194.    void Uart1_Isr() interrupt 4 using 2
  195. {
  196. // EA = 0;

  198.     if (RI==1)
  199.     {
  200.        RI = 0;               //Clear receive interrupt flag

  202.                
  203.          if(u8Rx1Head+1 != u8Rx1Tail)
  204.                 {
  205.                         u8Uart1RxBuffer[u8Rx1Head++] = SBUF;
  206.                         u8Rx1Head &= USART1_RX_BUFFER_MASK;
  207.                 }


  210.     }
  211.     if (TI==1)
  212.     {
  213.         TI=0;            //Clear transmit interrupt flag
  214.         busy1 = 0;           //Clear transmit busy flag
  215.                 if(u8Tx1Head != u8Tx1Tail)
  216.                 {
  217.                 bitCtrl_485Eable =1;
  218.                         SBUF = u8Uart1TxBuffer[u8Tx1Tail++];
  219.                         u8Tx1Tail &= USART1_TX_BUFFER_MASK;
  220.                 }
  221.                 else
  222.                 {
  223.                 bitCtrl_485Eable =0;
  224.                 }
  225.     }
  226. //        EA = 1;
  227. }


  230. /********串口2中断服务函数******/
  231.   /*******************************
  232.   接收数据缓存区满时，丢弃接收到的数据，数据处理后释放数据缓存区
  233.   ********************************/
  234. #define        S2RI  0x01
  235. #define        S2TI  0x02
  236. void Uart2_Isr() interrupt 8 using 2
  237. {
  238. // EA = 0;

  240.     if (S2CON&S2RI)
  241.     {
  242.         S2CON &= ~S2RI;             //Clear receive interrupt flag

  244.                
  245.          if(u8Rx2Head+1 != u8Rx2Tail)
  246.                 {
  247.                         u8Uart2RxBuffer[u8Rx2Head++] = S2BUF;
  248.                         u8Rx2Head &= USART2_RX_BUFFER_MASK;
  249.                 }


  252.     }
  253.     if (S2CON&S2TI)
  254.     {
  255.         S2CON &= ~S2TI;            //Clear transmit interrupt flag
  256.         busy2 = 0;           //Clear transmit busy flag
  257.                 if(u8Tx2Head != u8Tx2Tail)
  258.                 {
  259.                         bitCtrl_485_2Eable = 1;
  260.                         S2BUF = u8Uart2TxBuffer[u8Tx2Tail++];
  261.                         u8Tx2Tail &= USART2_TX_BUFFER_MASK;
  262.                 }
  263.                 else
  264.                 {
  265.                         bitCtrl_485_2Eable = 0;
  266.                 }
  267.     }
  268. //        EA = 1;
  269. }

  271. /********************************************************************************************/
  272. /*******读串口1缓冲区1字节函数********************************************************
  273. 读取一个字节的接收缓存数据 ，释放一个字节的缓存空间        读取的数据存放在*pdat
  274. 返回0，表示缓存区有未读数据
  275. 返回-1，表示缓存区没有未读数据
  276. ****************************/

  278. BYTE Recv1Data(BYTE *pdat)        
  279. {
  280.     if(u8Rx1Head != u8Rx1Tail)   //有未处理数据
  281.         {
  282.                 *pdat = u8Uart1RxBuffer[u8Rx1Tail++];
  283.                 u8Rx1Tail &= USART1_RX_BUFFER_MASK;
  284.                 return 0;
  285.         }
  286.         return -1;
  287. }
  288. /****************************************************************************************/


  291. /********************************************************************************************/
  292. /**********读串口2缓冲区1字节函数*****************************************************
  293. 读取一个字节的接收缓存数据 ，释放一个字节的缓存空间        读取的数据存放在*pdat
  294. 返回0，表示缓存区有未读数据
  295. 返回-1，表示缓存区没有未读数据
  296. ****************************/
  297. BYTE Recv2Data(BYTE *pdat)        
  298. {
  299.     if(u8Rx2Head != u8Rx2Tail)   //有未处理数据
  300.         {
  301.                 *pdat = u8Uart2RxBuffer[u8Rx2Tail++];
  302.                 u8Rx2Tail &= USART2_RX_BUFFER_MASK;
  303.                 return 0;
  304.         }
  305.         return -1;
  306. }
  307. /****************************************************************************************/

  309. /* Send a byte data to UART
  310. Input: dat (data to be sent)
  311. Output:None        
  312. 串口1发送一个字节的数据
  313. u8UartTxBuffer 用于发送数据的缓存  防止数据未及时发送时的数据堆积
  314. ----------------------------*/
  315.   


  318. BYTE Send1Data(BYTE dat)
  319. {
  320.         if((u8Tx1Head == u8Tx1Tail) && (0 == busy1))
  321.         {
  322.                          busy1 = 1;
  323.         bitCtrl_485Eable =1;
  324.         
  325. //                S3BUF = dat;
  326. //                S2BUF = dat;
  327.                 SBUF = dat;
  328.                 return 0;
  329.         }
  330.         if(u8Tx1Head+1 == u8Tx1Tail)
  331.         {
  332.                 return -1;        // full
  333.         }
  334.         u8Uart1TxBuffer[u8Tx1Head++] = dat;         //如果发送繁忙  则数据保存在发送缓存区
  335.         u8Tx1Head &= USART1_TX_BUFFER_MASK;
  336.         return 1;
  337. }


  340. /****************************************************************************************/
  341. /****************************************************************************************/


  344. /* Send a byte data to UART
  345. Input: dat (data to be sent)
  346. Output:None        
  347. 串口2发送一个字节的数据
  348. u8UartTxBuffer 用于发送数据的缓存  防止数据未及时发送时的数据堆积
  349. ----------------------------*/
  350. BYTE Send2Data(BYTE dat)
  351. {
  352.         if((u8Tx2Head == u8Tx2Tail) && (0 == busy2))
  353.         {
  354.                 busy2 = 1;
  355.                 bitCtrl_485_2Eable = 1;
  356. //                S3BUF = dat;
  357.                 S2BUF = dat;
  358. //                SBUF = dat;
  359.                 return 0;
  360.         }
  361.         if(u8Tx2Head+1 == u8Tx2Tail)
  362.         {
  363.                 return -1;        // full
  364.         }
  365.         u8Uart2TxBuffer[u8Tx2Head++] = dat;         //如果发送繁忙  则数据保存在发送缓存区
  366.         u8Tx2Head &= USART2_TX_BUFFER_MASK;
  367.         return 1;
  368. }
  369. /****************************************************************************************/
  370. /****************************************************************************************/




  375. /****************************************
  376.           从串口1数据缓存区读取数据函数
  377. 读取数据缓存区数据，释放缓存空间 读取的数据保存在mdbs_Rxbuf中！！
  378. 并判断接收数据 的有效性        (本地地址校验，读写位校验，数据长度校验，CRC校验)
  379. 返回0，表示已接收完成一组有效数据
  380. 返回-1，表示，缓存区没有数据或数据不完整！          或与本机地址不匹配
  381. !!!如果缓存中有数据，单数据不完整，则把已有数据保存在 mdbs_Rxbuf中，下次进入此函数，数据继续保存
  382.     mdbs1_Rxbuf[]          接收数据存储区
  383.         mdbs1_len          接收数据长度
  384.         mdbs1_maxlen  接收指令数据区的长度
  385.         mdbs1_stat          接收状态
  386.         mdbs1_pos          数据存储地址
  387.         mdbs1_overtime 接收超时标志
  388.         mdbs1_timerflag 连续接收标志
  389.         freq          时钟节拍
  390. 如果中间有数据错误，则重新寻找数据开始位置！！！
  391. ************************************************/
  392. unsigned char link_recv1_pkt(void)                  
  393. {
  394.         unsigned char u8dat;
  395.         if(mdbs1_timerflag)
  396.         {
  397.                 if(freq - mdbs1_overtime >= 10)
  398.                 {
  399.                         Link1ClearState();
  400.                 }
  401.         }
  402.         while(0 == Recv1Data(&u8dat))//
  403.         {
  404.                 switch(mdbs1_stat)  //初次进入  mdbs_stat=0
  405.                 {
  406.                         case 0:
  407.                         {
  408.                                 if(u8dat > 256)        //地址不能大于247？        255？
  409.                                 {
  410.                                         break;
  411.                                 }
  412.                                 if(PODeviceAddr!=u8dat)         return -1;           //不是目标地址返回-1
  413.                                 mdbs1_Rxbuf[mdbs1_pos++] = u8dat;
  414.                                 mdbs1_len++;
  415.                                 mdbs1_stat = 1;
  416.                                 freq=mdbs1_overtime;
  417.                                 mdbs1_timerflag = 1;
  418.                                 
  419.                         } break;

  421.                         case 1:           //功能码
  422.                         {
  423.                                 mdbs1_Rxbuf[mdbs1_pos++] = u8dat;
  424.                                 mdbs1_len++;
  425.                                 if((READ_INPUT == u8dat)||(WRITE_INPUT==u8dat))
  426.                                 {
  427.                                         mdbs1_stat = 2;
  428.                                         //mdbs_cnt = 0;
  429.                                         //mdbs_maxlen = 4;
  430.                                        
  431.                                 }
  432.                                 else
  433.                                 {
  434.                                         Link1ClearState();
  435.                                         break;                                
  436.                                 }
  437.                                 freq=mdbs1_overtime;
  438.                                 mdbs1_timerflag = 1;
  439.                         } break;

  441.                         case 2:          //标识码高字节，不做处理直接保存
  442.                         {
  443.                                 mdbs1_Rxbuf[mdbs1_pos++] = u8dat;
  444.                                 mdbs1_len++;
  445.                                 mdbs1_stat = 3;
  446.                                 freq=mdbs1_overtime;
  447.                                 mdbs1_timerflag = 1;
  448.                         } break;
  449.                         case 3:         //标识码底字节，不做处理直接保存
  450.                         {
  451.                                 mdbs1_Rxbuf[mdbs1_pos++] = u8dat;
  452.                                 mdbs1_len++;
  453.                                 mdbs1_stat = 4;
  454.                                 freq=mdbs1_overtime;
  455.                                 mdbs1_timerflag = 1;
  456.                         
  457.                         } break;
  458.                         
  459.                         case 4:         //数据长度
  460.                         {
  461.                                 mdbs1_Rxbuf[mdbs1_pos++] = u8dat;
  462.                                 mdbs1_len++;
  463.                              mdbs1_cnt++;
  464.                                 //if(mdbs_cnt >= mdbs_maxlen)
  465.                                 //{
  466.                                         mdbs1_stat = 5;
  467.                                         mdbs1_cnt = 0;
  468.                                         mdbs1_maxlen = u8dat;
  469.                                         if(u8dat==0)  //如果数据长度为0          只剩下CRC校验数据
  470.                                         {
  471.                                                 mdbs1_stat = 100;
  472.                                                 mdbs1_cnt = 0;
  473.                                                 mdbs1_maxlen = 2;
  474.                                         }
  475.                                 //}
  476.                                 freq=mdbs1_overtime;
  477.                                 mdbs1_timerflag = 1;
  478.                                 
  479.                         } break;
  480.                         case 5:        //数据长度不为0，继续接收有效数据
  481.                         {
  482.                                 mdbs1_Rxbuf[mdbs1_pos++] = u8dat;
  483.                                 mdbs1_len++;
  484.                                 mdbs1_cnt++;
  485.                                 if(mdbs1_cnt >= mdbs1_maxlen)
  486.                                 {
  487.                                         mdbs1_stat = 100;
  488.                                         mdbs1_cnt = 0;
  489.                                         mdbs1_maxlen = 2;
  490.                                 }
  491.                                 freq=mdbs1_overtime;
  492.                                 mdbs1_timerflag = 1;
  493.                         } break;
  494.                         
  495.                         case 100:  //CRC校验位
  496.                         {
  497.                                 mdbs1_Rxbuf[mdbs1_pos++] = u8dat;
  498.                                 mdbs1_len++;
  499.                                 mdbs1_cnt++;
  500.                                 if(mdbs1_cnt >= mdbs1_maxlen)
  501.                                 {
  502.                                         mdbs1_timerflag = 0;
  503.                                         mdbs1_data_len = mdbs1_len;
  504.                                         if((CRC16(mdbs1_Rxbuf, mdbs1_len) == 0) && (PODeviceAddr == mdbs1_Rxbuf[0]))         
  505.                                         {
  506.                                                 Link1ClearState();
  507.                                                 return 0;
  508.                                         }
  509.                                         Link1ClearState();
  510.                                 }
  511.                                 freq=mdbs1_overtime;
  512.                                 mdbs1_timerflag = 1;
  513.                         } break;

  515.                         default:
  516.                                 Link1ClearState();
  517.                                 break;
  518.                 }
  519.         }
  520.         return -1;
  521. }

  523. /****************************************************************************************/


  526. /****************************************
  527.           从串口2数据缓存区读取数据函数
  528. 读取数据缓存区数据，释放缓存空间 读取的数据保存在mdbs2_Rxbuf中！！
  529. 并判断接收数据 的有效性        (本地地址校验，读写位校验，数据长度校验，CRC校验)
  530. 返回0，表示已接收完成一组有效数据
  531. 返回-1，表示，缓存区没有数据或数据不完整！          或与本机地址不匹配
  532. !!!如果缓存中有数据，单数据不完整，则把已有数据保存在 mdbs_Rxbuf中，下次进入此函数，数据继续保存
  533.     mdbs2_Rxbuf[]          接收数据存储区
  534.         mdbs2_len          接收数据长度
  535.         mdbs2_maxlen  接收指令数据区的长度
  536.         mdbs2_stat          接收状态
  537.         mdbs2_pos          数据存储地址
  538.         mdbs2_overtime 接收超时标志
  539.         mdbs2_timerflag 连续接收标志
  540.         freq          时钟节拍
  541. 如果中间有数据错误，则重新寻找数据开始位置！！！
  542. ************************************************/

  544. unsigned char link_recv2_pkt(void)                  
  545. {
  546.         unsigned char u8dat;
  547.         if(mdbs2_timerflag)
  548.         {
  549.                 if(freq - mdbs2_overtime >= 10)
  550.                 {
  551.                         Link2ClearState();
  552.                 }
  553.         }
  554.         while(0 == Recv2Data(&u8dat))//
  555.         {
  556.                 switch(mdbs2_stat)  //初次进入  mdbs_stat=0
  557.                 {
  558.                         case 0:
  559.                         {
  560.                                 if(u8dat > 256)        //地址不能大于247？        255？
  561.                                 {
  562.                                         break;
  563.                                 }
  564.                                 if(MyDeviceAddr!=u8dat)         return -1;           //不是目标地址返回-1
  565.                                 mdbs2_Rxbuf[mdbs2_pos++] = u8dat;
  566.                                 mdbs2_len++;
  567.                                 mdbs2_stat = 1;
  568.                                 freq=mdbs2_overtime;
  569.                                 mdbs2_timerflag = 1;
  570.                         } break;

  572.                         case 1:           //功能码
  573.                         {
  574.                                 mdbs2_Rxbuf[mdbs2_pos++] = u8dat;
  575.                                 mdbs2_len++;
  576.                                 if((READ_INPUT == u8dat)||(WRITE_INPUT==u8dat))
  577.                                 {
  578.                                         mdbs2_stat = 2;
  579.                                         //mdbs_cnt = 0;
  580.                                         //mdbs_maxlen = 4;
  581.                                 }
  582.                                 else
  583.                                 {
  584.                                         Link2ClearState();
  585.                                         break;                                
  586.                                 }
  587.                                 freq=mdbs2_overtime;
  588.                                 mdbs2_timerflag = 1;
  589.                         } break;

  591.                         case 2:          //标识码高字节，不做处理直接保存
  592.                         {
  593.                                 mdbs2_Rxbuf[mdbs2_pos++] = u8dat;
  594.                                 mdbs2_len++;
  595.                                 mdbs2_stat = 3;
  596.                                 freq=mdbs2_overtime;
  597.                                 mdbs2_timerflag = 1;
  598.                         } break;
  599.                         case 3:         //标识码底字节，不做处理直接保存
  600.                         {
  601.                                 mdbs2_Rxbuf[mdbs2_pos++] = u8dat;
  602.                                 mdbs2_len++;
  603.                                 mdbs2_stat = 4;
  604.                                 freq=mdbs2_overtime;
  605.                                 mdbs2_timerflag = 1;
  606.                         } break;
  607.                         
  608.                         case 4:         //数据长度
  609.                         {
  610.                                 mdbs2_Rxbuf[mdbs2_pos++] = u8dat;
  611.                                 mdbs2_len++;
  612.                              mdbs2_cnt++;
  613.                                 //if(mdbs_cnt >= mdbs_maxlen)
  614.                                 //{
  615.                                         mdbs2_stat = 5;
  616.                                         mdbs2_cnt = 0;
  617.                                         mdbs2_maxlen = u8dat;
  618.                                         if(u8dat==0)  //如果数据长度为0          只剩下CRC校验数据
  619.                                         {
  620.                                                 mdbs2_stat = 100;
  621.                                                 mdbs2_cnt = 0;
  622.                                                 mdbs2_maxlen = 2;
  623.                                         }
  624.                                 //}
  625.                                 freq=mdbs2_overtime;
  626.                                 mdbs2_timerflag = 1;
  627.                         } break;
  628.                         case 5:        //数据长度不为0，继续接收有效数据
  629.                         {
  630.                                 mdbs2_Rxbuf[mdbs2_pos++] = u8dat;
  631.                                 mdbs2_len++;
  632.                                 mdbs2_cnt++;
  633.                                 if(mdbs2_cnt >= mdbs2_maxlen)
  634.                                 {
  635.                                         mdbs2_stat = 100;
  636.                                         mdbs2_cnt = 0;
  637.                                         mdbs2_maxlen = 2;
  638.                                 }
  639.                                 freq=mdbs2_overtime;
  640.                                 mdbs2_timerflag = 1;
  641.                         } break;
  642.                         
  643.                         case 100:  //CRC校验位
  644.                         {
  645.                                 mdbs2_Rxbuf[mdbs2_pos++] = u8dat;
  646.                                 mdbs2_len++;
  647.                                 mdbs2_cnt++;
  648.                                 if(mdbs2_cnt >= mdbs2_maxlen)
  649.                                 {
  650.                                         mdbs2_timerflag = 0;
  651.                                         mdbs2_data_len = mdbs2_len;
  652.                                         if((CRC16(mdbs2_Rxbuf, mdbs2_len) == 0) && (MyDeviceAddr == mdbs2_Rxbuf[0]))         
  653.                                         {
  654.                                                 Link2ClearState();
  655.                                                 return 0;
  656.                                         }
  657.                                         Link2ClearState();
  658.                                 }
  659.                                 freq=mdbs2_overtime;
  660.                                 mdbs2_timerflag = 1;
  661.                         } break;

  663.                         default:
  664.                                 Link2ClearState();
  665.                                 break;
  666.                 }
  667.         }
  668.         return -1;
  669. }


  672. /******************************/
  673. /**************************************************/
  674. /*****串口1发送数据函数***********/
  675. /*******发送指定长度的数据*****/


  678. void link1_send_pkt(unsigned char *buf, unsigned char len)
  679. {
  680.         unsigned char i,k;
  681.         for(i=0; i<len; i++)
  682.         {
  683.                 k = Send1Data(buf[i]);
  684.         }
  685. }



  689. /****************************************************************************************/
  690. /*****串口2发送数据函数***********/
  691. /*******发送指定长度的数据*****/
  692. void link2_send_pkt(unsigned char *buf, unsigned char len)
  693. {
  694.         unsigned char i,k;
  695.         for(i=0; i<len; i++)
  696.         {
  697.                 k = Send2Data(buf[i]);
  698.         }
  699. }

  701. /*****串口2发送数据函数
  702. 对指定长度的数据加CRC校验，并发送
  703. *********//*（发送串口1接收的的数据）*/


  706. void svr1_msg(unsigned char *command_buf,unsigned char sentlen)
  707. {
  708.         unsigned int crc;        
  709.         if(sentlen < 4)                   //指令长度不应小于4，否则是无效数据
  710.         {
  711.                 return;        
  712.         }        
  713. //        if(0 == sentlen)return;
  714.         crc = CRC16(command_buf,sentlen);
  715.         command_buf[sentlen]=crc>>8;
  716.         sentlen++;
  717.         command_buf[sentlen]=crc;
  718.         sentlen++;               
  719.         link1_send_pkt(command_buf,sentlen);
  720. }


  723. /******************************************************************************/
  724. /*****串口2发送数据函数
  725. 对指定长度的数据加CRC校验，并发送
  726. *********//*（发送串口1接收的的数据）*/
  727. void svr2_msg(unsigned char *command_buf,unsigned char sentlen)
  728. {
  729.         unsigned int crc;        
  730.         if(sentlen < 4)                   //指令长度不应小于4，否则是无效数据
  731.         {
  732.                 return;        
  733.         }        
  734. //        if(0 == sentlen)return;
  735.         crc = CRC16(command_buf,sentlen);
  736.         command_buf[sentlen]=crc>>8;
  737.         sentlen++;
  738.         command_buf[sentlen]=crc;
  739.         sentlen++;               
  740.         link2_send_pkt(command_buf,sentlen);
  741. }





  747. /*16位CRC校验表*/
  748. code const unsigned char auchCRCHi[]={
  749. 0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,
  750. 0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,
  751. 0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,
  752. 0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,
  753. 0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,
  754. 0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,
  755. 0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,
  756. 0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,

  758. 0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,
  759. 0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,
  760. 0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,
  761. 0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,
  762. 0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,
  763. 0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,
  764. 0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,
  765. 0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40
  766. };
  767. code const unsigned char auchCRCLo[]={
  768. 0x00,0xc0,0xc1,0x01,0xc3,0x03,0x02,0xc2,0xc6,0x06,0x07,0xc7,0x05,0xc5,0xc4,0x04,
  769. 0xcc,0x0c,0x0d,0xcd,0x0f,0xcf,0xce,0x0e,0x0a,0xca,0xcb,0x0b,0xc9,0x09,0x08,0xc8,
  770. 0xd8,0x18,0x19,0xd9,0x1b,0xdb,0xda,0x1a,0x1e,0xde,0xdf,0x1f,0xdd,0x1d,0x1c,0xdc,
  771. 0x14,0xd4,0xd5,0x15,0xd7,0x17,0x16,0xd6,0xd2,0x12,0x13,0xd3,0x11,0xd1,0xd0,0x10,
  772. 0xf0,0x30,0x31,0xf1,0x33,0xf3,0xf2,0x32,0x36,0xf6,0xf7,0x37,0xf5,0x35,0x34,0xf4,
  773. 0x3c,0xfc,0xfd,0x3d,0xff,0x3f,0x3e,0xfe,0xfa,0x3a,0x3b,0xfb,0x39,0xf9,0xf8,0x38,
  774. 0x28,0xe8,0xe9,0x29,0xeb,0x2b,0x2a,0xea,0xee,0x2e,0x2f,0xef,0x2d,0xed,0xec,0x2c,
  775. 0xe4,0x24,0x25,0xe5,0x27,0xe7,0xe6,0x26,0x22,0xe2,0xe3,0x23,0xe1,0x21,0x20,0xe0,

  777. 0xa0,0x60,0x61,0xa1,0x63,0xa3,0xa2,0x62,0x66,0xa6,0xa7,0x67,0xa5,0x65,0x64,0xa4,
  778. 0x6c,0xac,0xad,0x6d,0xaf,0x6f,0x6e,0xae,0xaa,0x6a,0x6b,0xab,0x69,0xa9,0xa8,0x68,
  779. 0x78,0xb8,0xb9,0x79,0xbb,0x7b,0x7a,0xba,0xbe,0x7e,0x7f,0xbf,0x7d,0xbd,0xbc,0x7c,
  780. 0xb4,0x74,0x75,0xb5,0x77,0xb7,0xb6,0x76,0x72,0xb2,0xb3,0x73,0xb1,0x71,0x70,0xb0,
  781. 0x50,0x90,0x91,0x51,0x93,0x53,0x52,0x92,0x96,0x56,0x57,0x97,0x55,0x95,0x94,0x54,
  782. 0x9c,0x5c,0x5d,0x9d,0x5f,0x9f,0x9e,0x5e,0x5a,0x9a,0x9b,0x5b,0x99,0x59,0x58,0x98,
  783. 0x88,0x48,0x49,0x89,0x4b,0x8b,0x8a,0x4a,0x4e,0x8e,0x8f,0x4f,0x8d,0x4d,0x4c,0x8c,
  784. 0x44,0x84,0x85,0x45,0x87,0x47,0x46,0x86,0x82,0x42,0x43,0x83,0x41,0x81,0x80,0x40
  785. };


  788. /****************************************************************************************/
  789. /*----------------------------
  790. ***********************************************/

  792. /*LRC校验子程序
  793. unsigned char LRC(unsigned char *auchMsg, unsigned char usDataLen)
  794. {
  795.         unsigned char uchLRC = 0;
  796.         while (usDataLen--) { uchLRC += *auchMsg++ ; }
  797. //        return ((uint8)(~uchLRC+1));
  798.         return ((unsigned char)(-((char)uchLRC)));
  799. }*/

  801. /*16位CRC校验子程序*/
  802. unsigned int CRC16(unsigned char* puchMsg, unsigned char usDataLen)
  803. {
  804.         unsigned char uchCRCHi=0xff;
  805.         unsigned char uchCRCLo=0xff;
  806.         unsigned char uIndex;
  807.         while(usDataLen--)
  808.         {
  809.                 uIndex=uchCRCHi^*(puchMsg++);
  810.                 uchCRCHi=uchCRCLo^auchCRCHi[uIndex];
  811.                 uchCRCLo=auchCRCLo[uIndex];
  812.         }
  813.         return uchCRCHi<<8|uchCRCLo;
  814. }



  818. //
  819. //void Timer0Init(void)                                //10毫秒@11.0592MHz
  820. //{
  821. //        AUXR &= 0x7F;                                        //定时器时钟12T模式
  822. //        TMOD &= 0xF0;                                        //设置定时器模式
  823. //        //TMOD |= 0x01;                                        //设置定时器模式
  824. //        TL0 = -(FOSC/12/100);                        //设置定时初值
  825. //        TH0 = -(FOSC/12/100) >> 8;                //设置定时初值
  826. //        TF0 = 0;                                                //清除TF0标志
  827. //        TR0 = 1;                                                //定时器0开始计时
  828. //        Timer0_InterruptFirst();
  829. //        ET0 = 1;                                                //enable timer0 interrupt
  830. //}

  832. /********************************************\

  834. /****************************************************************************************/

  836. /****************************************************************************************/

  838. /*

  840. */
  841. unsigned char MODbus_flag=0;//接收到指令标志
  842. unsigned long int MODbus_flag_time=0;
  843. unsigned long int MODbus_flag_Rtime=0;
  844. unsigned int MODbus_flag2=0;


  847. void Modbus_task(void)
  848. {
  849.   

  851.      unsigned int crc1;
  852.         unsigned char  i;



  856.         if(0 == link_recv2_pkt()) //串口2接收到有效命令
  857.         {
  858.            for(i=0;i<16;i++)
  859.            {
  860.            mdbs1_Txbuf[i]=mdbs2_Rxbuf[i];
  861.            
  862.            }
  863.                 mdbs1_Txbuf[0]=PODeviceAddr;        //本机地址改为目标地址

  865.             svr1_msg(mdbs1_Txbuf, mdbs2_data_len-2) ;  //发送更改后的数据                  //svr1_msg只能发送1ci?

  867.                 MODbus_flag=1;
  868.         }

  870.         if(MODbus_flag==1)
  871.         {   
  872.             
  873.             MODbus_flag_time++;
  874.                 if(0==link_recv1_pkt())  //串口2接收应答   进行数据校验  存储   
  875.                 {
  876.         

  878.                   for(i=0;i<16;i++)
  879.                    {
  880.                    mdbs2_Txbuf[i]=mdbs1_Rxbuf[i];
  881.                   
  882.                    }
  883.                         mdbs2_Txbuf[0]=        MyDeviceAddr;        //本机地址改为目标地址
  884.                   
  885.                    svr2_msg(mdbs2_Txbuf, mdbs1_data_len-2) ;  //发送更改后的数据
  886.                   
  887.                    MODbus_flag=0;
  888.                    MODbus_flag_time=0;
  889.                 }
  890.            else if(MODbus_flag_time>50000)
  891.                 {
  892.                   svr1_msg(mdbs1_Txbuf, mdbs2_data_len-2) ;
  893.                 // svr2_msg(mdbs1_Rxbuf, mdbs1_data_len-2) ;  //chongxin发送更改后的数据
  894.                  MODbus_flag_time=0;
  895.                 }

  897.           }
  898.         else
  899.         {         
  900.             MODbus_flag_Rtime++;
  901.            if(MODbus_flag_Rtime%500==0)
  902.         {
  903.                   bitCtrl_485Eable = 1;
  904.                   mod_comd[0]=PODeviceAddr;


  907.                         crc1 = CRC16(mod_comd,7);
  908.                 mod_comd[7]=crc1>>8;
  909.                  mod_comd[8]=crc1;

  911.              link1_send_pkt(mod_comd,9);        
  912.                   MODbus_flag2=1;
  913.                   MODbus_flag_Rtime=0;
  914.             }
  915.                  if(MODbus_flag2==1)
  916.                  {  
  917.                      Delay_nMS(10);
  918.                  bitCtrl_485Eable = 0;
  919.                          delay(20);
  920.                     if(0==link_recv1_pkt())
  921.                         {
  922.                     //  TM_CloseAllDisplay();
  923.                     DisplayTem(mdbs1_Rxbuf[5],mdbs1_Rxbuf[6]) ;//湿度
  924.               DisplayRH(mdbs1_Rxbuf[7],mdbs1_Rxbuf[8]) ;//温度
  925.                         MODbus_flag2=0;
  926.                         MODbus_flag_time=0;
  927.                         }
  928.         

  930.                         else
  931.                         {
  932.                             MODbus_flag_time++;
  933.                                 if(MODbus_flag_time>2000)
  934.                                 {
  935.                                 MODbus_flag_time=0;
  936.                           TM_OpenAllDisplay();
  937.                                 
  938.                           }
  939.                         }
  940.                 }
  941.    }
  942. }


  945. /*****************************************************************************************/
  946. /**根据modbus1接收区的数据指令，赋值modbus的发送区数据***/
  947. /**返回指令长度***/
  948. /*data_num接收区指令的数据长度
  949.   ack_num  发送区的指令长度
  950.   data_start 接收区标识码
  951. /****************************************************************************************/
  952. /*
  953. unsigned int modbus_data(unsigned char *command_buf, unsigned char *ack_buf)
  954. {
  955.         unsigned int data_start;
  956.         unsigned char data_num;
  957.         unsigned char ack_num;
  958.         unsigned char tempdata;                          
  959.         switch(command_buf[1])
  960.         {
  961.                 case READ_INPUT:        //读输入寄存器值读3区
  962.                         ack_buf[0]=command_buf[0];
  963.                         ack_buf[1]=command_buf[1];
  964.                         ack_buf[2]=command_buf[2];
  965.                         ack_buf[3]=command_buf[3];
  966.                         data_start=(command_buf[2]<<8)+command_buf[3];        //标识码
  967.                         //data_num=(command_buf[4]<<8)+command_buf[5];
  968.                         data_num = command_buf[4];                                                 //数据长度
  969.                         if(data_num>2) data_num=2;        //防止数据超界  //接收的指令数据长度要么是0要么是2
  970.                         //ack_buf[2]=data_num*2;
  971.                         ack_num=5;                                                                                 //应答信号从ack_buf【5】数据开始，        ack_buf【4】中要存放数据长度
  972.                         if(Addr_RH_Start == data_start)
  973.                         {
  974.                                 ack_buf[ack_num]=Sensor_Data[0];         ack_num++;
  975.                                 ack_buf[ack_num]=Sensor_Data[1];        ack_num++;         //7？？？
  976.                                 ack_buf[4] = 2;                 //应答指令数据长度
  977.                                 if(2 == data_num)
  978.                                 {
  979.                                         ack_buf[ack_num]=Sensor_Data[2];         ack_num++;
  980.                                         ack_buf[ack_num]=Sensor_Data[3];        ack_num++;
  981.                                         ack_buf[4] = 4;         //应答指令数据长度
  982.                                 }
  983.                                 
  984.                         }
  985.                         if(Addr_Temp_Start == data_start)
  986.                         {
  987.                                 ack_buf[ack_num]=Sensor_Data[2];         ack_num++;
  988.                                 ack_buf[ack_num]=Sensor_Data[3];        ack_num++;
  989.                                 ack_buf[4] = 2;
  990.                         }
  991.                         //modify by cjt 2016-07-08
  992.                         if(Addr_RHSet_Start == data_start)
  993.                         {
  994.                                 ack_buf[ack_num]=0;                         ack_num++;
  995.                                 ack_buf[ack_num]=u8DefaultRH;        ack_num++;
  996.                                 ack_buf[4] = 2;
  997.                         }
  998.                         if(Addr_TempSet_Start == data_start)
  999.                         {
  1000.                                 ack_buf[ack_num]=0;                         ack_num++;
  1001.                                 ack_buf[ack_num]=u8DefaultTemp;        ack_num++;
  1002.                                 ack_buf[4] = 2;
  1003.                         }
  1004.                         if(Addr_RDTemp_Start == data_start)
  1005.                         {
  1006.                                 ack_buf[ack_num]=0;                         ack_num++;
  1007.                                 ack_buf[ack_num]=u8ds18b20_temp;        ack_num++;
  1008.                                 ack_buf[4] = 2;
  1009. ……………………

  1011. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
RS-485.rar (7.05 KB, 下载次数: 621)


评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏15 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:279575 发表于 2018-9-18 15:53 | 只看该作者
请放一个完整的代码, 不然看的太累了
回复

使用道具 举报

板凳
ID:343707 发表于 2019-5-20 16:15 | 只看该作者
不错的东西，下来试试
回复

使用道具 举报

地板
ID:466896 发表于 2019-5-20 17:42 来自手机 | 只看该作者
⊙⊙！牛逼啊
回复

使用道具 举报

5#
ID:90212 发表于 2019-6-5 22:29 | 只看该作者
调用方法也得简单写一个啊，这样得完全消化才行
回复

使用道具 举报

6#
ID:43342 发表于 2019-6-6 20:36 | 只看该作者
谢谢楼主，牛人！
回复

使用道具 举报

7#
ID:442681 发表于 2019-6-28 08:04 | 只看该作者
楼主 自己调试过吗
回复

使用道具 举报

8#
ID:49198 发表于 2019-7-17 17:14 | 只看该作者
感谢楼主分享，正好用的到，谢谢
回复

使用道具 举报

9#
ID:57896 发表于 2019-7-18 18:26 | 只看该作者
这个程序看不懂，有没有完整的工程
回复

使用道具 举报

10#
ID:607998 发表于 2019-9-24 22:54 来自手机 | 只看该作者
谢谢，学习学习
回复

使用道具 举报

11#
ID:340655 发表于 2019-10-11 14:07 | 只看该作者
确实很棒
回复

使用道具 举报

12#
ID:340655 发表于 2019-10-11 14:08 | 只看该作者
牛人，这代码确实很棒
回复

使用道具 举报

13#
ID:59423 发表于 2019-10-11 18:04 | 只看该作者
代码写的太流畅了，逻辑清晰。
回复

使用道具 举报

14#
ID:59423 发表于 2019-10-12 08:51 | 只看该作者
已经下载，正在研读，准备用在项目上。
回复

使用道具 举报

15#
ID:631173 发表于 2019-10-28 13:59 | 只看该作者
这个帖子不错！
回复

使用道具 举报

16#
ID:653902 发表于 2019-12-15 20:09 | 只看该作者
正好在用15的片子，拿来学习一下。感谢楼主的代码。
回复

使用道具 举报

17#
ID:703942 发表于 2020-3-7 11:10 | 只看该作者
感谢楼主的分享，想学一下485通信有时间研究一下。
回复

使用道具 举报

18#
ID:459415 发表于 2020-3-11 19:13 | 只看该作者
不错的东西，下来试试
回复

使用道具 举报

19#
ID:739137 发表于 2020-5-19 18:31 | 只看该作者
谢谢分享！！！
回复

使用道具 举报

20#
ID:187802 发表于 2020-5-20 10:33 | 只看该作者

谢谢分享
回复

使用道具 举报

21#
ID:174969 发表于 2020-8-8 06:00 | 只看该作者
正需要，下载来看看，谢谢楼主！
回复

使用道具 举报

22#
ID:564550 发表于 2020-11-18 23:56 | 只看该作者
程序都不全，没什么参考价值
回复

使用道具 举报

23#
ID:165291 发表于 2020-11-23 09:28 | 只看该作者
支持一个，不知道好用不！
回复

使用道具 举报

24#
ID:255482 发表于 2020-12-20 16:00 | 只看该作者
能多机通讯吗？
回复

使用道具 举报

25#
ID:879060 发表于 2021-1-20 08:32 | 只看该作者
这个是标准的MODBUS RTU吗？可以和PLC通信吗？PLC地址如何设置呢？
回复

使用道具 举报

26#
ID:390416 发表于 2021-1-20 10:39 | 只看该作者
标题错误，485只是一个硬件。具体什么协议，最好说清楚。我用485芯片做过的协议，最少20多种了
回复

使用道具 举报

27#
ID:911776 发表于 2021-7-5 09:43 | 只看该作者
人人学会单片机 发表于 2021-1-20 10:39
标题错误，485只是一个硬件。具体什么协议，最好说清楚。我用485芯片做过的协议，最少20多种了

20多种协议？？？定制的？还是都是通用标准的哦
回复

使用道具 举报

28#
ID:911371 发表于 2021-7-29 14:20 | 只看该作者
真需要  研究一下
回复

使用道具 举报

29#
ID:886238 发表于 2021-8-21 13:27 | 只看该作者
学习中，感谢贡献
回复

使用道具 举报

30#
ID:99525 发表于 2022-5-25 15:34 | 只看该作者
看代码好像是modbus协议，接收和校验了modbus指令，没进行指令解析。
回复

使用道具 举报

31#
ID:334781 发表于 2022-8-22 10:59 | 只看该作者
感谢楼主的分享，想学一下485通信有时间研究一下,只是如果有一点程序方面的说明就更好了。
回复

使用道具 举报

32#
ID:284226 发表于 2023-9-9 12:35 | 只看该作者
好东西必回贴
回复

使用道具 举报

33#
ID:1093459 发表于 2023-9-13 18:58 | 只看该作者
好东西 一定要看看 研究一下
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表