标题: 51单片机频率计(数码管显示) [打印本页]
作者: musi798    时间: 2018-11-19 22:12
标题: 51单片机频率计(数码管显示)
误差不大

单片机源程序如下:

  2. #include "reg51.h"
  3. #include "intrins.h"

  5. #define CKSEL           (*(unsigned char volatile xdata *)0xfe00)
  6. #define CKDIV           (*(unsigned char volatile xdata *)0xfe01)
  7. #define IRC24MCR        (*(unsigned char volatile xdata *)0xfe02)
  8. #define XOSCCR          (*(unsigned char volatile xdata *)0xfe03)
  9. #define IRC32KCR        (*(unsigned char volatile xdata *)0xfe04)
  10. #define M 2000

  12. sfr     ADC_CONTR   =   0xbc;
  13. sfr     ADC_RES     =   0xbd;
  14. sfr     ADC_RESL    =   0xbe;
  15. sfr     ADCCFG      =   0xde;
  16. sfr     P_SW2       =   0xba;
  17. sbit    EADC        =   IE^5;
  18. sfr     AUXR        =   0x8e;
  19. sfr     CMPCR1      =   0xe6;
  20. sfr     CMPCR2      =   0xe7;
  21. sfr     IE2         =   0xaf;
  22. sfr     AUXINTIF    =   0xef;
  23. sfr     T4T3M       =   0xd1;
  24. sfr     TL3         =   0xd5;
  25. sfr     TH3         =   0xd4;
  26. sfr     IPH         =   0xb7;
  27. sfr     P1M0        =   0x92;
  28. sfr     P1M1        =   0x91;

  30. sbit FreIn  = P0^4;

  32. sbit P26 = P2^6;
  33. sbit P27 = P2^7;

  35. sbit CLK = P2^3;
  36. sbit DAT = P2^1;

  38. void display164(unsigned char udata)
  39. {
  40.   char i;
  41.   for(i=0;i<8;i++)
  42.   {
  43.     if(udata&0x80)
  44.     {
  45.       DAT=1;
  46.       CLK=0;
  47.       udata = udata<<1;
  48.       CLK=1;
  49.     }
  50.     else
  51.     {
  52.       DAT=0;
  53.       CLK=0;
  54.       udata = udata<<1;
  55.       CLK=1;
  56.     }
  57.   }
  58. }       

  60. void DiviVol()
  61. {
  62.         P26 = 1;
  63.         P27= 0;
  64. }
  65. void NotDiviVol()
  66. {
  67.         P27 = 1;
  68.         P26 = 0;
  69. }
  70. void delay(int ms)
  71. {
  72.         int a,b;
  73.         for(a=ms;a>0;a--)
  74.                 for(b=120;b>0;b--);
  75. }
  76. unsigned int time = 0;
  77. unsigned int count = 0;
  78. unsigned long frequency = 0,temp=0,tempone = 0;
  79. unsigned char code Table[]={0xee,0x28,0xcd,0x6d,0x2b,0x67,0xe7,0x2c,0xef,0x6f};
  80. unsigned char code PotTable[]={0xfe,0x38,0xdd,0x7d,0x3b,0x77,0xf7,0x3c,0xff,0x7f};

  82. unsigned int H=0,L=0;
  83. unsigned char tempp[7]={0};
  84. unsigned int Vol = 0,RawVol = 0;

  86. bit flag = 0;
  87. unsigned int qf = 0;
  88. void SetOutXtal()
  89. {
  90.         P_SW2 = 0x80;
  91.   XOSCCR = 0xc0;                              //启动外部晶振
  92.   while (!(XOSCCR & 1));                      //等待时钟稳定
  93.   CKDIV = 0x00;                               //时钟不分频
  94.   CKSEL = 0x01;                               //选择外部晶振
  95.   P_SW2 = 0x00;
  96. }
  97. void CMP_Ini()
  98. {
  99.         CMPCR1 = 0x86;
  100.         CMPCR2 = 0x42;
  101. //        CMPCR2 = 0x43;
  102.         P_SW2 = 0x00;
  103. }
  104. void T1_Ini()
  105. {
  106.         TMOD = 0x00;
  107.         TH1 = 0x3c;
  108.         TL1 = 0xb0;
  109.         AUXR = 0x00;
  110.         ET1 = 1;
  111. }
  112. void T3_Ini()
  113. {
  114.         T4T3M = 0x04;
  115.         TH3 = 0x00;
  116.         TL3 = 0x00;
  117.   IE2=0x20; //允许T3中断
  118. }
  119. void INT1_Ini()
  120. {
  121.         IT1 = 1;
  122.         EX1 = 1;
  123.         IP = 0x04;
  124.         IPH = 0x04;
  125. }
  126. void SysClkTest()
  127. {
  128.         display164(Table[0]);   //七个数码管都显示0，则系统时钟选择正常
  129.         display164(Table[0]);
  130.         display164(Table[0]);
  131.         display164(Table[0]);
  132.         display164(Table[0]);
  133.           display164(Table[0]);
  134.         display164(Table[0]);
  135.         display164(Table[0]);
  136. }
  137. void ADC_Ini()
  138. {
  139.         DiviVol();                                   //初始选择分压
  140.         P1M0 = 0x00;                                //设置P1.0为ADC口
  141.         P1M1 = 0x03;                                //P1.0和P1.1都设置为高阻输入模式
  142.         ADCCFG = 0x00;                              //设置ADC时钟为系统时钟/2/16/16
  143.         ADC_CONTR = 0x80;                           //使能ADC模块
  144. }
  145. void main()
  146. {
  147.         int timev[M]={0};
  148.         int i,imax,imaxp;
  149.         imaxp=0;
  150.    
  151.        
  152.         SetOutXtal();
  153.         SysClkTest();
  154.        
  155.         INT1_Ini();
  156.         CMP_Ini();
  157.         T1_Ini();
  158.         T3_Ini();
  159.         ADC_Ini();
  160.         EA = 1;

  162.         while(1)
  163.         {
  164.                 if(flag==0)
  165.                 {   
  166.                
  167.                        
  168.                         for(i=0;i<M;i++)
  169.                         {   
  170.                                 ADC_CONTR |= 0x40;                      //启动AD转换
  171.                                 _nop_();
  172.                                 _nop_();
  173.                                 delay(1);
  174.                                 while (!(ADC_CONTR & 0x20));            //查询ADC完成标志               
  175.                                 ADC_CONTR &= ~0x20;                     //清完成标志
  176.                                 H=ADC_RES;
  177.                                 L=ADC_RESL;
  178.                                 RawVol=H*16+L/16;
  179.                                 ADC_CONTR &= 0xa0;                                           
  180.                         //        Vol = RawVol*11;
  181.                                 timev[i]=RawVol*11;
  182.                                 delay(5);
  183.                         }
  184.                        
  185.                         imax=timev[0];
  186.                         for(i=1;i<M;i++)
  187.                     {

  189.                         if(timev[i]>imax)
  190.                         {
  191.                             imax=timev[i];
  192.                             //imaxp=i;
  193.                         }
  194.                 }
  195.                         Vol=2*imax;
  196.                

  198. //                        if(RawVol<33)
  199. //                        {       
  200. //                                NotDiviVol();       
  201. //                                delay(5);
  202. //                                ADC_CONTR = 0x81;                           //使能ADC模块
  203. //                                delay(5);
  204. //                                ADC_CONTR |= 0x40;                      //启动AD转换
  205. //                                _nop_();
  206. //                                _nop_();
  207. //                                while (!(ADC_CONTR & 0x20));            //查询ADC完成标志               
  208. //                                ADC_CONTR &= ~0x20;                     //清完成标志
  209. //                                H=ADC_RES;
  210. //                                L=ADC_RESL;
  211. //                            
  212. //                                RawVol=H*16+L/16;
  213. //
  214. //                                Vol = RawVol/11;
  215. //                               
  216. //                    }

  218.                                 display164(Table[Vol/10%10]);
  219.                                 display164(Table[Vol/100%10]);
  220.                                 display164(PotTable[Vol/1000%10]);
  221.                                 display164(Table[Vol/10000]);
  222.                                 display164(0x00);
  223.                             display164(0x00);
  224.                             display164(0x00);                       
  225.                                   display164(0x3e);
  226.                                   DiviVol();
  227.                                   delay(5);
  228.                                 //imax=0;
  229. //                  ADC_CONTR = 0x80;                           //使能ADC模块
  230. //                  ADC_CONTR |= 0x40;                          //启动AD转换
  231.                         time = 0;
  232.                   delay(6000);
  233.                  }
  234.                  if(flag==1)
  235.                  {
  236.                          if(time==0)
  237.                          {
  238. //                                while(FreIn==1);       
  239. //                    while(FreIn==0);       
  240.                           TR1=1;//打开T1、T3，开始测频
  241.               T4T3M |= 0x08;                       
  242.                          }                                 
  243.                  }          
  244.                  if(time==20)
  245.                  {                                       
  246.                          TR1 = 0;
  247.                         T4T3M &= 0xf7;               
  248.                         temp = TH3*256+TL3+count*65536;       
  249.                         tempone = temp+1;
  250.                         frequency = temp+(int)(tempone*0.0001);       
  251.                         tempp[0] = frequency%10;
  252.                         tempp[1] = (frequency/10)%10;
  253.                         tempp[2] = (frequency/100)%10;
  254.                         tempp[3] = (frequency/1000)%10;
  255.                         tempp[4] = (frequency/10000)%10;
  256.                         tempp[5] = (frequency/100000)%10;
  257.                         tempp[6] = (frequency/1000000)%10;
  258.                         if((frequency/1000000)%10==0)
  259.                         {
  260.                                 tempp[6] = 10;
  261.                                 if((frequency/100000)%10==0)
  262.                          {
  263.                                  tempp[5] = 10;
  264.                                         if((frequency/10000)%10==0)
  265.                                         {
  266.                                                 tempp[4] = 10;
  267.                                                 if((frequency/1000)%10==0)
  268.                                                 {
  269.                                                         tempp[3] = 10;
  270.                                                         if((frequency/100)%10==0)
  271.                                                         {
  272.                                                                 tempp[2] = 10;
  273.                                                                 if((frequency/10)%10==0)
  274.                                                                 {
  275.                                                                         tempp[1] = 10;
  276.                                                                         if(frequency%10==0)
  277.                                                                         {
  278.                                                                                 tempp[0] = 10;
  279.                                                                         }
  280.                                                                 }
  281.                                                         }
  282.                                                 }
  283.                                         }
  284.                          }
  285.                         }
  286.                         display164(Table[tempp[0]]);   //频率送显
  287.                         display164(Table[tempp[1]]);
  288.                         display164(Table[tempp[2]]);
  289.                         display164(Table[tempp[3]]);
  290.                         display164(Table[tempp[4]]);
  291.                         display164(Table[tempp[5]]);
  292.                         display164(Table[tempp[6]]);
  293.                         display164(0x71);               
  294.                         time = 0;
  295.                         count = 0;
  296.                         TH3 = 0;
  297.                         TL3 = 0;
  298.                         TH1 = 0x3c;
  299.                     TL1 = 0xb0;          

  301.            }       
  302.         }
  303. }
  304. void INT1_Ser() interrupt 2
  305. {
  306.         flag=!flag;
  307. }
  308. void T1_Isr() interrupt 3
  309. {       
  310.   time++;
  311. }
  312. void T3_Isr() interrupt 19
  313. {
  314.   count++;                        
  315.   AUXINTIF &= 0xfd; //清中断标志                       
  316. }

  318. /*
  319. #include "reg51.h"
  320. #include "intrins.h"

  322. #define CKSEL           (*(unsigned char volatile xdata *)0xfe00)
  323. #define CKDIV           (*(unsigned char volatile xdata *)0xfe01)
  324. #define IRC24MCR        (*(unsigned char volatile xdata *)0xfe02)
  325. #define XOSCCR          (*(unsigned char volatile xdata *)0xfe03)
  326. #define IRC32KCR        (*(unsigned char volatile xdata *)0xfe04)


  329. sfr     ADC_CONTR   =   0xbc;
  330. sfr     ADC_RES     =   0xbd;
  331. sfr     ADC_RESL    =   0xbe;
  332. sfr     ADCCFG      =   0xde;
  333. sfr     P_SW2       =   0xba;
  334. sbit    EADC        =   IE^5;
  335. sfr     AUXR        =   0x8e;
  336. sfr     CMPCR1      =   0xe6;
  337. sfr     CMPCR2      =   0xe7;
  338. sfr     IE2         =   0xaf;
  339. sfr     AUXINTIF    =   0xef;
  340. sfr     T4T3M       =   0xd1;
  341. sfr     TL3         =   0xd5;
  342. sfr     TH3         =   0xd4;
  343. sfr     IPH         =   0xb7;
  344. sfr     P1M0        =   0x92;
  345. sfr     P1M1        =   0x91;

  347. sbit FreIn  = P0^4;

  349. sbit P26 = P2^6;
  350. sbit P27 = P2^7;

  352. sbit CLK = P2^3;
  353. sbit DAT = P2^1;

  355. void display164(unsigned char udata)
  356. {
  357.   char i;
  358.   for(i=0;i<8;i++)
  359.   {
  360.     if(udata&0x80)
  361.     {
  362.       DAT=1;
  363.       CLK=0;
  364.       udata = udata<<1;
  365.       CLK=1;
  366.     }
  367.     else
  368.     {
  369.       DAT=0;
  370.       CLK=0;
  371.       udata = udata<<1;
  372.       CLK=1;
  373.     }
  374.   }
  375. }       

  377. void DiviVol()
  378. {
  379.         P26 = 1;
  380.         P27= 0;
  381. }
  382. void NotDiviVol()
  383. {
  384.         P27 = 1;
  385.         P26 = 0;
  386. }
  387. void delay(int ms)
  388. {
  389.         int a,b;
  390.         for(a=ms;a>0;a--)
  391.                 for(b=120;b>0;b--);
  392. }
  393. unsigned int time = 0;
  394. unsigned int count = 0;
  395. unsigned long frequency = 0,temp=0,tempone = 0;
  396. unsigned char code Table[]={0xee,0x28,0xcd,0x6d,0x2b,0x67,0xe7,0x2c,0xef,0x6f};
  397. unsigned char code PotTable[]={0xfe,0x38,0xdd,0x7d,0x3b,0x77,0xf7,0x3c,0xff,0x7f};
  398. //unsigned char code Table[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x00};
  399. //unsigned char code PotTable[]={0xbf,0x86,0xdb,0xcf,0xe6,0xed,0xfd,0x87,0xff,0xef};
  400. unsigned int H=0,L=0;
  401. unsigned char tempp[7]={0};
  402. unsigned int Vol = 0,RawVol = 0;

  404. bit flag = 0;
  405. unsigned int qf = 0;
  406. void SetOutXtal()
  407. {
  408.         P_SW2 = 0x80;
  409.   XOSCCR = 0xc0;                              //启动外部晶振
  410.   while (!(XOSCCR & 1));                      //等待时钟稳定
  411.   CKDIV = 0x00;                               //时钟不分频
  412.   CKSEL = 0x01;                               //选择外部晶振
  413.   P_SW2 = 0x00;
  414. }
  415. void CMP_Ini()
  416. {
  417.         CMPCR1 = 0x86;
  418.         CMPCR2 = 0x42;
  419. //        CMPCR2 = 0x43;
  420.         P_SW2 = 0x00;
  421. }
  422. void T1_Ini()
  423. {
  424.         TMOD = 0x00;
  425.         TH1 = 0x3c;
  426.         TL1 = 0xb0;
  427.         AUXR = 0x00;
  428.         ET1 = 1;
  429. }
  430. void T3_Ini()
  431. {
  432.         T4T3M = 0x04;
  433.         TH3 = 0x00;
  434.         TL3 = 0x00;
  435.   IE2=0x20; //允许T3中断
  436. }
  437. void INT1_Ini()
  438. {
  439.         IT1 = 1;
  440.         EX1 = 1;
  441.         IP = 0x04;
  442.         IPH = 0x04;
  443. }
  444. void SysClkTest()
  445. {
  446.         display164(Table[0]);   //七个数码管都显示0，则系统时钟选择正常
  447.         display164(Table[0]);
  448.         display164(Table[0]);
  449.         display164(Table[0]);
  450.         display164(Table[0]);
  451.           display164(Table[0]);
  452.         display164(Table[0]);
  453.         display164(Table[0]);
  454. }
  455. void ADC_Ini()
  456. {
  457.         DiviVol();                                   //初始选择分压
  458.         P1M0 = 0x00;                                //设置P1.0为ADC口
  459.         P1M1 = 0x03;                                //P1.0和P1.1都设置为高阻输入模式
  460.         ADCCFG = 0x00;                              //设置ADC时钟为系统时钟/2/16/16
  461.         ADC_CONTR = 0x80;                           //使能ADC模块
  462. }
  463. void main()
  464. {
  465.         SetOutXtal();
  466.         SysClkTest();
  467.        
  468.         INT1_Ini();
  469.         CMP_Ini();
  470.         T1_Ini();
  471.         T3_Ini();
  472.         ADC_Ini();
  473.         EA = 1;
  474.         while(1)
  475.         {
  476.                 if(flag==0)
  477.                 {      
  478.                         ADC_CONTR |= 0x40;                      //启动AD转换
  479.                         _nop_();
  480.                         _nop_();
  481.                         delay(1);
  482.                         while (!(ADC_CONTR & 0x20));            //查询ADC完成标志               
  483.                         ADC_CONTR &= ~0x20;                     //清完成标志
  484.                         H=ADC_RES;
  485.                         L=ADC_RESL;
  486.                         RawVol=H*16+L/16;
  487.                         ADC_CONTR &= 0xa0;                                           
  488.                         Vol = RawVol*11;
  489.                
  490. //                        if(RawVol<33)
  491. //                        {       
  492. //                                NotDiviVol();       
  493. //                                delay(5);
  494. //                                ADC_CONTR = 0x81;                           //使能ADC模块
  495. //                                delay(5);
  496. //                                ADC_CONTR |= 0x40;                      //启动AD转换
  497. //                                _nop_();
  498. //                                _nop_();
  499. //                                while (!(ADC_CONTR & 0x20));            //查询ADC完成标志               
  500. //                                ADC_CONTR &= ~0x20;                     //清完成标志
  501. //                                H=ADC_RES;
  502. //                                L=ADC_RESL;
  503. //                            
  504. //                                RawVol=H*16+L/16;
  505. //
  506. //                                Vol = RawVol/11;
  507. //                               
  508. //                    }

  510.                                 display164(Table[Vol/10%10]);
  511.                                 display164(Table[Vol/100%10]);
  512.                                 display164(PotTable[Vol/1000%10]);
  513.                                 display164(Table[Vol/10000]);
  514.                                 display164(0x00);
  515.                     display164(0x00);
  516.                     display164(0x00);                       
  517.                           display164(0x3e);
  518.                           DiviVol();
  519.                   delay(5);
  520.                   ADC_CONTR = 0x80;                           //使能ADC模块
  521.                   ADC_CONTR |= 0x40;                          //启动AD转换
  522.                         time = 0;
  523.                   delay(3000);
  524.                  }
  525.                  if(flag==1)
  526.                  {
  527.                          if(time==0)
  528.                          {
  529. //                                while(FreIn==1);       
  530. //                    while(FreIn==0);       
  531.                           TR1=1;//打开T1、T3，开始测频
  532.               T4T3M |= 0x08;                       
  533.                          }                                 
  534.                  }          
  535.                  if(time==20)
  536.                  {                                       
  537.                          TR1 = 0;
  538.                         T4T3M &= 0xf7;               
  539.                         temp = TH3*256+TL3+count*65536;       
  540.                         tempone = temp+1;
  541.                         frequency = temp+(int)(tempone*0.0001);       
  542.                         tempp[0] = frequency%10;
  543.                         tempp[1] = (frequency/10)%10;
  544.                         tempp[2] = (frequency/100)%10;
  545.                         tempp[3] = (frequency/1000)%10;
  546.                         tempp[4] = (frequency/10000)%10;
  547.                         tempp[5] = (frequency/100000)%10;
  548.                         tempp[6] = (frequency/1000000)%10;
  549.                         if((frequency/1000000)%10==0)
  550.                         {
  551.                                 tempp[6] = 10;
  552.                                 if((frequency/100000)%10==0)
  553.                          {
  554.                                  tempp[5] = 10;
  555.                                         if((frequency/10000)%10==0)
  556.                                         {
  557.                                                 tempp[4] = 10;
  558.                                                 if((frequency/1000)%10==0)
  559.                                                 {
  560.                                                         tempp[3] = 10;
  561.                                                         if((frequency/100)%10==0)
  562.                                                         {
  563.                                                                 tempp[2] = 10;
  564.                                                                 if((frequency/10)%10==0)
  565.                                                                 {
  566.                                                                         tempp[1] = 10;
  567.                                                                         if(frequency%10==0)
  568.                                                                         {
  569.                                                                                 tempp[0] = 10;
  570.                                                                         }
  571.                                                                 }
  572.                                                         }
  573.                                                 }
  574.                                         }
  575.                          }
  576.                         }
  577.                         display164(Table[tempp[0]]);   //频率送显
  578.                         display164(Table[tempp[1]]);
  579.                         display164(Table[tempp[2]]);
  580.                         display164(Table[tempp[3]]);
  581.                         display164(Table[tempp[4]]);
  582.                         display164(Table[tempp[5]]);
  583.                         display164(Table[tempp[6]]);
  584.                         display164(0x71);               
  585.                         time = 0;
  586.                         count = 0;
  587.                         TH3 = 0;
  588.                         TL3 = 0;
  589.                         TH1 = 0x3c;
  590.                     TL1 = 0xb0;          

  592.            }       
  593.         }
  594. }
  595. void INT1_Ser() interrupt 2
  596. {
  597.         flag=!flag;
  598. }
  599. void T1_Isr() interrupt 3
  600. {       
  601.   time++;
  602. }
  603. void T3_Isr() interrupt 19
  604. {
  605.   count++;                        
  606.   AUXINTIF &= 0xfd; //清中断标志                       
  607. }       
  608. */
复制代码

所有资料51hei提供下载:
测频率.rar (37.85 KB, 下载次数: 25)


作者: admin    时间: 2018-11-20 04:15
补全原理图或者详细说明一下电路连接即可获得100+黑币



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