标题: 求助3264双色点阵音乐频谱的问题 [打印本页]

---

作者: 1qaz2wsx77    时间: 2025-4-19 16:01
标题: 求助3264双色点阵音乐频谱的问题
偶得一块3264双色的点阵屏，想用STC15的单片机做一个音乐频谱，频率24M。可整了几天也整不出来，烦请老师帮忙看一下问题出在哪？该如何改？代码中：ADC读取部分移植于12864音乐频谱显示，好用，显示部分就简单了。可到一起就不好用了。之所以没有用定时器控制显示，是不会计算ADC的时序，怕程序出现问题。另：本论坛中也有音乐频谱的相关资料，可没有一个上机能用的，为此我还专门买了STC12的单片机，不知问题出在哪。

1. #include<math.h>
   
2. 
   
3. #include <STC15.h>
   
4. 
   
5. #include "intrins.h"
   
6. #define uchar unsigned char
   
7. #define uint unsigned int
   
8. 
   
9. 
   
10. 
    
11. #define ADC_POWER   0x80     
    
12. #define ADC_FLAG    0x10     
    
13. #define ADC_START   0x08     
    
14. #define ADC_SPEEDLL 0x00     
    
15. #define ADC_SPEEDL  0x20     
    
16. #define ADC_SPEEDH  0x40     
    
17. #define ADC_SPEEDHH 0x60     
    
18. 
    
19. struct compx                                                                           
    
20. {
    
21.         float real;
    
22.         float imag;
    
23. };
    
24. 
    
25. xdata struct compx s[ 64 ];                                                      
    
26. struct compx EE(struct compx,struct compx);   
    
27. void FFT(struct compx xin[],int N);                                    
    
28. 
    
29. 
    
30. sbit  R1=P3^6;   
    
31. sbit  R2=P3^7;   
    
32. sbit  G1=P2^4;   
    
33. sbit  G2=P2^5;   
    
34. 
    
35. sbit  STB=P2^6;   
    
36. sbit  SCK=P2^7;   
    
37. sbit  OE=P3^5;         
    
38. 
    
39. sbit  IA=P2^0;   
    
40. sbit  IB=P2^1;   
    
41. sbit  IC=P2^2;   
    
42. sbit  ID=P2^3;   
    
43. 
    
44. 
    
45. uchar data row;                        
    
46. 
    
47. 
    
48. void xianshi();      
    
49. void hang();         
    
50. 
    
51. 
    
52. void InitADC()
    
53. {
    
54.           P1ASF =0x01;              
    
55.           P1M0 = 0x01;                    
    
56.           P1M1 = 0x01;              
    
57.     ADC_RES = 0;               
    
58.           ADC_RESL = 0;                  
    
59.     ADC_CONTR = ADC_POWER | ADC_SPEEDLL;         
    
60. }
    
61. 
    
62. 
    
63. unsigned int  GetADCResult(unsigned char  ch)
    
64. {
    
65.     ADC_CONTR = ADC_POWER | ADC_SPEEDHH | ch | ADC_START;
    
66.     _nop_();                        
    
67.     _nop_();
    
68.     _nop_();
    
69.     _nop_();
    
70.     while (!(ADC_CONTR & ADC_FLAG));
    
71.     ADC_CONTR &= ~ADC_FLAG;         
    
72.     return (ADC_RES<<2+ADC_RESL);               
    
73. }
    
74. 
    
75. 
    
76. struct compx EE(struct compx a1,struct compx b2)        
    
77. {
    
78.         struct compx b3;
    
79.         b3.real=a1.real*b2.real-a1.imag*b2.imag;
    
80.         b3.imag=a1.real*b2.imag+a1.imag*b2.real;
    
81.         return(b3);
    
82. }
    
83. 
    
84. void FFT(struct compx xin[],int N)                                 
    
