51单片机32位心形流水灯源代码

1. #include<reg52.h>
   
2. #define uint unsigned int
   
3. #define uchar unsigned char
   
4. uchar code table0[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};
   
5. uchar code table1[]={0x7f,0xbf,0xdf,0xef,0xf7,0xfb,0xfd,0xfe};
   
6. uchar code table2[]={0xfe,0xfc,0xf8,0xf0,0xe0,0xc0,0x80,0x00};
   
7. uchar code table3[]={0x7f,0x3f,0x1f,0x0f,0x07,0x03,0x01,0x00};
   
8. uchar code table4[]={0x00,0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f,0xff};
   
9. uchar code table5[]={0x00,0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff};
   
10. uchar code table6[]={0xfe,0xfc,0xfa,0xf6,0xee,0xde,0xbe,0x7e};
    
11. uchar code table7[]={0x7f,0x3f,0x5f,0x6f,0x77,0x7b,0x7d,0x7e};
    
12. uchar i,j; uint tt=70;
    
13. void delay(uint time)
    
14. {
    
15. uint x,y;
    
16. for(x=time;x>0;x--)
    
17. for(y=110;y>0;y--);
    
18. }
    
19. void disp11()
    
20. {
    
21. for(j=0;j<2;j++)
    
22. {
    
23. for(i=0;i<8;i++)
    
24. {
    
25. P0=table0[i];
    
26. P2=table1[i];
    
27. P1=table1[i];
    
28. P3=table1[i];
    
29. delay(100);
    
30. }
    
31. P0=0xff; P2=0xff; P1=0xff; P3=0xff;
    
32. for(i=0;i<8;i++)
    
33. {
    
34. P0=table0[i];
    
35. P2=table1[i];
    
36. P1=table1[i];
    
37. P3=table1[i];
    
38. delay(100);
    
39. }
    
40. P0=0xff; P2=0xff; P1=0xff; P3=0xff;
    
41. }
    
42. }
    
43. void disp12()
    
44. {
    
45. for(i=0;i<8;i++)
    
46. {
    
47. P0=table2[i];
    
48. P2=table3[i];
    
49. P1=table3[i];
    
50. P3=table3[i];
    
51. delay(100);
    
52. }
    
53. delay(1000);
    
54. }
    
55. void disp13()
    
56. {
    
57. for(i=0;i<9;i++)
    
58. {
    
59. P0=table4[i];
    
60. P2=table5[i];
    
61. P1=table5[i];
    
62. P3=table5[i];
    
63. delay(100);
    
64. }
    
65. delay(300);
    
66. }
    
67. void disp14()
    
68. {
    
69. for(i=0;i<8;i++)
    
70. {
    
71. P0=table2[i];
    
72. P1=table2[i];
    
73. P2=table2[i];
    
74. P3=table3[i];
    
75. delay(100);
    
76. }
    
77. }
    
78. void disp15()
    
79. {
    
80. for(i=0;i<9;i++)
    
81. {
    
82. P0=table5[i];
    
83. P1=table5[i];
    
84. P2=table5[i];
    
85. P3=table4[i];
    
86. delay(100);
    
87. }
    
88. delay(300);
    
89. }
    
90. void disp16()
    
91. {
    
92. for(i=0;i<5;i++)
    
93. {
    
94. P0=0xaa; P1=0xaa; P2=0xaa; P3=0xaa;
    
95. delay(100);
    
96. P0=~P0; P1=~P1; P2=~P2; P3=~P3;
    
97. delay(100);
    
98. }
    
99. for(i=0;i<5;i++)
    
100. {
     
101. P0=0xaa; P1=0xaa; P2=0xaa; P3=0xaa;
     
102. delay(200);
     
103. P0=~P0; P1=~P1; P2=~P2; P3=~P3;
     
104. delay(200);
     
105. }
     
106. for(i=0;i<5;i++)
     
107. {
     
108. P0=0xaa; P1=0xaa; P2=0xaa; P3=0xaa;
     
109. delay(300);
     
110. P0=~P0; P1=~P1; P2=~P2; P3=~P3;
     
111. delay(300);
     
112. }
     
113. P0=0xff; P2=0xff; P1=0xff; P3=0xff;
     
114. delay(300);
     
115. }
     
