标题: 消洗台单片机源程序 RS485和Modbus协议的寄存器读取和单寄存器写入操作 [打印本页]
作者: NH6496    时间: 2017-3-15 16:09
标题: 消洗台单片机源程序 RS485和Modbus协议的寄存器读取和单寄存器写入操作
分享一个消洗台的单片机程序源码：

完整源码下载：
modbus通讯.zip (74.71 KB, 下载次数: 64)



部分源码预览：
  1. /*
  2. *******************************************************************************
  3. *   
  4. *
  5. * 文件名：main.c
  6. * 描  述：RS485的Modbus
  7. *
  8. * 备  注：
  9. *         支持Modbus协议的寄存器读取和单寄存器写入操作
  10. *******************************************************************************
  11. */

  13. #include <reg52.h>
  14. #include "i2c.h"
  15. #define KEY P1
  16. typedef unsigned int uint;         
  17. typedef unsigned char u8;
  18. unsigned char addr;
  19. unsigned char dat;

  21. int s=0,m=1,sa=0,ma=2,num;
  22. sbit LSA=P2^2;
  23. sbit LSB=P2^3;
  24. sbit LSC=P2^4;
  25. sbit OUTa=P2^5;
  26. sbit OUT=P2^6;
  27. sbit LE=P2^7;
  28.     uint a[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};//0到9
  29.     uint sg,ss,mg,ms,sga,ssa,mga,msa,K=0;
  30. sbit BUZZ = P1^5;
  31. bit flagBuzzOn = 0;   
  32. unsigned char KH,KL;
  33. unsigned char T0RH = 0;  
  34. unsigned char T0RL = 0;  
  35. unsigned char regGroup[5];  
  36. unsigned char MODADD=0X01;
  37. void ConfigTimer0(unsigned int ms);
  38. extern void UartDriver();
  39. extern void ConfigUART(unsigned int baud);
  40. extern void UartRxMonitor(unsigned char ms);
  41. extern void UartWrite(unsigned char *buf, unsigned char len);
  42. extern unsigned int GetCRC16(unsigned char *ptr,  unsigned char len);
  43. extern void zhu();
  44. extern        void DigDisplay();
  45. extern        void Timer1Init();
  46. extern        void delay(uint i);
  47. extern  int Keypros();
  48. extern        void At24c02Write(unsigned char addr,unsigned char dat)        ;
  49. extern        unsigned char At24c02Read(unsigned char addr);
  50. void main()
  51. {
  52.     unsigned char x=~OUT,y=~OUTa;
  53.        m=At24c02Read(1);         
  54.          
  55.            delay(1000);
  56.            ma=At24c02Read(2);
  57.            
  58.          while (1)
  59.      {
  60.            while((OUT&OUTa)==1)        
  61.           {  
  62.            
  63.                     EA = 1;            
  64.                     ConfigTimer0(1);   
  65.                     ConfigUART(9600);  
  66.          while ((KEY&0x0f)!=0x01)
  67.          {
  68.                   DigDisplay();
  69.           UartDriver();  
  70.          
  71.                   Keypros();
  72.                           if((KEY&0x0f)==0x01)
  73.                           {
  74.                          delay(3000);
  75.                             if((KEY&0x0f)==0x01)
  76.                          OUT=0;
  77.                      return;
  78.                         }
  79.                  }
  80.         
  81.                   
  82.          }
  83.            if((m||ma)!=0)
  84.            {
  85.             
  86.                   
  87.               
  88.                   zhu();
  89.                      KL=At24c02Read(4);
  90.                   delay(1000);
  91.                   
  92.                   KH=At24c02Read(3);
  93.                   delay(1000);
  94.                   K=(KH<<8)+KL;
  95.                   DigDisplay();
  96.                   K++;                        
  97.                      KH=K>>8;
  98.                   KL=K&0X00FF;
  99.                   At24c02Write(4,KL);  
  100.                      delay(1000);
  101.                   while(K==100){DigDisplay();}
  102.                   At24c02Write(3,KH);
  103.                      delay(1000);
  104.                      
  105.             }
  106.      }        
  107.          
  108.         }

  110.    


  113. void UartAction(unsigned char *buf, unsigned char len)
  114. {

  116.     unsigned char i;
  117.     unsigned char cnt;
  118.    
  119.     unsigned int  crc;
  120.     unsigned char crch, crcl;
  121.     MODADD=At24c02Read(0);
  122.     if (buf[0] !=MODADD ) //本机地址设定为0x01，
  123.     {                  
  124.         return;         
  125.     }
  126.    
  127.     crc = GetCRC16(buf, len-2);
  128.     crch = crc >> 8;
  129.     crcl = crc & 0xFF;
  130.     if ((buf[len-2]!=crch) || (buf[len-1]!=crcl))
  131.     {
  132.         return;  
  133.     }
  134.    
  135.     switch (buf[1])
  136.     {
  137.         case 0x03:  
  138.             if ((buf[2]==0x00) && (buf[3]<=0x05))
  139.             {
  140.                 if (buf[3] <= 0x04)
  141.                 {
  142.                                         regGroup[0]=At24c02Read(0);
  143.                                         regGroup[1]=At24c02Read(1);
  144.                     regGroup[2]=At24c02Read(2);
  145.                                         regGroup[3]=At24c02Read(3);
  146.                                         regGroup[4]=At24c02Read(4);
  147.                                         i = buf[3];      
  148.                     cnt = buf[5];   
  149.                     buf[2] = cnt*2;  
  150.                     len = 3;         
  151.                     while (cnt--)
  152.                     {
  153.                         buf[len++] = 0x00;         
  154.                         buf[len++] = regGroup[i++];
  155.                   
  156.                                     }
  157.                 }
  158.                 else  
  159.                 {
  160.                     buf[2] = 2;  
  161.                     buf[3] = 0x00;
  162.                     buf[4] = flagBuzzOn;
  163.                     len = 5;
  164.                 }
  165.                 break;
  166.             }
  167.             else  
  168.             {
  169.                 buf[1] = 0x83;
  170.                 buf[2] = 0x02;  
  171.                 len = 3;
  172.                 break;
  173.             }
  174.             
  175.         case 0x06:  
  176.             if ((buf[2]==0x00) && (buf[3]<=0x05))
  177.             {
  178.                 if (buf[3] <= 0x04)
  179.                 {
  180.                   switch(buf[3])
  181.                                    {
  182.                                    case 0:
  183.                                     i = buf[3];            
  184.                     regGroup[i] = buf[5];   
  185.                     MODADD = regGroup[i];
  186.                            
  187.                                         At24c02Write(0,MODADD);
  188.                    case 1:
  189.                                     i = buf[3];            
  190.                     regGroup[i] = buf[5];   
  191.                     m = regGroup[i];
  192.                            
  193.                                         At24c02Write(1,m);
  194.                                    case 2:
  195.                                     i = buf[3];            
  196.                     regGroup[i] = buf[5];   
  197.                     ma = regGroup[i];
  198.                            
  199.                                         At24c02Write(2,ma);
  200.                                    }
  201.                 }
  202.                 else  
  203.                 {
  204.                     flagBuzzOn = (bit)buf[5];
  205.                 }
  206.                 len -= 2;
  207.                 break;
  208.             }
  209.             else  
  210.             {
  211.                 buf[1] = 0x86;  
  212.                 buf[2] = 0x02;  
  213.                 len = 3;
  214.                 break;
  215.             }
  216.             
  217.         default:
  218.             buf[1] |= 0x80;  
  219.             buf[2] = 0x01;   
  220.             len = 3;
  221.             break;
  222.     }
  223.     crc = GetCRC16(buf, len);
  224.     buf[len++] = crc >> 8;   
  225.     buf[len++] = crc & 0xFF;  
  226.     UartWrite(buf, len);     
  227. }
  228. /* 配置并启动T0 */
  229. void ConfigTimer0(unsigned int ms)
  230. {
  231.     unsigned long tmp;  
  232.    
  233.     tmp = 11059200 / 12;      
  234.     tmp = (tmp * ms) / 1000;  
  235.     tmp = 65536 - tmp;        
  236.     tmp = tmp + 33;           
  237.     T0RH = (unsigned char)(tmp>>8);  
  238.     T0RL = (unsigned char)tmp;
  239.     TMOD &= 0xF0;   
  240.     TMOD |= 0x01;   
  241.     TH0 = T0RH;     
  242.     TL0 = T0RL;
  243.     ET0 = 1;      
  244.     TR0 = 1;        
  245. }
  246. /* T0中断服务函数，执行串口接收监控和蜂鸣器驱动 */
  247. void InterruptTimer0() interrupt 1
  248. {
  249.     TH0 = T0RH;  
  250.     TL0 = T0RL;
  251.     if (flagBuzzOn)  
  252.         BUZZ = ~BUZZ;
  253.     else
  254.         BUZZ = 1;
  255.     UartRxMonitor(1);  
  256. }
  257. /*******************************************************************************
  258. * 函 数 名         : delay
  259. * 函数功能                   : 延时函数，i=1时，大约延时10us
  260. *******************************************************************************/
  261. void delay(uint i)
  262. {
  263.         while(i--);        
  264. }

  266. /*******************************************************************************
  267. * 函数名         :Keypros()
  268. * 函数功能                 :按键处理函数
  269. * 输入           : 无
  270. * 输出                  : 键值
  271. *******************************************************************************/
  272. int Keypros()
  273. {
  274.         
  275.    if ((OUT&OUTa)!=0)
  276.    {
  277.         if((KEY&0x0f)==0x05)
  278.           {
  279.              m--;
  280.                  delay(30000);
  281.                 if(m<=1)
  282.                  m=1;
  283.           }
  284.          
  285.         if((KEY&0x0f)==0x06)
  286.         
  287.          {
  288.              m++;
  289.                  delay(40000);
  290.                 if(m>30)
  291.                  m=30;
  292.          }
  293.          

  295.         if((KEY&0x0f)==0x08)
  296.         {
  297.            ma--;
  298.          
  299.           delay(40000);
  300.                 if(ma<=1)
  301.                  ma=1;            //现在第1次ma减到0会死机---------------------------------------
  302.          }
  303.   
  304.         if((KEY&0x0f)==0x09)
  305.         {
  306.              ma++ ;
  307.           delay(30000);
  308.                  if(ma>30)
  309.                  ma=30;
  310.                 }
  311.                  if((KEY&0x0f)==0x0a)
  312.           {
  313.                 delay(1000);  
  314.                 if((KEY&0x0f)==0x0a)
  315.                 {        
  316.                         At24c02Write(1,m);   
  317.                     delay(1000);        // 等待写完。
  318.                         At24c02Write(2,ma);   
  319.                 }
  320.         
  321.            }
  322.                 if((KEY&0x0f)==0x0c)
  323.            {
  324.                  delay(1000);  
  325.              if((KEY&0x0f)==0x0c)
  326.                 {
  327.                   num=At24c02Read(1);          //读取EEPROM地址1内的数据保存在num中
  328.                   m=num;
  329.                    delay(1000);
  330.                   num=At24c02Read(2);
  331.                   ma=num;
  332.                 }
  333.           }
  334.      }
  335.          return(m,ma);
  336.   }

  338. /***************************************************
  339. 动态置LEDCOM口低电平
  340. **********************/
  341. void DigDisplay()

  343.   {                          
  344.                 u8 i;
  345.                
  346.                     sg=s%10;
  347.                     ss=s/10;
  348.                     mg=m%10;
  349.                     ms=m/10;
  350.                            sga=sa%10;
  351.                     ssa=sa/10;
  352.                     mga=ma%10;
  353.                     msa=ma/10;
  354.                  for(i=0;i<8;i++)
  355.                  {        
  356.                   switch(i)         
  357.                    {
  358.                         case(0):
  359.                                 LSA=0;LSB=0;LSC=0;   P0=a[sg]; break;//显示第0位
  360.                         case(1):
  361.                                 LSA=1;LSB=0;LSC=0;  P0=a[ss]; break;//显示第1位
  362.                         case(2):
  363.                                 LSA=0;LSB=1;LSC=0;   P0=a[mg]; break;//显示第2位
  364.                         case(3):
  365.                                 LSA=1;LSB=1;LSC=0;   P0=a[ms];break;//显示第3位
  366.                         case(4):
  367.                                 LSA=0;LSB=0;LSC=1;  P0=a[sga]; break;//显示第4位
  368.                         case(5):
  369.                                 LSA=1;LSB=0;LSC=1;  P0=a[ssa];break;//显示第5位
  370.                         case(6):
  371.                                 LSA=0;LSB=1;LSC=1;  P0=a[mga];; break;//显示第6位
  372.                         case(7):
  373.                                 LSA=1;LSB=1;LSC=1;   P0=a[msa]; break;//显示第7位        
  374.                    }
  375.                
  376.                 delay(10); //  增减亮度。      
  377.                 P0=0x00;//消隐
  378.            }
  379. }

  381. /*******************************************************************************
  382. * 函 数 名         : Timer1Init
  383. * 函数功能                   : 定时器1初始化
  384. * 输    入         : 无
  385. * 输    出         : 无
  386. *******************************************************************************/
  387. void Timer1Init()
  388. {        
  389.         TMOD=0X11;
  390.         ET1=1;
  391.         EA=1;
  392.         TR1=1;                        
  393. }
  394. /*******************************************************************************
  395. * 函 数 名         : void Timer1() interrupt 3
  396. * 函数功能                   : 定时器1中断函数
  397. * 输    入         : 无
  398. * 输    出         : 无
  399. *******************************************************************************/
  400. void Timer1() interrupt 3
  401. {
  402.         static uint i;
  403.             TH1=0X3c;        //给定时器赋初值，定时50ms
  404.             TL1=0Xb0;
  405.             i++;
  406.    if((s||m)!=0)
  407.         {
  408.            if(i==20)                  //中断次数
  409.         {
  410.           {
  411.                   i=0;
  412.           s--;
  413.                   }
  414.          if(s<=-1&&(m!=0))
  415.         {
  416.           s=59;
  417.           m--;
  418.                 }
  419.       
  420.               }
  421.       
  422.          
  423.         }
  424.   else
  425.         {
  426.         if((sa||ma)!=0)
  427.         {
  428.           if(i==20)
  429.         {
  430.           {
  431.                   i=0;
  432.           sa--;
  433.                   }
  434.          if(sa<=-1&&(ma!=0))
  435.         {
  436.           sa=59;
  437.           ma--;
  438.                 }
  439.         else{ ma-=0; if(ma<=-1) { ma=0; }}
  440.               }
  441.         else{ sa-=0; if(sa<=-1) { sa=0;  }}
  442.          
  443.                  if((sa||ma)!=0)
  444.            {
  445.                
  446.                     OUTa=0;        OUT=1;
  447.                
  448.                    }
  449.         
  450.              if((sa||ma)==0)  
  451.              {OUTa=1; OUT=1;TR1=0;}
  452.           }
  453.         }         
  454. }


  457. /*******************************************************************************
  458. * 函 数 名       : zhu
  459. * 函数功能               
  460. * 输    入       : 无
  461. * 输    出             : 无
  462. *******************************************************************************/
  463. void zhu()
  464.             
  465. {         while(ma||sa)
  466.         
  467.       {        
  468.            
  469.            if((KEY&0x0f)!=0x01)
  470.             {
  471.                   
  472.                    Keypros();
  473.            DigDisplay();
  474.                  }
  475.                     else
  476.                   {
  477.                   
  478.                    {
  479.                         if((KEY&0x0f)==0x01)
  480.                            delay(1000);
  481.                            if((KEY&0x0f)==0x01)
  482.                      {
  483.                   
  484.                            num=At24c02Read(1);          //读取EEPROM地址1内的数据保存在num中
  485.                            m=num;
  486.                            delay(1000);
  487.                            num=At24c02Read(2);
  488.                            ma=num;
  489.                                    
  490.                         while (sa||ma!=0)        
  491.                            { DigDisplay();
  492.                                    
  493.                              Timer1Init();  
  494.                               }
  495.                           }
  496.                  
  497.                    }           
  498.                 }                                            
  499.            }      
  500.    }
复制代码
作者: pangjineng    时间: 2018-1-21 10:12
陋习，一点注释没有。



欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1