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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 32*64点阵音乐频谱 单片机程序有小BUG 如何修改呢?
返回列表 发新帖
查看: 1512|回复: 4
收起左侧

32*64点阵音乐频谱 单片机程序有小BUG 如何修改呢?

[复制链接]
ID:39866 发表于 2021-5-18 13:06 | 显示全部楼层 |阅读模式
此本程序有小BUG

单片机使用STC12C5A60S2单片机24M晶振  响应速度还行，基本跟得上音乐节奏
就是有两行灯特别亮，其他的有点暗，而且有频闪感觉，像是交流供电的感觉。
哪位得神帮忙修改一下。

电路如下：
捕获.JPG


  2. #include "stc12c5a60s2.h"
  3. #include "intrins.h"
  4. #define uchar unsigned char
  5. #define uint unsigned int
  6. #define   FOSC 30000000L
  7. #define   BAUD 9600
  8. typedef   unsigned  char   BYTE;
  9. typedef   unsigned  int   WORD;

  11. /*Define ADC operation const for ADC_CONTR*/
  12. #define   ADC_POWER   0x80    //ADC power control bit
  13. #define   ADC_FLAG    0x10    //ADC complete flag
  14. #define   ADC_START   0x08    //ADC start control bit
  15. //#define   ADC_STOP   0x08
  16. #define   ADC_SPEEDLL   0x00    //540 clocks
  17. #define   ADC_SPEEDL   0x20    //360 clocks
  18. #define   ADC_SPEEDH   0x40    //180 clocks
  19. #define   ADC_SPEEDHH   0x60    //90 clocks

  21. #define  scan0    {IA=0;IB=0;IC=0;ID=0;}
  22. #define  scan1    {IA=1;IB=0;IC=0;ID=0;}
  23. #define  scan2    {IA=0;IB=1;IC=0;ID=0;}
  24. #define  scan3    {IA=1;IB=1;IC=0;ID=0;}
  25. #define  scan4    {IA=0;IB=0;IC=1;ID=0;}
  26. #define  scan5    {IA=1;IB=0;IC=1;ID=0;}
  27. #define  scan6    {IA=0;IB=1;IC=1;ID=0;}
  28. #define  scan7    {IA=1;IB=1;IC=1;ID=0;}
  29. #define  scan8    {IA=0;IB=0;IC=0;ID=1;}
  30. #define  scan9    {IA=1;IB=0;IC=0;ID=1;}
  31. #define scan10    {IA=0;IB=1;IC=0;ID=1;}
  32. #define scan11    {IA=1;IB=1;IC=0;ID=1;}
  33. #define scan12    {IA=0;IB=0;IC=1;ID=1;}
  34. #define scan13    {IA=1;IB=0;IC=1;ID=1;}
  35. #define scan14    {IA=0;IB=1;IC=1;ID=1;}
  36. #define scan15    {IA=1;IB=1;IC=1;ID=1;}











  48. void scan(unsigned char Value);
  49. void InitUart();
  50. void SendData(BYTE dat);
  51. void Delay(WORD n);
  52. void InitADC();
  53. void FFT();
  54. void scan(unsigned char Value);
  55. BYTE   ch = 0;    //ADC channel NO.
  56. BYTE   a = 0x55;    //ADC channel NO.



  60. //放大128倍后的sin整数表（128）        
  61. code char SIN_TAB[64] = { 0x00, 0x0c, 0x18, 0x24, 0x30, 0x3b, 0x46, 0x50,
  62. 0x59, 0x62, 0x69, 0x70, 0x75, 0x79, 0x7c, 0x7e,
  63. 0x7f, 0x7e, 0x7c, 0x79, 0x75, 0x70, 0x69, 0x62,
  64. 0x59, 0x50, 0x46, 0x3b, 0x30, 0x24, 0x18, 0x0c,
  65. 0x00, -0x0c, -0x18, -0x24, -0x30, -0x3b, -0x46, -0x50,
  66. -0x59, -0x62, -0x69, -0x70, -0x75, -0x79, -0x7c, -0x7e,
  67. -0x7f, -0x7e, -0x7c, -0x79, -0x75, -0x70, -0x69, -0x62,
  68. -0x59, -0x50, -0x46, -0x3b, -0x30, -0x24, -0x18, -0x0c,
  69. };

  71. //放大128倍后的cos整数表（128）
  72. code char COS_TAB[64] = { 0x7f, 0x7e, 0x7c, 0x79, 0x75, 0x70, 0x69, 0x62,
  73. 0x59, 0x50, 0x46, 0x3b, 0x30, 0x24, 0x18, 0x0c,
  74. 0x00, -0x0c, -0x18, -0x24, -0x30, -0x3b, -0x46, -0x50,
  75. -0x59, -0x62, -0x69, -0x70, -0x75, -0x79, -0x7c, -0x7e,
  76. -0x7f, -0x7e, -0x7c, -0x79, -0x75, -0x70, -0x69, -0x62,
  77. -0x59, -0x50, -0x46, -0x3b, -0x30, -0x24, -0x18, -0x0c,
  78. 0x00, 0x0c, 0x18, 0x24, 0x30, 0x3b, 0x46, 0x50,
  79. 0x59, 0x62, 0x69, 0x70, 0x75, 0x79, 0x7c, 0x7e,
  80. };

  82. //采样存储序列表
  83. code char LIST_TAB[64] = { 0, 32, 16, 48, 8, 40, 24, 56,
  84. 4, 36, 20, 52, 12, 44, 28, 60,
  85. 2, 34, 18, 50, 10, 42, 26, 58,
  86. 6, 38, 22, 54, 14, 46, 30, 62,
  87. 1, 33, 17, 49, 9, 41, 25, 57,
  88. 5, 37, 21, 53, 13, 45, 29, 61,
  89. 3, 35, 19, 51, 11, 43, 27, 59,
  90. 7, 39, 23, 55, 15, 47, 31, 63
  91. };
  92. int xdata Fft_Real[64]=0XFF;
  93. int xdata Fft_Image[64]=0XFF;               // fft的虚部
  94. uchar xdata LED_TAB2[32]=0XFF;                                //记录 漂浮物 是否需要 停顿一下
  95. uchar xdata LED_TAB[32]=0XFF;                                //记录红色柱状
  96. uchar xdata LED_TAB1[32]=0XFF;                                //记录 漂浮点

  98. //sbit  SDA_R=P4^4;        //下半屏红色数据
  99. //sbit  SDA_R_TOP=P2^7;//上半屏红色数据
  100. sbit  SDA_R=P2^4;        //下半屏红色数据
  101. sbit  SDA_R_TOP=P2^3;//上半屏红色数据
  102. sbit  SDA_G=P2^6;//下半屏绿色数据                                
  103. sbit  SDA_G_TOP=P2^5;
  104. sbit  STCP=P4^1;
  105. sbit  SHCP=P2^7;
  106. sbit OE=P0^4;                        ////输出使能
  107. sbit IA  =P4^0;  //行控制线A
  108. sbit IB  =P2^0;  //行控制线B
  109. sbit IC  =P2^1;  //行控制线C
  110. sbit ID  =P2^2;  //行控制线D


  113. sbit Key_light=P1^5;                        //亮度控制
  114. sbit key_moda=P3^0;                        //模式转换
  115. sbit key_color=P3^1;                        //颜色切换
  116. //sbit key_Down=P3^3;                        //时钟减
  117. void Scan_Mode();




  122. uchar COUNT=15,COUNT1=0,ADC_Count=0,LINE=15,G,T;
  123. uchar i,j,k,b,p;                 
  124. int Temp_Real,Temp_Imag,temp;                // 中间临时变量  
  125. uint TEMP1;
  126. uchar PWM;
  127. uchar Mode=0;//模式          0-2
  128. uchar color=1;                 //0-7
  129. uchar Stop_time=0;
  130. uchar stop=0;
  131. uchar count_time=0;
  132. uchar Light=0;
  133. uchar fractional_frequency=24;//分频


  136. /*----------------------------ADC interrupt service routine
  137. ----------------------------*/

  139. void adc_isr() interrupt 5 using 1
  140. {
  141. OE=0;
  142. EADC=0;        //ADC中断关
  143. ADC_CONTR &= !ADC_FLAG;   //每次中断后重新置0
  144. Fft_Real[LIST_TAB[ADC_Count]]=(int)((ADC_RES*3)<<2)+(ADC_RESL)*2;//-512;
  145.          //ADC_RES:A/D转换结果寄存器高,ADC_RESL:A/D转换结果寄存器低
  146.    
  147.                  if(ADC_Count<64) //采集64个AD值 没有滤波
  148.                    ADC_Count++;

  150. ADC_CONTR = ADC_POWER | ADC_SPEEDHH| ADC_START | ch; //重新开启ADC        保正每扫描一行取样一次(如果在中断中实时频繁取样会闪得厉害和有干扰问题)

  152. }
  153. /*----------------------------Initial ADC sfr
  154. ----------------------------*/


  157. void main()
  158. {
  159. //uchar i;
  160. InitUart();    //Init UART, use to show ADC result
  161. InitADC();    //Init ADC sfr
  162. IE = 0xa0;    //Enable ADC interrupt and Open master interrupt switch
  163. P4SW=0x30;
  164. P4M0=0x30;
  165. P4M1=0x00;
  166. ADC_Count=0;
  167. EADC=1;         //开启ADC中断
  168. while(1)
  169. {



  173. if(ADC_Count==64)//等待取样到64个点
  174.       {





  180.      OE=0;  //必需关138,否则会有点闪
  181.                 for(i=0;i<64;i++)
  182.               {
  183.                  Fft_Image[i]=0; //虚部清0


  186.               }

  188.                FFT();

  190.                ADC_Count=0;


  193.           }


  196.                
  197.                 if(key_moda==0) //按键S2 模式改变  16与64分频
  198.                 {
  199.                  Delay(1) ;
  200.                         if(key_moda==0)
  201.                         {
  202.                              Mode++;
  203.                                  if(Mode>2)
  204.                                  {
  205.                                       
  206.                                           Mode=0;        
  207.                                  }

  209.                                  Scan_Mode();         //16还是64分频的扫描模式
  210.                
  211.                         }
  212.                         while(key_moda==0);
  213.                 }
  214. //******************************************/
  215.                 if(key_color==0) //送颜色按键 3   柱条颜色改变
  216.                 {
  217.                         Delay(1) ;
  218.                         if(key_color==0)
  219.                         {
  220.                              color++;
  221.                                  if(color>7)
  222.                                  {
  223.                                       color=0;        
  224.                                  }

  226.                         }
  227.                 while(key_color==0);
  228.                 }
  229. //**********************************
  230.                 if(Key_light==0) //亮度控制
  231.                 {
  232.                 Delay(1) ;
  233.                         if(Key_light==0)
  234.                         {
  235.                              Light++;
  236.                                  if(Light>11)
  237.                                  {
  238.                                       Light=1;        
  239.                                  }
  240.                
  241.                                                 
  242.                         }
  243.                 //        while(Key_light==0);
  244.                 }
  245.                

  247. //////////////////////以下只产生一行扫描动作///////////////////////////////////////////////////////////////////////////////        
  248.                                 
  249. //        for        (G=1;G<fractional_frequency+1;G++)                                                  //往点阵屏送 一行的 数据 (fractional_frequency=16 对应16条光柱,每一次G++就送出下一位光柱)
  250.   for        (G=0;G<fractional_frequency;G++)
  251.         {                                
  252.                 if(color==0)  //如果是柱状红色
  253.                 {

  255.         
  256.                         if(LED_TAB[G]<=LINE+16)                ///////////上半屏    LED_TAB[G]记录着1至32级其中一级的功率值,LINE扫描行数初始15,LED_TAB[G]存着FFT值,
  257.                                 SDA_R_TOP=1;        //熄灭
  258.                         else
  259.                                 SDA_R_TOP=0;  //点亮
  260.                         if(LED_TAB[G]<=LINE)        /////////////下半屏LINE--
  261.                                 SDA_R=1;
  262.                         else
  263.                                 SDA_R=0;

  265.                         if(LED_TAB1[G]==LINE)        /////////////// 记录浮点
  266.                           {
  267.                                 SDA_G_TOP=1;
  268.                                 SDA_G=0;

  270.                            }
  271.                         else if(LED_TAB1[G]==(LINE+16))
  272.                            {
  273.                                 SDA_G_TOP=0;
  274.                                 SDA_G=1;

  276.                             }
  277.                         else
  278.                                 SDA_G=SDA_G_TOP=1;

  280.                                                            SHCP=1;
  281.                                         SHCP=0;
  282.                 }


  285.                                  
  286.                 if(color==1)  //如果是柱状绿色 浮点红色
  287.                 {

  289.         
  290.                         if(LED_TAB[G]<=LINE+16)                ///////////上半屏    LED_TAB[G]记录着1至32级其中一级的功率值,LINE扫描行数初始15,LED_TAB[G]存着FFT值,
  291.                                 SDA_G_TOP=1;        //熄灭
  292.                         else
  293.                                 SDA_G_TOP=0;  //点亮
  294.                         if(LED_TAB[G]<=LINE)        /////////////下半屏LINE--
  295.                                 SDA_G=1;
  296.                         else
  297.                                 SDA_G=0;

  299.                         if(LED_TAB1[G]==LINE)        /////////////// 记录浮点
  300.                           {
  301.                                 SDA_R_TOP=1;
  302.                                 SDA_R=0;

  304.                            }
  305.                         else if(LED_TAB1[G]==(LINE+16))
  306.                            {
  307.                                 SDA_R_TOP=0;
  308.                                 SDA_R=1;

  310.                             }
  311.                         else
  312.                                 SDA_R=SDA_R_TOP=1;

  314.                                                            SHCP=1;
  315.                                         SHCP=0;
  316.                 }




  321.         if(color==2)  //如果是柱状橙色 无浮点
  322.                   {

  324.         
  325.                         if(LED_TAB[G]<=LINE+16)                ///////////上半屏    LED_TAB[G]记录着1至32级其中一级的功率值,LINE扫描行数初始15,LED_TAB[G]存着FFT值,
  326.                                  {
  327.                                 
  328.                             SDA_G_TOP=1;        //熄灭
  329.                                 SDA_R_TOP=1;        //熄灭
  330.                                 }
  331.                         else
  332.                        {
  333.                             SDA_G_TOP=0;  //点亮
  334.                                 SDA_R_TOP=0;        //熄灭
  335.                                 }
  336.                         if(LED_TAB[G]<=LINE)        /////////////下半屏LINE--
  337.                                 {
  338.                                 SDA_G=1;
  339.                                 SDA_R=1;
  340.                                 }

  342.                         else
  343.                            
  344.                            {
  345.                             SDA_G=0;
  346.                                 SDA_R=0;
  347.                                 }
  348.                                            SHCP=1;
  349.                                 SHCP=0;
  350.                 }


  353.          if(color==3)  //如果是柱状橙色 无浮点
  354.                   {

  356.         
  357.                         if(LED_TAB[G]<=LINE+16)                ///////////上半屏    LED_TAB[G]记录着1至32级其中一级的功率值,LINE扫描行数初始15,LED_TAB[G]存着FFT值,
  358.                                  {
  359.                                 
  360.                             SDA_G_TOP=1;        
  361.                         
  362.                                 }
  363.                         else
  364.                        {
  365.                             SDA_G_TOP=0;  
  366.                
  367.                                 }
  368.                         if(LED_TAB[G]<=LINE)        /////////////下半屏LINE--
  369.                                 {
  370.                                 SDA_G=1;
  371.         
  372.                                 }

  374.                         else
  375.                            
  376.                            {
  377.                             SDA_G=0;
  378.                
  379.                                 }
  380.                                            SHCP=1;
  381.                                 SHCP=0;
  382.                 }
  383.                         if(color==4)  //如果是柱状橙色 无浮点
  384.                   {

  386.         
  387.                         if(LED_TAB[G]<=LINE+16)                ///////////上半屏    LED_TAB[G]记录着1至32级其中一级的功率值,LINE扫描行数初始15,LED_TAB[G]存着FFT值,
  388.                                  {
  389.                                 
  390.                           
  391.                                 SDA_R_TOP=1;        //熄灭
  392.                                 }
  393.                         else
  394.                        {
  395.                         
  396.                                 SDA_R_TOP=0;        //熄灭
  397.                                 }
  398.                         if(LED_TAB[G]<=LINE)        /////////////下半屏LINE--
  399.                                 {
  400.         
  401.                                 SDA_R=1;
  402.                                 }

  404.                         else
  405.                            
  406.                            {
  407.         
  408.                                 SDA_R=0;
  409.                                 }
  410.                                            SHCP=1;
  411.                                 SHCP=0;
  412.                 }


  415.                   if(color==5)  //如果是浮点红色
  416.                 {



  420.                         if(LED_TAB1[G]==LINE)        /////////////// 记录浮点
  421.                           {
  422.                                 SDA_G_TOP=1;
  423.                                 SDA_G=0;

  425.                            }
  426.                         else if(LED_TAB1[G]==(LINE+16))
  427.                            {
  428.                                 SDA_G_TOP=0;
  429.                                 SDA_G=1;

  431.                             }
  432.                         else
  433.                                 SDA_G=SDA_G_TOP=1;

  435.                                                            SHCP=1;
  436.                                         SHCP=0;
  437.                 }
  438.                             if(color==6)  //如果是浮点红色
  439.                 {



  443.                         if(LED_TAB1[G]==LINE)        /////////////// 记录浮点
  444.                           {
  445.                                 SDA_R_TOP=1;
  446.                                 SDA_R=0;

  448.                            }
  449.                         else if(LED_TAB1[G]==(LINE+16))
  450.                            {
  451.                                 SDA_R_TOP=0;
  452.                                 SDA_R=1;

  454.                             }
  455.                         else
  456.                                 SDA_R=SDA_R_TOP=1;

  458.                                                            SHCP=1;
  459.                                         SHCP=0;
  460.                 }
  461.                                   if(color==7)  //如果是浮点红色
  462.                 {



  466.                         if(LED_TAB1[G]==LINE)        /////////////// 记录浮点
  467.                           {
  468.                 SDA_R_TOP=SDA_G_TOP=1;
  469.                                 SDA_R=SDA_G=0;

  471.                            }
  472.                         else if(LED_TAB1[G]==(LINE+16))
  473.                            {
  474.                                 SDA_R_TOP=SDA_G_TOP=0;
  475.                                 SDA_R=SDA_G=1;

  477.                             }
  478.                         else
  479.                                 SDA_R_TOP=SDA_R=SDA_G=SDA_G_TOP=1;

  481.                                                            SHCP=1;
  482.                                         SHCP=0;
  483.                 }
  484.                
  485.         /*        else if(color==1)  //如果是柱状 绿色漂浮点是红色
  486.                 {        
  487.                         if(LED_TAB[G]<=LINE+16)
  488.                                 SDA_G_TOP=1;
  489.                         else
  490.                                 SDA_G_TOP=0;
  491.                         if(LED_TAB[G]<=LINE)
  492.                                 SDA_G=1;
  493.                         else
  494.                                 SDA_G=0;
  495.         
  496.                         if(LED_TAB1[G]==LINE)
  497.                           {
  498.                                 SDA_R_TOP=1;
  499.                                 SDA_R=0;
  500.                           }
  501.                         else if(LED_TAB1[G]==(LINE+16))
  502.                           {
  503.                                 SDA_R_TOP=0;
  504.                                 SDA_R=1;
  505.                           }
  506.                         else
  507.                                 SDA_R=SDA_R_TOP=1;
  508.                                                            SHCP=1;
  509.                                         SHCP=0;

  511.                
  512.                 }
  513.                 else if(color==2)  //如果是柱状 绿色 漂浮点是黄色
  514.                 {               
  515.                         if(LED_TAB1[G]==LINE)
  516.                           {
  517.                                 SDA_R_TOP=SDA_G_TOP=1;
  518.                                 SDA_R=SDA_G=0;
  519.                           }
  520.                         else if(LED_TAB1[G]==(LINE+16))
  521.                           {
  522.                                 SDA_R_TOP=SDA_G_TOP=0;
  523.                                 SDA_R=SDA_G=1;
  524.                            }
  525.                         else
  526.                                 {
  527.                                   SDA_R=SDA_R_TOP=1;
  528.                                   SDA_G=SDA_G_TOP=1;
  529.                                 }
  530.                         if((LED_TAB[G]<=LINE+16)&&(LED_TAB1[G]!=(LINE+16)))
  531.                                 SDA_G_TOP=1;
  532.                         else
  533.                                 SDA_G_TOP=0;
  534.                         if((LED_TAB[G]<=LINE)&&(LED_TAB1[G]!=LINE))
  535.                                 SDA_G=1;
  536.                         else
  537.                                 SDA_G=0;
  538.                                                       SHCP=1;
  539.                                     SHCP=0;
  540.                
  541.                 }
  542.                 if(color==3)  //如果是 柱状红色 漂浮点是黄色
  543.                 {                        
  544.                         if(LED_TAB1[G]==LINE)
  545.                           {
  546.                                 SDA_R_TOP=SDA_G_TOP=1;
  547.                                 SDA_R=SDA_G=0;
  548.                            }
  549.                         else if(LED_TAB1[G]==(LINE+16))
  550.                           {
  551.                                 SDA_R_TOP=SDA_G_TOP=0;
  552.                                 SDA_R=SDA_G=1;
  553.                            }
  554.                         else
  555.                            {
  556.                                         SDA_R=SDA_R_TOP=1;
  557.                                         SDA_G=SDA_G_TOP=1;
  558.                                 }
  559.                         if((LED_TAB[G]<=LINE+16)&&(LED_TAB1[G]!=(LINE+16)))
  560.                                 SDA_R_TOP=1;  
  561.                         else
  562.                                 SDA_R_TOP=0;
  563.                         if((LED_TAB[G]<=LINE)&&(LED_TAB1[G]!=LINE))
  564.                                 SDA_R=1;
  565.                         else
  566.                                 SDA_R=0;
  567.                                 
  568.                                             SHCP=1;
  569.                                 SHCP=0;
  570.                 }
  571. */               
  572.                    if(fractional_frequency==16) //如果是16分频 送2次一样的数据 中间送个空格
  573.                 {

  575.                         SHCP=1;
  576.                         SHCP=0;         //发送2次上一次的点亮数据  (时钟)
  577.                         SHCP=1;
  578.                         SHCP=0;
  579.                         /////////////////////
  580.                         SDA_G_TOP=1;
  581.                         SDA_G=1;                //这里送上熄灭数据
  582.                         SDA_R_TOP=1;
  583.                         SDA_R=1;
  584.                         ////////////////////
  585.                         SHCP=1;
  586.                         SHCP=0;          //发送1位熄灭数据   (时钟)
  587.                 }

  589.         

  591.          if(fractional_frequency==32) //如果是16分频 送2次一样的数据 中间送个空格
  592.                 {

  594.                         /////////////////////
  595.                         SDA_G_TOP=1;
  596.                         SDA_G=1;                //这里送上熄灭数据
  597.                         SDA_R_TOP=1;
  598.                         SDA_R=1;
  599.                         ////////////////////
  600.                         SHCP=1;
  601.                         SHCP=0;          //发送1位熄灭数据   (时钟)
  602.                 }



  606.           if(fractional_frequency==24) //如果是16分频 送2次一样的数据 中间送个空格
  607.                  {

  609.                         SHCP=1;
  610.                         SHCP=0;         //发送2次上一次的点亮数据  (时钟)

  612.                         /////////////////////
  613.                         SDA_G_TOP=1;
  614.                         SDA_G=1;                //这里送上熄灭数据
  615.                         SDA_R_TOP=1;
  616.                         SDA_R=1;
  617.                         ////////////////////
  618.                         SHCP=1;
  619.                         SHCP=0;          //发送1位熄灭数据   (时钟)
  620.                 }













  634.         }
  635. ////////////////////////////////////////////////////////////////////////
  636.         for(j=0;j<1;j++) //根据是16分频 与64分频 来判断柱状递减的速度 ///////////////
  637.         {
  638.                    if(LED_TAB[COUNT]>0)
  639.                         LED_TAB[COUNT]--;                   //(CORNT初始15)柱状递减，
  640.            //////////////////////////////////////
  641.                  if(COUNT>0)
  642.                         COUNT--;        
  643.                 else
  644.                 {

  646.                           COUNT=fractional_frequency;
  647.                 }
  648.                 ///////////////////////////////
  649.         }
  650.         

  652. //////////////////////////////////////////////////
  653.         if(fractional_frequency==16)   //判断是否是16分频
  654.            {
  655.                count_time++;
  656.                 if(count_time==1)
  657.                    {
  658.                         count_time=0;
  659.                         Stop_time=1;        
  660.                     }                                          //设置16或64分频递减时间
  661.         
  662.                
  663.            }
  664.         else  //如果是64分频
  665.            {
  666.                 Stop_time=2;         
  667.             }

  669. ////////////////////////////////////////////////////

  671. for(j=0;j<Stop_time;j++)        //16  Stop_time 变量漂浮点递减速度控制

  673.         {
  674.                    if(LED_TAB2[COUNT1]==0)
  675.                    {
  676.                            if(LED_TAB1[COUNT1]>LED_TAB[COUNT1])
  677.                                 LED_TAB1[COUNT1]--;
  678.                    }
  679.                    else
  680.                         LED_TAB2[COUNT1]--;
  681.                        COUNT1++;
  682.         }
  683. ////////////////////////////////////////////////////
  684. if(fractional_frequency==16)
  685.         {
  686.                 if(COUNT1>=fractional_frequency+1)
  687.                    COUNT1=0;        
  688.         }
  689. else
  690.         {
  691.                 if(COUNT1>=fractional_frequency)
  692.                         COUNT1=0;
  693.         }
  694. //*******************************************************************
  695.         OE=0;
  696. //////////////////////////////////
  697. //ADC_CONTR = ADC_POWER | ADC_SPEEDHH| ADC_START | ch; //重新开启ADC        保正每扫描一行取样一次(如果在中断中实时频繁取样会闪得厉害和有干扰问题)
  698. EADC=1;        //ADC中断开
  699. ////////////////////////////










  710.         STCP=0;
  711.         STCP=1;          //595锁存时钟


  714.         scan(15-LINE); //行扫描




  719.   OE=0;        
  720.         if(LINE>0)
  721.                 LINE--;
  722.         else
  723.                 {                        
  724.                         LINE=15;

  726.                 }




  731.    }

  733.   


  736. }

  738. void InitADC( )
  739. {

  741.   P1ASF = 0x01;                //00000010, 将 P1.1 置成模拟口那一位为1那一位就为输入口
  742.   AUXR1 &=0xFB;          //1111,1011, 令ADRJ=0时,10A/D转换后高8位在ADC_RES中,低2位在ADC_RESL中,为1时相反
  743. ADC_RES = 0;    //Clear previous result
  744. ADC_CONTR = ADC_POWER | ADC_SPEEDLL | ADC_START | ch;
  745. Delay(10);    //ADC power-on delay and Start A/D conversion
  746. }
  747. /*----------------------------Initial UART
  748. ----------------------------*/

  750. void InitUart()
  751. {
  752. SCON = 0x5a;    //8 bit data ,no parity bit
  753. TMOD = 0x20;    //T1 as 8-bit auto reload
  754. TH1 = TL1 = -(FOSC/12/32/BAUD);   //Set Uart baudrate

  756. //TH1=TL1=-(FOSC/12/32/BAUD);
  757. TR1 = 1;    //T1 start running
  758. }
  759. /*----------------------------Send one byte data to PC
  760. Input: dat (UART data)
  761. Output:-----------------------------*/
  762. void SendData(BYTE dat)
  763. {
  764. while (!TI);    //Wait for the previous data is sent
  765. TI = 0;    //Clear TI flag
  766. SBUF = dat;    //Send current data
  767. }
  768. /*----------------------------Software delay function
  769. ----------------------------*/
  770. void Delay(WORD n)
  771. {
  772. WORD x;
  773. while (n--)
  774. {
  775. x = 5000;
  776. while (x--);
  777. }
  778. }
  779. void FFT()
  780. {               
  781.     for( i=1; i<=6; i++)                            /* for(1) */
  782.     {
  783.         b=1;
  784.         b <<=(i-1);                                       //碟式运算，用于计算 隔多少行计算 例如 第一极 1和2行计算，，第二级
  785.         for( j=0; j<=b-1; j++)                              /* for (2) */
  786.         {
  787.             p=1;
  788.             p <<= (7-i);            
  789.             p = p*j;
  790.             for( k=j; k<64; k=k+2*b)                /* for (3) 基二fft */
  791.             {
  792.                 Temp_Real = Fft_Real[k];
  793.                                 Temp_Imag = Fft_Image[k];
  794.                                 temp = Fft_Real[k+b];
  795.                 Fft_Real[k] = Fft_Real[k] + ((Fft_Real[k+b]*COS_TAB[p])>>7) + ((Fft_Image[k+b]*SIN_TAB[p])>>7);
  796.                 Fft_Image[k] = Fft_Image[k] - ((Fft_Real[k+b]*SIN_TAB[p])>>7) + ((Fft_Image[k+b]*COS_TAB[p])>>7);
  797.                 Fft_Real[k+b] = Temp_Real - ((Fft_Real[k+b]*COS_TAB[p])>>7) - ((Fft_Image[k+b]*SIN_TAB[p])>>7);
  798.                 Fft_Image[k+b] = Temp_Imag + ((temp*SIN_TAB[p])>>7) - ((Fft_Image[k+b]*COS_TAB[p])>>7);     
  799.                 // 移位.防止溢出. 结果已经是本值的 1/64               
  800.                       Fft_Real[k] >>= 1;            
  801.                 Fft_Image[k] >>= 1;
  802.                        Fft_Real[k+b]  >>= 1;                 
  803.                 Fft_Image[k+b]  >>= 1;

  805.                                                                               
  806.             }     
  807.         }
  808.     }
  809. //        Fft_Real[0]=Fft_Image[0]=0;                  //去掉直流分量

  811.    for(j=0;j<=fractional_frequency;j++)        //转换记录一行16列功率值
  812.         {
  813.                 TEMP1=((((Fft_Real[j]* Fft_Real[j]))+((Fft_Image[j]*Fft_Image[j]))));//求功率
  814.                 //以下将功率转为一列32级,对应LED32个点
  815.         if(TEMP1<4)
  816.                         TEMP1=0;
  817.         else if(TEMP1<9)
  818.                         TEMP1=1;
  819.         else if(TEMP1<16)
  820.                         TEMP1=2;
  821.         else if(TEMP1<25)
  822.                         TEMP1=3;
  823.         else if(TEMP1<36)
  824.                         TEMP1=4;
  825.         else if(TEMP1<49)
  826.                         TEMP1=5;
  827.         else if(TEMP1<55)
  828.                         TEMP1=6;
  829.         else if(TEMP1<60)
  830.                         TEMP1=7;
  831.         else if(TEMP1<65)
  832.                         TEMP1=8;
  833.         else if(TEMP1<70)
  834.                         TEMP1=9;
  835.         else if(TEMP1<75)
  836.                         TEMP1=10;
  837.         else if(TEMP1<80)
  838.                         TEMP1=11;
  839.         else if(TEMP1<96)
  840.                         TEMP1=12;
  841.         else if(TEMP1<125)
  842.                         TEMP1=13;
  843.         else if(TEMP1<156)
  844.                         TEMP1=14;
  845.         else if(TEMP1<189)
  846.                         TEMP1=15;
  847.         else if(TEMP1<224)
  848.                         TEMP1=16;
  849.         else if(TEMP1<261)
  850.                         TEMP1=17;
  851.         else if(TEMP1<300)
  852.                         TEMP1=18;
  853.         else if(TEMP1<341)
  854.                         TEMP1=19;
  855.         else if(TEMP1<384)
  856.                         TEMP1=20;
  857.         else if(TEMP1<429)
  858.                         TEMP1=21;
  859.         else if(TEMP1<476)
  860.                         TEMP1=22;
  861.         else if(TEMP1<525)
  862.                         TEMP1=23 ;
  863.         else if(TEMP1<576)
  864.                         TEMP1=24;
  865.         else if(TEMP1<629)
  866.                         TEMP1=25;
  867.         else if(TEMP1<684)
  868.                         TEMP1=26;
  869.         else if(TEMP1<741)
  870.                         TEMP1=27;
  871.         else if(TEMP1<800)
  872.                         TEMP1=28;
  873.         else if(TEMP1<861)
  874.                         TEMP1=29;
  875.         else if(TEMP1<1024)
  876.                         TEMP1=30;
  877.         else
  878.                         TEMP1=31;
  879.         
  880.             if(TEMP1>(LED_TAB[j]))
  881.                         LED_TAB[j]=TEMP1;   ////////////////开始j=17  j--     
  882.         if(TEMP1>(LED_TAB1[j]))
  883.         {   
  884.                         LED_TAB1[j]=TEMP1;
  885.             LED_TAB2[j]=80;  //12                                              //提顿速度=12
  886.         }
  887.         }
  888.   
  889.    
  890. }

  892. void scan(unsigned char Value)
  893. {switch(Value)
  894.         {case  0: scan0;break;
  895.                   case  1: scan1;break;
  896.                    case  2: scan2;break;
  897.                     case  3: scan3;break;
  898.              case  4: scan4;break;
  899.                       case  5: scan5;break;
  900.                        case  6: scan6;break;
  901.                         case  7: scan7;break;
  902.                  case  8: scan8;break;
  903.                        case  9: scan9;break;
  904.                       case 10:scan10;break;
  905.                      case 11:scan11;break;
  906.             case 12:scan12;break;
  907.                   case 13:scan13;break;
  908.                  case 14:scan14;break;
  909.             case 15:scan15;break;
  910.            default:break;
  911.         }
  912. }

  914. void Scan_Mode()   //扫描模式
  915. {
  916.         switch (Mode)
  917.         {
  918.                 case 0x00:
  919.                         fractional_frequency=16; //16分频
  920.                         break;
  921.                 case 0x01:
  922.                         fractional_frequency=24;// 64分频
  923.                         break;
  924.                 case 0x02:
  925.                         fractional_frequency=32; //预留功能

  927.                         break;
  928.                 default:
  929.                         fractional_frequency=64;//否则为16分频
  930.                         break;
  931.         }        
  932. }
