標(biāo)題: 這個單片機程序為什么數(shù)據(jù)都不能存入at24c02中? [打印本頁]

---

作者: 無意之罪    時間: 2021-3-27 17:13
標(biāo)題: 這個單片機程序為什么數(shù)據(jù)都不能存入at24c02中?
請問一下這個程序里為什么數(shù)據(jù)都不能存入at24c02中

1. #include <STC15F2K60S2.h>
   
2. #include "ds1302.h"
   
3. #include "iic.h"
   
4. 
   
5. 
   
6. typedef unsigned char u8;
   
7. typedef unsigned int u16;
   
8. 
   
9. 
   
10. sbit COL1 = P4^4;
    
11. sbit COL2 = P4^2;
    
12. sbit COL3 = P3^5;
    
13. sbit COL4 = P3^4;
    
14. 
    
15. 
    
16. bit flat,add,m=0,del,non=0;
    
17. u8 timer=0,key_val=0,n=0,mom=0;
    
18. u16 f=0,fre=0,cyl=0,vol=0,vh=20,vl=10;
    
19. u8 num[10]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};
    
20. u8 write_time[7]={0x80,0x82,0x84,0x86,0x88,0x8a,0x8c};
    
21. u8 read_time[7]={0x81,0x83,0x85,0x87,0x89,0x8b,0x8d};
    
22. u8 time[7]={0x55,0x59,0x23,0x01,0x02,0x03,0x12};
    
23. u8 seg[8];
    
24. 
    
25. 
    
26. void delay(u8 x)
    
27. {
    
28.   while(x--);
    
29. }
    
30. 
    
31. void select(u8 deat,u8 date)
    
32. {
    
33.   switch(deat)
    
34.         {
    
35.           case 4:COL3=0;P2=(P2&0x1f)|0x80;break;
    
36.                 case 5:COL3=0;P2=(P2&0x1f)|0xa0;break;
    
37.                 case 6:COL3=0;P2=(P2&0x1f)|0xc0;break;
    
38.                 case 7:COL3=0;P2=(P2&0x1f)|0xe0;break;
    
39.         }
    
40.         P0 = date;
    
41. }
    
42. 
    
43. void close()
    
44. {
    
45.   select(4,0xff);
    
46.         select(5,0x00);
    
47.         select(6,0x00);
    
48.         select(7,0xff);
    
49. }
    
50. 
    
51. void ds1302_init()
    
52. {
    
53.   u8 i;
    
54.         Write_Ds1302_Byte(0x8e,0x00);
    
55.         for(i=0;i<7;i++)
    
56.         {
    
57.          Write_Ds1302_Byte(write_time[i],time[i]);
    
58.         }
    
59.         Write_Ds1302_Byte(0x8e,0x80);
    
60. }
    
61. 
    
62. 
    
63. void timer_init()
    
64. {
    
65.   TMOD = 0x15;
    
66.         AUXR |= 0x00;
    
67.         
    
68.         TH0 = 0xff;
    
69.         TL0 = 0xff;
    
70.         TH1 = (65535-50000)/256;
    
71.         TL1 = (65535-50000)%256;
    
72.         
    
73.         ET0 = 1;
    
74.         ET1 = 1;
    
75.         TR0 = 1;
    
76.         TR1 = 1;
    
77.         EA = 1;
    
78. }
    
79. 
    
80. void timer0_() interrupt 1
    
81. {
    
82.         TH0 = 0xff;
    
83.         TL0 = 0xff;
    
84.   f++;
    
85. }
    
86. 
    
87. void timer1_() interrupt 3
    
88. {
    
89.         TH1 = (65535-50000)/256;
    
90.         TL1 = (65535-50000)%256;
    
91.   timer++;
    
92.         if(!(timer%20)) flat=!flat;
    
93. }
    
94. 
    
95. 
    
96. void time_proc()
    
97. {
    
98.   u8 i;
    
99.         Write_Ds1302_Byte(0x8e,0x00);
    
100.         for(i=0;i<3;i++)
     
101.         {
     
102.           time[i]=Read_Ds1302_Byte(read_time[i]);
     
103.         }
     
104.         Write_Ds1302_Byte(0x8e,0x80);
     
105.         
     
106.         
     
107.         seg[0] = num[time[2]/16];
     
108.         seg[1] = num[time[2]%16];
     
109.         seg[2] = seg[5] = 0xbf;
     
110.         seg[3] = num[time[1]/16];
     
111.         seg[4] = num[time[1]%16];
     
112.         seg[6] = num[time[0]/16];
     
113.         seg[7] = num[time[0]%16];
     
114. }
     
