单片机智能温控风扇设计 带智能调速人体感应 毕业设计论文

helendcany

单片机智能温控风扇设计 带智能调速人体感应 毕业设计论文
+ D4 ]+ O' h4 {3 C- `( ?0 @1 Z* i
% r' H* A2 \- g) `' R8 O" `# v
& l* P: m) T1 k4 G51单片机做的温空风扇 数码管显示 带人体感应模块，实现智能调速，功能非常强大，这是一个本科的毕业设计，毕业论文 开题报告 源码 原理图 还有proteus仿真等等都是一应俱全. 还有答辩常见问题解答，焊接注意事项和调试讲解，以及详细的制作过程.

" v% s3 O5 x! T/ g0 Z8 @/ g7 r温空风扇实物图：


8 E& o$ N7 g' ]2 {: K# u温空风扇仿真截图：


温空风扇的DXP格式 protel99格式 温控风扇原理图：

& X7 J5 [. U# |  P: D, d
DXP格式用            altium designer Summer 软件打开
$ i. ^) n1 y& h2 `/ I  uprotel99格式用       protel99SE 软件打开
1 q' N  ?# V# ]$ }$ zPDF格式用            PDF 软件打开
Word格式用           Word 或用WPS 软件打开
7 Z, b' ~# x5 x, X0 W# X
! e1 u* d5 ~; Z, X4种格式的原理图都内容是一样的  只是打开方式不同
+ c, d0 U7 h: m9 b, Q
请看原理图焊接，不要看仿真图焊接。
' }$ C+ X- q2 V* ?, d  K% y9 g
) t) w8 J6 n1 y7 [. }6 S) D5 Dwrod格式里面的原理图是复制出来的，有一点点变行变形，麻烦大家注意一下，尽量看其他三种格式的图焊接，

如果论文里面的原理图和原理图文件夹内的图不一样的话，请大家以原理图文件夹内的为准，原理图文件夹的图是和实物配套的，可以自己截图或复制，然后粘贴到论文里面去。
' t  G7 ~" X7 V0 _) k- j
8 S* n' m% a& z智能调速温控风扇的毕业论文截图：

, ^- v, @5 A. n/ n7 }目 录
! t# V$ ~# `; {$ G. \; i绪  论    4
8 q5 g! i$ p0 Z8 L7 ?% Y: p1  系统概述    5
* n2 y, P9 G. ~3 T* j1 l6 c1.1  STC89C52单片机简介    5
9 c% @; t' O0 p& f; x1. 2  本设计任务和主要内容    5
" E5 K& V' T+ T7 y" K+ b2  方案论证    6
, N4 r4 H% z# {/ {! q. ^& U2．1 温度传感器的选用    6
2．2  控制核心的选择    7
2．3显示电路    7
2．4调速方式    7
2．5控制执行部件    8
( K9 l; ?8 l. j/ e2 K  m3 系统原理    8
+ b9 T0 j1 H7 J% {  C3.1  系统总体设计    8
7 m6 I( ]. Z) s" R3.2  控制装置原理    9
3．3  温度检测和显示电路    9
# Q% g) g1 d, g& W( A1 v3.3.1  DS18B20的温度处理方法    9
3.3.2  温度传感器和显示电路组成    11
  @& E& @" N+ E  n2 P) J# M6 ~3.4  电机调速电路    11
3.4.1  电机调速原理    12
7 ]" v, R: l( R/ V. e6 g: S. |8 G3.4.2  电机控制模块设计    13
4  控制器软件设计    14
" s9 W5 G* |: _7 P. U9 H' ?4.1  主程序    14
4.2  数字温度传感器模块和显示子模块    15
* d7 l7 O$ Q+ K  H4.3  电机调速与控制子模块    17
+ b  c- e& t% K9 `/ h+ Y+ m# C: }, N结 束 语    19
参考文献    20
, [3 P( }, \, Y5 l附录一    21

0 I( ~8 |  x1 d$ n& i6 x元件清单：
8 x( c( T' J  f0 g! k; Q

Comment	Description	Designator	Quantity
10uF	电容	C1	1
20	电容	C2, C3	2
	发光二极管	D1	1
SMG04_1	数码管	DS1	1
红外热释电	人体感应传感器	P1	1
Header 2	电源接口	P2, P3	2
9012	三极管	Q1, Q2, Q3, Q4, Q5	5
1K	电阻	R1, R2, R3, R8, R9,  R10, R11, R12	8
1K	电阻	R4, R5, R6, R7, R15	5
1K	电阻	R13	1
10K	电阻	R14, R16	2
SW-PB	按键	S1, S2, S3, S4	4
sw-灰色	电源开关	SW1	1
单片机	单片机	U1	1
DS18B20	温度传感器	U2	1
12M	晶振	Y1	1

8 _; j& U2 w, U5 E温空风扇程序：
$ G! R% i  Y& s如果没有装KEIL软件
找到  .c   .h结尾的文件即为程序。打开方式选择记事本打开
7 v9 F( F' x  }3 n) R或者到开发资料里安装KEIL软件
! P1 ^, W7 r1 P# p8 E/ S; Q
) m8 Z, U3 d' B1 I
" K: K5 j9 l# l  O1 c



#include <reg52.h>                 //调用单片机头文件
#define uchar unsigned char  //无符号字符型 宏定义        变量范围0~255
$ _9 @. b# i1 y6 Q" W! X9 j" G#define uint  unsigned int         //无符号整型 宏定义        变量范围0~65535

1 ^1 G) ?% R4 I* S3 U! y7 N
//数码管段选定义      0     1    2    3    4    5        6         7          8           9        
% B$ W* ?3 Y3 X- [' y' i  \/ W  ouchar code smg_du[]={0x28,0xe4,0x42,0x72,0xe5,0xa8,0x41,0x77,0x20,0xa0,
6 V6 s8 z' I0 m; I% _                                           0x60,0x25,0x39,0x26,0x31,0x71,0xff};         //断码
8 N/ [7 d; V2 y( w//数码管位选定义
/ O3 s* F/ {- f7 {! Puchar code smg_we[]={0xef,0xdf,0xbf,0x7f};
- I- `9 Z" }. |6 O/ w' Buchar dis_smg[8] = {0};        
uchar smg_i = 3;    //显示数码管的个位数
sbit dq   = P2^4;        //18b20 IO口的定义
2 B1 E1 [% X, X$ W. @sbit hw = P2^5;
+ g, Q4 x% q# v7 _1 c' auchar miao = 30;
9 R( U( a1 O1 B* B% P. O9 Zuchar flag_en;
1 D/ g8 a& w6 ]' X0 O
2 ], F+ M3 G1 _
bit flag_lj_en;                 //按键连加使能
$ x, X# g) o6 q& M7 R. o7 bbit flag_lj_3_en;         //按键连3次连加后使能  加的数就越大了
6 p# c. m5 i: _4 \# G- x' S# Z8 Wuchar key_time,key_value;      //用做连加的中间变量
bit key_500ms  ;
sbit pwm = P2^3;  
uchar f_pwm_l ;          //越小越慢

$ Z3 r+ ?- j4 w
& t" q. A% X% ?1 v; j7 Wuint temperature ;  //
bit flag_200ms ;
1 T- t3 j- i5 w" G9 \5 L; Buchar menu_1;       //菜单设计的变量
. I7 f2 ]2 a( o1 B4 @3 wuint t_high = 200,t_low = 100;           //温度上下限报警值
5 @  K. }6 F# |4 N4 @

/***********************1ms延时函数*****************************/
' N7 H" g3 o7 |" r: Qvoid delay_1ms(uint q)
{
        uint i,j;
        for(i=0;i<q;i++)
                for(j=0;j<120;j++);
}
! D7 l9 M  E* s
1 w! m, N* ]0 \5 v
/***********************小延时函数*****************************/
2 ~4 n/ q' P' `9 }void delay_uint(uint q)
{
5 {6 p; w# b& |, h7 l) L        while(q--);
: d9 Z. |9 q# W5 P  w}
* @3 I% l; _: c0 f
1 L" U4 t! ?; m2 l" W


/***********************数码显示函数*****************************/
void display()
{
        static uchar i;   
4 C3 \1 P! {5 V8 V# L        i++;
        if(i >= smg_i)
                i = 0;        
, N" ~; X; i* }2 Q        P1 = 0xff;                         //消隐
1 L- h2 J' }3 P$ |        P3 = smg_we;                          //位选
. h2 d1 z( E8 J( G$ h+ l' ^        P1 = dis_smg;                 //段选               
6 J8 F1 e1 n9 D7 o. v  n2 N

}
; }8 H% A- Z3 }6 g. w7 s! y! [, ]
( A  B5 v" S7 l+ w* l" X2 @
% ~0 e: U/ d2 z& l/***********************18b20初始化函数*****************************/
void init_18b20()
1 g0 l6 N: d/ Y# I0 i: {{
- a7 [. A* K" b0 |6 s7 v        bit q;
        dq = 1;                                //把总线拿高
        delay_uint(1);            //15us
        dq = 0;                                //给复位脉冲
        delay_uint(80);                //750us
; Z4 h+ |9 t, p        dq = 1;                                //把总线拿高 等待
        delay_uint(10);                //110us
        q = dq;                                //读取18b20初始化信号
        delay_uint(20);                //200us
        dq = 1;                                //把总线拿高 释放总线
}


: L9 D( w+ z$ q* z/*************写18b20内的数据***************/
& U: z  V  g  O! a& G6 Cvoid write_18b20(uchar dat)
5 Y$ Y, ^; U  t1 j% u% Y9 @{
( w6 L( v) Z- e/ z8 Y4 _7 f        uchar i;
        for(i=0;i<8;i++)
        {                                         //写数据是低位开始
                dq = 0;                         //把总线拿低写时间隙开始
7 U: D* C! O& Y$ S. Q; G0 e                dq = dat & 0x01; //向18b20总线写数据了
, s& a* E- H2 F3 X                delay_uint(5);         // 60us
                dq = 1;                         //释放总线
                dat >>= 1;
! p( C+ Z* \# S; p' i, k6 Q        }        
}
- r# C/ X, t0 M3 V6 {8 c- {9 Q% p/ |

! Z$ D5 r  d- ?- u9 u, U' {- o% a/*************读取18b20内的数据***************/
: ^1 D# A. Z+ `$ U: ?4 ^3 suchar read_18b20()
{
        uchar i,value;
        for(i=0;i<8;i++)
        {
3 S; J2 Z8 r7 m, U( n) b                dq = 0;                         //把总线拿低读时间隙开始
                value >>= 1;         //读数据是低位开始
  p, _' @8 F# n* r2 M; V. c                dq = 1;                         //释放总线
5 b# B7 \3 y; A+ `6 Y, C                if(dq == 1)                 //开始读写数据
                        value |= 0x80;
                delay_uint(5);         //60us        读一个时间隙最少要保持60us的时间
, v, i2 l" P7 c+ B        }
        return value;                 //返回数据
; w+ w+ w4 n6 n/ [+ Q! F+ y}
! @: h7 x8 g' X

+ b7 ?  o0 D2 a( `. c) M/*************读取温度的值 读出来的是小数***************/
! L! r6 O) W' X4 Puint read_temp()
2 Q0 B7 p/ P- z. v# N{
        uint value;
        uchar low;                           //在读取温度的时候如果中断的太频繁了，就应该把中断给关了，否则会影响到18b20的时序
  l& J/ K" e2 M9 t. W        init_18b20();                   //初始化18b20
1 c. y" K! Z5 D8 o5 w& s$ E* G1 v5 S/ p        write_18b20(0xcc);           //跳过64位ROM
8 e' b* p" i% n: A' {5 k1 y4 ~/ S        write_18b20(0x44);           //启动一次温度转换命令
4 K" Q5 G7 W( ?' q& @        delay_uint(50);                   //500us
& q1 r7 l. \1 i! i  y  K

3 T9 e: N% \: f# B1 C, K. t        init_18b20();                   //初始化18b20
        
        write_18b20(0xcc);           //跳过64位ROM
8 b0 p1 I8 @3 q        write_18b20(0xbe);           //发出读取暂存器命令
- }8 D. j6 {; I& z. V2 Y        
        low = read_18b20();           //读温度低字节
+ _1 u% S5 ~6 {2 Q3 L, m        value = read_18b20();  //读温度高字节
' j* ]! e# [/ z0 v        value <<= 8;                   //把温度的高位左移8位
        value |= low;                   //把读出的温度低位放到value的低八位中
4 }, Q! l0 m& f; l8 _        value *= 0.625;               //转换到温度值 小数
4 g" m/ F5 V# n* _; @        return value;                   //返回读出的温度 带小数
2 S3 \4 V  B& m! g: F6 }}

) t- R# B! C% W( `1 E7 H
/*************定时器0初始化程序***************/
6 n, j4 p; q+ ]* ]" @/ kvoid time_init()         
{
2 F% w7 w5 {- k) Q7 ^4 X2 M        EA   = 1;                   //开总中断
3 m1 M6 U% O& ^% o+ j0 e        TMOD = 0X21;          //定时器0、定时器1工作方式1
        ET0  = 1;                  //开定时器0中断
/ ], i6 V9 X% X        TR0  = 1;                  //允许定时器0定时


        ET1  = 1;                  //开定时器0中断
        TR1  = 1;                  //允许定时器0定时
}
  ~2 s- Q. z- N# S  C* j9 Y/ l
