标题: 如何通过单片机串口改变频率? [打印本页]

---

作者: starry1    时间: 2021-6-2 19:21
标题: 如何通过单片机串口改变频率?

怎么实现题目的第四个功能，前三个已经实现了，有没有大佬会,再原有的基础上实现第四个功能或者不用那么全，只是能通过串口发送一个字母然后改变一下频率也行，实在是不会了

单片机源程序如下:

1. #include<reg51.h>      
   
2. #include<intrins.h>
   
3. #define uchar unsigned char   
   
4. #define uint unsigned int
   
5. 
   
6. sbit s1=P1^0;         
   
7. sbit s2=P1^1;
   
8. sbit s3=P1^2;
   
9. 
   
10. 
    
11.                                                                            
    
12. sbit lcdrs=P1^6;      
    
13. sbit lcden=P1^7;
    
14. 
    
15. 
    
16. char num,boxing,u;      
    
17. int pinlv=50,bujin=10,bujin1=10;
    
18. uchar geshu=1;
    
19. uchar code table[]="0123456789";
    
20. uchar code table1[]="pinlv:boxing:";
    
21. unsigned long int m;
    
22. int n=0;
    
23. float hc=0;
    
24. int a,b,h,num1;
    
25. uchar code sin[64]={
    
26. 135,145,158,167,176,188,199,209,218,226,234,240,245,249,252,254,254,253,251,247,243,237,230,222,213,204,193,182,170,158,
    
27. 146,133,121,108,96,84,72,61,50,41,32,24,17,11,7,3,1,0,0,2,5,9,14,20,28,36,45,55,66,78,90,102,114,128
    
28. };                                          //ÕyÏò2¨è¡Âë
    
29. 
    
30. 
    
31. void delay(uint xms)
    
32. {
    
33.         int a,b;
    
34.         for(a=xms;a>0;a--)
    
35.                 for(b=110;b>0;b--);
    
36. }
    
37. void write_com(uchar com)
    
38. {
    
39.         lcdrs=0;
    
40.         P0=com;        
    
41.         delay(1);
    
42.         lcden=1;
    
43.         delay(1);                                                                           
    
44.         lcden=0;
    
45. }
    
46. 
    
47. void write_date(uchar date)
    
48. {
    
49.         lcdrs=1;
    
50.         P0=date;
    
51.         delay(1);
    
52.         lcden=1;
    
53.         delay(1);
    
54.         lcden=0;
    
55. }
    
56. 
    
57. void init_lcd()
    
58. {                                                                  
    
59.         lcden=0;¼  
    
60.         write_com(0x0f);
    
61.         write_com(0x38);
    
62.         write_com(0x01);
    
63.         write_com(0x0c);
    
64.         write_com(0x06);
    
65.         write_com(0x80);
    
66. }
    
67. void initclock()   
    
68. {
    
69.         uint i;
    
70.         TMOD=0x01;
    
71.         TH0=a;
    
72.         TL0=b;
    
73.         EA=1;
    
74.         ET0=1;
    
75.         TR0=1;
    
76.         for(i=6;i<13;i++)     
    
77.         {
    
78.                 write_date(table1[i]);
    
79.                 delay(2);
    
80.         }
    
81.         write_com(0x80+0x40);
    
82.         for(i=0;i<6;i++)
    
83.         {
    
84.                 write_date(table1[i]);
    
85.                 delay(2);
    
86.         }
    
87.         write_com(0x80+7);
    
88.                 write_date('s');
    
89.                 write_date('i');
    
90.                 write_date('n');
    
91.                 write_date(' ');
    
92.                 write_date(' ');
    
93.                 write_date(' ');
    
94.                 write_date(' ');
    
95.                 write_com(0x80+0x40+0xa);
    
96.                 write_date(' ');
    
97.                 write_date('1');
    
98.                 write_date('0');
    
99.                 write_date('H');
    
100.                 delay(2);
     
101.                 write_date('Z');
     
102.                 delay(2);
     
103. }
     
104. void display()      
     