复制代码





修改版64X32.zip (74.79 KB, 下载次数: 13)
回复

使用道具 举报

ID:419909 发表于 2021-5-18 20:34 | 显示全部楼层
这个扫描式的．而且有中断干扰．最容易闪和亮度不均匀了．很难调的．这种不适合做成品．试验练手来了解原理差不多．真正实用．还是要用专用芯片处理．单独的显示模块．采样处理与显示各自独立．
回复

使用道具 举报

ID:39866 发表于 2021-5-18 20:39 | 显示全部楼层
wfqxgw 发表于 2021-5-18 20:34
这个扫描式的．而且有中断干扰．最容易闪和亮度不均匀了．很难调的．这种不适合做成品．试验练手来了解原理 ...

谢谢大佬了，我才学习单片机，那天参考了论坛里面大佬的资料练手，成功了，显示啥的都没问题。就是响应特别慢，又从其他地方找了这个程序，响应速度可以，就是闪的眼睛不舒服。第一次成功玩单片机 想把这个做成能用的放起来
回复

使用道具 举报

ID:419909 发表于 2021-5-18 21:04 | 显示全部楼层
退而求次的方法就是把显示改为中断处理．且中断优先级为最高．但是这样可能会影响到其它功能．所以说．这是个很麻烦的事．要自己协调好各个函数功能占用时间
回复

使用道具 举报

ID:39866 发表于 2021-5-18 21:07 | 显示全部楼层
wfqxgw 发表于 2021-5-18 21:04
退而求次的方法就是把显示改为中断处理．且中断优先级为最高．但是这样可能会影响到其它功能．所以说．这是 ...

好吧，残废工程，我先学习吧，等后面了再研究怎么弄
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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