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

helendcany

单片机智能温控风扇设计 带智能调速人体感应 毕业设计论文
' F& _$ U& m% s; k

51单片机做的温空风扇 数码管显示 带人体感应模块，实现智能调速，功能非常强大，这是一个本科的毕业设计，毕业论文 开题报告 源码 原理图 还有proteus仿真等等都是一应俱全. 还有答辩常见问题解答，焊接注意事项和调试讲解，以及详细的制作过程.
9 Y% O% \  J$ H0 F3 b4 j
温空风扇实物图：
% Q$ h5 H' f2 p8 `1 B0 c

( N# s& s' q) P7 R温空风扇仿真截图：


/ x+ w' }" h) i. }- r* Y7 c温空风扇的DXP格式 protel99格式 温控风扇原理图：
! @+ r6 E- \. l$ J. C  @% a
- y1 E" L2 Z/ @
DXP格式用            altium designer Summer 软件打开
protel99格式用       protel99SE 软件打开
! b/ G0 D* r( vPDF格式用            PDF 软件打开
Word格式用           Word 或用WPS 软件打开
9 [( ]/ B0 _) e, M2 y. b# ^' ^
4种格式的原理图都内容是一样的  只是打开方式不同
+ m1 D$ R# \" z
请看原理图焊接，不要看仿真图焊接。

wrod格式里面的原理图是复制出来的，有一点点变行变形，麻烦大家注意一下，尽量看其他三种格式的图焊接，
* s1 O9 I) G1 A. t! N
如果论文里面的原理图和原理图文件夹内的图不一样的话，请大家以原理图文件夹内的为准，原理图文件夹的图是和实物配套的，可以自己截图或复制，然后粘贴到论文里面去。

  s, j6 k0 c0 T智能调速温控风扇的毕业论文截图：

目 录
绪  论    4
1  系统概述    5
1.1  STC89C52单片机简介    5
1. 2  本设计任务和主要内容    5
' ?5 R0 c, D  r* I1 b. q! o& C/ \; C2  方案论证    6
9 i: h- y0 G# X' G( t) U( c2．1 温度传感器的选用    6
2．2  控制核心的选择    7
/ p1 h/ h5 D) ]2．3显示电路    7
2．4调速方式    7
! H- [. G7 x# I' r" s2．5控制执行部件    8
3 系统原理    8
" h8 B; U) Y; x1 x6 ^* Y+ n: s3 [3.1  系统总体设计    8
4 \5 g! b$ Q7 L: Z* u3.2  控制装置原理    9
3．3  温度检测和显示电路    9
9 A( J! P) v) o3.3.1  DS18B20的温度处理方法    9
3.3.2  温度传感器和显示电路组成    11
6 j! L- R/ J( s- _3.4  电机调速电路    11
3.4.1  电机调速原理    12
& T6 W2 j2 n/ Y4 p$ \3.4.2  电机控制模块设计    13
4  控制器软件设计    14
, u* T# W, \/ i" K* P( E4.1  主程序    14
3 \$ i( w+ N# H( z4.2  数字温度传感器模块和显示子模块    15
9 ]) W* k4 f" {' d' ^  F- g5 V5 u4.3  电机调速与控制子模块    17
结 束 语    19
+ l0 c; x7 j& F- R8 |# d/ _+ }参考文献    20
附录一    21
$ S" W& g6 J+ p/ X3 R
5 q1 `1 o0 H5 @2 s+ R6 f元件清单：

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软件
找到  .c   .h结尾的文件即为程序。打开方式选择记事本打开
# S( k' {: E& f" T8 l0 q' X  V或者到开发资料里安装KEIL软件

( g. A  H, |) x% T& X7 X" U! h' {
0 K+ p2 R+ P% Q. p: I0 D

- w0 Y& F* ]  r( G+ _
3 Q  j6 p8 H8 O# D
#include <reg52.h>                 //调用单片机头文件
4 |" P) |3 z! e3 e$ {#define uchar unsigned char  //无符号字符型 宏定义        变量范围0~255
#define uint  unsigned int         //无符号整型 宏定义        变量范围0~65535
5 p* C8 ?6 H# C" j

//数码管段选定义      0     1    2    3    4    5        6         7          8           9        
uchar code smg_du[]={0x28,0xe4,0x42,0x72,0xe5,0xa8,0x41,0x77,0x20,0xa0,
                                           0x60,0x25,0x39,0x26,0x31,0x71,0xff};         //断码
& ^+ |% h" X/ o* l0 B! `//数码管位选定义
5 d# u% }  @4 T7 y4 ~: n* Q2 A) C* muchar code smg_we[]={0xef,0xdf,0xbf,0x7f};
% K* P  b) E- [uchar dis_smg[8] = {0};        
uchar smg_i = 3;    //显示数码管的个位数
5 p- I' S; n( m1 g" vsbit dq   = P2^4;        //18b20 IO口的定义
sbit hw = P2^5;
uchar miao = 30;
uchar flag_en;


bit flag_lj_en;                 //按键连加使能
( d* a  O& Y, l$ g! ?5 Ibit flag_lj_3_en;         //按键连3次连加后使能  加的数就越大了
' q- k' h" F8 W' v" B; k1 y5 M4 suchar key_time,key_value;      //用做连加的中间变量
bit key_500ms  ;
sbit pwm = P2^3;  
uchar f_pwm_l ;          //越小越慢
7 B7 d) |: }7 Z

