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

helendcany

单片机智能温控风扇设计 带智能调速人体感应 毕业设计论文
# e7 ]. {8 q# h- j9 K
  l3 L7 O6 Y0 X9 _) v. V, B2 z. D
51单片机做的温空风扇 数码管显示 带人体感应模块，实现智能调速，功能非常强大，这是一个本科的毕业设计，毕业论文 开题报告 源码 原理图 还有proteus仿真等等都是一应俱全. 还有答辩常见问题解答，焊接注意事项和调试讲解，以及详细的制作过程.
8 D! c+ h- v8 ^8 Y( {+ e
温空风扇实物图：

: G1 }4 `7 P! y5 T$ M  r) y4 }6 e4 G
  \1 ]  a# ]2 q$ l  z; g  Z温空风扇仿真截图：


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


DXP格式用            altium designer Summer 软件打开
' ?% N4 T4 N" zprotel99格式用       protel99SE 软件打开
PDF格式用            PDF 软件打开
Word格式用           Word 或用WPS 软件打开
1 _: F+ J3 [7 o5 `9 s3 M" W5 q
4 l/ c9 y/ a* o9 |4种格式的原理图都内容是一样的  只是打开方式不同

请看原理图焊接，不要看仿真图焊接。

2 X6 j5 O- B3 D- b# ]wrod格式里面的原理图是复制出来的，有一点点变行变形，麻烦大家注意一下，尽量看其他三种格式的图焊接，
; M: ?" H4 x5 N7 U6 R/ r1 Z+ K0 q3 X  W
如果论文里面的原理图和原理图文件夹内的图不一样的话，请大家以原理图文件夹内的为准，原理图文件夹的图是和实物配套的，可以自己截图或复制，然后粘贴到论文里面去。

4 [1 y* @% J+ u, n0 A5 v智能调速温控风扇的毕业论文截图：

目 录
, H/ E: G. f- H( v  P6 Y! Y绪  论    4
1  系统概述    5
* r" u  a" A% K4 g: H1.1  STC89C52单片机简介    5
1. 2  本设计任务和主要内容    5
) b1 r5 _! Q8 \3 ~2  方案论证    6
& C4 b' i' w0 V2．1 温度传感器的选用    6
2．2  控制核心的选择    7
/ E1 u5 B% W7 S1 X  G" x2．3显示电路    7
2．4调速方式    7
6 {) X5 W5 B0 M2．5控制执行部件    8
' [! n, |( \4 ?6 n. T* e3 系统原理    8
. Y- Y4 [( F+ f' r7 D) A6 p3.1  系统总体设计    8
. {! c4 [* U3 G4 H# e3.2  控制装置原理    9
) y( E6 o0 X, h( v& g3．3  温度检测和显示电路    9
3.3.1  DS18B20的温度处理方法    9
: k( o+ }. _- ^) {8 Q  `3 ?3.3.2  温度传感器和显示电路组成    11
& i5 P: y! Z) L$ s6 O8 {, W) p3.4  电机调速电路    11
( Z6 ^2 I6 N" i, }4 ?3.4.1  电机调速原理    12
3.4.2  电机控制模块设计    13
' D: X! e3 f3 R; s8 y4  控制器软件设计    14
+ R, k- Y. }. ~" r: A, d* O4.1  主程序    14
4.2  数字温度传感器模块和显示子模块    15
- _( F1 R& x. Y3 q* @4.3  电机调速与控制子模块    17
结 束 语    19
参考文献    20
附录一    21
' n# J5 o& }$ ~
元件清单：
4 q' V( G$ L# B' {
' P4 }& i( L! A/ Y: p6 E' T8 n

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结尾的文件即为程序。打开方式选择记事本打开
或者到开发资料里安装KEIL软件
  Z( B1 p9 o+ D' d

; G4 [$ Z9 e. ?$ _9 ^, @& e2 U
! v( P9 b3 ?  P

! Y4 f: q. B; u
  Q; f  u6 T7 ^; N6 G  o#include <reg52.h>                 //调用单片机头文件
#define uchar unsigned char  //无符号字符型 宏定义        变量范围0~255
; _- M) j' V- M5 v, G5 n#define uint  unsigned int         //无符号整型 宏定义        变量范围0~65535


//数码管段选定义      0     1    2    3    4    5        6         7          8           9        
9 O9 n2 @9 i, w0 nuchar code smg_du[]={0x28,0xe4,0x42,0x72,0xe5,0xa8,0x41,0x77,0x20,0xa0,
                                           0x60,0x25,0x39,0x26,0x31,0x71,0xff};         //断码
//数码管位选定义
uchar code smg_we[]={0xef,0xdf,0xbf,0x7f};
uchar dis_smg[8] = {0};        
uchar smg_i = 3;    //显示数码管的个位数
; g# m/ z8 N0 Y; R9 Fsbit dq   = P2^4;        //18b20 IO口的定义
sbit hw = P2^5;
uchar miao = 30;
uchar flag_en;
1 T" I6 ~9 n+ z

bit flag_lj_en;                 //按键连加使能
& Q# Z' B% w1 c$ [2 ~bit flag_lj_3_en;         //按键连3次连加后使能  加的数就越大了
8 f& G4 [/ ~' F: S& Puchar key_time,key_value;      //用做连加的中间变量
' |+ _& N2 f4 ^! F( Y9 abit key_500ms  ;
sbit pwm = P2^3;  
uchar f_pwm_l ;          //越小越慢


uint temperature ;  //
3 P* \- B* v' v2 u2 Kbit flag_200ms ;
$ t# c3 s3 p% b- B( I& }  F% vuchar menu_1;       //菜单设计的变量
" ~4 w5 g- w, r/ Juint t_high = 200,t_low = 100;           //温度上下限报警值
+ h2 d7 [5 r. \# }7 t
( j7 C$ z, y) H) k9 O7 l
8 c3 b* @3 j% ^8 Y/***********************1ms延时函数*****************************/
void delay_1ms(uint q)
{
" h' q( D' v; Y6 Y& h        uint i,j;
- ]0 G' E+ ^8 G# n+ `6 ]& }' f        for(i=0;i<q;i++)
& y: [1 r2 }0 P3 k4 U                for(j=0;j<120;j++);
" r" M/ O5 R+ D( f6 }( U9 `5 J7 Z}


6 u% @5 |0 v5 J  k. W1 z5 R/***********************小延时函数*****************************/
void delay_uint(uint q)
8 K- H4 v# p, s6 A  G5 l% M% ~{
        while(q--);
0 A; D  R% X4 X% c" J% Y* a}
% |( x* q; W# i/ X! D' R9 ?1 f



/***********************数码显示函数*****************************/
void display()
  v3 V# k2 d# ~, m{
        static uchar i;   
& a6 N) R1 O$ u2 {4 ^* S6 c        i++;
        if(i >= smg_i)
                i = 0;        
% O2 e; \0 Q8 P& J/ o9 \; v2 O; l        P1 = 0xff;                         //消隐
        P3 = smg_we;                          //位选
) N. B  u4 Y9 g# |5 {$ N3 ~4 f        P1 = dis_smg;                 //段选               
0 W; B  `6 b$ Z

}


/***********************18b20初始化函数*****************************/
) W* h, |$ d; h% y! N, m3 [$ svoid init_18b20()
' p3 K% L9 ~  }3 f& p" I6 b{
        bit q;
        dq = 1;                                //把总线拿高
        delay_uint(1);            //15us
! A1 I* x/ E# _4 I) g) E        dq = 0;                                //给复位脉冲
5 H3 }( o, I0 k# N        delay_uint(80);                //750us
  c3 U) W! z; X! Q7 P        dq = 1;                                //把总线拿高 等待
        delay_uint(10);                //110us
. t* V; Z% e; ^/ O6 J: [- m0 }0 W; O        q = dq;                                //读取18b20初始化信号
        delay_uint(20);                //200us
8 T$ m5 m3 I9 G0 i9 V% S2 |        dq = 1;                                //把总线拿高 释放总线
2 ?# ]' i: Z! d" a6 g9 X}

/ X! A; U  `9 P, n* [( ?
3 ]! Y, I/ n2 {( q. w( q, d/*************写18b20内的数据***************/
void write_18b20(uchar dat)
8 i2 W8 h& g$ P% M) u{
% S3 [' L+ m7 c4 F7 s# [        uchar i;
        for(i=0;i<8;i++)
        {                                         //写数据是低位开始
1 E8 b; x$ V4 z1 _$ L                dq = 0;                         //把总线拿低写时间隙开始
                dq = dat & 0x01; //向18b20总线写数据了
                delay_uint(5);         // 60us
                dq = 1;                         //释放总线
; `5 m0 m/ }% z: [                dat >>= 1;
        }        
}

7 c& F& X( p" k. G7 i& m0 i! y
/*************读取18b20内的数据***************/
uchar read_18b20()
* _7 P6 b2 f$ e8 Z! C  D" p{
0 j' Z* V, y' j  n        uchar i,value;
        for(i=0;i<8;i++)
2 f% I6 d& n# |+ R( m        {
" z( P# o: l1 b# S0 ], X# b                dq = 0;                         //把总线拿低读时间隙开始
                value >>= 1;         //读数据是低位开始
                dq = 1;                         //释放总线
% U$ k) `6 W* u- y$ w1 B+ W  N                if(dq == 1)                 //开始读写数据
                        value |= 0x80;
8 o( [0 N0 b$ m* M/ b* O& `+ i4 R                delay_uint(5);         //60us        读一个时间隙最少要保持60us的时间
$ Y* c. ~. I" ~6 d& \+ e1 D        }
6 u* Z$ \  S+ q& Z        return value;                 //返回数据
$ w* Q$ ^# Q$ V( N! L; l}

# t& B5 U2 f" j
/*************读取温度的值 读出来的是小数***************/
uint read_temp()
{
        uint value;
- g/ d, U' g# M4 L        uchar low;                           //在读取温度的时候如果中断的太频繁了，就应该把中断给关了，否则会影响到18b20的时序
; d) ?* v. _+ G$ P) ]        init_18b20();                   //初始化18b20
/ H" F7 P( e, H, L* w# e. O$ y        write_18b20(0xcc);           //跳过64位ROM
2 h* o4 F$ c. @/ C) M  b        write_18b20(0x44);           //启动一次温度转换命令
        delay_uint(50);                   //500us
