欧美极品高清xxxxhd,国产日产欧美最新,无码AV国产东京热AV无码,国产精品人与动性XXX,国产传媒亚洲综合一区二区,四库影院永久国产精品,毛片免费免费高清视频,福利所导航夜趣136

 找回密碼
 立即注冊

QQ登錄

只需一步，快速開始

搜索
查看: 19935|回復: 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空間 騰訊微博騰訊微博 騰訊朋友騰訊朋友
收藏收藏16 分享淘帖 頂頂 踩踩
回復

使用道具 舉報

無效樓層，該帖已經被刪除
板凳
ID:279575 發表于 2018-9-18 15:53 | 只看該作者
請放一個完整的代碼, 不然看的太累了
回復

使用道具 舉報

地板
ID:343707 發表于 2019-5-20 16:15 | 只看該作者
不錯的東西，下來試試
回復

使用道具 舉報

5#
ID:466896 發表于 2019-5-20 17:42 來自觸屏版 | 只看該作者
⊙⊙！牛逼啊
回復

使用道具 舉報

6#
ID:90212 發表于 2019-6-5 22:29 | 只看該作者
調用方法也得簡單寫一個啊，這樣得完全消化才行
回復

使用道具 舉報

7#
ID:43342 發表于 2019-6-6 20:36 | 只看該作者
謝謝樓主，牛人！
回復

使用道具 舉報

8#
ID:442681 發表于 2019-6-28 08:04 | 只看該作者
樓主 自己調試過嗎
回復

使用道具 舉報

9#
ID:49198 發表于 2019-7-17 17:14 | 只看該作者
感謝樓主分享，正好用的到，謝謝
回復

使用道具 舉報

10#
ID:57896 發表于 2019-7-18 18:26 | 只看該作者
這個程序看不懂，有沒有完整的工程
回復

使用道具 舉報

11#
ID:607998 發表于 2019-9-24 22:54 來自觸屏版 | 只看該作者
謝謝，學習學習
回復

使用道具 舉報

12#
ID:340655 發表于 2019-10-11 14:07 | 只看該作者
確實很棒
回復

使用道具 舉報

13#
ID:340655 發表于 2019-10-11 14:08 | 只看該作者
牛人，這代碼確實很棒
回復

使用道具 舉報

14#
ID:59423 發表于 2019-10-11 18:04 | 只看該作者
代碼寫的太流暢了，邏輯清晰。
回復

使用道具 舉報

15#
ID:59423 發表于 2019-10-12 08:51 | 只看該作者
已經下載，正在研讀，準備用在項目上。
回復

使用道具 舉報

16#
ID:631173 發表于 2019-10-28 13:59 | 只看該作者
這個帖子不錯！
回復

使用道具 舉報

17#
ID:653902 發表于 2019-12-15 20:09 | 只看該作者
正好在用15的片子，拿來學習一下。感謝樓主的代碼。
回復

使用道具 舉報

18#
ID:703942 發表于 2020-3-7 11:10 | 只看該作者
感謝樓主的分享，想學一下485通信有時間研究一下。
回復

使用道具 舉報

19#
ID:459415 發表于 2020-3-11 19:13 | 只看該作者
不錯的東西，下來試試
回復

使用道具 舉報

20#
ID:739137 發表于 2020-5-19 18:31 | 只看該作者
謝謝分享！！！
回復

使用道具 舉報

21#
ID:187802 發表于 2020-5-20 10:33 | 只看該作者

謝謝分享
回復

使用道具 舉報

22#
ID:174969 發表于 2020-8-8 06:00 | 只看該作者
正需要，下載來看看，謝謝樓主！
回復

使用道具 舉報

23#
無效樓層，該帖已經被刪除
24#
ID:564550 發表于 2020-11-18 23:56 | 只看該作者
程序都不全，沒什么參考價值
回復

使用道具 舉報

25#
ID:165291 發表于 2020-11-23 09:28 | 只看該作者
支持一個，不知道好用不！
回復

使用道具 舉報

26#
ID:255482 發表于 2020-12-20 16:00 | 只看該作者
能多機通訊嗎？
回復

使用道具 舉報

27#
無效樓層，該帖已經被刪除
28#
ID:879060 發表于 2021-1-20 08:32 | 只看該作者
這個是標準的MODBUS RTU嗎？可以和PLC通信嗎？PLC地址如何設置呢？
回復

使用道具 舉報

29#
ID:390416 發表于 2021-1-20 10:39 | 只看該作者
標題錯誤，485只是一個硬件。具體什么協議，最好說清楚。我用485芯片做過的協議，最少20多種了
回復

使用道具 舉報

30#
無效樓層，該帖已經被刪除
31#
無效樓層，該帖已經被刪除
32#
無效樓層，該帖已經被刪除
33#
無效樓層，該帖已經被刪除
34#
ID:911776 發表于 2021-7-5 09:43 | 只看該作者
人人學會單片機 發表于 2021-1-20 10:39
標題錯誤，485只是一個硬件。具體什么協議，最好說清楚。我用485芯片做過的協議，最少20多種了

20多種協議？？？定制的？還是都是通用標準的哦
回復

使用道具 舉報

35#
ID:911371 發表于 2021-7-29 14:20 | 只看該作者
真需要  研究一下
回復

使用道具 舉報

36#
無效樓層，該帖已經被刪除
37#
ID:886238 發表于 2021-8-21 13:27 | 只看該作者
學習中，感謝貢獻
回復

使用道具 舉報

38#
ID:99525 發表于 2022-5-25 15:34 | 只看該作者
看代碼好像是modbus協議，接收和校驗了modbus指令，沒進行指令解析。
回復

使用道具 舉報

39#
ID:334781 發表于 2022-8-22 10:59 | 只看該作者
感謝樓主的分享，想學一下485通信有時間研究一下,只是如果有一點程序方面的說明就更好了。
回復

使用道具 舉報

40#
ID:284226 發表于 2023-9-9 12:35 | 只看該作者
好東西必回貼
回復

使用道具 舉報

您需要登錄后才可以回帖 登錄 | 立即注冊

本版積分規則

小黑屋|51黑電子論壇 |51黑電子論壇6群 QQ 管理員QQ:125739409;技術交流QQ群281945664

Powered by 單片機教程網

快速回復 返回頂部 返回列表