uint temperature ;  //
6 ^3 ~7 b5 f4 S/ n8 X( ~6 ybit flag_200ms ;
uchar menu_1;       //菜单设计的变量
uint t_high = 200,t_low = 100;           //温度上下限报警值
9 ?7 j! B2 Q( T  v& M! }

9 ^4 ]5 H4 I7 b4 u6 D" E/***********************1ms延时函数*****************************/
2 R- O9 e5 D1 P5 Y) Fvoid delay_1ms(uint q)
{
        uint i,j;
        for(i=0;i<q;i++)
+ t4 z% `  X0 }; g4 J7 \. r                for(j=0;j<120;j++);
}

& R4 T, x, D% X9 M& H* B# |
8 E% x8 [4 M) \( G; O5 K: ^/ I/***********************小延时函数*****************************/
+ N! E% E) r) c4 ?void delay_uint(uint q)
! D" K3 j* q  k# {8 M2 g{
        while(q--);
}
) F4 M. z0 w. J2 @$ T$ _

) B/ P. \2 t, `$ T) }

/***********************数码显示函数*****************************/
void display()
  T0 Z6 G! F# b. I{
        static uchar i;   
        i++;
        if(i >= smg_i)
                i = 0;        
        P1 = 0xff;                         //消隐
        P3 = smg_we;                          //位选
1 {0 ^5 {1 ?& w: U        P1 = dis_smg;                 //段选               

+ p! D+ b' I6 X2 Q( F3 F% w
}

9 E- U3 u7 a+ q( j1 A* n- c
/***********************18b20初始化函数*****************************/
void init_18b20()
{
        bit q;
! h' I$ q/ Z& n        dq = 1;                                //把总线拿高
        delay_uint(1);            //15us
        dq = 0;                                //给复位脉冲
& |. D) X' S" ~: M+ \        delay_uint(80);                //750us
6 C8 L6 P# T+ `- [3 E        dq = 1;                                //把总线拿高 等待
. `& W* X% W. W- C- r) n        delay_uint(10);                //110us
        q = dq;                                //读取18b20初始化信号
7 R; f  |: c+ p1 @# |- x; ~' q        delay_uint(20);                //200us
) ]% S+ d* P1 q8 r$ Z        dq = 1;                                //把总线拿高 释放总线
}

$ n' j* V9 `# I! T
/*************写18b20内的数据***************/
void write_18b20(uchar dat)
{
, H* @% @( M- L4 Y% ?        uchar i;
. j) U0 e7 T) M+ P2 I& c        for(i=0;i<8;i++)
        {                                         //写数据是低位开始
                dq = 0;                         //把总线拿低写时间隙开始
9 r2 V) q8 M0 ~# k2 ^4 t                dq = dat & 0x01; //向18b20总线写数据了
3 s1 q0 c, L$ h: s8 J                delay_uint(5);         // 60us
' e: [6 d/ K- A. s                dq = 1;                         //释放总线
                dat >>= 1;
        }        
; v! U9 Z6 E# B7 Z: t  ]5 g1 c$ ~}
% b$ C, p4 `9 L
/ m, B( M/ n" K! D* c. R( x" p
  @* {" P" Q8 [( R; \# z/*************读取18b20内的数据***************/
uchar read_18b20()
  j( \! S! H, X5 u{
4 `5 ?, }% w# p4 n% k) s: g        uchar i,value;
        for(i=0;i<8;i++)
        {
3 u1 w% H9 U1 l2 u) X                dq = 0;                         //把总线拿低读时间隙开始
) L; G5 ]" w% p' F8 G( ]( w$ q                value >>= 1;         //读数据是低位开始
* K( g7 J) Y" m6 n8 D' W  _                dq = 1;                         //释放总线
                if(dq == 1)                 //开始读写数据
                        value |= 0x80;
                delay_uint(5);         //60us        读一个时间隙最少要保持60us的时间
        }