' Q7 r% N) i  H4 h1 k* C

        init_18b20();                   //初始化18b20
        
        write_18b20(0xcc);           //跳过64位ROM
4 l7 v% Z& T, K+ s  [        write_18b20(0xbe);           //发出读取暂存器命令
        
        low = read_18b20();           //读温度低字节
        value = read_18b20();  //读温度高字节
/ ]9 [- i( m9 b7 p: L. V        value <<= 8;                   //把温度的高位左移8位
        value |= low;                   //把读出的温度低位放到value的低八位中
        value *= 0.625;               //转换到温度值 小数
        return value;                   //返回读出的温度 带小数
}
% \2 N3 q; {+ k- z4 W8 l$ \$ r

/*************定时器0初始化程序***************/
void time_init()         
* H5 n1 r1 f9 ]  O. I{
& i9 G2 J' S5 |. [' z& t# T        EA   = 1;                   //开总中断
3 l, L/ G- g, ?0 w. ~% j        TMOD = 0X21;          //定时器0、定时器1工作方式1
        ET0  = 1;                  //开定时器0中断
        TR0  = 1;                  //允许定时器0定时
4 z8 ]" G  R3 W! o

        ET1  = 1;                  //开定时器0中断
+ I# E; h9 C9 O$ Z. E- a( \1 p/ l# f        TR1  = 1;                  //允许定时器0定时
, P: a! e' e! ^}

/ @6 ^5 ^6 V8 ~& B4 U" l3 R
/********************独立按键程序*****************/
uchar key_can;         //按键值


void key()         //独立按键程序
5 D/ x9 S$ _. Q2 C{
        static uchar key_new;
3 @" b0 q* \. i8 v" y( R        key_can = 20;                   //按键值还原
( [! t% I. R( w4 J        P2 |= 0x07;
        if((P2 & 0x07) != 0x07)                //按键按下
        {
                if(key_500ms == 1)        //连加
                {
                        key_500ms = 0;
                        key_new = 1;
% w1 `- I7 Y* Y( I5 T2 p                }
- o2 q- S7 {; k5 J6 U; t5 ]                delay_1ms(1);                     //按键消抖动
                if(((P2 & 0x07) != 0x07) && (key_new == 1))
$ @) R3 m, z& X: D5 Q* P/ Q. a                {                                                //确认是按键按下
- {  z' V$ b# [+ H                        key_new = 0;
7 l) L6 |9 j8 Y8 j8 a! X4 V. q  P8 ~                        switch(P2 & 0x07)
                        {
                                case 0x06: key_can = 1; break;           //得到k2键值
. {3 Z& N1 w9 \6 V3 @                                case 0x04: key_can = 2; break;           //得到k3键值
                                case 0x02: key_can = 3; break;           //得到k4键值
( p: C; Q' p* s) p; S6 Y                        }
                        flag_lj_en = 1;         //连加使能
                }                        
        }
2 ?8 F6 j9 ~4 j0 ?6 j8 L! N        else
        {
7 A% C9 L0 k9 d" v& G# ^                if(key_new == 0)
                {
) _$ {$ S- w3 h% A# ], l% A                        key_new = 1;
                        flag_lj_en = 0;                //关闭连加使能
                        flag_lj_3_en = 0;        //关闭3秒后使能
- z9 `% k' t0 x! O                        key_value = 0;                //清零
                        key_time = 0;
                        key_500ms = 0;
  Q- }; y1 D* J, @. ^! {, l% z$ F                }
* n/ U  W! |. {7 ^) m0 |: t        }        
8 N9 T8 Z& r" H" C8 W}
$ m, c( ]! Z6 [+ y, V' q
) O6 J0 X3 z) y$ S& O
/****************按键处理数码管显示函数***************/
void key_with()
{
- K: Q9 ]' W  m' D- e        if(key_can == 1)          //设置键
        {
# e3 w: n' S" Q: v9 n- U' I/ j                f_pwm_l = 30;
0 ?6 `! l* o8 \# K                menu_1 ++;
2 d9 s8 |" s4 x- B  f                if(menu_1 >= 3)
                {
                        menu_1 = 0;
9 s; u6 a4 h: J7 q9 {7 N/ o                        smg_i = 3;                  //数码管显示3位
                }
% e9 [! `2 f3 f  O        }
. u, M' X" j# P1 s( h0 i% \        if(menu_1 == 1)                        //设置高温报警
        {
/ \& W: Y5 X9 H  [                smg_i = 4;                  //数码管显示4位
8 f( z) K7 L! S$ }2 D3 y                if(key_can == 2)
                {
                        if(flag_lj_3_en == 0)
4 y7 n7 [5 ^# y0 }- g2 V. f4 b                                t_high ++ ;                //按键按下未松开自动加三次        
                        else
                                t_high += 10;        //按键按下未松开自动加三次之后每次自动加10
' }$ p. B1 N9 ]2 W4 P' M                        if(t_high > 990)
( P) K8 F. M" l9 F                                t_high = 990;
' j9 v9 a7 v3 B, _0 A) M" A1 `                }
                if(key_can == 3)
                {
8 |% \7 ]4 A, z8 \, j                        if(flag_lj_3_en == 0)
+ q, p4 Z/ Y" O4 N# a                                t_high -- ;                //按键按下未松开自动减三次        
                        else
) M5 j. s4 I8 _5 N7 ~! x                                t_high -= 10;        //按键按下未松开自动减三次之后每次自动减10
                        if(t_high <= t_low)
                                t_high = t_low + 1;
* r. _, b# I! d3 }6 T2 \1 E                }
5 B& E& o& P) U) e                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
        }        
; R0 x/ @/ A# @! P        if(menu_1 == 2)                        //设置低温报警
        {
                smg_i = 4;                  //数码管显示4位
/ |5 A" h1 H6 T                if(key_can == 2)
9 R6 l$ N9 z/ _0 L                {
                        if(flag_lj_3_en == 0)
+ X- Z8 ~2 ~1 ^6 O0 `- _                                t_low ++ ;                        //按键按下未松开自动加三次        
                        else
& Z: I. i$ ]5 }0 u+ a! y                                t_low += 10;                //按键按下未松开自动加三次之后每次自动加10
- k/ o- I, D/ h- b& P                        if(t_low >= t_high)
3 O& e0 @+ I9 C- F8 t- \$ w                                t_low = t_high - 1;
6 p1 m. B# b2 F                }
9 E0 G, f# ?: m- m                if(key_can == 3)
                {
                        if(flag_lj_3_en == 0)
                                t_low -- ;                        //按键按下未松开自动减三次        
1 A( Z4 s, {5 c3 q4 w4 e5 ~                        else
+ j2 ~$ g$ @- C                                t_low -= 10;                //按键按下未松开自动加三次之后每次自动加10
                        if(t_low <= 10)
" N* ^/ Q5 ]4 _1 q3 O. w0 [8 a                                t_low = 10;
                }
                dis_smg[0] = smg_du[t_low % 10];                   //取小数显示
                dis_smg[1] = smg_du[t_low / 10 % 10] & 0xdf;   //取个位显示
                dis_smg[2] = smg_du[t_low / 100 % 10] ;               //取十位显示
                dis_smg[3] = 0x3D;          //L
        }        
}  

9 O( T  E. v0 c) ?0 W
' Q. n! T6 p6 G, I0 B/****************风扇控制函数***************/
void fengshan_kz()
  P5 ]' e4 c. ]6 f7 c* \" X4 _{
- m2 T3 N2 E/ c$ N" G4 d3 ~/ E        if(flag_en == 1)
        {
9 z% E3 M& o6 {- \                if(temperature >= t_high)          //风扇全开
                {        
                        TR1 = 1;
) \8 r" x, l, |$ a% V2 X                        pwm = 0;
                }
9 j; P: {9 B1 O, Q3 @                else if((temperature < t_high)        && (temperature >= t_low))                   //风扇缓慢
                {
                        f_pwm_l = 60;         
/ R" C$ ~9 @6 B( D/ s. i                        TR1 = 1;
0 z! N. H1 H. n                }
- W5 r* s! M  y/ B* e                else if(temperature < t_low)         //关闭风扇
" x9 A4 }* x% h% [: t0 Y! k                {
" y' k/ z- X1 ~* e& @. S# u+ V                        TR1 = 0;
) Q  f, \/ e9 n; X* @- A+ j' j3 d0 @                        pwm = 1;
                }        
) D/ L. e2 o, J0 d) M1 U        }               
}
: h" C  b, q9 O5 b4 l' z               
0 T1 v, |4 t# J
% a5 s7 r; ~  |
/****************主函数***************/
# B) l* Y! x- b, t( Z" S  gvoid main()
{
6 D: H$ E9 f2 o' n        static uchar value;
! p- J! G5 m/ t/ u5 |3 o) J/ v        time_init();                    //初始化定时器
        temperature = read_temp();                //先读出温度的值        
        delay_1ms(650);                                
        temperature = read_temp();                         //先读出温度的值
) E3 r& }* j; F3 R( C0 [1 M        dis_smg[0] = smg_du[temperature % 10];         //取温度的小数显示
        dis_smg[1] = smg_du[temperature / 10 % 10] & 0xdf; //取温度的个位显示
0 h4 `- U9 X( `- {" e2 g6 y$ \        dis_smg[2] = smg_du[temperature / 100 % 10] ;           //取温度的十位显示
7 ?3 G3 Q) W" s; l  n, r        while(1)
        {               
                key();                                        //按键程序
                if(key_can < 10)
                {
                        key_with();                        //设置报警温度        
9 O% M! ^3 F# U3 g5 u                }
                if(flag_200ms == 1)            //200ms 处理一次温度程序
                {           
) \  _. ]/ `+ l1 \" p1 Z                        flag_200ms = 0;        
# _* V% \0 u& Q8 `) z. L0 X  w* V5 h/ B                        temperature = read_temp();        //先读出温度的值
9 h" g9 f' T+ i- A; v% r! U1 A                        if(menu_1 == 0)
- u1 L" K- k  c                        {        
                                smg_i = 3;
( X! I' Z  C6 b# f( b& ^" p& G                                dis_smg[0] = smg_du[temperature % 10];         //取温度的小数显示
6 }. n# a# @4 Q                                dis_smg[1] = smg_du[temperature / 10 % 10] & 0xdf; //取温度的个位显示
                                dis_smg[2] = smg_du[temperature / 100 % 10] ;           //取温度的十位显示
) e! P. b3 h* q3 F                        }
                        fengshan_kz();        //风扇控制函数
' {0 n; E0 H0 d: Z# M                        value ++;
8 M$ g& S, B6 C3 e0 o1 F, n                        if(value >= 4)
* p. R3 f$ ^5 @3 U                        {
                                value = 0;
                                if(miao != 0)
. I2 j( R+ \+ w- V- `, S8 `                                {
                                        miao --;    //时间减1
  E- N9 i  q: q' W7 S7 ?. O( K2 D                                }
4 c) i9 ^. y, f8 Y6 R1 \  d                                if(miao == 0)
- D& n* t7 w  |; X                                        flag_en = 0;
//                                dis_smg[3] = smg_du[miao % 10] ;
                        }
                        if(hw == 1)  //感应到人
                        {
! N+ @; t2 c8 B3 _                                miao = 30;
5 I* Z6 Y1 U4 G* q" ]( K0 c                                flag_en = 1;
                        }
                }


# g( J" W  T; j& {' n  H                display();                //数码管显示函数
4 x9 b) D  j( L; A1 ~& }: O& t        }
}
# ~; F; d  G- }, u3 o9 r) X3 c
* [) t, y2 z. r
; H2 {# B% l  F% F/*************定时器0中断服务程序***************/
+ o/ q4 R& D3 x/ w6 lvoid time0_int() interrupt 1
{        
        static uchar value;                         //定时2ms中断一次
4 C( H6 R* I) b! j        TH0 = 0xf8;
        TL0 = 0x30;     //2ms
        value++;         
  x: H8 }0 u$ Y, w# t8 C        if(value >= 150)
        {
8 ^" ?0 ^, ~; X3 ?4 t7 K                value = 0;         
1 b/ ]; ^( l$ ~5 G, ?8 A                flag_200ms = 1;
5 q0 |9 I* F. U! Q        }
( s9 D( Q6 U# l9 o9 G5 F        if(flag_lj_en == 1)           //按下按键使能
        {
. j& N! q# A8 I  A) Q                key_time ++;
                if(key_time >= 250) //500ms
, ~9 n; Q- M: j2 D$ z                {
& h' B1 l5 Y: W+ f$ W- f1 Q7 n                        key_time = 0;
, @% E% G7 A" m                        key_500ms = 1; //500ms
                        key_value ++;
( C/ X# u0 R+ Z$ B- o$ d                        if(key_value > 3)
                        {
6 m5 Q8 v( o0 {6 B                                key_value = 10;
  R( k/ Z  _- ^& F$ P                                flag_lj_3_en = 1; //3次后1.5秒连加大些
' M' [5 H. G% B! V" [6 t8 i  S* C                        }                                                
                }
3 ?. }/ n; B, Q9 A        }
}
4 ]$ a) d" n7 \% I, F



/*******************定时器1用做单片机模拟PWM 调节***********************/
void Timer1() interrupt 3  //调用定时器1
{
        static uchar value_l;
        TH1=0xff;    //    定时中断一次
1 T( X$ J" e  s% `        TL1=0xec;         //



  n3 k( _! ]; H3 e
…………余下代码请下载附件…………

1 P5 e7 h% ^! w& h7 }3 B
. q9 W" }% O6 b& J& M5 D' O下载：

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

9 G2 A' M& \+ z+ K; Y! }8 c

abcde1234

好东东，学习一下

th2010-gc01

好东西！谢谢分享！

季节渐冷

感谢楼主
2 z4 u. G/ s% V: e
$ ?% \8 Y) k; o& [; \. `

kailang

好东西，学习一下楼主