115. 
     
116. 
     
117. void time_deal()
     
118. {
     
119.         u8 i;
     
120.         for(i=0;i<3;i++)
     
121.         time[i]=Read_Ds1302_Byte(read_time[i]);
     
122.         seg[0] = num[time[2]/16];
     
123.         seg[1] = num[time[2]%16];
     
124.         seg[2] = seg[5] = 0xbf;
     
125.         seg[3] = num[time[1]/16];
     
126.         seg[4] = num[time[1]%16];
     
127.         seg[6] = num[time[0]/16];
     
128.         seg[7] = num[time[0]%16];
     
129.   if(flat)
     
130.         {        
     
131.                 n%=3;
     
132.                 seg[7-n*3]=0xff;
     
133.           seg[7-n*3-1]=0xff;
     
134.         }
     
135.         if(add)
     
136.         {
     
137.           add=0;
     
138.                 n%=3;
     
139.                 time[n]++;
     
140.                 if((time[n]&0x0f)>9) time[n]+=6;
     
141.                 if((time[n]>0x59)&&(n<2)) time[n]=0x00;
     
142.                 else if((time[n]>0x23)&&(n==2)) time[n]=0x00;
     
143.                 Write_Ds1302_Byte(0x8e,0x00);
     
144.           for(i=0;i<3;i++)
     
145.            {
     
146.             Write_Ds1302_Byte(write_time[i],time[i]);
     
147.            }
     
148.            Write_Ds1302_Byte(0x8e,0x80);
     
149.          }
     
150.         if(del)
     
151.         {
     
152.           del=0;
     
153.                 n%=3;
     
154.                 if(((time[n]&0x0f)==0)&&(time[n]!=0)) time[n]= time[n]-0x10+0x09;
     
155.                 else if((time[n]==0)&&(n<2)) time[n]=0x59;
     
156.                 else if((time[n]==0)&&(n==2)) time[n]=0x23;
     
157.                 else time[n]--;
     
158.                 Write_Ds1302_Byte(0x8e,0x00);
     
159.           for(i=0;i<3;i++)
     
160.           {
     
161.             Write_Ds1302_Byte(write_time[i],time[i]);
     
162.           }
     
163.           Write_Ds1302_Byte(0x8e,0x80);
     
164.          }
     
165. }
     
166. 
     
167. void vol_proc()
     
168. {
     
169.   vol=read_date(0x90,0x03);
     
170.         vol=vol/5.1;
     
171.         seg[0]=seg[2]=0xbf;
     
172.         seg[1]=num[1];
     
173.         seg[3]=0xff;
     
174.         seg[4]=num[vol%100/10];
     
175.         seg[5]=num[vol%10];
     
176.         seg[6]=num[0];
     
177.         seg[7]=num[0];
     
178. }
     
179. 
     
180. 
     
181. void vol_deal()
     
182. {
     
183.         vh=at24c02read(0x09);
     
184.         vl=at24c02read(0x0b);
     
185.   seg[0]=num[vh/10];
     
186.         seg[1]=num[vh%10];
     
187.         seg[2]=num[0];
     
188.         seg[3]=num[0];
     
189.         seg[4]=num[vl/10];
     
190.         seg[5]=num[vl%10];
     
191.         seg[6]=num[0];
     
192.         seg[7]=num[0];
     
193.         if(flat)
     
194.         {
     
195.                 n%=2;
     
196.           seg[n*4]=0xff;
     
197.                 seg[n*4+1]=0xff;
     
198.                 seg[n*4+2]=0xff;
     
199.                 seg[n*4+3]=0xff;
     
200.         }
     
201.         if(add)
     
202.         {
     
203.           add=0;
     
204.                 if(!n)
     
205.                   vh+=5;
     
206.                 else
     
207.                         vl+=5;
     
208.                 if(vh>=50) vh=50;
     
209.                 if(vl>=50) vl=50;
     
210.         }
     
211. 
     
212.         if(del)
     
213.         {
     
214.           del=0;
     
215.                 if(!n)
     
216.                         vh-=5;
     
217.                 else
     
218.                         vl-=5;
     
219.                 if(vh==0) vh=0;
     
220.                 if(vl==0) vl=0;
     
221.         }
     
222.         write_date(0x09,vh);
     
223.   write_date(0x0b,vl);
     
224. }        
     
