找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 1954|回复: 1
打印 上一主题 下一主题
收起左侧

51单片机采样频率可调的幅值采集,显示,传输

[复制链接]
跳转到指定楼层
楼主
ID:367626 发表于 2018-7-9 09:04 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
  1.                                                  #include <reg52.h>
  2. #include <intrins.h>

  3. bit flag =1;                                        //采样刷新标志位
  4. sbit SCL = P2^1;                                //I2C时钟
  5. sbit SDA = P2^0;                                //I2C数据
  6. sbit du=P2^6;                                        //数码管段选
  7. sbit we=P2^7;                                        //数码管位选
  8. sbit RST=P2^4;                                        //DS1302时钟使能端
  9. sbit in1=P3^4;                                        //键盘行扫描检测
  10. sbit in2=P3^5;
  11. sbit in3=P3^6;
  12. sbit in4=P3^7;
  13. sbit bibi=P2^3;
  14. unsigned int code table[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};        //数码管显示译码
  15. unsigned int buffer[3]={0x00,0x00,0x00};                        //电压显示缓存
  16. unsigned char Ratebuffer[6];                                                //采样周期送串口缓存
  17. unsigned int ConfigBuffer[4];                                                //采样周期数码管显示缓存
  18. unsigned char sending;                                                                //串口发送一字节数据发送完成标志位
  19. unsigned int Timerflag=1000;                                                //采样周期全局变量
  20. unsigned int TimerflagBuffer;                                                //采样周期缓存,用于判断采样周期是否发生变化,若是则送24C02储存
  21. unsigned char TimerT0[4];                                                        //存储按键设置的采样周期各位数
  22. unsigned char num1;                                                                        //将采样周期分解为两个8位数据,送24C02存储
  23. unsigned char num2;
  24. unsigned int te;
  25. unsigned int tr;
  26. unsigned int valu;


  27. void Delay();                                                                //用于I2C总线延迟
  28. void delay1(unsigned char a);                                //用于数码管显示延迟以及24C02存储延迟
  29. void Start();                                                                //I2C总线开始信号
  30. void Stop();                                                                //I2C总线结束信号
  31. bit Write(unsigned char dat);                                //向I2C总线写一字节数据,并返回应答信号
  32. unsigned char ReadNAK();                                        //从I2C总线读一字节数据
  33. unsigned char ReadACK();                                        //从I2C总线读多字节数据
  34. void Timer();                                                                //1ms定时,用于采样周期
  35. unsigned char ADC(unsigned char ch);                //从ADC读一字节数据
  36. void display(unsigned int t0,unsigned int t1,unsigned int t2);        //数码管显示电压值
  37. void display2(unsigned int t0,unsigned int t1,unsigned int t2,unsigned int t3);        //数码管显示采样周期
  38. void transfer(unsigned char *str,unsigned int val);                //将电压值转换为ASCII码,用于串口发送
  39. void UART();                                                                                        //设置串行通信
  40. void Config();                                                                                        //设置外部中断1
  41. unsigned char E2Read(unsigned char addr);                                //从24C02读取最后一次设置的采样周期,用于程序初始化
  42. void E2Write(unsigned char addr,unsigned char dat);                //向24C02写入变化后的采样周期


  43. void main()
  44. {
  45.         unsigned int val;
  46.         unsigned char str[10];
  47.         unsigned char i;
  48.        
  49.        
  50.         RST=0;                                                                //DS1302芯片占用I2C总线,应先关闭使能
  51.         num1=E2Read(0);
  52.         num2=E2Read(1);
  53.         Timerflag=num2*256+num1;
  54.         TimerflagBuffer=Timerflag;
  55.         Config();
  56.         Timer();
  57.         UART();
  58.        
  59.         while(1)
  60.         {
  61.                 if(in1==0)                                                //若按键1按下,则进入外部中断1
  62.                 P3=0xf7;
  63.                 if(flag==1)
  64.                 {
  65.                         flag=0;
  66.                         val=ADC(2);
  67.                         val=196*val/100;                        //转换ADC读出的原始数据,避免小数运算
  68.                        
  69.                         valu=val;
  70.                         buffer[0]=table[val%10];
  71.                         buffer[1]=table[val/10%10];
  72.                         buffer[2]=table[val/100%10]+0x80;
  73.                        
  74.                         Ratebuffer[0]=',';                        //将采样周期转ASCII码,用于串口发送
  75.                         Ratebuffer[1]=Timerflag/1000%10+'0';
  76.                         Ratebuffer[2]=Timerflag/100%10+'0';
  77.                         Ratebuffer[3]=Timerflag/10%10+'0';
  78.                         Ratebuffer[4]=Timerflag%10+'0';
  79.                         Ratebuffer[5]=',';
  80.                        
  81.                         transfer(str,val);
  82.                        
  83.                         for(i=0;i<5;i++)
  84.                         {
  85.                                 SBUF=str[i];
  86.                                 sending=1;
  87.                                 while(sending);
  88.                         }
  89.                         for(i=0;i<6;i++)
  90.                         {
  91.                                 SBUF=Ratebuffer[i];
  92.                                 sending=1;
  93.                                 while(sending);
  94.                         }
  95.                        
  96.                 }
  97.                 display(buffer[0],buffer[1],buffer[2]);
  98.                
  99.                 if(valu>400)
  100.                 {
  101.                         if(te<200)bibi=0;
  102.                         else bibi=1;
  103.                 }
  104.                 if(valu<150)
  105.                 {
  106.                         if(tr<800)bibi=0;
  107.                         else bibi=1;
  108.                 }
  109.                 if(valu>150&&valu<400)
  110.                 {
  111.                         te=0;
  112.                         tr=0;
  113.                         bibi=1;
  114.                 }
  115.                 if(TimerflagBuffer!=Timerflag)                //检测采样周期变化,并存储到掉电不丢失模块
  116.                 {
  117.                         num2=Timerflag/256;
  118.                         num1=Timerflag%256;
  119.                         E2Write(0,num1);
  120.                         E2Write(1,num2);
  121.                         TimerflagBuffer=Timerflag;
  122.                 }
  123.         }
  124. }

  125. void Delay()
  126. {
  127.         _nop_();_nop_();_nop_();_nop_();
  128. }

  129. void delay1(unsigned char a)
  130. {
  131.          unsigned char j,k;
  132.          for(j=a;j>0;j--)
  133.          for(k=125;k>0;k--);
  134. }

  135. void Start()
  136. {
  137.         SDA=1;
  138.         SCL=1;
  139.         Delay();
  140.         SDA=0;
  141.         Delay();
  142.         SCL=0;

  143. }

  144. void Stop()
  145. {
  146.         SCL=0;
  147.         SDA=0;
  148.         Delay();
  149.         SCL=1;
  150.         Delay();
  151.         SDA=1;
  152.         Delay();
  153. }

  154. bit Write(unsigned char dat)
  155. {
  156.         bit ack;
  157.         unsigned char mask;
  158.         for(mask=0x80;mask!=0;mask>>=1)
  159.         {
  160.                 if((mask&dat)==0)
  161.                 {
  162.                         SDA=0;
  163.                 }
  164.                 else
  165.                 {
  166.                         SDA=1;
  167.                 }
  168.                 Delay();
  169.                 SCL=1;
  170.                 Delay();
  171.                 SCL=0;
  172.         }
  173.        
  174.         SDA=1;
  175.         Delay();
  176.         SCL=1;
  177.         ack=SDA;
  178.         Delay();
  179.         SCL=0;
  180.         return(ack);
  181. }

  182. unsigned char ReadNAK()
  183. {
  184.         unsigned char mask;
  185.         unsigned char dat;
  186.         SDA=1;
  187.         for(mask=0x80;mask!=0;mask>>=1)
  188.         {
  189.                 Delay();
  190.                 SCL=1;
  191.                 if(SDA==0)
  192.                 {
  193.                         dat&= ~mask;
  194.                 }
  195.                 else
  196.                 {
  197.                         dat|=mask;
  198.                 }
  199.                 Delay();
  200.                 SCL=0;
  201.         }
  202.         SDA=1;
  203.         Delay();
  204.         SCL=1;
  205.         Delay();
  206.         SCL=0;
  207.         return dat;
  208. }

  209. unsigned char ReadACK()
  210. {
  211.         unsigned char mask;
  212.         unsigned char dat;
  213.         SDA=1;
  214.         for(mask=0x80;mask!=0;mask>>=1)
  215.         {
  216.                 Delay();
  217.                 SCL=1;
  218.                 if(SDA==0)
  219.                 {
  220.                         dat&=~mask;
  221.                 }
  222.                 else
  223.                 {
  224.                         dat|=mask;
  225.                 }
  226.                 Delay();
  227.                 SCL=0;
  228.         }
  229.         SDA=0;
  230.         Delay();
  231.         SCL=1;
  232.         Delay();
  233.         SCL=0;
  234.         return(dat);
  235. }

  236. void Timer()
  237. {
  238.         TMOD=0x01;
  239.         TH0=0xfc;
  240.         TL0=0x66;
  241.         ET0=1;
  242.         EA=1;
  243.         TR0=1;
  244. }

  245. unsigned char ADC(unsigned char ch)
  246. {
  247.         unsigned char val;
  248.         EA=0;
  249.         Start();
  250.         if(Write(0x48<<1))
  251.         {
  252.                 Stop();
  253.                 return 0;
  254.         }
  255.         Write(0x40|ch);
  256.         Start();
  257.         Write((0x48<<1)|0x01);
  258.         val=ReadACK();
  259.         val=ReadNAK();
  260.         Stop();
  261.         EA=1;
  262.         return val;
  263. }

  264. void display(unsigned int t0,unsigned int t1,unsigned int t2)
  265. {
  266.          P0=t0;du=1;du=0;P0=0xdf;we=1;we=0;delay1(5);
  267.          P0=t1;du=1;du=0;P0=0xef;we=1;we=0;delay1(5);
  268.          P0=t2;du=1;du=0;P0=0xf7;we=1;we=0;delay1(5);
  269. }

  270. void display2(unsigned int t0,unsigned int t1,unsigned int t2,unsigned int t3)
  271. {
  272.          P0=t0;du=1;du=0;P0=0xdf;we=1;we=0;delay1(5);
  273.          P0=t1;du=1;du=0;P0=0xef;we=1;we=0;delay1(5);
  274.          P0=t2;du=1;du=0;P0=0xf7;we=1;we=0;delay1(5);
  275.          P0=t3;du=1;du=0;P0=0xfb;we=1;we=0;delay1(5);
  276. }

  277. void transfer(unsigned char *str,unsigned int val)
  278. {
  279.         str[0]=(val/100%10)+'0';
  280.         str[1]='.';
  281.         str[2]=(val/10%10)+'0';
  282.         str[3]=(val%10)+'0';
  283.         str[4]='V';
  284. }

  285. void UART()
  286. {
  287.         EA=0;
  288.         SCON=0x50;
  289.         PCON=0x00;
  290.         TMOD|=0x20;
  291.         TH1=0xfd;
  292.         TL1=0xfd;
  293.         REN=1;
  294.         ES=1;
  295.         TR1=1;
  296.         EA=1;
  297. }

  298. void Config()
  299. {
  300.         EA=0;
  301.         TCON|=0x04;
  302.         P3=0xff;
  303.         EX1=1;
  304.         EA=1;
  305.        
  306. }

  307. unsigned char E2Read(unsigned char addr)
  308. {
  309.         unsigned char dat;
  310.        
  311.         Start();
  312.         Write(0xa0);
  313.         Write(addr);
  314.         Start();
  315.         Write(0xa1);
  316.         dat=ReadNAK();
  317.         Stop();
  318.         delay1(100);
  319.         return dat;
  320. }

  321. void E2Write(unsigned char addr,unsigned char dat)
  322. {
  323.         Start();
  324.         Write(0xa0);
  325.         Write(addr);
  326.         Write(dat);
  327.         Stop();
  328.         delay1(5000);
  329. }

  330. void interruptT0() interrupt 1                        //定时器T0中断,通过标志位完成设置的采样周期计时
  331. {
  332.         static unsigned long t = 0;
  333.         TH0=0xfc;
  334.         TL0=0x66;
  335.         t++;
  336.         if(valu>400)
  337.         {
  338.                 te++;
  339.                 if(te>400)
  340.                 te=1;
  341.         }
  342.         if(valu<400&&valu>150)
  343.         {
  344.                 te=0;tr=0;bibi=1;
  345.         }
  346.         if(valu<150)
  347.         {
  348.                 tr++;
  349.                 if(tr>1600)
  350.                 tr=1;
  351.         }
  352.         if(t>=Timerflag)
  353.         {
  354.                 t=0;
  355.                 flag=1;
  356.         }
  357. }

  358. void interruptS() interrupt 4
  359. {
  360.         unsigned long temp;
  361.         static signed char n=3;
  362.         static unsigned char t[4];                        //串口接收到的采样周期缓存
  363.         if(RI==1)
  364.         {
  365.                 EA=0;
  366.                 RI=0;
  367.                 temp=SBUF;
  368.                 if(n>=0)
  369.                 {
  370.                         t[n]=temp-'0';                                //将接收到的ASCII码转换为10进制存储
  371.                         n--;
  372.                 }
  373.                 if(n<0)                                                        //接收到四位数后更新采样周期
  374.                 {
  375.                         n=3;
  376.                         Timerflag=t[3]*1000+t[2]*100+t[1]*10+t[0];
  377.                        
  378.                 }
  379.                 EA=1;
  380.                
  381.         }
  382.         else
  383.         {
  384.                 TI=0;
  385.                 sending=0;
  386.         }
  387. }

  388. void interruptEX0() interrupt 2                        //外部中断1,完成按键操作,进入中断后立即显示当前的采样周期
  389. {
  390.         signed char i;
  391.         bit backup;                                                        //按键备份,用于去抖
  392.         REN=0;
  393.         EA=0;
  394.         ConfigBuffer[0]=table[Timerflag%10];
  395.         ConfigBuffer[1]=table[Timerflag/10%10];
  396.         ConfigBuffer[2]=table[Timerflag/100%10];
  397.         ConfigBuffer[3]=table[Timerflag/1000%10];
  398.         while(1)
  399.         {
  400.                 display2(ConfigBuffer[0],ConfigBuffer[1],ConfigBuffer[2],ConfigBuffer[3]);
  401.                 if(in2==0)                                                //按键2按下则退出中断服务程序
  402.                 {
  403.                         P3=0xff;
  404.                         EA=1;
  405.                         break;
  406.                 }
  407.                 if(in3==0)                                                //按键3按下则开始设置采样周期,并在数码管显示
  408.                 {
  409.                         while(in3!=1);                                //检测按键跳变
  410.                         ConfigBuffer[0]=0x00;ConfigBuffer[1]=0x00;ConfigBuffer[2]=0x00;ConfigBuffer[3]=0x00;
  411.                         while(1)
  412.                         {
  413.                                
  414.                                 for(i=3;i>=0;i--)                //键盘矩阵扫描,读取4位采样周期
  415.                                 {
  416.                                         while(1)
  417.                                         {
  418.                                         display2(ConfigBuffer[0],ConfigBuffer[1],ConfigBuffer[2],ConfigBuffer[3]);
  419.                                         P3=0xfe;
  420.                                            if(in1==0)
  421.                                            {
  422.                                                    backup=in1;                //按键去抖
  423.                                                    delay1(20);
  424.                                                    if(backup!=in1)continue;
  425.                                                    while(in1!=1);        //检测跳变为一次有效按键
  426.                                                    ConfigBuffer[i]=table[0];TimerT0[i]=0;break;
  427.                                            }
  428.                                         if(in2==0)
  429.                                         {
  430.                                                 backup=in2;
  431.                                                    delay1(20);
  432.                                                    if(backup!=in2)continue;
  433.                                                 while(in2!=1);
  434.                                                 ConfigBuffer[i]=table[1];TimerT0[i]=1;break;
  435.                                         }
  436.                                         if(in3==0)
  437.                                         {
  438.                                                 backup=in3;
  439.                                                    delay1(20);
  440.                                                    if(backup!=in3)continue;
  441.                                                 while(in3!=1);
  442.                                                 ConfigBuffer[i]=table[2];TimerT0[i]=2;break;
  443.                                         }
  444.                                         if(in4==0)
  445.                                         {
  446.                                                 backup=in4;
  447.                                                    delay1(20);
  448.                                                    if(backup!=in4)continue;
  449.                                                 while(in4!=1);
  450.                                                 ConfigBuffer[i]=table[3];TimerT0[i]=3;break;
  451.                                         }
  452.                                         P3=0xfd;
  453.                                         if(in1==0)
  454.                                         {
  455.                                                 backup=in1;
  456.                                                    delay1(20);
  457.                                                    if(backup!=in1)continue;
  458.                                                 while(in1!=1);
  459.                                                 ConfigBuffer[i]=table[4];TimerT0[i]=4;break;
  460.                                         }
  461.                                         if(in2==0)
  462.                                         {
  463.                                                 backup=in2;
  464.                                                    delay1(20);
  465.                                                    if(backup!=in2)continue;
  466.                                                 while(in2!=1);
  467.                                                 ConfigBuffer[i]=table[5];TimerT0[i]=5;break;
  468.                                         }
  469.                                         if(in3==0)
  470.                                         {
  471.                                                 backup=in3;
  472.                                                    delay1(20);
  473.                                                    if(backup!=in3)continue;
  474.                                                 while(in3!=1);
  475.                                                 ConfigBuffer[i]=table[6];TimerT0[i]=6;break;
  476.                                         }
  477.                                         if(in4==0)
  478.                                         {
  479.                                                 backup=in4;
  480.                                                    delay1(20);
  481.                                                    if(backup!=in4)continue;
  482.                                                 while(in4!=1);
  483.                                                 ConfigBuffer[i]=table[7];TimerT0[i]=7;break;
  484.                                         }
  485.                                         P3=0xfb;
  486.                                         if(in1==0)
  487.                                         {
  488.                                                 backup=in1;
  489.                                                    delay1(20);
  490.                                                    if(backup!=in1)continue;
  491.                                                 while(in1!=1);
  492.                                                 ConfigBuffer[i]=table[8];TimerT0[i]=8;break;
  493.                                         }
  494.                                         if(in2==0)
  495.                                         {
  496.                                                 backup=in2;
  497.                                                    delay1(20);
  498.                                                    if(backup!=in2)continue;
  499.                                                 while(in2!=1);
  500.                                                 ConfigBuffer[i]=table[9];TimerT0[i]=9;break;
  501.                                         }
  502.                                         }
  503.                                 }
  504.                                 Timerflag=TimerT0[3]*1000+TimerT0[2]*100+TimerT0[1]*10+TimerT0[0];
  505.                                
  506.                                 P3=0xff;
  507.                                 EA=1;
  508.                                 break;
  509.                         }
  510.                
  511.                 }
  512.         }
  513.         REN=1;
  514. }
复制代码


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

使用道具 举报

沙发
ID:1 发表于 2018-7-10 03:48 | 只看该作者
能分享下原理图吗?
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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