7 Z9 |& L  T6 |4 N( e# q        return value;                 //返回数据
}
1 t$ X# h6 Q5 y3 P# ?9 C
( n  z& J  _$ f: _) P$ o* @% @
1 O* m' V$ Z4 v$ M% o6 S/ _$ Q/*************读取温度的值 读出来的是小数***************/
uint read_temp()
{
% R, t: u2 X% s        uint value;
        uchar low;                           //在读取温度的时候如果中断的太频繁了，就应该把中断给关了，否则会影响到18b20的时序
        init_18b20();                   //初始化18b20
        write_18b20(0xcc);           //跳过64位ROM
1 e2 a, Q; M1 u8 D1 g  y        write_18b20(0x44);           //启动一次温度转换命令
        delay_uint(50);                   //500us
4 B* j& ?1 x: F. l0 C% I9 u

        init_18b20();                   //初始化18b20
        
        write_18b20(0xcc);           //跳过64位ROM
8 K$ C7 p% Y( q        write_18b20(0xbe);           //发出读取暂存器命令
        
3 c4 j9 |& {3 l2 e, W( v        low = read_18b20();           //读温度低字节
+ l, k& s3 e& T; J; |) `( V+ e; ?        value = read_18b20();  //读温度高字节
) R% E" w9 Q9 y% p  G( n& ~        value <<= 8;                   //把温度的高位左移8位
! x' q$ N# K% M( `6 V8 q        value |= low;                   //把读出的温度低位放到value的低八位中
0 F5 B: ?3 S1 R        value *= 0.625;               //转换到温度值 小数
        return value;                   //返回读出的温度 带小数
}
/ c3 V& \# V! R! g

" A9 {# V/ r! c/ [/*************定时器0初始化程序***************/
void time_init()         
{
        EA   = 1;                   //开总中断
) l% w9 p  c' ~9 y        TMOD = 0X21;          //定时器0、定时器1工作方式1
: y9 S  F3 f" S( q$ B        ET0  = 1;                  //开定时器0中断
  j9 p2 w4 R" q" }: w' \        TR0  = 1;                  //允许定时器0定时
9 j, P5 u  F9 g# N( a- _6 c3 C

        ET1  = 1;                  //开定时器0中断
        TR1  = 1;                  //允许定时器0定时
}

, {  w, T- h% z2 D5 |
9 }# s0 ^2 T4 D1 ^/********************独立按键程序*****************/
7 Q" E) Y: S; auchar key_can;         //按键值