85. {
    
86.         int f,m,nv2,nm1,i,k,j=1,l;
    
87.         struct compx v,w,t;
    
88.         nv2=N/2;
    
89.         f=N;
    
90.         for(m=1;(f=f/2)!=1;m++){;}
    
91.         nm1=N-1;
    
92.         for(i=0;i<nm1;i++)                                          
    
93.         {
    
94.                 if(i<j)
    
95.                 {
    
96.                         t=xin[j];
    
97.                         xin[j]=xin[i];
    
98.                         xin[i]=t;
    
99.                 }
    
100.                 k=nv2;                                                      
     
101.                 while(k<j)
     
102.                 {
     
103.                         j=j-k;
     
104.                         k=k/2;
     
105.                 }
     
106.                 j=j+k;
     
107.         }
     
108.         {
     
109.                 int le,lei,ip;
     
110.                   float pi;
     
111.                   for(l=1;l<=m;l++)
     
112.                    {
     
113.                 le=pow(2,l);                                                
     
114.                     lei=le/2;
     
115.                     pi=3.14159265;
     
116.                     v.real=1.0;
     
117.                 v.imag=0.0;  
     
118.                    w.real=cos(pi/lei);                                          
     
119.                     w.imag=-sin(pi/lei);
     
120.                   
     
121.                 for(j=1;j<=lei;j++)                                          
     
122.                      {
     
123.                         for(i=j-1;i<N;i=i+le)                                         
     
124.                               {
     
125.                                     ip=i+lei;
     
126.                                        t=EE(xin[ ip ],v);
     
127.                                        xin[ ip ].real=xin[ i ].real-t.real;   
     
128.                                        xin[ ip ].imag=xin[ i ].imag-t.imag;
     
129.                                        xin[ i ].real=xin[ i ].real+t.real;
     
130.                                        xin[ i ].imag=xin[ i ].imag+t.imag;
     
131.                               }
     
132.                               v=EE(v,w);   
     
133.                       }     
     
134.                    }
     
135.           }
     
136. }
     
137. 
     
138. 
     
139. void main (void)
     
140. {
     
141. 
     
142.         int N=64,i;                                                            
     
143.         float offset;
     
144. 
     
145.         P1M0=0x00;
     
146.   P1M1=0x00;
     
147.   P3M0=0x00;
     
148.   P3M1=0x00;
     
149.   P2M0=0x00;
     
150.   P2M1=0x00;
     
151. 
     
152.   InitADC();         
     
153.         offset=GetADCResult(0);
     
154.       
     
155.         while (1)         
     
156.         {
     
157.                         for(i=0;i<N;i++)                                      
     
158.                   {
     
159.                                 ADC_CONTR=0xC8;                                         
     
160. 
     
161.                                 while(!(ADC_CONTR&0x10));
     
162.                                    s[i].real=((float)ADC_RES*4+(float)(ADC_RESL%0x04)-offset)/4;  
     
163.                                    s[i].imag=0;
     
164.                   }
     
165.                        
     
166.                           FFT(s,N);        
     
167.                     xianshi();
     
168.         }
     
169. }
     
170. 
     
171. 
     
172. 
     
173. void hang(unsigned char Value)
     
174. {
     
175.         switch(Value)
     
176.         {
     
177.                                         case  0: {IA=0;IB=0;IC=0;ID=0;}break;
     
178.                       case  1: {IA=1;IB=0;IC=0;ID=0;}break;
     
179.                       case  2: {IA=0;IB=1;IC=0;ID=0;}break;
     
180.                       case  3: {IA=1;IB=1;IC=0;ID=0;}break;
     
181.           case  4: {IA=0;IB=0;IC=1;ID=0;}break;
     
182.                       case  5: {IA=1;IB=0;IC=1;ID=0;}break;
     
183.                       case  6: {IA=0;IB=1;IC=1;ID=0;}break;
     
184.                       case  7: {IA=1;IB=1;IC=1;ID=0;}break;
     
185.           case  8: {IA=0;IB=0;IC=0;ID=1;}break;
     
186.                       case  9: {IA=1;IB=0;IC=0;ID=1;}break;
     
187.                       case 10: {IA=0;IB=1;IC=0;ID=1;}break;
     
188.                       case 11: {IA=1;IB=1;IC=0;ID=1;}break;
     
189.           case 12: {IA=0;IB=0;IC=1;ID=1;}break;
     
190.                       case 13: {IA=1;IB=0;IC=1;ID=1;}break;
     
191.                        case 14: {IA=0;IB=1;IC=1;ID=1;}break;
     
192.                 case 15: {IA=1;IB=1;IC=1;ID=1;}break;
     
193.         }
     
194.                                        
     
195. }
     
