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

helendcany

单片机智能温控风扇设计 带智能调速人体感应 毕业设计论文
, S3 W" T6 X+ m% c, K6 q

51单片机做的温空风扇 数码管显示 带人体感应模块，实现智能调速，功能非常强大，这是一个本科的毕业设计，毕业论文 开题报告 源码 原理图 还有proteus仿真等等都是一应俱全. 还有答辩常见问题解答，焊接注意事项和调试讲解，以及详细的制作过程.
8 [( B* b/ {- D: H, v
# M! _- ^; {% `* n: o4 S5 ?温空风扇实物图：
' q! i9 H! j5 ~/ Z; x

温空风扇仿真截图：
; ]6 Q7 m! j: v9 M

# _: w. u5 O% ]  I: u, ~5 ]" A温空风扇的DXP格式 protel99格式 温控风扇原理图：
3 ~5 q+ r3 F9 F" t; k- H

6 Z# ?) p2 F/ z  j2 ]; ~$ pDXP格式用            altium designer Summer 软件打开
protel99格式用       protel99SE 软件打开
PDF格式用            PDF 软件打开
Word格式用           Word 或用WPS 软件打开
% f4 E- I( L" ^1 _% q
4种格式的原理图都内容是一样的  只是打开方式不同

5 l) d) E6 w0 R; X请看原理图焊接，不要看仿真图焊接。
  l$ k: L- U' R- B& z- O
2 b$ \4 @! J3 Z& b: m6 awrod格式里面的原理图是复制出来的，有一点点变行变形，麻烦大家注意一下，尽量看其他三种格式的图焊接，
7 @" Y5 R& |' e; W2 Q
如果论文里面的原理图和原理图文件夹内的图不一样的话，请大家以原理图文件夹内的为准，原理图文件夹的图是和实物配套的，可以自己截图或复制，然后粘贴到论文里面去。

智能调速温控风扇的毕业论文截图：
1 C# Z% |, W5 G; F/ z: ?% A
, _+ e, L9 [. ?目 录
% R* D' G7 L3 f; S绪  论    4
  p; K8 |$ F0 w/ l" h! p" J1  系统概述    5
) A" S* u, [0 R# N1.1  STC89C52单片机简介    5
1. 2  本设计任务和主要内容    5
2  方案论证    6
2．1 温度传感器的选用    6
3 |" Q) _0 W. V2．2  控制核心的选择    7
2．3显示电路    7
2．4调速方式    7
: |6 o; @) \$ N2．5控制执行部件    8
3 系统原理    8
3.1  系统总体设计    8
" B$ a4 T* ^% {1 H9 i& D/ s" @- S" E3.2  控制装置原理    9
, ]4 U: D: O& W2 F9 K6 K3．3  温度检测和显示电路    9
3.3.1  DS18B20的温度处理方法    9
3.3.2  温度传感器和显示电路组成    11
3.4  电机调速电路    11
( n& N- u' P8 \  Z3 U& g2 M$ H3.4.1  电机调速原理    12
3.4.2  电机控制模块设计    13
, O4 U/ }4 Q3 K% {4  控制器软件设计    14
  A+ s5 t, l. a1 |4.1  主程序    14
1 j5 a1 a2 h4 Z  M2 m9 V) }- `4.2  数字温度传感器模块和显示子模块    15
4.3  电机调速与控制子模块    17
3 S% P- y+ v1 v8 r0 Z结 束 语    19
8 C5 a# ~* z; d. x参考文献    20
5 q! v& D* @3 f/ V8 y& K$ b附录一    21
) V& c! o( l/ u' O8 Q
8 G/ q; M* q6 X0 ~# \% M/ o1 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

温空风扇程序：
如果没有装KEIL软件
; w; \  Q5 m8 p' x( S( t9 X找到  .c   .h结尾的文件即为程序。打开方式选择记事本打开
5 Q0 |( |/ F# E或者到开发资料里安装KEIL软件

2 ^# |1 W$ |! ]" }
9 U4 I5 ?7 T4 q! n4 F$ `# q+ F
/ K- s+ T+ k( I. L

2 m$ j( B1 t+ c( A0 x
; b) Y  l7 N, a* a" u; i& `#include <reg52.h>                 //调用单片机头文件
#define uchar unsigned char  //无符号字符型 宏定义        变量范围0~255
#define uint  unsigned int         //无符号整型 宏定义        变量范围0~65535
2 w7 G5 |& ~) x0 K: G& P
! g. p6 x) q; g
//数码管段选定义      0     1    2    3    4    5        6         7          8           9        
uchar code smg_du[]={0x28,0xe4,0x42,0x72,0xe5,0xa8,0x41,0x77,0x20,0xa0,
. e0 Z* G* d' G' J6 Z                                           0x60,0x25,0x39,0x26,0x31,0x71,0xff};         //断码
- o: g# z" q1 E- n: Q//数码管位选定义
# _0 \6 v! p: M" ~! cuchar code smg_we[]={0xef,0xdf,0xbf,0x7f};
" s$ G: F* {+ y9 j7 d1 Vuchar dis_smg[8] = {0};        
uchar smg_i = 3;    //显示数码管的个位数
sbit dq   = P2^4;        //18b20 IO口的定义
. b/ W3 P1 H) J' Y6 S" `, N8 Usbit hw = P2^5;
uchar miao = 30;
0 n" P9 m5 ?8 s* huchar flag_en;
. D3 o1 {% e; m( k) e) w
7 V' \" C6 H3 W% R
1 i0 F- j' m4 r5 a/ V" v: xbit flag_lj_en;                 //按键连加使能
bit flag_lj_3_en;         //按键连3次连加后使能  加的数就越大了
, j' k: u1 x5 |; U" Ruchar key_time,key_value;      //用做连加的中间变量
bit key_500ms  ;
  S( G0 `$ D0 E& A+ Csbit pwm = P2^3;  
uchar f_pwm_l ;          //越小越慢

; i- X% J; j' J9 k$ D; p$ `
! y" ?5 E( ~/ P  K9 Guint temperature ;  //
bit flag_200ms ;
uchar menu_1;       //菜单设计的变量
- @8 T& E4 `1 F$ ]! wuint t_high = 200,t_low = 100;           //温度上下限报警值

5 g2 [( P3 B! A8 A
/***********************1ms延时函数*****************************/
7 D5 e& J) W/ [0 o! Uvoid delay_1ms(uint q)
, z, u3 X! _0 k& g! s/ ^4 Q8 h0 ?{
        uint i,j;
# V9 I* d" p6 J; o4 v        for(i=0;i<q;i++)
                for(j=0;j<120;j++);
}
) H5 o* t& j; y. {- N( R
" u& }( n) o( j/ x
9 z0 ?* v- i+ X1 `/***********************小延时函数*****************************/
1 T0 k% C4 K$ ^5 m- u- Qvoid delay_uint(uint q)
{
6 w% A  E* L5 t2 g' R; t        while(q--);
! G1 h; A& o. b9 {& u}
7 P5 O* j7 w( |' y  o# b  Y
! P8 D- c6 v2 M


( B3 Q2 u: l* c6 I% ]2 p8 r/***********************数码显示函数*****************************/
void display()
{
) K7 |* U* v3 l4 x/ b! I$ ^8 R+ T        static uchar i;   
        i++;
        if(i >= smg_i)
                i = 0;        
. u* t& a! W" w  u9 x; i        P1 = 0xff;                         //消隐
        P3 = smg_we;                          //位选
! G5 q& M) I. P: z( i# o        P1 = dis_smg;                 //段选               


}
0 w9 r( @- _6 N0 c) Y

/***********************18b20初始化函数*****************************/
  `- c4 Y$ T9 w0 K& J$ Mvoid init_18b20()
$ o% ^, J8 d; ~3 i2 |' P9 p{
        bit q;
        dq = 1;                                //把总线拿高
7 s( O" n" S0 p4 ]        delay_uint(1);            //15us
: L7 r6 a0 I& u' }# Q        dq = 0;                                //给复位脉冲
        delay_uint(80);                //750us
& x8 s  D/ v- {        dq = 1;                                //把总线拿高 等待
        delay_uint(10);                //110us
" R1 E$ q% Y; G7 K        q = dq;                                //读取18b20初始化信号
        delay_uint(20);                //200us
        dq = 1;                                //把总线拿高 释放总线
% I1 _, U1 d; U/ R* r}
1 i4 ?$ |  r6 ?0 h
% E. c- U% H3 M" N  T' p( \
; J2 b0 f, \0 k, y$ @/*************写18b20内的数据***************/
) r# H, `( O5 K0 X/ A  cvoid write_18b20(uchar dat)
9 Q* |% x: P7 r1 \0 u3 L( A2 D{
6 R. X' v4 ^( B+ t  ^        uchar i;
# \8 J: O7 |2 o- }& Z0 b) f        for(i=0;i<8;i++)
        {                                         //写数据是低位开始
                dq = 0;                         //把总线拿低写时间隙开始
! S, |# W) P8 d9 S( b2 m                dq = dat & 0x01; //向18b20总线写数据了
; y  @. E0 u6 l) [2 J- \                delay_uint(5);         // 60us
                dq = 1;                         //释放总线
9 u% a# k  R5 o' g                dat >>= 1;
! a2 M. {! A1 h9 c8 e% `2 u$ A# m        }        
}


/*************读取18b20内的数据***************/
" F' @( O3 U) t0 _uchar read_18b20()
{
  r" o* N5 i- A" e, g' `# o        uchar i,value;
9 s6 K( m& m' ^+ A' V& V3 X3 J        for(i=0;i<8;i++)
1 }* H1 m6 i* {8 F9 Y$ t        {
                dq = 0;                         //把总线拿低读时间隙开始
# x- F4 C, C' H3 X) g6 b                value >>= 1;         //读数据是低位开始
                dq = 1;                         //释放总线
                if(dq == 1)                 //开始读写数据
                        value |= 0x80;
+ I2 g3 [0 m8 s6 W; D9 W) U- F                delay_uint(5);         //60us        读一个时间隙最少要保持60us的时间
5 C* U# E, o8 ~- O/ ~8 l% z" _        }
; ]* m3 f6 f% j* _4 b        return value;                 //返回数据
}
1 t  x! N. C: H5 ^8 P5 C; }. u- G
0 F$ e" ]- B: `$ P
/*************读取温度的值 读出来的是小数***************/
uint read_temp()
8 F) P* Q) P8 f" L! [* V' F' _# F+ ?1 S{
        uint value;
        uchar low;                           //在读取温度的时候如果中断的太频繁了，就应该把中断给关了，否则会影响到18b20的时序
        init_18b20();                   //初始化18b20
        write_18b20(0xcc);           //跳过64位ROM
- _+ @- e( [: V/ {7 j+ A; j; a        write_18b20(0x44);           //启动一次温度转换命令
  j6 C( D' L, _5 i4 l0 v  K0 c: o        delay_uint(50);                   //500us

: m& n# u; {) J1 c4 ^9 e
6 K' c9 q6 s; i3 L        init_18b20();                   //初始化18b20
        
        write_18b20(0xcc);           //跳过64位ROM
8 B+ Q3 r; Z' W2 R2 V; n        write_18b20(0xbe);           //发出读取暂存器命令
: ]2 L8 {9 Y4 l: Q" U        
6 a! `7 x1 [" X2 [$ D3 V        low = read_18b20();           //读温度低字节
        value = read_18b20();  //读温度高字节
: `: W1 k$ _* x4 [; g        value <<= 8;                   //把温度的高位左移8位
        value |= low;                   //把读出的温度低位放到value的低八位中
        value *= 0.625;               //转换到温度值 小数
        return value;                   //返回读出的温度 带小数
}


/*************定时器0初始化程序***************/
, X: A5 ^2 t  d# J% v9 o7 J3 vvoid time_init()         
$ M( A" {# v& _  ^{
        EA   = 1;                   //开总中断
4 X1 ~9 i. v/ J9 [* E        TMOD = 0X21;          //定时器0、定时器1工作方式1
* D$ A, T2 y7 Y  y0 b        ET0  = 1;                  //开定时器0中断
        TR0  = 1;                  //允许定时器0定时


        ET1  = 1;                  //开定时器0中断
$ w. V* d: q- N( [: O9 w& }- @1 w6 a        TR1  = 1;                  //允许定时器0定时
}


/********************独立按键程序*****************/
6 k1 m6 {  a7 g/ A- Suchar key_can;         //按键值
( j$ Q8 H" E; S- w9 l$ V2 \* j

void key()         //独立按键程序
{
* r1 |! P& G: R% ~' D3 h7 C: ~        static uchar key_new;
# ^4 ^/ G/ I' v' S0 h        key_can = 20;                   //按键值还原
        P2 |= 0x07;
        if((P2 & 0x07) != 0x07)                //按键按下
        {
                if(key_500ms == 1)        //连加
. A; |6 e+ `6 K' i3 R! k) M0 ^0 s                {
                        key_500ms = 0;
8 x2 {' `  X0 r/ u                        key_new = 1;
                }
4 P0 o4 h, F- g' E! u& w                delay_1ms(1);                     //按键消抖动
                if(((P2 & 0x07) != 0x07) && (key_new == 1))
7 z- Z* m+ C& \8 C& a) {                {                                                //确认是按键按下
% i9 A% {! X& d                        key_new = 0;
5 u% l' A! S5 k* ^                        switch(P2 & 0x07)
* V. G0 z' l. @" ]                        {
                                case 0x06: key_can = 1; break;           //得到k2键值
                                case 0x04: key_can = 2; break;           //得到k3键值
% `6 A# L' R& P                                case 0x02: key_can = 3; break;           //得到k4键值
+ M  E0 ^4 j: G                        }
: C! N+ {" ^8 @$ k2 h                        flag_lj_en = 1;         //连加使能
8 h! v7 a* L6 y$ P1 s                }                        
        }
/ h3 P. i  [  t: O8 f* q: u        else
7 e& r1 |+ T; }, J        {
( L& a* {4 N# a$ l                if(key_new == 0)
                {
5 f9 ]" ]# ]3 u                        key_new = 1;
                        flag_lj_en = 0;                //关闭连加使能
                        flag_lj_3_en = 0;        //关闭3秒后使能
( n2 O0 ?  x9 I6 W                        key_value = 0;                //清零
. X$ n6 @6 q3 f4 X& J( R                        key_time = 0;
3 b7 l/ \, t; C' }1 ]                        key_500ms = 0;
                }
, u9 }8 c% j+ J3 Z# J: Q        }        
" a9 i8 o# D- m3 R: B% V}
2 c% Z+ H$ ?! D, _. K2 L) L9 S
# ~" L& Q# L* }4 P- z
/****************按键处理数码管显示函数***************/
8 P3 H1 _. o7 Yvoid key_with()
{
' \& H; r3 h% R5 b        if(key_can == 1)          //设置键
        {
) T+ M) y" ~! E& [9 ~                f_pwm_l = 30;
) T, O# {+ ~4 `. D& ~" V                menu_1 ++;
" v5 a% w- V* g9 ]; G  W- L5 s, {5 p; Z                if(menu_1 >= 3)
+ ?* h! {# S$ _  u5 w2 e$ ?                {
                        menu_1 = 0;
8 L6 S9 }2 J2 v2 |8 M% Z# L7 U                        smg_i = 3;                  //数码管显示3位
) j* B, ], G4 R                }
        }
        if(menu_1 == 1)                        //设置高温报警
' s" J. I. m+ @1 l+ T        {
/ a% W+ `4 y  V                smg_i = 4;                  //数码管显示4位
+ d; C  k6 {% Z0 B' ^                if(key_can == 2)
                {
9 L! G+ z# Y4 n8 c) F( L# f; s                        if(flag_lj_3_en == 0)
3 F' G' B' e. c                                t_high ++ ;                //按键按下未松开自动加三次        
) o+ J# b4 P( m# K/ e+ z                        else
                                t_high += 10;        //按键按下未松开自动加三次之后每次自动加10
; \, P: Y" ]! V                        if(t_high > 990)
  N! Q. [2 o. |6 M: G8 p                                t_high = 990;
6 f  {% `$ H& }' c/ l' p( W                }
                if(key_can == 3)
, E; M. V5 z. s! @, k: _0 B                {
' S, c) X/ P" D5 b/ L9 v  B  P2 q                        if(flag_lj_3_en == 0)
                                t_high -- ;                //按键按下未松开自动减三次        
                        else
, G. t  B! a1 O9 @1 v1 \* C0 i; ~                                t_high -= 10;        //按键按下未松开自动减三次之后每次自动减10
- S3 U+ e4 H5 ]( t& q                        if(t_high <= t_low)
- i! Q4 ^+ r5 y- w  L, F                                t_high = t_low + 1;
3 ^. V, }  L6 m; d6 J                }
                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] ;           //取十位显示
                dis_smg[3] = 0x64;         //H
' [: l( X; i$ d, B" @+ ]' o        }        
        if(menu_1 == 2)                        //设置低温报警
3 ]. v0 a0 t6 T$ _        {
                smg_i = 4;                  //数码管显示4位
                if(key_can == 2)
- {( f8 l4 x* S0 }8 b                {
" `5 a' ]1 t9 ?! |! p: S                        if(flag_lj_3_en == 0)
8 }/ t- d$ M8 s7 ~& B8 O                                t_low ++ ;                        //按键按下未松开自动加三次        
- n+ b' I3 O  Q                        else
3 a  {; d& H2 E7 t, y- ^. U* A                                t_low += 10;                //按键按下未松开自动加三次之后每次自动加10
                        if(t_low >= t_high)
                                t_low = t_high - 1;
                }
1 O1 _/ `3 H6 M, v2 h                if(key_can == 3)
6 C4 a$ Y4 A& \, d7 |, I                {
" @, E- n' o" D1 R- b! Y7 E                        if(flag_lj_3_en == 0)
                                t_low -- ;                        //按键按下未松开自动减三次        
' H, J4 u3 F  ]0 P: n                        else
2 G; a* \# q, Z+ A; W                                t_low -= 10;                //按键按下未松开自动加三次之后每次自动加10
2 C5 p: H2 d4 y3 Z+ Z                        if(t_low <= 10)
                                t_low = 10;
                }
                dis_smg[0] = smg_du[t_low % 10];                   //取小数显示
. \6 G2 ?* O$ M                dis_smg[1] = smg_du[t_low / 10 % 10] & 0xdf;   //取个位显示
                dis_smg[2] = smg_du[t_low / 100 % 10] ;               //取十位显示
                dis_smg[3] = 0x3D;          //L
        }        
6 }$ A" k5 q: E. O$ V$ n+ D9 v}  
2 j7 m% @0 O, x
6 h0 B& `  T( g
/****************风扇控制函数***************/
. w- a% r2 H2 l5 ^void fengshan_kz()
+ K5 B9 a+ \% i/ u0 s4 l{
+ U) [& j& a, t        if(flag_en == 1)
8 i3 d# i2 Z* v" r+ Z        {
                if(temperature >= t_high)          //风扇全开
                {        
                        TR1 = 1;
                        pwm = 0;
                }
                else if((temperature < t_high)        && (temperature >= t_low))                   //风扇缓慢
+ r6 F4 C0 s- ^4 }+ O  u                {
                        f_pwm_l = 60;         
* F9 Y) x$ q8 F- {! }2 G+ W                        TR1 = 1;
3 }% m/ u' Z/ e                }
# d  D6 g% {2 G) @3 Q# B8 b                else if(temperature < t_low)         //关闭风扇
                {
                        TR1 = 0;
7 G* P3 m7 K: V6 r4 Y                        pwm = 1;
                }        
        }               
}
               

; h& N9 f$ u+ L0 j
, e/ x- H7 r; {+ u4 j/****************主函数***************/
void main()
{
        static uchar value;
        time_init();                    //初始化定时器
& T3 V1 K6 k2 j1 C$ _! J# O        temperature = read_temp();                //先读出温度的值        
$ y7 D/ p# \% W+ ?        delay_1ms(650);                                
6 `9 [# n6 u' q/ y& Y' u# q        temperature = read_temp();                         //先读出温度的值
        dis_smg[0] = smg_du[temperature % 10];         //取温度的小数显示
        dis_smg[1] = smg_du[temperature / 10 % 10] & 0xdf; //取温度的个位显示
. |3 Y2 u3 {( y6 d% u, @3 c0 n# b        dis_smg[2] = smg_du[temperature / 100 % 10] ;           //取温度的十位显示
        while(1)
        {               
& S# i( D( D/ C& ~                key();                                        //按键程序
                if(key_can < 10)
                {
; E2 A( c1 F! J8 b1 }9 u                        key_with();                        //设置报警温度        
                }
- `6 n/ G0 ?0 x  \! k                if(flag_200ms == 1)            //200ms 处理一次温度程序
                {           
                        flag_200ms = 0;        
                        temperature = read_temp();        //先读出温度的值
4 ~, J( @1 K: K# F% s. q8 d                        if(menu_1 == 0)
                        {        
0 H9 h; ]9 D' D5 N                                smg_i = 3;
                                dis_smg[0] = smg_du[temperature % 10];         //取温度的小数显示
: u8 m  l: |3 k- o5 ^                                dis_smg[1] = smg_du[temperature / 10 % 10] & 0xdf; //取温度的个位显示
                                dis_smg[2] = smg_du[temperature / 100 % 10] ;           //取温度的十位显示
                        }
6 G) _" q5 g/ g- d2 a                        fengshan_kz();        //风扇控制函数
                        value ++;
                        if(value >= 4)
& |' @: ?/ s5 N+ c1 W% E9 K; q* n                        {
0 [; o0 Y$ m8 m7 l, k                                value = 0;
4 i1 \5 U; ^3 h! P) x+ R                                if(miao != 0)
' C+ K8 m8 }4 ^5 V" q+ O* L2 |                                {
2 C  u0 S. U2 m+ x$ D  M                                        miao --;    //时间减1
! g' f% A/ p  ]. Z/ o                                }
! @% e" ], u% K+ |  h                                if(miao == 0)
                                        flag_en = 0;
//                                dis_smg[3] = smg_du[miao % 10] ;
                        }
                        if(hw == 1)  //感应到人
2 Z+ P7 E. V  \; J                        {
: L. v9 e( A, e5 P9 _                                miao = 30;
                                flag_en = 1;
                        }
. |' z6 R+ b5 S                }


                display();                //数码管显示函数
        }
; B& o5 `: [) O, x7 X0 K}
+ J, u2 r/ L+ C; c5 H
9 n' u' T# J+ H  }
/*************定时器0中断服务程序***************/
void time0_int() interrupt 1
{        
        static uchar value;                         //定时2ms中断一次
1 ?' \& R+ I* F+ _& ~, o        TH0 = 0xf8;
        TL0 = 0x30;     //2ms
        value++;         
6 E( w7 |' q* {        if(value >= 150)
        {
/ Q/ J9 C4 H7 G4 M8 k6 a5 _0 y( k                value = 0;         
                flag_200ms = 1;
0 G$ L' b; w0 [3 J* m$ R; u        }
        if(flag_lj_en == 1)           //按下按键使能
        {
                key_time ++;
% {/ N9 ]  R) `4 z6 e; Y7 ]                if(key_time >= 250) //500ms
1 ~# @. P4 W+ D5 ^                {
                        key_time = 0;
                        key_500ms = 1; //500ms
9 w5 n/ e/ v& L" G. K# y" L7 h                        key_value ++;
                        if(key_value > 3)
) R5 P- t8 w5 [& X  o; i. D, D+ K                        {
                                key_value = 10;
                                flag_lj_3_en = 1; //3次后1.5秒连加大些
                        }                                                
                }
% T7 j+ U0 R, }' T( R! Y1 H# F        }
- h7 f$ I9 @3 f, ]- }$ l8 k}


' W9 q! R; x# h
: @+ b8 A  Y+ O7 ]
/*******************定时器1用做单片机模拟PWM 调节***********************/
) B; j1 @5 A+ Vvoid Timer1() interrupt 3  //调用定时器1
8 S. }8 D& i+ L4 s3 M{
        static uchar value_l;
        TH1=0xff;    //    定时中断一次
        TL1=0xec;         //



3 \2 G+ b% B& w* ?4 ^  |$ w5 j
…………余下代码请下载附件…………
. R, V8 x8 D  g7 ~
6 c% h2 V$ F# }% @6 b6 s
下载：
6 Z2 ~2 C( T  M

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

0 A. n7 S4 c' V/ ?+ G% i

abcde1234

好东东，学习一下

th2010-gc01

好东西！谢谢分享！

季节渐冷

感谢楼主
. }! i- L/ O# l' ~" a6 \4 c' q, n
  x0 r' s# e4 v; M: S

kailang

好东西，学习一下楼主