116. void disp17()
     
117. {
     
118. for(i=0;i<8;i++)
     
119. {
     
120. P0=table3[i];
     
121. delay(100);
     
122. }
     
123. for(i=0;i<8;i++)
     
124. {
     
125. P1=table2[i];
     
126. delay(100);
     
127. }
     
128. for(i=0;i<8;i++)
     
129. {
     
130. P3=table2[i];
     
131. delay(100);
     
132. }
     
133. for(i=0;i<8;i++)
     
134. {
     
135. P2=table2[i];
     
136. delay(100);
     
137. }
     
138. P0=0xff; P1=0xff; P3=0xff; P2=0xff;
     
139. for(i=0;i<8;i++)
     
140. {
     
141. P0=table3[i];
     
142. delay(50);
     
143. }
     
144. for(i=0;i<8;i++)
     
145. {
     
146. P1=table2[i];
     
147. delay(50);
     
148. }
     
149. for(i=0;i<8;i++)
     
150. {
     
151. P3=table2[i];
     
152. delay(50);
     
153. }
     
154. for(i=0;i<8;i++)
     
155. {
     
156. P2=table2[i];
     
157. delay(50);
     
158. }
     
159. P0=0xff; P1=0xff; P3=0xff; P2=0xff;
     
160. }
     
161. void disp18()
     
162. {
     
163. for(i=0;i<8;i++)
     
164. {
     
165. P0=table3[i];
     
166. delay(100);
     
167. }
     
168. P0=0xff;
     
169. for(i=0;i<8;i++)
     
170. {
     
171. P1=table2[i];
     
172. delay(100);
     
173. }
     
174. P1=0xff;
     
175. for(i=0;i<8;i++)
     
176. {
     
177. P3=table2[i];
     
178. delay(100);
     
179. }
     
180. P3=0xff;
     
181. for(i=0;i<8;i++)
     
182. {
     
183. P2=table2[i];
     
184. delay(100);
     
185. }
     
186. P2=0xff;
     
187. }
     
188. void disp19()
     
189. {
     
190. for(i=0;i<8;i++)
     
191. {
     
192. P2=table3[i];
     
193. delay(100);
     
194. }
     
195. for(i=0;i<8;i++)
     
196. {
     
197. P3=table3[i];
     
198. delay(100);
     
199. }
     
200. for(i=0;i<8;i++)
     
201. {
     
202. P1=table3[i];
     
203. delay(100);
     
204. }
     
205. for(i=0;i<8;i++)
     
206. {
     
207. P0=table2[i];
     
208. delay(100);
     
209. }
     
210. P0=0xff; P1=0xff; P3=0xff; P2=0xff;
     
211. for(i=0;i<8;i++)
     
212. {
     
213. P2=table3[i];
     
214. delay(50);
     
215. }
     
216. for(i=0;i<8;i++)
     
217. {
     
218. P3=table3[i];
     
219. delay(50);
     
220. }
     
221. for(i=0;i<8;i++)
     
222. {
     
223. P1=table3[i];
     
224. delay(50);
     
225. }
     
226. for(i=0;i<8;i++)
     
227. {
     
228. P0=table2[i];
     
229. delay(50);
     
230. }
     
231. P0=0xff; P1=0xff; P3=0xff; P2=0xff;
     
232. }
     
233. void disp20()
     
234. {
     
235. for(i=0;i<8;i++)
     
236. {
     
237. P2=table3[i];
     
238. delay(100);
     
239. }
     
240. P2=0xff;
     
241. for(i=0;i<8;i++)
     
242. {
     
243. P3=table3[i];
     
244. delay(100);
     
245. }
     
246. P3=0xff;
     
247. for(i=0;i<8;i++)
     
248. {
     
249. P1=table3[i];
     
250. delay(100);
     
251. }
     
252. P1=0xff;
     
253. for(i=0;i<8;i++)
     
254. {
     
255. P0=table2[i];
     
256. delay(100);
     
257. }
     
258. P0=0xff;
     
259. }
     
260. void disp21()
     