196. 
     
197. 
     
198. void xianshi()
     
199. {
     
200.   unsigned char i,j;
     
201.         unsigned char dis_rdata[16];
     
202. 
     
203.         for(i=0;i<16;i++)         
     
204.         {
     
205.                 float t0=0;
     
206.                 t0=sqrt(pow((s[i  ].real+s[i+1].real),2)+pow((s[i  ].imag+s[i+1].imag),2))/2;
     
207.                 dis_rdata[i]=(unsigned char)t0;
     
208.         }
     
209. 
     
210.                          for(j=0;j<64;j++)           
     
211.                         {                                       
     
212.                                 SCK=0;
     
213.                                 SCK=1;
     
214. 
     
215.                                 if(dis_rdata[j]<=row+16) R1=1;
     
216.                                 else R1=0;
     
217.                                 if(dis_rdata[j]<=row) R2=1;
     
218.                                 else R2=0;
     
219.                         }
     
220. 
     
221.                 STB=1;
     
222.                 STB=0;                                
     
223. 
     
224.                 row++;
     
225.                         if(row>15)row=0;
     
226.                         OE=1;
     
227.                 hang(row);                        
     
228.                 OE=0;
     
229. }
     

复制代码

---

作者: 622323wjl    时间: 2025-4-19 22:31
### 代码问题分析
1. **头文件包含与编译器兼容性**
    - 代码中包含了`STC15.h`头文件，该头文件用于STC15系列单片机，对寄存器等进行定义。确保该头文件与所使用的编译器版本兼容，不同编译器对头文件的支持和解析可能存在差异。如果编译器对某些寄存器定义识别有误，可能导致程序运行异常。
    - 虽然包含了`math.h`用于运算（如在`FFT`函数中使用`pow`、`cos`、`sin`等函数），但在单片机开发中，`math.h`库函数的实现可能会消耗较多资源（如代码空间和运行时间）。对于资源有限的单片机（如STC15 ），可能需要考虑使用简化的运算替代方案，或者优化库函数的使用。
2. **ADC部分**
    - 在`InitADC`函数中，对`P1ASF`、`P1M0`、`P1M1`进行设置，用于配置ADC相关引脚的功能。确保这些设置与实际硬件连接匹配，例如所选的ADC通道引脚是否正确配置为模拟输入功能。
    - 在`GetADCResult`函数中，通过设置`ADC_CONTR`寄存器启动ADC转换，并等待转换完成标志位。这里存在一个潜在问题，在等待转换完成标志位时，只是简单地循环检测，没有添加超时机制。如果ADC转换出现异常，可能导致程序进入死循环。可以添加一个计数器，在一定次数检测后跳出循环并进行错误处理。
3. **FFT（快速傅里叶变换）部分**
    - `FFT`函数实现较为复杂，在计算过程中涉及到大量的复数运算（通过`EE`函数实现复数乘法 ）。需要仔细检查复数运算逻辑是否正确，例如`EE`函数中复数乘法的计算是否符合数学定义，确保在运算过程中不会出现精度丢失或计算错误，影响FFT结果的准确性。
    - 在`FFT`函数中，一些变量的初始化和计算逻辑可能存在问题。例如`for(m = 1;(f = f/2) != 1;m++){;}`这部分代码用于计算FFT的级数，要确保计算结果正确，否则后续的蝶形运算可能会出现错误。
4. **显示部分**
    - 在`xianshi`函数中，计算频谱数据并控制点阵屏显示。这里计算频谱数据的方式是根据FFT结果进行简单处理，需要确认这种处理方式是否能准确反映音乐频谱。例如，计算平方根等操作是否符合实际频谱显示需求。
    - 点阵屏的显示控制逻辑较为简单，通过`SCK`、`STB`、`OE`等引脚控制数据传输和显示。需要检查这些引脚的时序是否与点阵屏的硬件要求严格匹配。如果时序出现偏差，可能导致显示异常，如显示乱码、部分区域不显示等问题。同时，在控制`R1`、`R2`等引脚时，判断条件和逻辑可能需要进一步优化，以实现更准确的频谱显示效果。