225. 
     
226. 
     
227. 
     
228. void fre_proc()
     
229. {
     
230.         TR0=1;
     
231.         TR1=1;
     
232.         if(timer>=20)
     
233. {
     
234.    timer%=20;
     
235.          fre=f;
     
236.          f=0;
     
237. }
     
238. 
     
239. if(fre>=20000) fre=20000;
     
240. if(fre<=500) fre=500;
     
241. 
     
242. seg[0]=seg[2]=0xbf;
     
243. seg[1]=num[2];
     
244. seg[3]=num[fre/10000];
     
245. seg[4]=num[fre%10000/1000];
     
246. seg[5]=num[fre%1000/100];
     
247. seg[6]=num[fre%100/10];
     
248. seg[7]=num[fre%10];
     
249. }
     
250. 
     
251. void cyl_proc()
     
252. {
     
253.         float cy;
     
254.         
     
255.         TR0=1;TR1=1;
     
256. if(timer>20)
     
257. {
     
258.    timer%=20;
     
259.          fre = f;
     
260.          f=0;
     
261. }
     
262. 
     
263. if(fre>=20000) fre=20000;
     
264. if(fre<=500) fre=500;
     
265. 
     
266. cy=1.0/fre;
     
267. cyl=cy*1000*1000;
     
268. 
     
269. seg[0]=seg[2]=0xbf;
     
270. seg[1]=num[2];
     
271. seg[3]=num[cyl/10000];
     
272. seg[4]=num[cyl%10000/1000];
     
273. seg[5]=num[cyl%1000/100];
     
274. seg[6]=num[cyl%100/10];
     
275. seg[7]=num[cyl%10];
     
276. }
     
277. 
     
278. 
     
279. 
     
280. 
     
281. void timer_proc()
     
282. {
     
283.   u8 timed[3];
     
284.         time[0]=at24c02read(0x03);
     
285.         time[1]=at24c02read(0x05);
     
286.         time[2]=at24c02read(0x07);
     
287.         
     
288.         seg[0]=num[timed[2]/16];
     
289.         seg[1]=num[timed[2]%16];
     
290.         seg[2]=seg[5]=0xbf;
     
291.         seg[3]=num[timed[1]/16];
     
292.         seg[4]=num[timed[1]%16];
     
293.         seg[6]=num[timed[0]/16];
     
294.         seg[7]=num[timed[0]%16];
     
295. }
     
296. 
     
297. void lei_proc()
     
298. {
     
299.   u8 lei;
     
300.         
     
301.         lei = at24c02read(0x01);
     
302.         
     
303.         seg[0]=seg[1]=seg[2]=seg[3]=seg[4]=seg[5]=0xff;
     
304.         seg[6]=num[0];
     
305.         seg[7]=num[lei];
     
306. }
     
307. 
     
308. 
     
309. 
     
310. void key_proc()
     
311. {
     
312.   u8 key;
     
313.         
     
314.         P3=0x0f;
     
315.         COL1=0;COL2=1;
     
316.         COL3=1;COL4=1;
     
317.         key = P3&0x0f;
     
318.         if(key!=0x0f)
     
319.                 key |= 0x70;
     
320.         else
     
321.         {
     
322.           COL1=1;COL2=0;
     
323.                 key = P3&0x0f;
     
324.                 if(key!=0x0f)
     
325.                         key |= 0xb0;
     
326.                 else
     
327.                 {
     
328.                   COL2=1;COL3=0;
     
329.                 key = P3&0x0f;
     
330.                 if(key!=0x0f)
     
331.                         key |= 0xd0;
     
332.                 else
     
333.                 {
     
334.                  COL3=1;COL4=0;
     
335.                         key = P3&0x0f;
     
336.                         if(key!=0x0f)
     
337.                                 key |= 0xe0;
     
338.                         else
     
339.                                 COL4=1;
     
340.                 }
     
341.                 }
     
342.         }
     
343.         
     
344.         switch(key)
     
345.         {
     
346.           case 0x77:key_val=4;break;
     
347.                 case 0x7b:key_val=5;break;
     
348.                 case 0x7d:key_val=6;break;
     
349.                 case 0x7e:key_val=7;break;
     
350.                 case 0xbb:key_val=9;break;
     
351.                 case 0xbd:key_val=10;break;
     
352.                 case 0xbe:key_val=11;break;
     
353.                 default:key_val=0;
     
354.         }
     
355. }
     