105. {
     
106.         uchar wan,qian,bai,shi,ge;
     
107.         uint a=0;
     
108.         a=pinlv;
     
109.         wan=a/10000;
     
110.         qian=a/1000%10;
     
111.         bai=a/100%10;
     
112.         shi=a%100/10;
     
113.         ge=a%100%10;
     
114.         write_com(0x80+0x40+8);
     
115.         write_date(table[wan]);
     
116.         delay(2);
     
117.         write_date(table[qian]);
     
118.         delay(2);
     
119.         write_date(table[bai]);
     
120.         delay(2);
     
121.         
     
122.         write_date(table[shi]);
     
123.         delay(2);
     
124.         write_date(table[ge]);
     
125.         delay(2);
     
126.         write_date('H');
     
127.         delay(2);
     
128.         write_date('Z');
     
129.         delay(2);
     
130.         if(boxing==0)
     
131.         {
     
132.                 write_com(0x80+7);
     
133.                 write_date('s');
     
134.                 write_date('i');
     
135.                 write_date('n');
     
136.                 write_date(' ');
     
137.                 write_date(' ');
     
138.                 write_date(' ');
     
139.                 write_date(' ');
     
140.         }
     
141. 
     
142. 
     
143. }
     
144. uchar keyscan()
     
145. {
     
146. //        if(P1&0x0F==0x0F) return 0;
     
147.         if(s1==0)
     
148.         {         
     
149.                 EA=0;
     
150.                 delay(1);
     
151.                 if(s1==0)
     
152.                 {
     
153.                         while(!s1);
     
154.                         pinlv+=bujin;
     
155.                         if(pinlv>30000)
     
156.                         {
     
157.                                 pinlv=30000;
     
158.                         }
     
159.                         geshu=pinlv/120+1;
     
160.                         if(pinlv>960)
     
161.                         {
     
162.                                 geshu=8;
     
163.                                 bujin=100;
     
164.                                 bujin1=100;
     
165.                         }
     
166.                         if(pinlv>1080) geshu=10;
     
167.                         if(pinlv>2000) geshu=11;
     
168. 
     
169.                         hc=15625/pinlv;
     
170.                         m=hc*geshu;
     
171.                         m-=54;
     
172.                         m/=15;
     
173.                         
     
174.                         EA=1;
     
175.                         display();
     
176.                         
     
177.                 }
     
178.         }
     
179.         if(s2==0)
     
180.         {         
     
181.                
     
182.                 delay(1);
     
183.                 if(s2==0)
     
184.                 {
     
185.                         EA=0;        
     
186.                         while(!s2);
     
187.                         pinlv-=bujin;
     
188.                         if(pinlv<0)
     
189.                         {
     
190.                                 pinlv=0;
     
191.                         }
     
192.                         geshu=pinlv/120+1;
     
193.                         if(pinlv>960)
     
194.                         {
     
195.                                 geshu=8;
     
196.                                 bujin=100;
     
197.                                 bujin1=100;
     
198.                         }
     
199.                         if(pinlv>1080) geshu=10;
     
200.                         if(pinlv>2000) geshu=11;
     
201.                         if(pinlv<=3100)
     
202.                                 {hc=15625/pinlv;
     
203.                                 m=hc*geshu;
     
204.                                 m-=54;
     
205.                                 m/=15;}        
     
206.                         else
     
207.                         {
     
208.                                 m=65276+(pinlv-480);
     
209.                         }
     
210.                         display();        
     
211.                         EA=1;
     
212.                 }
     
213.         }
     
214.         if(s3==0)
     
215.         {         
     
216.                 delay(1);
     
217.                 if(s3==0)
     
218.                 {
     
219.                         EA=0;
     
220.                         while(!s3);
     
221.                         if(pinlv!=10)
     
222.                         {
     
223.                            pinlv=10;
     
224.                      hc=15625/pinlv;
     
225.                            m=hc*geshu;
     
226.                                  m-=54;
     
227.                            m/=15;
     
228.                         }
     
229.                         else if(pinlv==10)
     
230.                         {
     
231.                            pinlv=100;
     
232.                                  hc=15625/pinlv;
     
233.                            m=hc*geshu;
     
234.                                  m-=54;
     
235.                            m/=15;
     
236.                                 }
     
237.                         
     
238.                         display();
     
239.                         EA=1;
     
240. 
     
241.                 }
     
242.         }
     
243.         return 1;        
     
244. }
     
245. 
     
246. void main()
     