5. **整体时序与资源管理**
    - 由于没有使用定时器控制显示，而是在主循环中不断进行ADC读取、FFT计算和显示操作，可能导致各部分操作的时序混乱。例如，ADC读取频率可能与FFT计算和显示频率不匹配，影响最终的频谱显示效果。建议使用定时器来精确控制各部分操作的时间间隔，确保程序运行的稳定性和准确性。
    - STC15单片机资源有限，在进行ADC读取、FFT计算和点阵屏显示等操作时，要注意资源管理。例如，代码中定义了较多的变量（如`xdata struct compx s[64]` ），需要确保这些变量的存储不会超出单片机的内存限制。同时，FFT计算等操作可能会占用较多的计算资源和时间，要合理优化算法，避免程序运行过于缓慢或出现死机现象。

### 改进建议
1. **ADC部分改进**
    - 在`GetADCResult`函数中添加超时机制。例如：
```c
unsigned int GetADCResult(unsigned char ch)
{
    int timeout = 100; // 设置超时次数
    ADC_CONTR = ADC_POWER | ADC_SPEEDHH | ch | ADC_START;
    _nop_();
    _nop_();
    _nop_();
    _nop_();
    while (!(ADC_CONTR & ADC_FLAG) && timeout > 0) {
        timeout--;
    }
    if (timeout == 0) {
        // 处理超时错误，例如返回一个错误值
        return 0xFFFF;
    }
    ADC_CONTR &= ~ADC_FLAG;
    return (ADC_RES<<2+ADC_RESL);
}
```
2. **FFT部分改进**
    - 对`FFT`函数中的变量初始化和计算逻辑进行详细验证。可以通过打印中间变量的值等方式，检查每一步计算是否正确。例如，在计算级数的部分：
```c
for(m = 1;(f = f/2) != 1;m++){;}
// 可以添加打印语句，查看m和f的值是否符合预期
// 如：printf("m = %d, f = %d\n", m, f);
```
    - 优化复数运算部分的代码，提高计算精度和效率。可以参考一些成熟的FFT算法实现，对比检查代码中的运算逻辑是否正确。
3. **显示部分改进**
    - 重新评估频谱数据的计算方式，可以参考相关的音乐频谱显示算法资料，确保计算出的数据能准确反映音乐频谱。
    - 使用示波器等工具测量点阵屏控制引脚的时序，与点阵屏的硬件手册进行对比，精确调整时序逻辑。例如，确保`SCK`、`STB`等信号的脉冲宽度、上升沿和下降沿时间等符合要求。
4. **整体时序与资源管理改进**
    - 使用定时器来控制程序的运行时序。例如，设置一个定时器中断，每隔一定时间（如根据音乐信号的频率和采样要求确定 ）触发一次ADC读取操作，然后进行FFT计算和显示操作。在STC15单片机中，可以通过配置定时器相关寄存器来实现。
    - 对代码中的变量进行优化，合理分配内存资源。如果内存紧张，可以考虑减少不必要的变量定义，或者对一些变量进行复用。同时，对FFT等复杂算法进行优化，减少计算资源的消耗。例如，可以使用定点运算替代部分浮点运算，以提高运算速度和减少资源占用。

---

作者: 1qaz2wsx77    时间: 2025-4-20 07:57

622323wjl 发表于 2025-4-19 22:31
### 代码问题分析
1. **头文件包含与编译器兼容性**
    - 代码中包含了`STC15.h`头文件，该头文件用于ST ...

感谢！谢谢你的指导，分析的很有道理。比DeepSeek分析的还好。

---

作者: wl20020807    时间: 2025-8-15 15:38

1qaz2wsx77 发表于 2025-4-20 07:57
感谢！谢谢你的指导，分析的很有道理。比DeepSeek分析的还好。

程序改进得如何了

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1