6 e  I+ W6 d% ]- A" }void key()         //独立按键程序
{
        static uchar key_new;
$ A" @  F. V  V2 ?7 \# ^& L        key_can = 20;                   //按键值还原
        P2 |= 0x07;
        if((P2 & 0x07) != 0x07)                //按键按下
        {
- X: X/ n5 W) b                if(key_500ms == 1)        //连加
                {
5 M1 K" `. n( s2 M  n3 J+ F                        key_500ms = 0;
# `. c8 c$ m9 Z1 o' u0 X                        key_new = 1;
! ]" _8 z0 v3 M  B                }
/ X7 p+ d/ }8 D0 p                delay_1ms(1);                     //按键消抖动
2 t( Z$ B1 J/ V  r0 v& u                if(((P2 & 0x07) != 0x07) && (key_new == 1))
$ J$ d8 j9 o+ D6 _% t+ m" h                {                                                //确认是按键按下
                        key_new = 0;
  f2 y( y* ~7 P. x                        switch(P2 & 0x07)
( e% O, I9 G$ w3 T                        {
                                case 0x06: key_can = 1; break;           //得到k2键值
* s' a5 D& \( [% R$ W                                case 0x04: key_can = 2; break;           //得到k3键值
+ O7 P! R' f4 B  Q3 I9 ~6 ~                                case 0x02: key_can = 3; break;           //得到k4键值
- H- C3 J* ]6 @( f                        }
                        flag_lj_en = 1;         //连加使能
                }                        
        }
. K) R& @7 H: O4 p) v4 R9 V: |# ^) E        else
' ]4 W$ \# T% j$ r        {
" ^. f$ W: Y0 {5 q( Q                if(key_new == 0)
                {
0 j4 ]- k! f( w9 c                        key_new = 1;
# g2 w& E# _7 z: r                        flag_lj_en = 0;                //关闭连加使能
                        flag_lj_3_en = 0;        //关闭3秒后使能
                        key_value = 0;                //清零
                        key_time = 0;
  y6 h# s/ N% N" \0 Q                        key_500ms = 0;
) K5 u& d) n/ e* j, S% M; m                }
9 K/ T0 x) s, I1 p& z        }        
: K& x& _4 `1 Z9 Y}
( _. O& A: F1 X

/****************按键处理数码管显示函数***************/
  U/ ^, S- g, I* ivoid key_with()
7 f( F3 N# |  W: R6 p- `{
6 a# Q$ \% A- e5 M        if(key_can == 1)          //设置键
2 `! w' s; e* {        {
3 k7 }' P( W0 I1 {& h                f_pwm_l = 30;
                menu_1 ++;
                if(menu_1 >= 3)
+ ]' B- M. c+ ^6 L8 q9 p5 f: B                {
. Z+ O; I- n/ e( J                        menu_1 = 0;
                        smg_i = 3;                  //数码管显示3位
5 B5 U/ u. a1 B: H  e7 V                }
        }
0 S# p) ?7 n4 v, m        if(menu_1 == 1)                        //设置高温报警
        {
                smg_i = 4;                  //数码管显示4位
* n; K" X' B( C3 w                if(key_can == 2)
                {
0 y6 V# D/ p# ~1 ^" e, u6 f$ B                        if(flag_lj_3_en == 0)
' _9 C& G4 t- Y9 Y. C. E: W                                t_high ++ ;                //按键按下未松开自动加三次        
                        else
1 ], S8 Z1 {3 P$ Y$ X% J# ^. D                                t_high += 10;        //按键按下未松开自动加三次之后每次自动加10
                        if(t_high > 990)
  Q8 v* K* G) T- n, U4 i                                t_high = 990;
                }
2 ]' D/ z! g, B/ e                if(key_can == 3)
" n5 t4 a3 e$ w8 i2 h: L- v' H& @: L                {
                        if(flag_lj_3_en == 0)
                                t_high -- ;                //按键按下未松开自动减三次        
0 [' {/ M  K3 q# i% q' d6 ]' A                        else
7 K( M9 B% d9 K) Y' w7 D                                t_high -= 10;        //按键按下未松开自动减三次之后每次自动减10
                        if(t_high <= t_low)
                                t_high = t_low + 1;
: Q1 J. Y7 R( T! ~( a                }
$ U3 C: A4 l) r0 b  V' ]                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] ;           //取十位显示
* G( b/ Y+ C- M                dis_smg[3] = 0x64;         //H
        }        
        if(menu_1 == 2)                        //设置低温报警
        {
                smg_i = 4;                  //数码管显示4位
                if(key_can == 2)
                {
( F* i; W' x7 Q/ J3 P& a% K                        if(flag_lj_3_en == 0)
( i2 ?9 W+ p8 K% Z3 ]* P                                t_low ++ ;                        //按键按下未松开自动加三次        
                        else
& e4 s, W2 X% l3 l$ W                                t_low += 10;                //按键按下未松开自动加三次之后每次自动加10
1 L& {0 Q: c( W0 y+ r                        if(t_low >= t_high)
$ G- U8 x( b! {- |# a                                t_low = t_high - 1;
                }
4 L, L  y( Q& R0 P: X                if(key_can == 3)
1 D/ W2 R0 X7 t- x! n3 m% [) T1 O                {
                        if(flag_lj_3_en == 0)
1 c& c8 Y) t7 |6 I$ _) U+ {  ^                                t_low -- ;                        //按键按下未松开自动减三次        
) ]" s' s* f9 N5 y                        else
% G: w7 z% s8 X4 n+ i0 p                                t_low -= 10;                //按键按下未松开自动加三次之后每次自动加10
                        if(t_low <= 10)
; C8 Y  g/ \( h+ k                                t_low = 10;
                }
2 n! `% N+ x: z3 P                dis_smg[0] = smg_du[t_low % 10];                   //取小数显示
. }: Z) C% o/ T$ Y9 J                dis_smg[1] = smg_du[t_low / 10 % 10] & 0xdf;   //取个位显示
7 K- z4 ~' q- m5 {8 N. A' {$ h+ X                dis_smg[2] = smg_du[t_low / 100 % 10] ;               //取十位显示
6 W2 S( \' V* T$ H6 R7 s- A) R                dis_smg[3] = 0x3D;          //L
        }        
! y. n' \% [$ O0 T; p4 j}  
5 k: S6 q7 V0 [9 o. E# c

  D6 }( p! U2 A; A+ H/****************风扇控制函数***************/
void fengshan_kz()
9 Y' ?( p6 |6 k7 `1 r3 N{
        if(flag_en == 1)
        {
' h. }8 A- R* P( G                if(temperature >= t_high)          //风扇全开
; i4 I$ Q, @1 p# A* X                {        
                        TR1 = 1;
                        pwm = 0;
/ X/ H4 q8 s4 [% @                }
( X# R$ J& I4 u: S* E: S& y                else if((temperature < t_high)        && (temperature >= t_low))                   //风扇缓慢
                {
                        f_pwm_l = 60;         
& k1 ~2 ?" x7 |                        TR1 = 1;
                }
8 A+ V; E3 G9 a# G& i6 }& G% w                else if(temperature < t_low)         //关闭风扇
/ D9 z0 [. ~+ y; R3 h' _5 H                {
                        TR1 = 0;
                        pwm = 1;
                }        
        }               
}
8 ?; |4 u. S9 t2 b+ `% T( i+ c# @               

: a: E' L7 w, L9 O7 ]% L
/****************主函数***************/
void main()
{
* L+ U2 ?( C  ?$ i1 T! z7 P        static uchar value;
        time_init();                    //初始化定时器
7 \, w& s  `& Z' p        temperature = read_temp();                //先读出温度的值        
        delay_1ms(650);                                
1 b$ |+ D& G' h7 C: ~' o        temperature = read_temp();                         //先读出温度的值
        dis_smg[0] = smg_du[temperature % 10];         //取温度的小数显示
& d" q# I$ J3 S- w7 }1 d* }        dis_smg[1] = smg_du[temperature / 10 % 10] & 0xdf; //取温度的个位显示
        dis_smg[2] = smg_du[temperature / 100 % 10] ;           //取温度的十位显示
        while(1)
9 p7 `9 D' ?. A9 m- P        {               
( ~* G; F# n' A( v$ n4 m0 s% p                key();                                        //按键程序
- }1 Z3 E! R$ t9 S1 o2 }4 f                if(key_can < 10)
                {
& e$ ^3 C4 v8 l4 ^' s' R                        key_with();                        //设置报警温度        
                }
8 C9 m4 F2 U% ?5 L! ?, c! ]                if(flag_200ms == 1)            //200ms 处理一次温度程序
                {           
) R# E, m( i  g2 }( k. u                        flag_200ms = 0;        
                        temperature = read_temp();        //先读出温度的值
                        if(menu_1 == 0)
8 I& B, x4 ^0 i/ Y& T                        {        
# T/ c+ ?# @: A4 L- y/ j                                smg_i = 3;
) V1 Z, O: r: z8 u/ u                                dis_smg[0] = smg_du[temperature % 10];         //取温度的小数显示
                                dis_smg[1] = smg_du[temperature / 10 % 10] & 0xdf; //取温度的个位显示
; x' X; y2 ]( t' l3 ^+ I                                dis_smg[2] = smg_du[temperature / 100 % 10] ;           //取温度的十位显示
                        }
: L, E3 D9 u0 O  j9 X" L5 u# h: U                        fengshan_kz();        //风扇控制函数
! H8 g- t6 F6 P5 q% J# E$ H8 D. i. G                        value ++;
4 ^7 M0 S6 }3 p2 {" P3 e) _6 a" H7 V  c/ Z                        if(value >= 4)
                        {
                                value = 0;
                                if(miao != 0)
                                {
                                        miao --;    //时间减1
                                }
" y: Z6 h) j5 r' z# K; k5 K                                if(miao == 0)
# ?3 T& ?/ r+ n/ G                                        flag_en = 0;
) a- k9 u( Q" w% N' ~//                                dis_smg[3] = smg_du[miao % 10] ;
: O8 a- Z) |# U3 K9 ?6 g. {3 f                        }
0 f! p8 V, ]9 j, S: ~3 a0 v0 ]                        if(hw == 1)  //感应到人
                        {
0 h# h( G( T) ?4 W4 o4 _0 \: [1 h                                miao = 30;
                                flag_en = 1;
                        }
                }
0 L0 m, z% a* ~+ Y9 m) ~- U

$ D4 [; b' S0 x2 }; ^- g                display();                //数码管显示函数
, W8 l2 c4 [1 l2 j' Z        }
}

. l- z' |" y4 b* d
+ A* p7 m# J5 N/*************定时器0中断服务程序***************/
void time0_int() interrupt 1
{        
        static uchar value;                         //定时2ms中断一次
' m2 M9 D1 P4 w! v        TH0 = 0xf8;
        TL0 = 0x30;     //2ms
" `& k; d) Q8 R" n        value++;         
1 z+ {+ ^* s- J1 y& S' X7 r        if(value >= 150)
        {
' \1 ]& B) c, Q, e3 Q2 Z5 b% _                value = 0;         
& T1 H( p$ Z$ E3 S6 N                flag_200ms = 1;
' @9 I3 d/ H: ^7 J# k4 w5 r. d        }
        if(flag_lj_en == 1)           //按下按键使能
7 f" U! Q8 Y) ]1 H        {
( A& [$ H# u8 N" g3 V1 j* [                key_time ++;
                if(key_time >= 250) //500ms
                {
( N  M* ]' E' S4 \" L                        key_time = 0;
" [, |, ~9 Q1 x6 k5 M- e/ }9 m, a                        key_500ms = 1; //500ms
                        key_value ++;
                        if(key_value > 3)
                        {
. Z: t6 I! ^  J* \4 V0 Y                                key_value = 10;
                                flag_lj_3_en = 1; //3次后1.5秒连加大些
                        }                                                
& {2 h3 K4 N6 Q                }
4 Y# f$ k# k" O2 _3 d4 Z        }
' B! ~( H3 `; m, F) y}




" k4 q# [( ~, X( O% ]; h+ C  v( C/*******************定时器1用做单片机模拟PWM 调节***********************/
# h' C. i$ u: v4 U5 Evoid Timer1() interrupt 3  //调用定时器1
{
; S2 g8 N1 z8 Y: v. I  Y+ k        static uchar value_l;
  d$ K5 T3 |: ^8 m& M! \        TH1=0xff;    //    定时中断一次
        TL1=0xec;         //
2 ^0 F* d) ]; y8 n$ }& l


3 c, C9 z* k& r4 x9 ?
. S' q# p0 W2 f8 d; y4 t…………余下代码请下载附件…………
3 n1 |. e8 n; T3 Y# R1 G

下载：
2 ?5 B# \( a- k$ \; c

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

* W- O  Q1 M0 h% G

abcde1234

好东东，学习一下

th2010-gc01

好东西！谢谢分享！

季节渐冷

感谢楼主
' Z# m1 C% f4 w) \( b

kailang

好东西，学习一下楼主