247. {        
     
248.         
     
249.         init_lcd();
     
250.         hc=15625/pinlv;
     
251.         m=hc*geshu;
     
252.         m-=54;
     
253.         m/=15;
     
254. 
     
255.         initclock();
     
256.         display();
     
257. //        csda=0;
     
258. //        wr=0;
     
259.         while(1)
     
260.         {
     
261.                  
     
262.                  switch(boxing)
     
263.                  {
     
264.                          case 0:        P2=sin[u];
     
265.                                 break;
     
266. 
     
267.                  }
     
268.                 u+=geshu;
     
269.                 n=m;
     
270.                 if(u>=64)
     
271.                 {
     
272.                         u=0;
     
273.                 }
     
274.                 while(n-->0);
     
275.         }
     
276. }
     
277. void T0_time()interrupt 1   
     
278. {
     
279.         
     
280. 
     
281. //                TH0=a;
     
282. //                TL0=b;
     
283.                 TH0=0;
     
284.                 TL0=0;
     
285.                 if(h==0)
     
286.                  {
     
287.                           keyscan();
     
288.                  }
     
289. }

复制代码

---

作者: wdgao    时间: 2021-6-2 22:14
这就相当于50个动作，可以通过串口发送编码，接收编码解码后控制即可。

---

作者: shhds    时间: 2021-6-2 22:56
我的程序大概就这样
#include<reg51.h>
#include<absacc.h>

#define DAC0832 XBYTE[0x8000]
#define zkb 25
unsigned char tamp=0xff,a=0;
unsigned char b = 0;

void UartInit()
{
        SCON =0x50; // SCON: 模式 1, 8-bit UART, 使能接收
        TMOD |= 0x20; // TMOD:timer 1, mode 2, 8-bit 重装
        TH1 =TL1= 0xFD; // TH1: 重装值9600 波特率 晶振 11.0592MHz
        TR1 =1; // TR1: timer 1 打开
        EA = 1; //打开总中断
        ES = 1; //打开串口中断
        PCON=0;
}

void main()
{

        TMOD=0x01;
        EA=1;
        TR0=1;
        ET0=1;
  TH0 = 0xF7;
        TL0 = 0x00;
        DAC0832=tamp;
        UartInit();
        while(1);
        
}

void js() interrupt 1
{
        if(b == '1')
        {
                TH0 = 0x0f;
                TL0 = 0x00;
        }
        else
        {
                TH0 = 0xF7;
                TL0 = 0x00;
        }
        a++;
        if(a==(zkb*2)/5)
        {
                tamp=~tamp;
                DAC0832=tamp;        
        }
        if(a==40)
        {
                tamp=~tamp;
                DAC0832=tamp;
                a=0;
        }
               
}

void Uart_Receive(void) interrupt 4         
{
//        unsigned char ch,num;
        ES = 0;
        
        if (RI)                                        //如果接收完成则进入
        {
                b = SBUF;
        }
        RI = 0;                            //RI清0，重新接收
        ES = 1;                            //串口1中断允许                        
}

0.png (98.92 KB, 下载次数: 56)

下载附件

2021-6-2 23:04 上传

---

作者: shumivan    时间: 2021-6-16 08:42
直接输入数值进行转换不行吗,不要搞太复杂.

---

作者: fefen0    时间: 2021-6-16 09:12
#include <reg52.h>
#include <math.h>
#define uchar unsigned char
#define uint unsigned int
#define DA_DATA  P1    //DAC0832数据口
#define AMP_DEFAULT      5.0f    //默认幅值  单位：V
#define AMP_MAX          12.0f   //最大幅值为12
#define AMP_MIN          0.0f    //最小幅值
#define T                1000     //计时周期  单位：us
#define CYCLE_DEFAULT    1000    //默认正弦周期   单位：us
#define CYCLE_MAX        20000    //最大周期
#define CYCLE_MIN                 1000
#define PI               3.1415926f

/****************************变量*******************************/
uint Angle = 0;   //角度  0-360
int time = 0;            //计时
int cycle_T = 0;    //正弦周期
float Amp = 0.0f;

//定义DAC0832接口
sbit DA_WR = P2^1;         //写输入信号
sbit DA_CS = P2^0;   //片选信号


//定义按键接口
sbit key0 = P2^2;  //增大周期
sbit key1 = P2^3;  //减小周期
sbit key2 = P2^4;  //增大幅值
sbit key3 = P2^5;  //减小幅值