356. 
     
357. 
     
358. 
     
359. void seg_proc()
     
360. {
     
361.   select(6,0x01);select(7,seg[0]);delay(1000);
     
362.         select(6,0x02);select(7,seg[1]);delay(1000);
     
363.         select(6,0x04);select(7,seg[2]);delay(1000);
     
364.         select(6,0x08);select(7,seg[3]);delay(1000);
     
365.         select(6,0x10);select(7,seg[4]);delay(1000);
     
366.         select(6,0x20);select(7,seg[5]);delay(1000);
     
367.         select(6,0x40);select(7,seg[6]);delay(1000);
     
368.         select(6,0x80);select(7,seg[7]);delay(1000);
     
369.         close();
     
370. }
     
371. 
     
372. void mom_proc()
     
373. {
     
374.   if((vol>vh)||(vol<vl))
     
375.         {
     
376.                 if(vol>vh)
     
377.                 {write_date(0x01,1);delay(5000);}
     
378.           else if(vol<vl)
     
379.                 {write_date(0x01,0);delay(5000);}
     
380.                
     
381.                 write_date(0x03,time[0]);delay(5000);
     
382.                 write_date(0x05,time[1]);delay(5000);
     
383.                 write_date(0x07,time[2]);delay(5000);
     
384.         }
     
385.         key_proc();
     
386.         if(key_val==11)
     
387.         {
     
388.          add=1;
     
389.                 while(key_val==11)
     
390.                 {
     
391.                         key_proc();
     
392.                   seg_proc();
     
393.                 }
     
394.         }
     
395.         if(key_val==10)
     
396.         {
     
397.          del=1;
     
398.                 while(key_val==10)
     
399.                 {
     
400.                         key_proc();
     
401.                   seg_proc();
     
402.                 }
     
403.         }
     
404.         if(key_val==9)
     
405.         {
     
406.           mom=3;
     
407.                 m=0;
     
408.                 while(key_val==9)
     
409.                 {
     
410.                         key_proc();
     
411.                   seg_proc();
     
412.                 }
     
413.         }
     
414.         if(key_val==7)
     
415.         {
     
416.           mom=0;
     
417.                 non=0;
     
418.                 n=2;
     
419.                 while(key_val==7)
     
420.                 {
     
421.                         key_proc();
     
422.                   seg_proc();
     
423.                 }
     
424.         }
     
425.         if(key_val==6)
     
426.         {
     
427.           mom=1;
     
428.                 non=0;
     
429.                 n=1;
     
430.                 while(key_val==6)
     
431.                 {
     
432.                         key_proc();
     
433.                   seg_proc();
     
434.                 }
     
435.         }
     
436.         if(key_val==5)
     
437.         {
     
438.           mom=2;
     
439.                 m=0;
     
440.                 while(key_val==5)
     
441.                 {
     
442.                         key_proc();
     
443.                   seg_proc();
     
444.                 }
     
445.         }
     
446.         if(key_val==4)
     
447.         {
     
448.                 m=!m;
     
449.                 non=1;
     
450.                 n++;
     
451.                 while(key_val==4)
     
452.                 {
     
453.                         key_proc();
     
454.                   seg_proc();
     
455.                 }
     
456.         }
     
457. }
     
458. 
     
459. 
     
460. 
     
461. void main()
     