261. {
     
262. for(i=0;i<8;i++)
     
263. {
     
264. P0=table1[i];
     
265. P2=table1[i];
     
266. delay(100);
     
267. }
     
268. P0=0xff; P2=0xff;
     
269. for(i=0;i<8;i++)
     
270. {
     
271. P1=table0[i];
     
272. P3=table1[i];
     
273. delay(100);
     
274. }
     
275. for(i=0;i<8;i++)
     
276. {
     
277. P1=table1[i];
     
278. P3=table0[i];
     
279. delay(100);
     
280. }
     
281. P1=0xff; P3=0xff;
     
282. for(i=0;i<8;i++)
     
283. {
     
284. P0=table0[i];
     
285. P2=table0[i];
     
286. delay(100);
     
287. }
     
288. }
     
289. void disp22()
     
290. {
     
291. for(j=0;j<5;j++)
     
292. {
     
293. for(i=0;i<8;i++)
     
294. {
     
295. P0=table1[i];
     
296. P2=table1[i];
     
297. delay(tt);
     
298. }
     
299. P0=0xff; P2=0xff;
     
300. for(i=0;i<8;i++)
     
301. {
     
302. P1=table0[i];
     
303. P3=table1[i];
     
304. delay(tt);
     
305. }
     
306. P1=0xff; P3=0xff;
     
307. tt=tt-10;
     
308. }
     
309. for(j=0;j<16;j++)
     
310. {
     
311. for(i=0;i<8;i++)
     
312. {
     
313. P0=table1[i];
     
314. P2=table1[i];
     
315. delay(20);
     
316. }
     
317. P0=0xff; P2=0xff;
     
318. for(i=0;i<8;i++)
     
319. {
     
320. P1=table0[i];
     
321. P3=table1[i];
     
322. delay(20);
     
323. }
     
324. P1=0xff; P3=0xff;
     
325. }
     
326. tt=20;
     
327. for(j=0;j<5;j++)
     
328. {
     
329. for(i=0;i<8;i++)
     
330. {
     
331. P0=table1[i];
     
332. P2=table1[i];
     
333. delay(tt);
     
334. }
     
335. P0=0xff; P2=0xff;
     
336. for(i=0;i<8;i++)
     
337. {
     
338. P1=table0[i];
     
339. P3=table1[i];
     
340. delay(tt);
     
341. }
     
342. P1=0xff; P3=0xff;
     
343. tt=tt+10;
     
344. }
     
345. tt=70;
     
346. }
     
347. void disp23()
     
348. {
     
349. for(i=0;i<2;i++)
     
350. {
     
351. P0=0x00; P2=0x00;
     
352. delay(1000);
     
353. P0=0xff; P2=0xff;
     
354. P1=0x00; P3=0x00;
     
355. delay(1000);
     
356. P1=0xff; P3=0xff;
     
357. }
     
358. }
     
359. void disp24()
     
360. {
     
361. P1=0xff; P3=0xff; P0=0xff; P2=0xff;
     
362. for(i=0;i<2;i++)
     
363. {
     
364. P0=0x00; P1=0x00;
     
365. delay(1000);
     
366. P0=0xff; P1=0xff;
     
367. P2=0x00; P3=0x00;
     
368. delay(1000);
     
369. P2=0xff; P3=0xff;
     
370. }
     
371. }
     
372. void disp25()
     
373. {
     
374. for(i=0;i<5;i++)
     
375. {
     
376. P0=0xaa; P1=0xaa; P2=0xaa; P3=0xaa;
     
377. delay(1000);
     
378. P0=~P0; P1=~P1; P2=~P2; P3=~P3;
     
379. delay(1000);
     
380. }
     
381. }
     
382. void main()
     
383. {
     
384. while(1)
     
385. {
     
386. disp11();
     
387. disp12();
     
388. disp13();
     
389. disp14();
     
390. disp15();
     
391. disp16();
     
392. disp17();
     
393. disp18();
     
394. disp19();
     
395. disp20();
     
396. disp21();
     
397. disp22();
     
398. disp23();
     
399. disp24();
     
400. disp25();
     
401. }
     
402. }

复制代码

想说的是，楼主这个很早就已经出现过了，参数代码都没变过。