//延时
void delayms(int x)
{  uint i,j;
    for(i=x;i>0;i--)
          for(j=110;j>0;j--);
}

/**********************************
外设初始化函数
***********************************/
void da_init()          
{
   DA_WR = 0;
   DA_CS = 0;
   DA_DATA = 0;
   key0 = 1;   //按键置高
   key1 = 1;   //按键置高
   key2 = 1;   //按键置高
   key3 = 1;   //按键置高
}
/**********************************
定时器初始化函数
***********************************/
void init()          
{
   TMOD = 0x01;        //设置定时器工作方式，第二位为定时器0
   TH0 = (65536 - T)/256; //定时器0高8位  定时时间1ms
   TL0 = (65536 - T)/256; //定时器0低8位
   TR0 = 1;           //打开定时器
   ET0 = 1;           //开定时器中断
   EA = 1;     //开总中断
}

/**********************************
按键检测函数
***********************************/
void key_check()
{
   /*按键端口置高*/
   key0 = 1;
   key1 = 1;
   key2 = 1;
   key3 = 1;

   /*增大周期*/
   if(key0 == 0)
   {
                   delayms(5);         //按键消抖
                if(key0 == 0)   
                {
                  cycle_T = cycle_T + 2000;   //每次增加2000us
                  /*限幅*/
                  if (cycle_T > CYCLE_MAX)
                  {
                          cycle_T        =  CYCLE_MAX;
                  }
                }
                while(!key0);        //等待按键松开
   }
   /*减小周期*/
   if(key1 == 0)
   {
                   delayms(5);         //按键消抖
                if(key1 == 0)   
                {
                  cycle_T = cycle_T - 2000;   //每次减小2000us
                  /*限幅*/
                  if (cycle_T < CYCLE_MIN)
                  {
                          cycle_T        =  CYCLE_MIN;
                  }
                }
                while(!key1);        //等待按键松开
   }
   /*增大幅值*/
   if(key2 == 0)
   {
                   delayms(5);         //按键消抖
                if(key2 == 0)   
                {
                  Amp = Amp + 1.0f;
                  if (Amp >= AMP_MAX)
                           Amp = AMP_MAX;
                }
                while(!key2);        //等待按键松开
   }
   /*减小幅值*/
   if(key3 == 0)
   {
                   delayms(5);         //按键消抖
                if(key3 == 0)   
                {
                  Amp = Amp - 1.0f;
                  if (Amp <= AMP_MIN)
                           Amp = AMP_MIN;
                }
                while(!key3);        //等待按键松开
   }

}

/**********************************
波形发生函数
***********************************/
void wave()
{
        float sinAngle = 0.0f;

        Angle ++;   //角度自加
        if (Angle >= 360)
                Angle = 0;       
        sinAngle = sin(((float)Angle * PI / 180.0f));   //求角度对应的正弦值  返回[-1,1]
        sinAngle = sinAngle * Amp / AMP_MAX;     //按照幅值范围等比例放大缩小
        DA_DATA         = (int)(((sinAngle + 1.0f) / 2.0f) * 255.0f);
}

void main()
{  
   init(); //定时器初始化
   cycle_T = CYCLE_DEFAULT;  //初始化为默认正弦周期
   Amp = AMP_DEFAULT;       //初始化为默认幅值     
   da_init();    //DA初始化
   while(1)
   {  
     key_check();
   }
}

void T0_time() interrupt 1
{
        TH0 = (65536 - T)/256; //定时器0高8位  定时时间1ms
    TL0 = (65536 - T)/256; //定时器0低8位
        time ++;
        if (time > (cycle_T / T))   //0.1ms
        {
           time = 0;
           wave();          //波形发生函数
        }       
}

---

作者: fefen0    时间: 2021-6-16 09:12
不懂得再问

---

作者: lsgzq    时间: 2021-6-16 18:01
给你说一个思路，程序你自己写。通过上位机串口发送一串十六进的数字，单片机串口收到这个数字后，用接收到的数字给单片机的频率发生定时器赋值，用赋值改变定时器的初值，就可能实现串口调节频率。
      例如串口收到6，就给定时器的初值减1、串口收到8，就给定时器的初值加1，从而实现频率的升或降。

---

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

Powered by Discuz! X3.1