462. {  
     
463.         timer_init();
     
464.         ds1302_init();
     
465.    close();
     
466.         vh=at24c02read(0x09);
     
467.         vl=at24c02read(0x0b);
     
468.         while(1)
     
469.         {
     
470.                 mom_proc();
     
471.                 if((!mom)&&(non))
     
472.                 {
     
473.                   time_deal();
     
474.                         seg_proc();
     
475.                 }
     
476.                 else if((!mom)&&(!non))
     
477.                 {
     
478.                   time_proc();
     
479.                         seg_proc();
     
480.                 }
     
481.                 else if((mom==1)&&(non))
     
482.                 {
     
483.                   vol_deal();
     
484.                         seg_proc();
     
485.                 }
     
486.                 else if((mom==1)&&(!non))
     
487.                 {
     
488.                   vol_proc();
     
489.                         seg_proc();
     
490.                 }
     
491.                 else if((mom==2)&&(m))
     
492.                 {
     
493.                   cyl_proc();
     
494.                         seg_proc();
     
495.                 }
     
496.                 else if((mom==2)&&(!m))
     
497.                 {
     
498.                   fre_proc();
     
499.                         seg_proc();
     
500.                 }
     
501.                 else if((mom==3)&&(m))
     
502.                 {
     
503.                   timer_proc();
     
504.                         seg_proc();
     
505.                 }
     
506.                 else if((mom==3)&&(!m))
     
507.                 {
     
508.                   lei_proc();
     
509.                         seg_proc();
     
510.                 }
     
511.         }
     
512. }
     
513. 
     
514. 
     
515. 
     
516. #include "iic.h"
     
517. #include "reg52.h"
     
518. #include "intrins.h"
     
519. 
     
520. #define DELAY_TIME 5
     
521. 
     
522. #define SlaveAddrW 0xA0
     
523. #define SlaveAddrR 0xA1
     
524. 
     
525. sbit SDA = P2^1;  
     
526. sbit SCL = P2^0;
     
527. 
     
528. void IIC_Delay(unsigned char i)
     
529. {
     
530.     do{_nop_();}
     
531.     while(i--);        
     
532. }
     
533. 
     
534. void IIC_Start(void)
     
535. {
     
536.     SDA = 1;
     
537.     SCL = 1;
     
538.     IIC_Delay(DELAY_TIME);
     
539.     SDA = 0;
     
540.     IIC_Delay(DELAY_TIME);
     
541.     SCL = 0;        
     
542. }
     
543. 
     
544. 
     
545. void IIC_Stop(void)
     
546. {
     
547.     SDA = 0;
     
548.     SCL = 1;
     
549.     IIC_Delay(DELAY_TIME);
     
550.     SDA = 1;
     
551.     IIC_Delay(DELAY_TIME);
     
552. }
     
553. 
     
554. 
     
555. void IIC_SendAck(bit ackbit)
     
556. {
     
557.     SCL = 0;
     
558.     SDA = ackbit;                                          
     
559.     IIC_Delay(DELAY_TIME);
     
560.     SCL = 1;
     
561.     IIC_Delay(DELAY_TIME);
     
562.     SCL = 0;
     
563.     SDA = 1;
     
564.     IIC_Delay(DELAY_TIME);
     
565. }
     
566. 
     
567. 
     
568. bit IIC_WaitAck(void)
     
569. {
     
570.     bit ackbit;
     
571.         
     
572.     SCL  = 1;
     
573.     IIC_Delay(DELAY_TIME);
     
574.     ackbit = SDA;
     
575.     SCL = 0;
     
576.     IIC_Delay(DELAY_TIME);
     
577.     return ackbit;
     
578. }
     
579. 
     
580. 
     
581. void IIC_SendByte(unsigned char byt)
     
582. {
     
583.     unsigned char i;
     
584. 
     
585.     for(i=0; i<8; i++)
     
586.     {
     
587.         SCL  = 0;
     
588.         IIC_Delay(DELAY_TIME);
     
589.         if(byt & 0x80) SDA  = 1;
     
590.         else SDA  = 0;
     
591.         IIC_Delay(DELAY_TIME);
     
592.         SCL = 1;
     
593.         byt <<= 1;
     
594.         IIC_Delay(DELAY_TIME);
     
595.     }
     
596.     SCL  = 0;  
     
597. }
     
598. 
     
599. 
     
600. unsigned char IIC_RecByte(void)
     
601. {
     
602.     unsigned char i, da;
     
603.     for(i=0; i<8; i++)
     
604.     {   
     
605.             SCL = 1;
     
606.         IIC_Delay(DELAY_TIME);
     
607.         da <<= 1;
     
608.         if(SDA) da |= 1;
     
609.         SCL = 0;
     
610.         IIC_Delay(DELAY_TIME);
     
611.     }
     
612.     return da;   
     
613. }
     