6 l  i  j) q7 M  i9 b
3 Q8 g  {" k5 s  @* s/********************独立按键程序*****************/
' k1 T( w+ \: \- S$ F) N0 Ruchar key_can;         //按键值


! c+ [) Z: |; H4 X  m* Qvoid key()         //独立按键程序
{
        static uchar key_new;
        key_can = 20;                   //按键值还原
        P2 |= 0x07;
) E9 `: r. n. R        if((P2 & 0x07) != 0x07)                //按键按下
' I0 |% h- q* _7 V$ l        {
                if(key_500ms == 1)        //连加
                {
                        key_500ms = 0;
2 w4 y( ^1 V7 I$ s( W0 c/ T                        key_new = 1;
                }
; Y' n* l: i: a3 J% Z% D                delay_1ms(1);                     //按键消抖动
3 L4 R( y9 _5 Z                if(((P2 & 0x07) != 0x07) && (key_new == 1))
                {                                                //确认是按键按下
3 k" d2 F' n1 w) O' T                        key_new = 0;
1 S: _$ i6 `+ X- t" v+ u* _* h                        switch(P2 & 0x07)
3 l1 K0 {  x+ d                        {
) u- J& i3 }: ~) {( y/ j7 e                                case 0x06: key_can = 1; break;           //得到k2键值
0 X8 t& Y. T. o# X0 x                                case 0x04: key_can = 2; break;           //得到k3键值
                                case 0x02: key_can = 3; break;           //得到k4键值
  y" k. ^3 _% w7 N3 a9 h& @                        }
                        flag_lj_en = 1;         //连加使能
$ t0 m" v! ?( {1 Z# i% @  F# t                }                        
, y4 w# W5 V0 b8 h3 j2 J  r        }
# v8 S) \( {8 e6 w5 _        else
        {
1 \9 D3 T* p1 X6 w% A0 ]1 C" ]0 \                if(key_new == 0)
" D' x, g" N- \3 v5 u8 l$ @3 }' _                {
                        key_new = 1;
9 a( J9 R1 n% y0 c                        flag_lj_en = 0;                //关闭连加使能
/ h# h+ k( C3 y, y  r* ~' i1 P: i                        flag_lj_3_en = 0;        //关闭3秒后使能
, `. c8 s, p+ y, H7 d                        key_value = 0;                //清零
                        key_time = 0;
- |$ S; X3 ?, D6 v                        key_500ms = 0;
                }
. {1 p# H( \* G. _+ |        }        
5 [0 Q0 A; a* ?6 c; _4 `}

; z. N/ T( l# U; f
4 L  T/ g7 m1 f9 o" c# v' E/****************按键处理数码管显示函数***************/
  N, [- u7 a- t6 ~" X; t6 G6 Uvoid key_with()
0 F8 d8 F* E) R2 z; Z/ P$ a{
/ N2 c  k+ J/ G: ]; d8 L- A        if(key_can == 1)          //设置键
        {
7 W' G4 H1 S- K6 P                f_pwm_l = 30;
                menu_1 ++;
4 _) g6 y" l6 e3 Y( T% V8 f9 ~                if(menu_1 >= 3)
                {
1 y2 {$ i9 ~8 |2 g9 P+ |" e8 \/ Y1 X                        menu_1 = 0;
) \( p9 p. z9 V1 v0 n                        smg_i = 3;                  //数码管显示3位
% Y* x5 e& ~3 f. V                }
        }
" T( T" x5 S; @( d/ ?% a' R        if(menu_1 == 1)                        //设置高温报警
        {
. ]: m+ c  X! o                smg_i = 4;                  //数码管显示4位
& C2 C( U. b8 U$ E7 ]! A8 l3 S, q! v                if(key_can == 2)
                {
                        if(flag_lj_3_en == 0)
                                t_high ++ ;                //按键按下未松开自动加三次        
                        else
# m+ u+ ]- `! S  F                                t_high += 10;        //按键按下未松开自动加三次之后每次自动加10
% u4 a  I  q. F9 [& U" k: ^                        if(t_high > 990)
" c0 \# {' q) b) N' O                                t_high = 990;
                }
3 z) T! O# ]5 \2 M7 \; Q. ~/ n                if(key_can == 3)
2 ]( ^% C  n5 P                {
                        if(flag_lj_3_en == 0)
                                t_high -- ;                //按键按下未松开自动减三次        
6 Y: ^: ]6 p. w                        else
                                t_high -= 10;        //按键按下未松开自动减三次之后每次自动减10
                        if(t_high <= t_low)
. J! |2 F. Z! i# E( [                                t_high = t_low + 1;
2 n/ i: p; y3 l% i8 x                }
                dis_smg[0] = smg_du[t_high % 10];                   //取小数显示
                dis_smg[1] = smg_du[t_high / 10 % 10] & 0xdf;  //取个位显示
                dis_smg[2] = smg_du[t_high / 100 % 10] ;           //取十位显示
6 t2 g! i( i9 H- A' W5 h1 }                dis_smg[3] = 0x64;         //H
        }        
        if(menu_1 == 2)                        //设置低温报警
        {
4 o1 p0 ?) p$ ?( n; P                smg_i = 4;                  //数码管显示4位
                if(key_can == 2)
                {
; G* k0 v+ x+ |; t; K                        if(flag_lj_3_en == 0)
. T/ T) f- I" [6 l- w% c, m                                t_low ++ ;                        //按键按下未松开自动加三次        
                        else
                                t_low += 10;                //按键按下未松开自动加三次之后每次自动加10
6 i! B  B0 L$ \' Z" K& I                        if(t_low >= t_high)
; f# R; G% I. q                                t_low = t_high - 1;
6 h( `  r  U1 p) [$ P4 i                }
                if(key_can == 3)
                {
9 `7 B, Q- I' p                        if(flag_lj_3_en == 0)
                                t_low -- ;                        //按键按下未松开自动减三次        
  x6 h; j& [$ \8 ^$ Y  a7 C                        else
5 M; A$ W% [- L/ y: o% ]$ O/ k9 p7 X                                t_low -= 10;                //按键按下未松开自动加三次之后每次自动加10
                        if(t_low <= 10)
0 I( P- @9 N7 s                                t_low = 10;
                }
                dis_smg[0] = smg_du[t_low % 10];                   //取小数显示
$ z  I- g% _0 g! O3 _7 O& K                dis_smg[1] = smg_du[t_low / 10 % 10] & 0xdf;   //取个位显示
  Z8 x8 N# ?9 q) v' e$ @9 h                dis_smg[2] = smg_du[t_low / 100 % 10] ;               //取十位显示
0 z0 j. y6 A2 N, K  ?                dis_smg[3] = 0x3D;          //L
        }        
}  
4 L' i, \2 G: [, `+ T9 E* T

/****************风扇控制函数***************/
$ p, X+ }/ z& q1 V( }void fengshan_kz()
{
        if(flag_en == 1)
+ _+ k, a* ^6 D0 E        {
                if(temperature >= t_high)          //风扇全开
                {        
6 m( w& \6 x6 l0 A: |$ F$ \                        TR1 = 1;
1 _# L9 s* p7 o& D5 G                        pwm = 0;
                }
6 J0 Y: c' ]( {5 o: C                else if((temperature < t_high)        && (temperature >= t_low))                   //风扇缓慢
  |- Y* R3 C; l& H                {
                        f_pwm_l = 60;         
3 W( T+ i. E3 j* [3 L8 M                        TR1 = 1;
8 O* o9 w$ e9 b8 T2 Q                }
1 {* e! ~- G' u4 o' }8 ^                else if(temperature < t_low)         //关闭风扇
& A$ J  d1 a. G/ N* Q/ n$ H& v                {
4 j" J- q3 |3 ?1 ^                        TR1 = 0;
' e. p" a2 U6 ^. f                        pwm = 1;
( Z+ t0 B6 O& I* h2 E7 ~                }        
        }               
+ U; y; b' @  t! g}
               
9 E: r4 R! l" S0 A+ P* K2 P. r

, J+ N. @/ F2 ~; T/****************主函数***************/
void main()
{
        static uchar value;
% R3 [9 W: `) U" W. M2 l3 X4 s: c        time_init();                    //初始化定时器
        temperature = read_temp();                //先读出温度的值        
        delay_1ms(650);                                
4 s' v. e6 K2 Y        temperature = read_temp();                         //先读出温度的值
        dis_smg[0] = smg_du[temperature % 10];         //取温度的小数显示
        dis_smg[1] = smg_du[temperature / 10 % 10] & 0xdf; //取温度的个位显示
, N6 d% ?9 O* m! R        dis_smg[2] = smg_du[temperature / 100 % 10] ;           //取温度的十位显示
        while(1)
8 b1 H1 b: p5 k, p4 V. d        {               
                key();                                        //按键程序
                if(key_can < 10)
                {
                        key_with();                        //设置报警温度        
9 L9 c! l6 p6 {, e6 w) _3 _$ K                }
1 j, [' L$ U5 @* o& M                if(flag_200ms == 1)            //200ms 处理一次温度程序
1 Z! H; f( M! a7 x; F, ^- j                {           
8 m3 @7 ]5 t. N) S" o( X                        flag_200ms = 0;        
- I& m; X+ V( n2 V5 a; l                        temperature = read_temp();        //先读出温度的值
6 s6 g* f4 o7 o8 g8 h                        if(menu_1 == 0)
                        {        
2 t; P6 V  Y$ w. U, r: V# o3 R                                smg_i = 3;
' D$ n& N( R+ s% a$ P4 `                                dis_smg[0] = smg_du[temperature % 10];         //取温度的小数显示
                                dis_smg[1] = smg_du[temperature / 10 % 10] & 0xdf; //取温度的个位显示
                                dis_smg[2] = smg_du[temperature / 100 % 10] ;           //取温度的十位显示
                        }
- X3 h2 ^& {/ Z2 R                        fengshan_kz();        //风扇控制函数
) ~1 R) _3 M( M! W  U+ S2 G7 O$ J                        value ++;
3 J8 G5 b8 |8 s1 p6 D. r                        if(value >= 4)
                        {
0 g; A3 S+ M  F  C. J: t) ]                                value = 0;
& q  b. @. j9 w4 S9 K" w0 _( H, s                                if(miao != 0)
                                {
& X( y% c- Z+ E( o( a  d' Z                                        miao --;    //时间减1
: V& l, L1 J% K) G% H) T                                }
* e) p* V, A' |9 o                                if(miao == 0)
                                        flag_en = 0;
# s5 Q3 Y  s. r6 k//                                dis_smg[3] = smg_du[miao % 10] ;
  u0 i# @) s% f7 S                        }
                        if(hw == 1)  //感应到人
8 i' B+ L5 v( a( N1 X# K( k6 u  m) _                        {
                                miao = 30;
$ H- H; l& J% a" o                                flag_en = 1;
                        }
                }


* u7 Z) h* q7 I8 p/ f                display();                //数码管显示函数
        }
8 ~0 `( ?0 X2 r! z2 Z, s5 e}

) E: ?2 h! ~; |2 }: H1 S
! r' c: L  H) ]1 t( O+ C/*************定时器0中断服务程序***************/
void time0_int() interrupt 1
{        
        static uchar value;                         //定时2ms中断一次
0 {* V( k. s9 o1 w; A- i        TH0 = 0xf8;
6 z  e$ k+ |* a: ?        TL0 = 0x30;     //2ms
. G' u& R5 @& n, o: h* e1 G        value++;         
: H( d$ O. l! t& t' e* A& p        if(value >= 150)
# x) s; j+ M7 B5 |1 f        {
' X& m) g  q9 U; G- K$ B& a: H                value = 0;         
* j+ s# E* S/ l5 u1 Q* u. u                flag_200ms = 1;
* _* M; Z( q- y  n        }
        if(flag_lj_en == 1)           //按下按键使能
        {
                key_time ++;
                if(key_time >= 250) //500ms
0 Z" k. l- \: n                {
( ?2 I- h7 D3 T* B1 e& y0 ?" I  a                        key_time = 0;
8 K" U% P; E/ l% \8 s7 i8 [  {                        key_500ms = 1; //500ms
- Y+ g. ?, |7 R0 {2 M& K                        key_value ++;
                        if(key_value > 3)
- k, s! Z/ F) b$ Q                        {
( c7 d/ Z, C$ L8 n$ f                                key_value = 10;
                                flag_lj_3_en = 1; //3次后1.5秒连加大些
+ N2 X" F5 F+ J( Z3 f/ M1 i                        }                                                
                }
* \! p4 Y9 g; w9 p' G        }
}
: }' S  P+ {8 r$ V8 q1 n, Z

3 b7 D5 s3 `6 \4 v" r8 Y# r0 f

4 J$ I9 r- ]# \- |! w7 n/*******************定时器1用做单片机模拟PWM 调节***********************/
+ t7 Q% Q, x+ \& z4 k/ Qvoid Timer1() interrupt 3  //调用定时器1
. l/ u/ r% v; P( N; N{
8 b! W; U7 M- a1 j        static uchar value_l;
3 T) M! J# B2 j        TH1=0xff;    //    定时中断一次
        TL1=0xec;         //

- f- f" v5 ]* b6 R

" |8 E1 R8 t! N" k1 ~1 ]; |$ }, r
# l" s% f0 O. z1 {- q1 A…………余下代码请下载附件…………

: \: U# d: ^( p( o
下载：
- V# m' K. y% [. i

游客，如果您要查看本帖隐藏内容请回复

abcde1234

好东东，学习一下

th2010-gc01

好东西！谢谢分享！

季节渐冷

感谢楼主
4 H8 j) \  P& m6 S* s) p$ \
3 K) k: z& v: d& w; m4 [

kailang

好东西，学习一下楼主