找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 1354|回复: 0
打印 上一主题 下一主题
收起左侧

自己做得单片机万年历 Proteus仿真程序与原理图PCB文件

[复制链接]
跳转到指定楼层
楼主
自己做的
Altium Designer画的原理图和PCB图如下:(51hei附件中可下载工程文件)


Proteus仿真是用8.1版本的

单片机源程序如下:
  1. /*
  2. * 万年历
  3. */

  4. #include "main.h"                         //包含头文件main.h
  5. #include "LCD.h"                        //包含头文件LCD.h
  6. #include "DS1302.h"                        //包含头文件DS1302.h
  7. #include "word.h"                        //包含头文件word.h
  8. #include "lunar_calendar.h" //包含头文件lunar_calendar.h
  9. #include "buzz.h"                        //包含头文件buzz.h


  10. TIME time, tmp_time;        //时间变量
  11. ALARM alarm;                                //时间变量
  12. bit Alarm_flag=0;                        //时间变量
  13. bit Clock_flag=0;                        //时间变量
  14. bit flag=0;                                        //时间变量

  15. sbit DQ=P2^6;   //DS18B20 pin 温度传感器引脚

  16. //-----------------18B20-----------------------
  17. unsigned char L_18B20,H_18B20,zhengshu,shangwen,xiawen;  //温度用变量
  18. unsigned int fg=0,xiaoshu_a;                                                        //温度用变量
  19. //-----------------18B20----------------------
  20. //-------------音乐-----------------------------
  21. uint8 code SONG_TONE[]=          //音乐数据
  22. {
  23.         212,212,190,212,159,169,212,212,190,212,142,159,212,212,106,126,129,169,190,119,119,126,159,142,159,0
  24. };
  25. uint8 code SONG_LONG[]=//
  26. {
  27.         9,3,12,12,12,24,9,3,12,12,12,24,9,3,12,12,12,12,12,9,3,12,12,12,24,0
  28. };
  29. //------------------------------------------------------------

  30. void delay(uint16 n)//延时us级
  31. {
  32.         while (n--);
  33. }
  34. //************************************************************************/
  35. // 函数: LCD_Delay()
  36. // 描述: 延时t ms函数
  37. // 参数: t
  38. // 返回: 无
  39. // 备注: 11.0592MHZ       t=1延时时间约1ms
  40. // 版本:  2011/01/01      First version
  41. //************************************************************************/
  42. void Delay_nms(unsigned int t)
  43. {
  44.         unsigned int i,j;
  45.         for(i=0;i<t;i++)             //循环t次
  46.         for(j=0;j<113;j++)                 //循环113次 每次约3us
  47.         ;
  48. }
  49. /////////////////////////////////////////////////
  50. //-----------播放音乐----------------------------
  51. void PlayMusic()
  52. {
  53.         uint16 i =0,j,k;
  54.         while(SONG_LONG[i]!=0||SONG_TONE[i]!=0)
  55.         {
  56.                  for(j=0;j<SONG_LONG[i]*20;j++)                 //读取数据
  57.                 {
  58.                          BEEP = ~BEEP;                                        //蜂鸣器取反
  59.                         for(k=0;k<SONG_TONE[i]/3;k++);  //读取数据
  60.                 }
  61.                 Delay_nms(10);                                                //延时10ms
  62.                 i++;                                             //累加1
  63.         }
  64.         BEEP =1;                                                                //关闭蜂鸣器
  65. }
  66. /////////////////////////////////////////////////
  67. /*------DS18B20------*/
  68. void delay_18B20(unsigned int i)
  69. {
  70.         while(i--);
  71. }
  72. /*DS18B20的复位脉冲 主机通过拉低单总线至少480us以产生复位脉冲
  73.   然后主机释放单总线并进入接收模式 此时单总线电平被拉高
  74.   DS18B20检测到上升沿后 延时15~60us,拉低总线60~240us产生应答脉冲  */                                               
  75. void Init_DS18B20(void)
  76. {
  77.          unsigned char x=0;
  78.          DQ = 1;          //DQ复位
  79.          delay_18B20(8);  //稍做延时
  80.          DQ = 0;          //单片机将DQ拉低
  81.          delay_18B20(80); //精确延时 大于 480us
  82.          DQ = 1;          //拉高总线
  83.          delay_18B20(14); //延时
  84.          x=DQ;            //稍做延时后 如果x=0则初始化成功 x=1则初始化失败
  85.          delay_18B20(20); //延时
  86. }

  87. /*写时隙 主机在写1时隙向DS18B20写入1,在写0时隙向DS18B20写入0
  88.   所有写时隙至少需要60us,且在两次写时隙之间至少需要1us的恢复时间
  89.   两种写时隙均以主机拉低总线开始
  90.   产生写1时隙:主机拉低总线后,必须在15us内释放总线,由上拉电阻拉回至高电平
  91.   产生写0时隙:主机拉低总线后,必须整个时隙保持低电平 */
  92. void WriteOneChar(unsigned char dat)
  93. {
  94.         unsigned char i=0;
  95.         for (i=8; i>0; i--)//循环8次
  96.         {
  97.                   DQ = 0;                        //DQ输出0
  98.                 DQ = dat&0x01;
  99.             delay_18B20(5); //延时
  100.                 DQ = 1;         //DQ输出1
  101.             dat>>=1;        //右移位
  102. }
  103. }
  104.   
  105. /*所有读时隙至少60us 且两次独立的读时隙之间至少需要1us的恢复时间
  106.   每次读时隙由主机发起,拉低总线至少1us。
  107.   若传1,则保持总线高电平;若发送0,则拉低总线
  108.   传0时DS18B20在该时隙结束时释放总线,再拉回高电平状态,主机必须在读时隙开始后的15us内释放总线,并保持采样总线状态 */
  109. unsigned char ReadOneChar(void)
  110. {
  111.         unsigned char i=0;
  112.         unsigned char dat = 0;
  113.         for (i=8;i>0;i--)
  114.          {
  115.                   DQ = 0;                 // 给脉冲信号
  116.                   dat>>=1;      //移位
  117.                   DQ = 1;                 // 给脉冲信号
  118.                   if(DQ)       //如果DQ=1,执行下面的语句   
  119.                   dat|=0x80;
  120.                   delay_18B20(4);//延时
  121.          }
  122.         return(dat);                //返回数据
  123. }
  124.                  

  125. void read_18B20(void)
  126. {

  127.         Init_DS18B20();
  128.         WriteOneChar(0xCC);            // 跳过读序号列号的操作
  129.         WriteOneChar(0x44);         // 启动温度转换

  130.         delay_18B20(100);       // this message is wery important

  131.         Init_DS18B20();                        //初始化DS18B20
  132.         WriteOneChar(0xCC);         //跳过读序号列号的操作
  133.         WriteOneChar(0xBE);         //读取温度寄存器等(共可读9个寄存器) 前两个就是温度

  134.         delay_18B20(100);                //延时

  135.         L_18B20=ReadOneChar();        //读取低八位数据
  136.         H_18B20=ReadOneChar();        //读取高八位数据

  137.         zhengshu=L_18B20/16+H_18B20*16; //整数部分
  138.         xiaoshu_a=(L_18B20&0x0f)*10/16; //小数第一位
  139. }
  140. //------------------DS18B20---------------------
  141. /////////////////////////////////////////////////
  142. /*
  143. * 按键扫描
  144. */
  145. int8 scan_key(void)
  146. {
  147.         int8 val=-1;                  //初始化键值为-1

  148.         if (KeyIn1 == 0)                 //判断=0?有无按键按键
  149.         {
  150.                 val = 1;                         //键值=1
  151.                 while (KeyIn1 == 0); //等待按键释放
  152.         }
  153.         else if (KeyIn2 == 0)         //判断=0?有无按键按键
  154.         {
  155.                 val = 2;                        //键值=2
  156.                 while (KeyIn2 == 0);//等待按键释放
  157.         }
  158.         else if (KeyIn3 == 0)        //判断=0?有无按键按键
  159.         {
  160.                 val = 3;                        //键值=3
  161.                 while (KeyIn3 == 0);//等待按键释放
  162.         }

  163.         //if (val > 0)
  164.                 //buzzer_sound();

  165.         return val;                                //返回键值
  166. }

  167. /*
  168. * 主界面框架
  169. */
  170. void main_frame(void)
  171. {
  172.         play32(80, 2, 10); //显示数
  173.         play32(32, 2, 10); //显示数
  174.         play8(16, 0, S_xie);//显示斜线
  175.         play8(40, 0, S_xie);//显示斜线
  176. //        play8(96, 0, RH);
  177. //        play8(120, 0, S_percent);
  178.         play8(120, 6, S_du);//显示度
  179. }

  180. /*
  181. * 主界面
  182. */
  183. void main_show(bit refresh)
  184. {
  185.     uint8  lunar[2];
  186.         if (refresh)
  187.                 read_time((uint8 *)&time);// 读时间函数// 时间                                                                                          
  188.         if (refresh || (time.sec != tmp_time.sec)) // 秒更新
  189.         {
  190.                 tmp_time.sec = time.sec;                                  //读取秒数据
  191.             play8_num(104, 6,zhengshu);                           //温度显示
  192.                 play32_num(96, 2, time.sec);                        //显示秒
  193.         }
  194.         if (refresh)
  195.                 main_frame();//刷新界面
  196.         if (refresh || (time.min != tmp_time.min)) // 分更新
  197.         {
  198.                 if (!refresh)
  199.                         flag = 0;
  200.                 tmp_time.min = time.min;//读取分
  201.                 play32_num(48, 2, time.min); //显示分
  202.         }
  203.         if (refresh || (time.hour != tmp_time.hour)) // 时更新
  204.         {
  205.                 if ((!refresh)&&(Clock_flag))
  206.                         alarm_sound();
  207.                 tmp_time.hour = time.hour;                                 //读取时
  208.                 play32_num(0, 2, time.hour);                        //显示时
  209.         }
  210.         if (refresh || (time.day != tmp_time.day))  //日更新
  211.         {
  212.                 tmp_time.day = time.day;                                //读取日
  213.                 play8_num(48, 0, time.day);                                //显示日
  214.                 // 农历       
  215.                 turn_lunar_calendar(&time, lunar);
  216.                 play_lunar_calendar(0, 6, lunar[0], lunar[1]);
  217.         }
  218.         if (refresh || (time.week != tmp_time.week)) // 周更新
  219.         {
  220.                 tmp_time.week = time.week;                                //读取周
  221.                 play_week(68, 0, time.week);                        //显示周
  222.         }
  223.         if (refresh || (time.mon != tmp_time.mon))  // 月更新
  224.         {
  225.                 tmp_time.mon = time.mon;                                //读取月
  226.                 play8_num(24, 0, time.mon);                                //显示月
  227.                 // 农历       
  228.                 turn_lunar_calendar(&time, lunar);                                //转换农历月
  229.                 play_lunar_calendar(0, 6, lunar[0], lunar[1]);        //显示农历月
  230.         }

  231.         if (refresh || (time.year != tmp_time.year)) // 年更新
  232.         {
  233.                 tmp_time.year = time.year;                                        //读取年数据
  234.                 play8_num(0, 0, time.year);                                        //显示年
  235.                 // 农历       
  236.                 turn_lunar_calendar(&time, lunar);                                //转换农历年
  237.                 play_lunar_calendar(0, 6, lunar[0], lunar[1]);        //显示农历年
  238.         }
  239.        
  240. }
  241. /*
  242. * 主机界面设置
  243. */
  244. void main_set(void)
  245. {
  246.         int8 key_val, state=1;                                 //变量
  247.         play32_num(96, 2|0x80, time.sec);        //显示秒                       
  248.         while (1)
  249.         {        key_val = scan_key();//键盘扫描
  250.                 if (key_val == 1) // 设置
  251.                 {
  252.                         if (state >= 7)
  253.                                 state = 0;
  254.                         else
  255.                                 state++;                                //位置状态加1
  256.                         set_time((uint8 *)&time);        //设置时间
  257.                         main_show(1);                                //显示主界面
  258.                         switch (state)
  259.                         {        case 0:        set_time((uint8 *)&time); break;//设置时间
  260.                                 case 1:        play32_num(96, 2|0x80, time.sec); break;//显示秒
  261.                                 case 2:        play32_num(48, 2|0x80, time.min); break;//显示分
  262.                                 case 3:        play32_num(0, 2|0x80, time.hour); break;//显示时
  263.                                 case 4:        play_week(68, 0|0x80, time.week); break;//显示周
  264.                                 case 5:        play8_num(48, 0|0x80, time.day); break; //显示日
  265.                                 case 6:        play8_num(24, 0|0x80, time.mon); break; //显示月
  266.                                 case 7:        play8_num(0, 0|0x80, time.year); break; //显示年
  267.                                 default: break;                //退出循环                                                  
  268.                         }
  269.                 }
  270.                 else if (key_val > 1)//按键值大于1
  271.                 {
  272.                         if (state == 1)//位置1设置秒
  273.                         {
  274.                                 if (key_val == 3)//加按下?
  275.                                         time.sec++;//秒加1
  276.                                 else
  277.                                         time.sec--; //秒减1
  278.                                 if (time.sec >= 60)
  279.                                         time.sec = 0;
  280.                                 else if (time.sec < 0)
  281.                                         time.sec = 59;      
  282.                                 play32_num(96, 2|0x80, time.sec);//显示秒
  283.                         }
  284.                         else if (state == 2)                                //位置2设置分
  285.                         {
  286.                                 if (key_val == 3)                                //加按下?
  287.                                         time.min++;                                        //加1
  288.                                 else
  289.                                         time.min--;                                        //减1
  290.                                 if (time.min >= 60)
  291.                                         time.min = 0;
  292.                                 else if (time.min < 0)
  293.                                         time.min = 59;
  294.                                 play32_num(48, 2|0x80, time.min);//显示分
  295.                         }
  296.                         else if (state == 3)                                //位置3设置时
  297.                         {                if (key_val == 3)                                //加按下?
  298.                                         time.hour++;                                //加1
  299.                                 else
  300.                                         time.hour--;                                //减1
  301.                                 if (time.hour >= 24)
  302.                                         time.hour = 0;
  303.                                 else if (time.hour < 0)
  304.                                         time.hour = 23;
  305.                                 play32_num(0, 2|0x80, time.hour);//显示时
  306.                         }
  307.                         else if (state == 4)                                //位置4设置周
  308.                         {                if (key_val == 3)                        //加按下?
  309.                                         time.week++;                                //加1
  310.                                 else
  311.                                         time.week--;                                //减1
  312.                                 if (time.week >= 8)
  313.                                         time.week = 1;
  314.                                 else if (time.week < 1)
  315.                                         time.week = 7;
  316.                                 play_week(68, 0|0x80, time.week);//显示周
  317.                         }
  318.                         else if (state == 5)//位置5设置日
  319.                         {
  320.                                 if (key_val == 3)                                //加按下?
  321.                                         time.day++;                                        //加1
  322.                                 else
  323.                                         time.day--;                                        //减1
  324.                                 if (time.day >= 32)
  325.                                         time.day = 1;
  326.                                 else if (time.day < 1)
  327.                                         time.day = 31;
  328.                                 play8_num(48, 0|0x80, time.day);//显示日
  329.                         }
  330.                         else if (state == 6)                                //位置6设置月
  331.                         {
  332.                                 if (key_val == 3)                                //加按下?
  333.                                         time.mon++;                                        //加1
  334.                                 else
  335.                                         time.mon--;                                        //减1
  336.                                 if (time.mon >= 13)
  337.                                         time.mon = 1;
  338.                                 else if (time.mon < 1)
  339.                                         time.mon = 12;
  340.                                 play8_num(24, 0|0x80, time.mon);//显示月
  341.                         }
  342.                         else if (state == 7)                                //位置7设置年
  343.                         {
  344.                                 if (key_val == 3)                                //加按下?
  345.                                         time.year++;                                //加1
  346.                                 else
  347.                                         time.year--;                                //减1
  348.                                 if (time.year >= 100)
  349.                                         time.year = 0;                                //0年
  350.                                 else if (time.year < 0)
  351.                                         time.year = 99;                                //99年
  352.                                 play8_num(0, 0|0x80, time.year);//显示年
  353.                         }
  354.                         else
  355.                         {
  356.                                 break;                //退出循环
  357.                         }
  358.                 }
  359.                 if (state == 0)
  360.                         break;                //退出循环
  361.         }
  362. }

  363. /*
  364. * 闹钟界面显示
  365. */
  366. void alarm_show(void)
  367. {
  368.         int8 key_val, state=1;
  369.         uint32 t=0;

  370.         play16(0, 0, nao);                        //显示 闹
  371.         play16(16, 0, zhong);                //钟
  372.         play16(32, 0, maohao);                //冒号:
  373.         if (Alarm_flag)
  374.                 play16(48, 0, kai);                //开
  375.         else
  376.                 play16(48, 0, guan);//关
  377.         play32_num(32, 2, alarm.hour);        //时
  378.         play32(64, 2, 10);                                //冒号
  379.         play32_num(80, 2, alarm.min);        //分
  380.         play16(0, 6, zheng);                        //显示 整
  381.         play16(16, 6, dian);                        //显示 点
  382.         play16(32, 6, bao);                                //显示 报
  383.         play16(48, 6, shi);                                //显示 时
  384.         play16(64, 6, maohao);                        //显示 冒号
  385.         if (Clock_flag)
  386.                 play16(80, 6, kai);                        //显示 开
  387.         else
  388.                 play16(80, 6, guan);                //显示 关       
  389.         for (t=0; t<30000; t++)
  390.         {        key_val = scan_key();                //键盘扫描 获取键值
  391.                 if (key_val > 1)                        //判断数据
  392.                         break;
  393.                 else if (key_val == 1)                //判断数据
  394.                 {
  395.                         if (Alarm_flag)
  396.                                 play16(48, 0|0x80, kai);//显示 开
  397.                         else
  398.                                 play16(48, 0|0x80, guan);//关                       
  399.                         while (1)
  400.                         {                                key_val = scan_key();//键盘扫描 获取键值
  401.                                 if (key_val == 1)                                 // 完成设置
  402.                                 {
  403.                                         if (state >= 4)                                //判断数据
  404.                                                 state = 0;
  405.                                         else
  406.                                                 state++;
  407.                                         if (Alarm_flag)
  408.                                                 play16(48, 0, kai);                        //显示 开
  409.                                         else
  410.                                                 play16(48, 0, guan);                //显示 关
  411.                                         play32_num(32, 2, alarm.hour);  //闹钟 时 显示
  412.                                         play32_num(80, 2, alarm.min);        //闹钟 分 显示
  413.                                         if (Clock_flag)
  414.                                                 play16(80, 6, kai);                        //显示 开
  415.                                         else
  416.                                                 play16(80, 6, guan);                //显示 关

  417.                                         switch (state) //判断数据
  418.                                         {
  419.                                                 case 1:        
  420.                                                         if (Alarm_flag)//判断数据
  421.                                                                 play16(48, 0|0x80, kai);        //显示 开
  422.                                                         else
  423.                                                                 play16(48, 0|0x80, guan);         //显示 关
  424.                                                         break;
  425.                                                 case 2:
  426.                                                         play32_num(80, 2|0x80, alarm.min);//闹钟 分 显示
  427.                                                         break;
  428.                                                 case 3:
  429.                                                         play32_num(32, 2|0x80, alarm.hour);//闹钟 时 显示
  430.                                                         break;
  431.                                                 case 4:
  432.                                                         if (Clock_flag)//判断数据
  433.                                                                 play16(80, 6|0x80, kai);//显示 开
  434.                                                         else
  435.                                                                 play16(80, 6|0x80, guan);//显示 关
  436.                                                         break;
  437.                                                 default: break;
  438.                                         }
  439.                                 }
  440.                                 else if (key_val > 1)//判断数据
  441.                                 {
  442.                                         if (state == 1)//判断数据
  443.                                         {
  444.                                                 Alarm_flag = ~Alarm_flag;
  445.                                                 if (Alarm_flag)
  446.                                                         play16(48, 0|0x80, kai);//显示 开
  447.                                                 else
  448.                                                         play16(48, 0|0x80, guan);//显示 关
  449.                                         }
  450.                                         else if (state == 2)//判断数据
  451.                                         {
  452.                                                 if (key_val == 3)//判断数据
  453.                                                         alarm.min++;//加1
  454.                                                 else
  455.                                                         alarm.min--;//减1
  456.                                                 if (alarm.min >= 60)//判断数据
  457.                                                         alarm.min = 0;
  458.                                                 else if (alarm.min < 0)//判断数据
  459.                                                         alarm.min = 59;
  460.                                                 play32_num(80, 2|0x80, alarm.min);//闹钟 分 显示
  461.                                         }
  462.                                         else if (state == 3)//判断数据
  463.                                         {
  464.                                                 if (key_val == 3)//判断数据
  465.                                                         alarm.hour++;//加1
  466.                                                 else
  467.                                                         alarm.hour--;//减1
  468.                                                 if (alarm.hour >= 24)//判断数据
  469.                                                         alarm.hour = 0;
  470.                                                 else if (alarm.hour < 0)//判断数据
  471.                                                         alarm.hour = 23;
  472.                                                 play32_num(32, 2|0x80, alarm.hour);//闹钟 时 显示
  473.                                         }
  474.                                         else if (state == 4)                        //判断数据
  475.                                         {
  476.                                                 Clock_flag = ~Clock_flag;
  477.                                                 if (Clock_flag)                                //判断数据
  478.                                                         play16(80, 6|0x80, kai);//显示 开
  479.                                                 else
  480.                                                         play16(80, 6|0x80, guan);//显示 关
  481.                                         }
  482.                                         else
  483.                                         {
  484.                                                 break;        //退出
  485.                                         }
  486.                                 }
  487.                                 if (state == 0)        //状态为0退出
  488.                                 break;                        //状态为0退出
  489.                         }
  490.                         if (state == 0)                //状态为0退出
  491.                                 break;                        //状态为0退出
  492.                 }

  493.         }
  494. }


  495. main()
  496. {
  497.         uint8 key_val;
  498.     read_18B20();    //初始DS18B20
  499.     Delay_nms(1000);//延时1S,等待18B20工作正常


  500.         LCD_init();           //初始化液晶
  501.         clear12864();         //清屏幕
  502.         main_frame();         //显示主界面框架
  503.         main_show(1);         //刷新1次

  504.     read_18B20();                                    //读温度
  505.         play8_num(104, 6,zhengshu);   //显示温度

  506.         while(1)
  507.         {
  508.                 key_val = scan_key();
  509.                 if (key_val == 1)         //K1?
  510.                 {
  511.                         main_set();           //设置主界面
  512.                 }
  513.                 else if (key_val == 2)    //K2?
  514.                 {
  515.                         clear12864();         //清屏幕
  516.                         alarm_show();                  //闹钟画面
  517.                         clear12864();              //清屏幕
  518.                         main_show(1);                  //主界面
  519.                 }
  520.                 else if (key_val == 3)    //K3?
  521.                 {
  522.                         clear12864();         //清屏幕
  523.                         alarm_show();                  //闹钟画面
  524.                         clear12864();         //清屏幕
  525.                         main_show(1);                  //主界面
  526.                 }
  527.                 else
  528.                 {
  529.                         read_time((uint8 *)&time);                        //读取时间
  530.                         main_show(0);                                                //显示主界面
  531.                         if((time.sec%2)==0){read_18B20();}  //每隔2S采集一次

  532.                 }
  533.                
  534.                 // 闹钟
  535.                 if (Alarm_flag)//如果闹钟标志有 执行下面的
  536.                 {
  537.                         if ((flag == 0) && (alarm.hour == time.hour) && (alarm.min == time.min))//判断条件是否满足
  538.                         {
  539.                                 flag = 1;
  540.                                 clear12864();     //清屏幕
  541.                                 alarm_show();     //闹钟
  542.                             PlayMusic();      //播放音乐
  543.                                 PlayMusic();      //播放音乐
  544.                                 clear12864();     //清屏幕  
  545.                                 main_show(1);     //显示主界面
  546.                         }
  547.                 }
  548.         }
  549. }
复制代码

所有资料51hei附件下载:
万年历.7z (3.13 MB, 下载次数: 46)


无标题.jpg (184.9 KB, 下载次数: 43)

无标题.jpg

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励!

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏3 分享淘帖 顶1 踩
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表