614. 
     
615. 
     
616. 
     
617. void write_date(unsigned char deet,unsigned char date)
     
618. {
     
619.   IIC_Start();
     
620.         IIC_SendByte(0xa0);
     
621.         IIC_WaitAck();
     
622.         IIC_SendByte(deet);
     
623.         IIC_WaitAck();
     
624.         IIC_SendByte(date);
     
625.         IIC_SendAck(1);
     
626.         IIC_Stop();  
     
627. }
     
628. 
     
629. 
     
630. unsigned char read_date(unsigned char deat,unsigned char deet)
     
631. {
     
632.         
     
633.         unsigned char date;
     
634.   IIC_Start();
     
635.         IIC_SendByte(deat);
     
636.         IIC_WaitAck();
     
637.         IIC_SendByte(deet);
     
638.         IIC_WaitAck();
     
639.         IIC_Stop();  
     
640.         
     
641.         IIC_Start();
     
642.         IIC_SendByte(deat+1);
     
643.         IIC_WaitAck();
     
644.         date = IIC_RecByte();
     
645. //        IIC_SendAck(1);
     
646.         IIC_Stop();
     
647.         return date;
     
648. }
     
649. 
     
650. unsigned char at24c02read(unsigned char deet)
     
651. {
     
652.   unsigned char dat;
     
653.         IIC_Start();
     
654.         IIC_SendByte(0xa0);
     
655.         IIC_WaitAck();
     
656.         IIC_SendByte(deet);
     
657.         IIC_WaitAck();
     
658.         
     
659.         IIC_Start();
     
660.         IIC_SendByte(0xa1);
     
661.         IIC_WaitAck();
     
662.         dat=IIC_RecByte();
     
663. //        IIC_SendAck(0);
     
664.         IIC_Stop();
     
665.         
     
666.         return dat;
     
667. }
     
668. 
     
669. 
     
670. 
     
671. #include "ds1302.h"
     
672. #include <reg52.h>
     
673. #include <intrins.h>
     
674. 
     
675. sbit SCK=P1^7;               
     
676. sbit SDA=P2^3;               
     
677. sbit RST = P1^3;                                                                           
     
678. 
     
679. void Write_Ds1302(unsigned  char temp)
     
680. {
     
681.         unsigned char i;
     
682.         for (i=0;i<8;i++)            
     
683.         {
     
684.                 SCK=0;
     
685.                 SDA=temp&0x01;
     
686.                 temp>>=1;
     
687.                 SCK=1;
     
688.         }
     
689. }   
     
690. 
     
691. void Write_Ds1302_Byte( unsigned char address,unsigned char dat )     
     
692. {
     
693.          RST=0;        _nop_();
     
694.          SCK=0;        _nop_();
     
695.          RST=1;         _nop_();  
     
696.          Write_Ds1302(address);        
     
697.          Write_Ds1302(dat);               
     
698.          RST=0;
     
699. }
     
700. 
     
701. unsigned char Read_Ds1302_Byte ( unsigned char address )
     
702. {
     
703.          unsigned char i,temp=0x00;
     
704.          RST=0;        _nop_();
     
705.          SCK=0;        _nop_();
     
706.          RST=1;        _nop_();
     
707.          Write_Ds1302(address);
     
708.          for (i=0;i<8;i++)         
     
709.          {               
     
710.                 SCK=0;
     
711.                 temp>>=1;        
     
712.                  if(SDA)
     
713.                  temp|=0x80;        
     
714.                  SCK=1;
     
715.         }
     
716.          RST=0;        _nop_();
     
717.          SCK=0;        _nop_();
     
718.         SCK=1;        _nop_();
     
719.         SDA=0;        _nop_();
     
720.         SDA=1;        _nop_();
     
721.         return (temp);                        
     
722. }
     

復(fù)制代碼

---

作者: man1234567    時間: 2021-3-29 17:36
如果有人讀并且試你這個700多行程序并且告訴你答案，那么大概率是有現(xiàn)成的和你一樣的硬件也同程度并同樣學(xué)習(xí)到這里并且同樣用一個母板......

---

作者: 無意之罪    時間: 2021-4-1 19:49
已經(jīng)解決了

---

歡迎光臨 (http://www.torrancerestoration.com/bbs/)

Powered by Discuz! X3.1