久久久久久久999_99精品久久精品一区二区爱城_成人欧美一区二区三区在线播放_国产精品日本一区二区不卡视频_国产午夜视频_欧美精品在线观看免费

 找回密碼
 立即注冊

QQ登錄

只需一步，快速開始

搜索
查看: 14281|回復: 2
收起左側

51單片機匯編語言及C語言經典實例 實驗及課程設計

[復制鏈接]
ID:421335 發表于 2018-11-5 20:27 | 顯示全部樓層 |閱讀模式
51單片機匯編語言及C語言經典實例
實驗及課程設計



一、閃爍燈
如圖1 所示為一簡單單片機系統原理圖：在 P1.0 端口上接一個發光二極管 L1，使 L1 在不停地一亮一滅，一亮一滅的時間間隔為 0.2 秒。


延時程序的設計方法，作為單片機的指令的執行的時間是很短，數量大微秒級，因此，我們要求的閃爍時間間隔為 0.2 秒，相對于微秒來說，相差太大，所以我們在執行某一指令時，插入延時程序，來達到我們的要求，但這樣的延時程
序是如何設計呢？下面具體介紹其原理：如圖 4.1.1 所示的石英晶體為 12MHz，因此，1 個機器周期為 1 微秒，機器周期 微秒如圖 1 所示，當 P1.0 端口輸出高電平，即 P1.0＝1 時，根據發光二極管的單向導電性可知，這時發光二極管 L1 熄滅；當P1.0 端口輸出低電平，即 P1.0＝0 時，發光二極管 L1 亮；我們可以使用 SETB P1.0指令使 P1.0端口輸出高電平，使用 CLR P1.0 指令使 P1.0 端口輸出低電平。

C 語言源程序
  1. #include <AT89X51.H>
  2. sbit L1=P1^0;
  3. void delay02s(void) //延時 0.2 秒子程序
  4. {
  5. unsigned char i,j,k;
  6. for(i=20;i>0;i--)
  7. for(j=20;j>0;j--)
  8. for(k=248;k>0;k--);                       

  10. }
  11. void main(void)
  12. {
  13. while(1)
  14. {
  15. L1=0;
  16. delay02s();
  17. L1=1;
  18. delay02s();
  19. }
復制代碼

匯編源程序
  1. ORG 0
  2. START: CLR P1.0
  3. LCALL DELAY
  4. SETB P1.0
  5. LCALL DELAY
  6. LJMP START
  7. DELAY: MOV R5,#20 ;延時子程序，延時 0.2 秒
  8. D1: MOV R6,#20
  9. D2: MOV R7,#248



  13. DJNZ R7,$
  14. DJNZ R6,D2
  15. DJNZ R5,D1
  16. RET
  17. END
復制代碼
                                                   

二、多路開關狀態指示
如圖 3 所示，AT89S51 單片機的 P1.0－P1.3 接四個發光二極管 L1－L4，
P1.4－P1.7 接了四個開關 K1－K4，編程將開關的狀態反映到發光二極管上。
（開關閉合，對應的燈亮，開關斷開，對應的燈滅）。
對于開關狀態檢測，相對單片機來說，是輸入關系，我們可輪流檢測每個開關狀
態，根據每個開關的狀態讓相應的發光二極管指示，可以采用 JB P1.X，REL
或 JNB P1.X，REL 指令來完成；也可以一次性檢測四路開關狀態，然后讓其指
示，可以采用 MOV A，P1 指令一次把 P1 端口的狀態全部讀入，然后取高 4 位的狀態來指示。
方法1（匯編源程序）
ORG 00H
START: MOV A,P1


ANL A,#0F0H
RR A
RR A
RR A
RR A
ORL A,#0F0H
MOV P1,A
SJMP START
END

方法1（C語言程序）
#INClude <AT89X51.H>
unsigned char temp;

void main(void)
{
while(1)
{
temp=P1>>4;
temp=temp | 0xf0;
P1=temp;
}
}
方法2（匯編源程序）
ORG 00H
START: JB P1.4,NEXT1
CLR P1.0
SJMP NEX1


NEXT1: SETB P1.0
NEX1: JB P1.5,NEXT2
CLR P1.1
SJMP NEX2
NEXT2: SETB P1.1
NEX2: JB P1.6,NEXT3
CLR P1.2
SJMP NEX3
NEXT3: SETB P1.2
NEX3: JB P1.7,NEXT4
CLR P1.3
SJMP NEX4
NEXT4: SETB P1.3
NEX4: SJMP START
END
方法2（C 語言源程序）
#INClude <AT89X51.H>

void main(void)
{
while(1)
{
if(P1_4==0)
{
P1_0=0;
}
Else
{
P1_0=1;
}
if(P1_5==0)
{
P1_1=0;
}
else
{
P1_1=1;
}
if(P1_6==0)
{
P1_2=0;
}
else
{
P1_2=1;
}
if(P1_7==0)
{
P1_3=0;
}
else
三、廣告燈的設計
利用取表的方法，使端口 P1 做單一燈的變化：左移 2 次，右移 2 次，閃爍 2 次
（延時的時間 0.2 秒）。
利用 MOV DPTR，＃DATA16 的指令來使數據指針寄存器指到表的開
頭。
利用 MOVC A，＠A＋DPTR 的指令，根據累加器的值再加上 DPTR 的
值，就可以使程序計數器 PC 指到表格內所要取出的數據。因此，只要把控制碼建成一個表，而利用 MOVC A，＠A＋DPTR 做取碼的操作，
就可方便地處理一些復雜的控制動作，取表過程如下圖所示：
匯編源程序
ORG 0
START: MOV DPTR,#TABLE
LOOP: CLR A
MOVC A,@A+DPTR
CJNE A,#01H,LOOP1
JMP START
LOOP1: MOV P1,A
MOV R3,#20
LCALL DELAY
INC DPTR
JMP LOOP
DELAY: MOV R4,#20
D1:     MOV R5,#248
DJNZ R5,$
DJNZ R4,D1
DJNZ R3,DELAY
R             RET
T       ABLE: DB 0FEH,0FDH,0FBH,0F7H
DB 0EFH,0DFH,0BFH,07FH
DB 0FEH,0FDH,0FBH,0F7H
DB 0EFH,0DFH,0BFH,07FH
DB 07FH,0BFH,0DFH,0EFH
DB 0F7H,0FBH,0FDH,0FEH
DB 07FH,0BFH,0DFH,0EFH
DB 0F7H,0FBH,0FDH,0FEH
DB 00H, 0FFH,00H, 0FFH
DB 01H
END
C 語言源程序
#INClude <AT89X51.H>
unsigned char code table[]={0xfe,0xfd,0xfb,0xf7,
0xef,0xdf,0xbf,0x7f,0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f,
0x7f,0xbf,0xdf,0xef,0xf7,0xfb,0xfd,0xfe,0x7f,0xbf,0xdf,0xef,
0xf7,0xfb,0xfd,0xfe,0x00,0xff,0x00,0xff,0x01};
unsigned char i;
void delay(void)
{
unsigned char m,n,s;
for(m=20;m>0;m--)
for(n=20;n>0;n--)
for(s=248;s>0;s--);
}
void main(void)
{
while(1)
{
if(table[ i]!=0x01)
{
P1=table[ i];
i++;
delay();
}
else
{
i=0;
}
}
}


四、 00－59 秒計時器
如下圖8所示，在 AT89S51 單片機的 P0 和 P2 端口分別接有兩個共陰數碼管，P0 口驅動顯示秒的時間的十位，而 P2 口驅動顯示秒的時間的個位。在設計過程中我們用一個存儲單元作為秒計數單元，當一秒鐘到來時，就讓秒計數單元加 1，當秒計數達到 60 時，就自動返回到 0，重新秒計數。
對于秒計數單元中的數據要把它十位數和個位數分開，方法仍采用對 10 整除和對 10 求余。
匯編源程序
Second EQU 30H
ORG 0000H
START: MOV Second, #00H
NEXT: MOV A, Second
MOV B,#10
DIV AB
MOV DPTR,#TABLE
MOVC A,@A+DPTR
MOV P0,A
MOV A,B
MOVC A,@A+DPTR
MOV P2,A
LCALL DELY1S
INC Second
MOV A,Second
CJNE A,#60,NEXT
LJMP START
DELY1S: MOV R5,#100
D2: MOV R6,#20
D1: MOV R7,#248
DJNZ R7,$
DJNZ R6,D1
DJNZ R5,D2
RET
TABLE: DB 3FH,06H,5BH,4FH,66H,6DH,7DH,07H,7FH,6FH
END


C 語言源程序
#include <AT89X51.H>
unsigned char code table[]={0x3f,0x06,0x5b,0x4f,0x66,
0x6d,0x7d,0x07,0x7f,0x6f};
unsigned char Second;
void delay1s(void)
{
unsigned char i,j,k;
for(k=100;k>0;k--)
for(i=20;i>0;i--)
for(j=248;j>0;j--);
}
void main(void)
{
Second=0;
P0=table[Second/10];
P2=table[Second%10];
while(1)
{
delay1s();
Second++;
if(Second==60)
{
Second=0;
}
P0=table[Second/10];
P2=table[Second%10];
}
}


五、動態數碼顯示技術
如圖 9 所示，P0 端口接動態數碼管的字形碼筆段，P2 端口接動態數碼管的數位選擇端，P1.7接
一個開關，當開關接高電平時，顯示“12345”字樣；當開關接低電平時，顯示“HELLO”字樣。
動態掃描方法：動態接口采用各數碼管循環輪流顯示的方法，當循環顯示頻率較高時，利用人眼的暫留特性，看不出閃爍顯示現象，這種顯示需要一個接口完成字形碼的輸出（字形選擇），另一接口完成各數碼管的輪流點亮（數位選擇）。
在進行數碼顯示的時候，要對顯示單元開辟 8 個顯示緩沖區，每個顯示緩沖區裝有顯示的不同數據即可。對于顯示的字形碼數據我們采用查表方法來完成。

匯編源程序
ORG 0000H
START: JB P1.7,DIR1
MOV DPTR,#TABLE1
SJMP DIR
DIR1: MOV DPTR,#TABLE2
DIR: MOV R0,#00H
MOV R1,#01H
NEXT: MOV A,R0
MOVC A,@A+DPTR
MOV P0,A
MOV A,R1
MOV P2,A
LCALL DAY
INC R0
RL A
MOV R1,A
CJNE R1,#0DFH,NEXT
SJMP START
DAY: MOV R6,#4
D1: MOV R7,#248
DJNZ R7,$
DJNZ R6,D1
RET
TABLE1: DB 06H,5BH,4FH,66H,6DH
TABLE2: DB 78H,79H,38H,38H,3FH
END






C 語言源程序
  1. #include <AT89X51.H>
  2. Unsigned char code table1[ ]={0x06,0x5b,0x4f,0x66,0x6d};
  3. Unsigned char code table2[]={0x78,0x79,0x38,0x38,0x3f};
  4. Unsigned char i；
  5. Unsigned char a，b；
  6. Unsigned char temp；

  8. void main(void)
  9. {
  10.            while(1)
  11. {
  12. temp=0xfe;
  13. for(i=0;i<5;i++)
  14.           {
  15. if(P1_7==1)
  16. {
  17. P0=table1[ i];
  18.                  }
  19.         else
  20.                  {
  21. P0=table2[ i];
  22.                   }
  23. P2=temp;
  24. a=temp<<(i+1);
  25. b=temp>>(7-i);
  26.               temp=a|b;
  27. for(a=4;a>0;a--)
  28. for(b=248;b>0;b--);
  29. }
  30.                }
復制代碼



六、4×4 矩陣式鍵盤識別技術
如圖 11 所示，用 AT89S51 的并行口 P1 接 4×4 矩陣鍵盤，以 P1.0－P1.3作輸入線，以 P1.4－P1.7 作輸出線；在數碼管上顯示每個按鍵的“0－F”序。對應的按鍵的序號排列如圖12 所示每個按鍵有它的行值和列值 ，行值和列值的組合就是識別這個按鍵的編碼。矩陣的行線和列線分別通過兩并行接口和 CPU 通信。每個按鍵的狀態同樣需變成數字量“0”和“1”，開關的一端（列線）通過電阻接 VCC，而接地是通過程序輸出數字“0”實現的。鍵盤處理程序的任務是：確定有無鍵按下，判斷哪一個鍵按下，鍵的功能是什么；
還要消除按鍵在閉合或斷開時的抖動。兩個并行口中，一個輸出掃描碼，使按鍵逐行動態接地，另一個并行口輸入按鍵狀態，由行掃描值和回饋信號共同形成鍵編碼而識別按鍵，通過軟件查表，查出該鍵的
功能。


匯編源程序
  1. KEYBUF EQU 30H
  2. ORG 00H
  3. START: MOV KEYBUF,#2
  4. WAIT:
  5. MOV P3,#0FFH
  6. CLR P3.4
  7. MOV A,P3
  8. ANL A,#0FH
  9. XRL A,#0FH
  10. JZ NOKEY1
  11. LCALL DELY10MS
  12. MOV A,P3
  13. ANL A,#0FH
  14. XRL A,#0FH
  15. JZ NOKEY1
  16. MOV A,P3
  17. ANL A,#0FH
  18. CJNE A,#0EH,NK1
  19. MOV KEYBUF,#0
  20. LJMP DK1
  21. NK1: CJNE A,#0DH,NK2
  22. MOV KEYBUF,#1
  23. LJMP DK1
  24. NK2: CJNE A,#0BH,NK3
  25. MOV KEYBUF,#2
  26. LJMP DK1
  27. NK3: CJNE A,#07H,NK4
  28. MOV KEYBUF,#3
  29. LJMP DK1
  30. NK4: NOP
  31. DK1:
  32. MOV A,KEYBUF
  33. MOV DPTR,#TABLE
  34. MOVC A,@A+DPTR
  35. MOV P0,A
  36. DK1A: MOV A,P3
  37. ANL A,#0FH
  38. XRL A,#0FH
  39. JNZ DK1A
  40. NOKEY1:
  41. MOV P3,#0FFH
  42. CLR P3.5
  43. MOV A,P3
  44. ANL A,#0FH
  45. XRL A,#0FH
  46. JZ NOKEY2
  47. LCALL DELY10MS
  48. MOV A,P3
  49. ANL A,#0FH
  50. XRL A,#0FH
  51. JZ NOKEY2
  52. MOV A,P3
  53. ANL A,#0FH
  54. CJNE A,#0EH,NK5
  55. MOV KEYBUF,#4
  56. LJMP DK2
  57. NK5: CJNE A,#0DH,NK6
  58. MOV KEYBUF,#5
  59. LJMP DK2
  60. NK6: CJNE A,#0BH,NK7
  61. MOV KEYBUF,#6
  62. LJMP DK2
  63. NK7: CJNE A,#07H,NK8
  64. MOV KEYBUF,#7
  65. LJMP DK2
  66. NK8: NOP
  67. DK2:
  68. MOV A,KEYBUF
  69. MOV DPTR,#TABLE
  70. MOVC A,@A+DPTR
  71. MOV P0,A
  72. DK2A: MOV A,P3
  73. ANL A,#0FH
  74. XRL A,#0FH
  75. JNZ DK2A
  76. NOKEY2:
  77. MOV P3,#0FFH
  78. CLR P3.6
  79. MOV A,P3
  80. ANL A,#0FH
  81. XRL A,#0FH
  82. JZ NOKEY3
  83. LCALL DELY10MS
  84. MOV A,P3
  85. ANL A,#0FH
  86. XRL A,#0FH
  87. JZ NOKEY3
  88. MOV A,P3
  89. ANL A,#0FH
  90. CJNE A,#0EH,NK9
  91. MOV KEYBUF,#8
  92. LJMP DK3
  93. NK9: CJNE A,#0DH,NK10
  94. MOV KEYBUF,#9
  95. LJMP DK3
  96. NK10: CJNE A,#0BH,NK11
  97. MOV KEYBUF,#10

  99. LJMP DK3
  100. NK11: CJNE A,#07H,NK12
  101. MOV KEYBUF,#11
  102. LJMP DK3
  103. NK12: NOP
  104. DK3:
  105. MOV A,KEYBUF
  106. MOV DPTR,#TABLE
  107. MOVC A,@A+DPTR
  108. MOV P0,A
  109. DK3A: MOV A,P3
  110. ANL A,#0FH
  111. XRL A,#0FH
  112. JNZ DK3A
  113. NOKEY3:
  114. MOV P3,#0FFH
  115. CLR P3.7
  116. MOV A,P3
  117. ANL A,#0FH
  118. XRL A,#0FH
  119. JZ NOKEY4
  120. LCALL DELY10MS
  121. MOV A,P3
  122. ANL A,#0FH
  123. XRL A,#0FH
  124. JZ NOKEY4
  125. MOV A,P3
  126. ANL A,#0FH
  127. CJNE A,#0EH,NK13
  128. MOV KEYBUF,#12
  129. LJMP DK4
  130. NK13: CJNE A,#0DH,NK14
  131. MOV KEYBUF,#13
  132. LJMP DK4
  133. NK14: CJNE A,#0BH,NK15
  134. MOV KEYBUF,#14
  135. LJMP DK4
  136. NK15: CJNE A,#07H,NK16
  137. MOV KEYBUF,#15
  138. LJMP DK4
  139. NK16: NOP
  140. DK4:
  141. MOV A,KEYBUF
  142. MOV DPTR,#TABLE
  143. MOVC A,@A+DPTR
  144. MOV P0,A
  145. DK4A: MOV A,P3
  146. ANL A,#0FH
  147. XRL A,#0FH
  148. JNZ DK4A
  149. NOKEY4:
  150. LJMP WAIT
  151. DELY10MS:
  152. MOV R6,#10
  153. D1: MOV R7,#248
  154. DJNZ R7,$
  155. DJNZ R6,D1
  156. RET
  157. TABLE: DB 3FH,06H,5BH,4FH,66H,6DH,7DH,07H
  158. DB 7FH,6FH,77H,7CH,39H,5EH,79H,71H
  159. END
復制代碼

C 語言源程序
  1. #INClude <AT89X51.H>
  2. unsigned char code table[]={0x3f,0x06,0x5b,0x4f,
  3. 0x66,0x6d,0x7d,0x07,
  4. 0x7f,0x6f,0x77,0x7c,
  5. 0x39,0x5e,0x79,0x71};
  6. unsigned char temp;
  7. unsigned char key;
  8. unsigned char i,j;
  9. void main(void)
  10. {
  11. while(1)
  12. {
  13. P3=0xff;
  14. P3_4=0;
  15. temp=P3;
  16. temp=temp & 0x0f;
  17. if (temp!=0x0f)
  18. {
  19. for(i=50;i>0;i--)
  20. for(j=200;j>0;j--);
  21. temp=P3;
  22. temp=temp & 0x0f;
  23. if (temp!=0x0f)
  24. {
  25. temp=P3;
  26. temp=temp & 0x0f;
  27. switch(temp)
  28. {
  29. case 0x0e:
  30. key=7;
  31. break;
  32. case 0x0d:
  33. key=8;
  34. break;
  35. case 0x0b:
  36. key=9;
  37. break;
  38. case 0x07:
  39. key=10;
  40. break;
  41. }
  42. temp=P3;
  43. P1_0=~P1_0;
  44. P0=table[key];
  45. temp=temp & 0x0f;
  46. while(temp!=0x0f)
  47. {
  48. temp=P3;
  49. temp=temp & 0x0f;
  50. }
  51. }
  52. }
  53. P3=0xff;
  54. P3_5=0;
  55. temp=P3;
  56. temp=temp & 0x0f;
  57. if (temp!=0x0f)
  58. {
  59. for(i=50;i>0;i--)
  60. for(j=200;j>0;j--);
  61. temp=P3;
  62. temp=temp & 0x0f;
  63. if (temp!=0x0f)
  64. {
  65. temp=P3;
  66. temp=temp & 0x0f;
  67. switch(temp)
  68. {
  69. case 0x0e:
  70. key=4;
  71. break;
  72. case 0x0d:
  73. key=5;
  74. break;
  75. case 0x0b:
  76. key=6;
  77. break;
  78. case 0x07:
  79. key=11;
  80. break;
  81. }
  82. temp=P3;
  83. P1_0=~P1_0;
  84. P0=table[key];
  85. temp=temp & 0x0f;
  86. while(temp!=0x0f)
  87. {
  88. temp=P3;
  89. temp=temp & 0x0f;
  90. }
  91. }
  92. }
  93. P3=0xff;
  94. P3_6=0;
  95. temp=P3;
  96. temp=temp & 0x0f;
  97. if (temp!=0x0f)
  98. {
  99. for(i=50;i>0;i--)
  100. for(j=200;j>0;j--);
  101. temp=P3;
  102. temp=temp & 0x0f;
  103. if (temp!=0x0f)
  104. {
  105. temp=P3;
  106. temp=temp & 0x0f;
  107. switch(temp)
  108. {
  109. case 0x0e:
  110. key=1;
  111. break;
  112. case 0x0d:
  113. key=2;
  114. break;
  115. case 0x0b:
  116. key=3;
  117. break;
  118. case 0x07:
  119. key=12;
  120. break;
  121. }
  122. temp=P3;
  123. P1_0=~P1_0;
  124. P0=table[key];
  125. temp=temp & 0x0f;
  126. while(temp!=0x0f)
  127. {
  128. temp=P3;
  129. temp=temp & 0x0f;
  130. }
  131. }
  132. }
  133. P3=0xff;
  134. P3_7=0;
  135. temp=P3;
  136. temp=temp & 0x0f;
  137. if (temp!=0x0f)
  138. {
  139. for(i=50;i>0;i--)
  140. for(j=200;j>0;j--);
  141. temp=P3;
  142. temp=temp & 0x0f;
  143. if (temp!=0x0f)

  145. {
  146. temp=P3;
  147. temp=temp & 0x0f;
  148. switch(temp)
  149. {
  150. case 0x0e:
  151. key=0;
  152. break;
  153. case 0x0d:
  154. key=13;
  155. break;
  156. case 0x0b:
  157. key=14;
  158. break;
  159. case 0x07:
  160. key=15;
  161. break;

  163. }
  164. temp=P3;
  165. P1_0=~P1_0;
  166. P0=table[key];
  167. temp=temp & 0x0f;
  168. while(temp!=0x0f)
  169. {
  170. temp=P3;
  171. temp=temp & 0x0f;
  172. }
  173. }
  174. }
  175. }
  176. }
復制代碼





七、按鍵識別方法
每按下一次開關 SP1，計數值加 1，通過AT89S51 單片機的 P1 端口的 P1.0 到 P1.3
顯示出其二進制計數值。
*程序設計方法：作為一個按鍵從沒有按下到按下以及釋放是一個完整的過程，也就是說，當我們按下一個按鍵時，總希望某個命令只執行一次，而在按鍵按下的 過程中，不要有干擾進來，因為，在按下的過程中，一旦有干擾過來，可能造成誤觸發過程，這并不是我們所想要的。因此在按鍵按下的時候,要把我們手上的干擾信號以及按鍵的機械接觸等干擾信號給濾除掉，一般情況下，我們可以采用電容來濾除掉這些干擾信號，但實際上，會增加硬件成本及硬件電路的體積，這是我們不希望，總得有個辦法解決這個問題，因此我們可以采用軟件濾波的方法去除這些干擾信號，一般情況下，一個按鍵按下的時候，總是在按下的時刻存在著一定的干擾信號，按下之后就基本上進入了穩定的狀態。具體的一個按鍵從按下到釋放的全過程的信號圖如上圖所示：從圖中可以看出，我們在程序設計時，從按鍵被識別按下之后，延時 5ms 以上，從而避開了干擾信號區域，我們再來檢測一次，看按鍵是否真得已經按下，若真得已經按下，這時肯定輸出為低電平，若這時檢測到的是高電平，證明剛才是由于干擾信號引起的誤觸發，CPU 就認為是誤觸發信號而舍棄這次的按鍵識別過程。從而提高了系統的可靠性。
由于要求每按下一次，命令被執行一次，直到下一次再按下的時候，再執行一次命令，因此從按鍵被識別出來之后，我們就可以執行這次的命令，所以要有一個等待按鍵釋放的過程，顯然釋放的過程，就是使其恢復成高電平狀態。






1． 匯編源程序

ORG 0000H
START: MOV R1,#00H ;初始化 R1 為 0，表示從 0 開始計數
MOV A, R1 ;
CPL A ;取反指令
MOV P1,A ;送出 P1 端口由發光二極管顯示
REL: JB P3.7,REL ;判斷 SP1 是否按下
LCALL DELAY10MS ;若按下，則延時 10ms 左右
JB P3.7,REL ;再判斷 SP1 是否真得按下
INC R1 ;若確實按下，則進行按鍵處理，使
MOV A,R1 ;計數內容加 1，并送出 P1 端口由
CPL A ;發光二極管顯示
MOV P1,A ;
JNB P3.7,$ ;等待 SP1 釋放
SJMP REL ;繼續對 K1 按鍵掃描
DELAY10MS: MOV R6,#20 ;延時 10ms 子程序
L1: MOV R7,#248
DJNZ R7,$
DJNZ R6,L1
RET
END
































2.  C 語言源程序

#include <AT89X51.H>
unsigned char count;
void delay10ms(void)
{
unsigned char i,j;
for(i=20;i>0;i--)
for(j=248;j>0;j--);
}
void main(void)
{
while(1)
{
if(P3_7==0)
{
delay10ms();
if(P3_7==0)
{
count++;
if(count==16)
{
count=0;
}
P1=~count;
while(P3_7==0);
}
}
}
}


八、數字鐘
（1． 開機時，顯示 12：00：00 的時間開始計時；
（2． P0.0/AD0 控制“秒”的調整，每按一次加 1 秒；
（3． P0.1/AD1 控制“分”的調整，每按一次加 1 分；
（4． P0.2/AD2 控制“時”的調整，每按一次加 1 個小時

6． 匯編源程序
SECOND EQU 30H
MINITE EQU 31H
HOUR EQU 32H
HOURK BIT P0.0
MINITEK BIT P0.1
SECONDK BIT P0.2
DISPBUF EQU 40H
DISPBIT EQU 48H
T2SCNTA EQU 49H
T2SCNTB EQU 4AH
TEMP EQU 4BH
ORG 00H
LJMP START
ORG 0BH
LJMP INT_T0
START: MOV SECOND,#00H
MOV MINITE,#00H
MOV HOUR,#12
MOV DISPBIT,#00H
MOV T2SCNTA,#00H
MOV T2SCNTB,#00H
MOV TEMP,#0FEH
LCALL DISP
MOV TMOD,#01H
MOV TH0,#(65536-2000) / 256
MOV TL0,#(65536-2000) MOD 256
SETB TR0
SETB ET0
SETB EA
WT: JB SECONDK,NK1
LCALL DELY10MS
JB SECONDK,NK1
INC SECOND
MOV A,SECOND
CJNE A,#60,NS60
MOV SECOND,#00H
NS60: LCALL DISP
JNB SECONDK,$
NK1: JB MINITEK,NK2
LCALL DELY10MS
JB MINITEK,NK2
INC MINITE
MOV A,MINITE
CJNE A,#60,NM60
MOV MINITE,#00H
NM60: LCALL DISP
JNB MINITEK,$
NK2: JB HOURK,NK3
LCALL DELY10MS
JB HOURK,NK3
INC HOUR
MOV A,HOUR
CJNE A,#24,NH24
MOV HOUR,#00H
NH24: LCALL DISP
JNB HOURK,$
NK3: LJMP WT
DELY10MS:
MOV R6,#10
D1: MOV R7,#248
DJNZ R7,$
DJNZ R6,D1
RET
DISP:
MOV A,#DISPBUF
ADD A,#8
DEC A
MOV R1,A
MOV A,HOUR
MOV B,#10
DIV AB
MOV @R1,A
DEC R1
MOV A,B
MOV @R1,A
DEC R1
MOV A,#10
MOV@R1,A
DEC R1
MOV A,MINITE
MOV B,#10
DIV AB
MOV @R1,A
DEC R1
MOV A,B
MOV @R1,A
DEC R1
MOV A,#10
MOV@R1,A
DEC R1
MOV A,SECOND
MOV B,#10
DIV AB
MOV @R1,A
DEC R1
MOV A,B
MOV @R1,A
DEC R1
RET
INT_T0:
MOV TH0,#(65536-2000) / 256
MOV TL0,#(65536-2000) MOD 256
MOV A,#DISPBUF
ADD A,DISPBIT
MOV R0,A
MOV A,@R0
MOV DPTR,#TABLE
MOVC A,@A+DPTR
MOV P1,A
MOV A,DISPBIT
MOV DPTR,#TAB
MOVC A,@A+DPTR
MOV P3,A
INC DISPBIT
MOV A,DISPBIT
CJNE A,#08H,KNA
MOV DISPBIT,#00H
KNA: INC T2SCNTA
MOV A,T2SCNTA
CJNE A,#100,DONE
MOV T2SCNTA,#00H
INC T2SCNTB
MOV A,T2SCNTB
CJNE A,#05H,DONE
MOV T2SCNTB,#00H
INC SECOND
MOV A,SECOND
CJNE A,#60,NEXT
MOV SECOND,#00H
INC MINITE
MOV A,MINITE
CJNE A,#60,NEXT
MOV MINITE,#00H
INC HOUR
MOV A,HOUR
CJNE A,#24,NEXT
MOV HOUR,#00H
NEXT: LCALL DISP
DONE: RETI
TABLE: DB 3FH,06H,5BH,4FH,66H,6DH,
7DH,07H,7FH,6FH,40H
TAB: DB 0FEH,0FDH,0FBH,0F7H,0EFH,
0DFH,0BFH,07FH
END


7． C 語言源程序
#INClude <AT89X51.H>
unsigned char code dispcode[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71,0x00};
unsigned char dispbitcode[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};
unsigned char dispbuf[8]={0,0,16,0,0,16,0,0};
unsigned char dispbitcnt;
unsigned char second;
unsigned char minite;
unsigned char hour;
unsigned int tcnt;
unsigned char mstcnt;
unsigned char i,j;
void main(void)
{
TMOD=0x02;
TH0=0x06;
TL0=0x06;
TR0=1;
ET0=1;
EA=1;
while(1)
{
if(P0_0==0)
{
for(i=5;i>0;i--)
for(j=248;j>0;j--);
if(P0_0==0)
{
second++;
if(second==60)
{
second=0;
}
dispbuf[0]=second%10;
dispbuf[1]=second/10;
while(P0_0==0);
}
}
if(P0_1==0)
{
for(i=5;i>0;i--)
for(j=248;j>0;j--);
if(P0_1==0)
{
minite++;
if(minite==60)
{
minite=0;
}
dispbuf[3]=minite%10;
dispbuf[4]=minite/10;
while(P0_1==0);
}
}
if(P0_2==0)
{
for(i=5;i>0;i--)
for(j=248;j>0;j--);
if(P0_2==0)
{
hour++;
if(hour==24)
{
hour=0;
}
dispbuf[6]=hour%10;
dispbuf[7]=hour/10;
while(P0_2==0);
}
}
}
}
void t0(void) interrupt 1 using 0
{
mstcnt++;
if(mstcnt==8)
{
mstcnt=0;
P1=dispcode[dispbuf[dispbitcnt]];
P3=dispbitcode[dispbitcnt];
dispbitcnt++;
if(dispbitcnt==8)
{
dispbitcnt=0;
}
}
tcnt++;
if(tcnt==4000)
{


tcnt=0;
second++;
if(second==60)
{
second=0;
minite++;
if(minite==60)
{
minite=0;
hour++;
if(hour==24)
{
hour=0;
}
}
}
dispbuf[0]=second%10;
dispbuf[1]=second/10;
dispbuf[3]=minite%10;
dispbuf[4]=minite/10;
dispbuf[6]=hour%10;
dispbuf[7]=hour/10;
}
}
}


九． ADC0809A/D 轉換器基本應用技術
1 基本知識ADC0809 是帶有 8 位 A/D 轉換器、8 路多路開關以及微處理機兼容的控制邏輯的 CMOS組件。它是逐次逼近式 A/D 轉換器，可以和單片機直接接口。
2 ADC0809 的內部邏輯結構圖9-1

由上圖可知，ADC0809 由一個 8 路模擬開關、一個地址鎖存與譯碼器、一個 A/D轉換器和一個三態輸出鎖存器組成。多路開關可選通 8 個模擬通道，允許 8 路模擬量分時輸入，共用 A/D 轉換器進行轉換。三態輸出鎖器用于鎖存 A/D 轉換完的數字量，當 OE 端為高電平時，才可以從三態輸出鎖存器取走轉換完的數據。
3 引腳結構
IN0－IN7：8 條模擬量輸入通道
ADC0809 對輸入模擬量要求：信號單極性，電壓范圍是 0－5V，若信號太小，必須進行放大；輸入的模擬量在轉換過程中應該保持不變，如若模擬量變化太快，則需在輸入前增加采樣保持電路。
地址輸入和控制線：4 條
ALE 為地址鎖存允許輸入線，高電平有效。當 ALE 線為高電平時，地址鎖存與譯
碼器將 A，B，C 三條地址線的地址信號進行鎖存，經譯碼后被選中的通道的模擬
量進轉換器進行轉換。A，B 和 C 為地址輸入線，用于選通 IN0－IN7 上的一路模
擬量輸入。通道選擇表如下表所示。
C
B
A
選擇的通道
0
0
0
IN0
0
0
1
IN1
0
1
0
IN2
0
1
1
IN3
1
0
0
IN4
1
0
1
IN5
1
1
0
IN6
1
1
1
IN7

數字量輸出及控制線：11 條
ST 為轉換啟動信號。當 ST 上跳沿時，所有內部寄存器清零；下跳沿時，開始進
行 A/D 轉換；在轉換期間，ST 應保持低電平。EOC 為轉換結束信號。當 EOC 為高
電平時，表明轉換結束；否則，表明正在進行 A/D 轉換。OE 為輸出允許信號，
用于控制三條輸出鎖存器向單片機輸出轉換得到的數據。OE＝1，輸出轉換得到
的數據；OE＝0，輸出數據線呈高阻狀態。D7－D0 為數字量輸出線。
CLK 為時鐘輸入信號線。因 ADC0809 的內部沒有時鐘電路，所需時鐘信號必須由
外界提供，通常使用頻率為 500KHZ，VREF（＋），VREF（－）為參考電壓輸入。
4 ADC0809 應用說明
（1）． ADC0809 內部帶有輸出鎖存器，可以與 AT89S51 單片機直接相連。
（2）． 初始化時，使 ST 和 OE 信號全為低電平。
（3）． 送要轉換的哪一通道的地址到 A，B，C 端口上。
（4）． 在 ST 端給出一個至少有 100ns 寬的正脈沖信號。
（5）． 是否轉換完畢，我們根據 EOC 信號來判斷。
（6）． 當 EOC 變為高電平時，這時給 OE 為高電平，轉換的數據就輸出給單片機了。
5 實驗任務
如下圖所示，從 ADC0809 的通道 IN3 輸入 0－5V 之間的模擬量，通過 ADC0809
轉換成數字量在數碼管上以十進制形成顯示出來。ADC0809 的 VREF 接＋5V電壓。
6 電路原理圖


5． 系統板上硬件連線
（1）． 把“單片機系統板”區域中的 P1 端口的 P1.0－P1.7 用 8 芯排線連接到“動態數碼顯示”區域中的 A B C D E F G H 端口上，作為數碼管的筆段驅動。
（2）． 把“單片機系統板”區域中的 P2 端口的 P2.0－P2.7 用 8 芯排線連接到“動態數碼顯示”區域中的 S1 S2 S3 S4 S5 S6 S7 S8 端口上，作為數碼管的位段選擇。
（3）． 把“單片機系統板”區域中的 P0 端口的 P0.0－P0.7 用 8 芯排線連接到“模數轉換模塊”區域中的 D0D1D2D3D4D5D6D7 端口上，A/D 轉換完畢的數據輸入到單片機的 P0 端口
（4）． 把“模數轉換模塊”區域中的 VREF 端子用導線連接到“電源模塊”區域中的 VCC 端子上；
（5）． 把“模數轉換模塊”區域中的 A2A1A0 端子用導線連接到“單片機系統”區域中的 P3.4 P3.5 P3.6 端子上；
（6）． 把“模數轉換模塊”區域中的 ST 端子用導線連接到“單片機系統”
區域中的 P3.0 端子上；
（7）． 把“模數轉換模塊”區域中的 OE 端子用導線連接到“單片機系統”區域中的 P3.1 端子上；
（8）．把“模數轉換模塊”區域中的 EOC 端子用導線連接到“單片機系統”區域中的 P3.2 端子上；
（9）． 把“模數轉換模塊”區域中的 CLK 端子用導線連接到“分頻模塊”區域中的 /4 端子上；
（10）． 把“分頻模塊”區域中的 CK IN 端子用導線連接到“單片機系統”區域中的 ALE 端子上；
（11）． 把“模數轉換模塊”區域中的 IN3 端子用導線連接到“三路可調壓模塊”區域中的 VR1 端子上；
6． 程序設計內容
（1）． 進行 A/D 轉換時，采用查詢 EOC 的標志信號來檢測 A/D 轉換是否完畢，若完畢則把數據通過 P0 端口讀入，經過數據處理之后在數碼管上顯示。
（2）． 進行 A/D 轉換之前，要啟動轉換的方法：ABC＝110 選擇第三通道ST＝0，ST＝1，ST＝0 產生啟動轉換的正脈沖信號






7． 匯編源程序
  1. CH EQU 30H
  2. DPCNT EQU 31H
  3. DPBUF EQU 33H
  4. GDATA EQU 32H
  5. ST BIT P3.0
  6. OE BIT P3.1
  7. EOC BIT P3.2
  8. ORG 00H
  9. LJMP START
  10. ORG 0BH
  11. LJMP T0X
  12. ORG 30H
  13. START: MOV CH,#0BCH
  14. MOV DPCNT,#00H
  15. MOV R1,#DPCNT
  16. MOV R7,#5
  17. MOV A,#10
  18. MOV R0,#DPBUF
  19. LOP: MOV @R0,A
  20. INC R0
  21. DJNZ R7,LOP
  22. MOV @R0,#00H
  23. INC R0
  24. MOV @R0,#00H
  25. INC R0
  26. MOV @R0,#00H
  27. MOV TMOD,#01H
  28. MOV TH0,#(65536-4000)/256
  29. MOV TL0,#(65536-4000)
  30. MOD 256
  31. SETB TR0
  32. SETB ET0
  33. SETB EA
  34. WT: CLR ST
  35. SETB ST
  36. CLR ST
  37. WAIT: JNB EOC,WAIT
  38. SETB OE
  39. MOV GDATA,P0
  40. CLR OE
  41. MOV A,GDATA
  42. MOV B,#100
  43. DIV AB
  44. MOV 33H,A
  45. MOV A,B
  46. MOV B,#10
  47. DIV AB
  48. MOV 34H,A
  49. MOV 35H,B
  50. SJMP WT
  51. T0X: NOP
  52. MOV TH0,#(65536-4000)/256
  53. MOV TL0,#(65536-4000) MOD 256
  54. MOV DPTR,#DPCD
  55. MOV A,DPCNT
  56. ADD A,#DPBUF
  57. MOV R0,A
  58. MOV A,@R0
  59. MOVC A,@A+DPTR
  60. MOV P1,A
  61. MOV DPTR,#DPBT
  62. MOV A,DPCNT
  63. MOVC A,@A+DPTR
  64. MOV P2,A
  65. INC DPCNT
  66. MOV A,DPCNT
  67. CJNE A,#8,NEXT
  68. MOV DPCNT,#00H
  69. NEXT: RETI
  70. DPCD: DB 3FH,06H,5BH,4FH,66H
  71. DB 6DH,7DH,07H,7FH,6FH,00H
  72. DPBT: DB 0FEH,0FDH,0FBH,0F7H
  73. DB 0EFH,0DFH,0BFH,07FH
  74. END
復制代碼






8． C 語言源程序
  1. #INClude <AT89X52.H>
  2. unsigned char code dispbitcode[]={0xfe,0xfd,0xfb,0xf7,
  3. 0xef,0xdf,0xbf,0x7f};
  4. unsigned char code dispcode[]={0x3f,0x06,0x5b,0x4f,0x66,
  5. 0x6d,0x7d,0x07,0x7f,0x6f,0x00};
  6. unsigned char dispbuf[8]={10,10,10,10,10,0,0,0};
  7. unsigned char dispcount;
  8. sbit ST=P3^0;
  9. sbit OE=P3^1;
  10. sbit EOC=P3^2;
  11. unsigned char channel=0xbc;//IN3
  12. unsigned char getdata;
  13. void main(void)
  14. {

  16. TMOD=0x01;
  17. TH0=(65536-4000)/256;
  18. TL0=(65536-4000)%256;
  19. TR0=1;
  20. ET0=1;
  21. EA=1;
  22. P3=channel;
  23. while(1)
  24. {
  25. ST=0;
  26. ST=1;
  27. ST=0;
  28. while(EOC==0);
  29. OE=1;
  30. getdata=P0;
  31. OE=0;
  32. dispbuf[2]=getdata/100;
  33. getdata=getdata%10;
  34. dispbuf[1]=getdata/10;
  35. dispbuf[0]=getdata%10;
  36. }
  37. }
  38. void t0(void) interrupt 1 using 0
  39. {
  40. TH0=(65536-4000)/256;
  41. TL0=(65536-4000)%256;
  42. P1=dispcode[dispbuf[dispcount]];
  43. P2=dispbitcode[dispcount];
  44. dispcount++;
  45. if(dispcount==8)
  46. {
  47. dispcount=0;
  48. }
  49. }
復制代碼


3


十、DS18B20 數字溫度計使用
1．DS18B20 基本知識
DS18B20 數字溫度計是 DALLAS 公司生產的 1－Wire，即單總線器件，具有線路簡單，體積小的特點。因此用它來組成一個測溫系統，具有線路簡單，在一根通信線，可以掛很多這樣的數字溫度計，十分方便。
1、DS18B20 產品的特點
（1）、只要求一個端口即可實現通信。
（2）、在 DS18B20 中的每個器件上都有獨一無二的序列號。
（3）、實際應用中不需要外部任何元器件即可實現測溫。
（4）、測量溫度范圍在－55。C 到＋125。C 之間。
（5）、數字溫度計的分辨率用戶可以從 9 位到 12 位選擇。
（6）、內部有溫度上、下限告警設置。
2、DS18B20 的引腳介紹
TO－92 封裝的 DS18B20 的引腳排列見圖 1，其引腳功能描述見表 1。（底視圖）圖 1


由于 DS18B20 采用的是 1－Wire 總線協議方式，即在一根數據線實現數據的雙向傳輸，而對 AT89S51 單片機來說，硬件上并不支持單總線協議，因此，我們必須采用軟件的方法來模擬單總線的協議時序來完成對 DS18B20 芯片的訪問。

由于 DS18B20 是在一根 I/O 線上讀寫數據，因此，對讀寫的數據位有著嚴格的時序要求。DS18B20 有嚴格的通信協議來保證各位數據傳輸的正確性和完整性。該協議定義了幾種信號的時序：初始化時序、讀時序、寫時序。所有時序都是將主機作為主設備，單總線器件作為從設備。而每一次命令和數據的傳輸都是從主機主動啟動寫時序開始，如果要求單總線器件回送數據，在進行寫命令后，主機需啟動讀時序完成數據接收。數據和命令的傳輸都是低位在先。
DS18B20 的復位時序

DS18B20 的讀時序對于DS18B20 的讀時序分為讀 0時序和讀 1 時序兩個過程。對于 DS18B20的讀時隙是從主機把單總線拉低之后，在 15 秒之內就得釋放單總線，以讓 DS18B20 把數據傳輸到單總線上。DS18B20 在完成一個讀時序過程，至少需要 60us 才能完成。


對于 DS18B20 的寫時序仍然分為寫 0 時序和寫 1 時序兩個過程。對于DS18B20 寫 0 時序和寫 1 時序的要求不同，當要寫 0 時序時，單總線要被拉低至少 60us，保證 DS18B20 能夠在 15us 到 45us 之間能夠正確地采樣 IO 總線上的“0”電平，當要寫 1 時序時，單總線被拉低之后，在 15us 之內就得釋放單總線。


4． 實驗任務
用一片 DS18B20 構成測溫系統，測量的溫度精度達到 0.1 度，測量的溫度的范圍在－20 度到＋100 度之間，用 8 位數碼管顯示出來。
5． 電路原理圖






7． C 語言源程序
  1. #INClude <AT89X52.H>
  2. #INClude <INTRINS.h>
  3. unsigned char code displaybit[]={0xfe,0xfd,0xfb,0xf7,
  4. 0xef,0xdf,0xbf,0x7f};
  5. unsigned char code displaycode[]={0x3f,0x06,0x5b,0x4f,
  6. 0x66,0x6d,0x7d,0x07,
  7. 0x7f,0x6f,0x77,0x7c,
  8. 0x39,0x5e,0x79,0x71,0x00,0x40};
  9. unsigned char code dotcode[32]={0,3,6,9,12,16,19,22,
  10. 25,28,31,34,38,41,44,48,
  11. 50,53,56,59,63,66,69,72,
  12. 75,78,81,84,88,91,94,97};
  13. unsigned char displaycount;
  14. unsigned char displaybuf[8]={16,16,16,16,16,16,16,16};
  15. unsigned char timecount;
  16. unsigned char readdata[8];
  17. sbit DQ=P3^7;
  18. bit sflag;
  19. bit resetpulse(void)
  20. {
  21. unsigned char i;
  22. DQ=0;
  23. for(i=255;i>0;i--);
  24. DQ=1;
  25. for(i=60;i>0;i--);
  26. RETurn(DQ);
  27. for(i=200;i>0;i--);
  28. }
  29. void writecommandtods18b20(unsigned char command)
  30. {
  31. unsigned char i;
  32. unsigned char j;
  33. for(i=0;i<8;i++)
  34. {
  35. if((command & 0x01)==0)
  36. {
  37. DQ=0;
  38. for(j=35;j>0;j--);
  39. DQ=1;
  40. }
  41. else
  42. {
  43. DQ=0;
  44. for(j=2;j>0;j--);
  45. DQ=1;
  46. for(j=33;j>0;j--);
  47. }
  48. command=_cror_(command,1);
  49. }
  50. }
  51. Unsigned  char readdatafromds18b20(void)

  53. Unsigned char i;
  54. Unsigned char j;
  55. Unsigned char temp;
  56. temp=0;
  57. for(i=0;i<8;i++)
  58. {
  59. temp=_cror_(temp,1);
  60. DQ=0;
  61. _nop_();
  62. _nop_();
  63. DQ=1;
  64. for(j=10;j>0;j--);
  65. if(DQ==1)
  66. {
  67. temp=temp | 0x80;
  68. }
  69. else
  70. {
  71. temp=temp | 0x00;
  72. }
  73. for(j=200;j>0;j--);
  74. }
  75. RETurn(temp);
  76. }
  77. void main(void)
  78. {
  79. TMOD=0x01;
  80. TH0=(65536-4000)/256;
  81. TL0=(65536-4000)%256;
  82. ET0=1;
  83. EA=1;
  84. while(resetpulse());
  85. writecommandtods18b20(0xcc);
  86. writecommandtods18b20(0x44);
  87. TR0=1;
  88. while(1)
  89. {
  90. ;
  91. }
  92. }
  93. void t0(void) interrupt 1 using 0
  94. {
  95. unsigned char x;
  96. unsigned int result;
  97. TH0=(65536-4000)/256;
  98. TL0=(65536-4000)%256;
  99. if(displaycount==2)
  100. {
  101. P0=displaycode[displaybuf[displaycount]] | 0x80;
  102. }
  103. else
  104. {
  105. P0=displaycode[displaybuf[displaycount]];
  106. }
  107. P2=displaybit[displaycount];
  108. displaycount++;
  109. if(displaycount==8)
  110. {
  111. displaycount=0;
  112. }
  113. timecount++;
  114. if(timecount==150)
  115. {
  116. timecount=0;
  117. while(resetpulse());
  118. writecommandtods18b20(0xcc);
  119. writecommandtods18b20(0xbe);
  120. readdata[0]=readdatafromds18b20();
  121. readdata[1]=readdatafromds18b20();
  122. for(x=0;x<8;x++)
  123. {
  124. displaybuf[x]=16;
  125. }
  126. sflag=0;
  127. if((readdata[1] & 0xf8)!=0x00)
  128. {
  129. sflag=1;
  130. readdata[1]=~readdata[1];
  131. readdata[0]=~readdata[0];
  132. result=readdata[0]+1;
  133. readdata[0]=result;
  134. if(result>255)
  135. {
  136. readdata[1]++;
  137. }
  138. }
  139. readdata[1]=readdata[1]<<4;
  140. readdata[1]=readdata[1] & 0x70;
  141. x=readdata[0];
  142. x=x>>4;
  143. x=x & 0x0f;
  144. readdata[1]=readdata[1] | x;
  145. x=2;
  146. result=readdata[1];
  147. while(result/10)
  148. {
  149. displaybuf[x]=result%10;
  150. result=result/10;
  151. x++;
  152. }
  153. displaybuf[x]=result;
  154. if(sflag==1)
  155. {
  156. displaybuf[x+1]=17;
  157. }
  158. x=readdata[0] & 0x0f;
  159. x=x<<1;
  160. displaybuf[0]=(dotcode[x])%10;
  161. displaybuf[1]=(dotcode[x])/10;
  162. while(resetpulse());
  163. writecommandtods18b20(0xcc);
  164. writecommandtods18b20(0x44);
  165. }
  166. }
復制代碼





11、 4×4 鍵盤及 8 位數碼管顯示構成的電子密碼鎖
用 4×4 組成 0－9 數字鍵及確認鍵。

用 8 位數碼管組成顯示電路提示信息，當輸入密碼時，只顯示“8.”，當密碼位數輸入完畢按下確認鍵時，對輸入的密碼與設定的密碼進行比較，若密碼正確，則門開，此處用 LED 發光二極管亮一秒鐘做為提示，同時發出“叮咚”聲；若密碼不正確，禁止按鍵輸入 3 秒，同時發出“嘀、嘀”
報警聲；若在 3 秒之內仍有按鍵按下，則禁止按鍵輸入 3 秒被重新禁止。
4． 程序設計內容
（1）． 4×4 行列式鍵盤識別技術：有關這方面內容前面已經討論過，這里不再重復。
（2）． 8 位數碼顯示，初始化時，顯示“P   ”，接著輸入最大 6 位數的密碼，當密碼輸入完后，按下確認鍵，進行密碼比較，然后給出相應的信息。在輸入密碼過程中，顯示器只顯示“8.”。當數字輸入超過 6個時，給出報警信息。在密碼輸入過程中，若輸入錯誤，可以利用“DEL”鍵刪除剛才輸入的錯誤的數字。
（3）． 4×4 行列式鍵盤的按鍵功能分布圖如圖 4.33.2 所示：




5． C 語言源程序
  1. #include <AT89X52.H>
  2. unsigned char ps[]={1,2,3,4,5};
  3. unsigned char code dispbit[]={0xfe,0xfd,0xfb,0xf7,
  4. 0xef,0xdf,0xbf,0x7f};
  5. unsigned char code dispcode[]={0x3f,0x06,0x5b,0x4f,0x66,
  6. 0x6d,0x7d,0x07,0x7f,0x6f,
  7. 0x77,0x7c,0x39,0x5e,0x79,0x71,
  8. 0x00,0x40,0x73,0xff};
  9. unsigned char dispbuf[8]={18,16,16,16,16,16,16,16};
  10. unsigned char dispcount;
  11. unsigned char flashcount;
  12. unsigned char temp;
  13. unsigned char key;
  14. unsigned char keycount;
  15. unsigned char pslen=5;
  16. unsigned char getps[6];
  17. bit keyoverflag;
  18. bit errorflag;
  19. bit rightflag;
  20. unsigned int second3;
  21. unsigned int aa,bb;
  22. unsigned int cc;
  23. bit okflag;
  24. bit alarmflag;
  25. bit hibitflag;
  26. unsigned char oka,okb;
  27. void main(void)
  28. {
  29. unsigned char i,j;
  30. TMOD=0x01;
  31. TH0=(65536-500)/256;
  32. TL0=(65536-500)%256;
  33. TR0=1;
  34. ET0=1;
  35. EA=1;
  36. while(1)
  37. {
  38. P3=0xff;
  39. P3_4=0;
  40. temp=P3;
  41. temp=temp & 0x0f;
  42. if (temp!=0x0f)
  43. {
  44. for(i=10;i>0;i--)
  45. for(j=248;j>0;j--)；
  46. temp=P3;
  47. temp=temp & 0x0f;
  48. if (temp!=0x0f)
  49. {
  50. temp=P3;
  51. temp=temp & 0x0f;
  52. switch(temp)
  53. {
  54. case 0x0e:
  55. key=7;
  56. break;
  57. case 0x0d:
  58. key=8;
  59. break;
  60. case 0x0b:
  61. key=9;
  62. break;
  63. case 0x07:
  64. key=10;
  65. break;
  66. }
  67. temp=P3;
  68. P1_1=~P1_1;
  69. if((key>=0) && (key<10))
  70. {
  71. if(keycount<6)
  72. {
  73. getps[keycount]=key;
  74. dispbuf[keycount+2]=19;
  75. }
  76. keycount++;
  77. if(keycount==6)
  78. {
  79. keycount=6;
  80. }
  81. else if(keycount>6)
  82. {
  83. keycount=6;
  84. keyoverflag=1;//key overflow
  85. }
  86. }
  87. else if(key==12)//delete key
  88. {
  89. if(keycount>0)
  90. {
  91. keycount--;
  92. getps[keycount]=0;
  93. dispbuf[keycount+2]=16;
  94. }
  95. else
  96. {
  97. keyoverflag=1;
  98. }
  99. }
  100. else if(key==15)//enter key
  101. {
  102. if(keycount!=pslen)
  103. {
  104. errorflag=1;
  105. rightflag=0;
  106. second3=0;
  107. }
  108. else
  109. {
  110. for(i=0;i<keycount;i++)
  111. {
  112. if(getps[ i]!=ps[ i])
  113. {
  114. i=keycount;
  115. errorflag=1;
  116. rightflag=0;
  117. second3=0;
  118. goto a;
  119. }
  120. }
  121. errorflag=0;
  122. rightflag=1;
  123. a: i=keycount;
  124. }
  125. }
  126. temp=temp & 0x0f;
  127. while(temp!=0x0f)
  128. {
  129. temp=P3;
  130. temp=temp & 0x0f;
  131. }
  132. keyoverflag=0;//?????????
  133. }
  134. }
  135. P3=0xff;
  136. P3_5=0;
  137. temp=P3;
  138. temp=temp & 0x0f;
  139. if (temp!=0x0f)
  140. {
  141. for(i=10;i>0;i--)
  142. for(j=248;j>0;j--);
  143. temp=P3;
  144. temp=temp & 0x0f;
  145. if (temp!=0x0f)
  146. {
  147. temp=P3;
  148. temp=temp & 0x0f;
  149. switch(temp)
  150. {
  151. case 0x0e:
  152. key=4;
  153. break;
  154. case 0x0d:
  155. key=5;
  156. break;
  157. case 0x0b:
  158. key=6;
  159. break;
  160. case 0x07:
  161. key=11;
  162. break;
  163. }
  164. temp=P3;
  165. P1_1=~P1_1;
  166. if((key>=0) && (key<10))
  167. {
  168. if(keycount<6)
  169. {
  170. getps[keycount]=key;
  171. dispbuf[keycount+2]=19;
  172. }
  173. keycount++;
  174. if(keycount==6)
  175. {
  176. keycount=6;
  177. }
  178. else if(keycount>6)
  179. {
  180. keycount=6;
  181. keyoverflag=1;//key overflow
  182. }
  183. }
  184. else if(key==12)//delete key
  185. {
  186. if(keycount>0)
  187. {
  188. keycount--;
  189. getps[keycount]=0;
  190. dispbuf[keycount+2]=16;
  191. }
  192. else
  193. {
  194. keyoverflag=1;
  195. }
  196. }
  197. else if(key==15)//enter key
  198. {
  199. if(keycount!=pslen)
  200. {
  201. errorflag=1;
  202. rightflag=0;
  203. second3=0;
  204. }
  205. else
  206. {
  207. for(i=0;i<keycount;i++)
  208. {
  209. if(getps[ i]!=ps[ i])
  210. {
  211. i=keycount;
  212. errorflag=1;
  213. rightflag=0;
  214. second3=0;
  215. goto a4;
  216. }
  217. }
  218. errorflag=0;
  219. rightflag=1;
  220. a4: i=keycount;
  221. }
  222. }
  223. temp=temp & 0x0f;
  224. while(temp!=0x0f)
  225. {
  226. temp=P3;
  227. temp=temp & 0x0f;
  228. }
  229. keyoverflag=0;//?????????
  230. }
  231. }
  232. P3=0xff;
  233. P3_6=0;
  234. temp=P3;
  235. temp=temp & 0x0f;
  236. if (temp!=0x0f)
  237. {
  238. for(i=10;i>0;i--)
  239. for(j=248;j>0;j--);
  240. temp=P3;
  241. temp=temp & 0x0f;
  242. if (temp!=0x0f)
  243. {
  244. temp=P3;
  245. temp=temp & 0x0f;
  246. switch(temp)
  247. {
  248. case 0x0e:
  249. key=1;
  250. break;
  251. case 0x0d:
  252. key=2;
  253. break;
  254. case 0x0b:
  255. key=3;
  256. break;
  257. case 0x07:
  258. key=12;
  259. break;
  260. }
  261. temp=P3;
  262. P1_1=~P1_1;
  263. if((key>=0) && (key<10))
  264. {
  265. if(keycount<6)
  266. {
  267. getps[keycount]=key;
  268. dispbuf[keycount+2]=19;
  269. }
  270. keycount++;
  271. if(keycount==6)
  272. {
  273. keycount=6;
  274. }
  275. else if(keycount>6)
  276. {
  277. keycount=6;
  278. keyoverflag=1;//key overflow
  279. }
  280. }
  281. else if(key==12)//delete key
  282. {
  283. if(keycount>0)
  284. {
  285. keycount--;
  286. getps[keycount]=0;
  287. dispbuf[keycount+2]=16;
  288. }
  289. else
  290. {
  291. keyoverflag=1;
  292. }
  293. }
  294. else if(key==15)//enter key
  295. {
  296. if(keycount!=pslen)
  297. {
  298. errorflag=1;
  299. rightflag=0;
  300. second3=0;
  301. }
  302. else
  303. {
  304. for(i=0;i<keycount;i++)
  305. {
  306. if(getps[ i]!=ps[ i])
  307. {
  308. i=keycount；
  309. errorflag=1;
  310. rightflag=0;
  311. second3=0;
  312. goto a3;
  313. }
  314. }
  315. errorflag=0;
  316. rightflag=1;
  317. a3: i=keycount;
  318. }
  319. }
  320. temp=temp & 0x0f;
  321. while(temp!=0x0f)
  322. {
  323. temp=P3;
  324. temp=temp & 0x0f;
  325. }
  326. keyoverflag=0;//?????????
  327. }
  328. }
  329. P3=0xff;
  330. P3_7=0;
  331. temp=P3;
  332. temp=temp & 0x0f;
  333. if (temp!=0x0f)
  334. {
  335. for(i=10;i>0;i--)
  336. for(j=248;j>0;j--);
  337. temp=P3;
  338. temp=temp & 0x0f;
  339. if (temp!=0x0f)
  340. {
  341. temp=P3;
  342. temp=temp & 0x0f;
  343. switch(temp)
  344. {
  345. case 0x0e:
  346. key=0;
  347. break;
  348. case 0x0d:
  349. key=13;
  350. break;
  351. case 0x0b；
  352. key=14;
  353. break;
  354. case 0x07:
  355. key=15;
  356. break;
  357. }
  358. temp=P3;
  359. P1_1=~P1_1;
  360. if((key>=0) && (key<10))
  361. {
  362. if(keycount<6)
  363. {
  364. getps[keycount]=key;
  365. dispbuf[keycount+2]=19;
  366. }
  367. keycount++;
  368. if(keycount==6)
  369. {
  370. keycount=6;
  371. }
  372. else if(keycount>6)
  373. {
  374. keycount=6;
  375. keyoverflag=1;//key overflow
  376. }
  377. }
  378. else if(key==12)//delete key
  379. {
  380. if(keycount>0)
  381. {
  382. keycount--;
  383. getps[keycount]=0;
  384. dispbuf[keycount+2]=16;
  385. }
  386. else
  387. {
  388. keyoverflag=1;
  389. }
  390. }
  391. else if(key==15)//enter key
  392. {
  393. if(keycount!=pslen)
  394. {
  395. errorflag=1;
  396. rightflag=0;
  397. second3=0;
  398. }
  399. else
  400. {
  401. for(i=0;i<keycount;i++)
  402. {
  403. if(getps[ i]!=ps[ i])
  404. {
  405. i=keycount;
  406. errorflag=1;
  407. rightflag=0;
  408. second3=0;
  409. goto a2;
  410. }
  411. }
  412. errorflag=0;
  413. rightflag=1;
  414. a2: i=keycount;
  415. }
  416. }
  417. temp=temp & 0x0f;
  418. while(temp!=0x0f)
  419. {
  420. temp=P3;
  421. temp=temp & 0x0f;
  422. }
  423. keyoverflag=0;//?????????
  424. }
  425. }
  426. }
  427. }
  428. void t0(void) interrupt 1 using 0
  429. {
  430. TH0=(65536-500)/256;
  431. TL0=(65536-500)%256;
  432. flashcount++;
  433. if(flashcount==8)
  434. {
  435. flashcount=0;
  436. P0=dispcode[dispbuf[dispcount]];
  437. P2=dispbit[dispcount];
  438. dispcount++;
  439. if(dispcount==8)
  440. {
  441. dispcount=0;
  442. }
  443. }
  444. if((errorflag==1) && (rightflag==0))
  445. {
  446. bb++;
  447. if(bb==800)
  448. {
  449. bb=0;
  450. alarmflag=~alarmflag;
  451. }
  452. if(alarmflag==1)//sound alarm signal
  453. {
  454. P1_7=~P1_7;
  455. }
  456. aa++;
  457. if(aa==800)//light alarm signal
  458. {
  459. aa=0;
  460. P1_0=~P1_0;
  461. }
  462. second3++;
  463. if(second3==6400)
  464. {
  465. second3=0;
  466. errorflag=0;
  467. rightflag=0;
  468. alarmflag=0;
  469. bb=0;
  470. aa=0;
  471. }
  472. }
  473. else if((errorflag==0) && (rightflag==1))
  474. {
  475. P1_0=0;
  476. cc++;
  477. if(cc<1000)
  478. {
  479. okflag=1;
  480. }
  481. else if(cc<2000)
  482. {
  483. okflag=0;
  484. }
  485. else
  486. {
  487. errorflag=0;
  488. rightflag=0;
  489. P1_7=1;
  490. cc=0;
  491. oka=0;
  492. okb=0;
  493. okflag=0;
  494. P1_0=1;
  495. }
  496. if(okflag==1)
  497. {
  498. oka++;
  499. if(oka==2)
  500. {
  501. oka=0;
  502. P1_7=~P1_7;
  503. }
  504. }
  505. else
  506. {
  507. okb++;
  508. if(okb==3)
  509. {
  510. okb=0;
  511. P1_7=~P1_7;
  512. }
  513. }
  514. }
  515. if(keyoverflag==1)
  516. {
  517. P1_7=~P1_7;
  518. }
  519. }
復制代碼




12． 6 位數顯頻率計數器
1． 實驗任務
利用 AT89S51 單片機的 T0、T1 的定時計數器功能，來完成對輸入的信號進行頻率計數，計數的頻率結果通過 8 位動態數碼管顯示出來。要求能夠對0－250KHZ 的信號頻率進行準確計數，計數誤差不超過±1HZ。
3． 程序設計內容
（1）． 定時/計數器 T0 和 T1 的工作方式設置，由圖可知，T0 是工作在計數狀態下，對輸入的頻率信號進行計數，但對工作在計數狀態下的T0，最大計數值為 fOSC/24，由于 fOSC＝12MHz，因此：T0 的最大計數頻率為250KHz。對于頻率的概念就是在一秒只數脈沖的個數，即為頻率值。
所以 T1 工作在定時狀態下，每定時 1 秒中到，就停止 T0 的計數，而從 T0 的計數單元中讀取計數的數值，然后進行數據處理。送到數碼管顯示出來。
（2）． T1 工作在定時狀態下，最大定時時間為 65ms，達不到 1 秒的定時，所
以采用定時 50ms，共定時 20 次，即可完成 1 秒的定時功能。


． C 語言源程序
  1. #include <AT89X52.H>
  2. unsigned char code dispbit[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};
  3. unsigned char code dispcode[]={0x3f,0x06,0x5b,0x4f,0x66,
  4. 0x6d,0x7d,0x07,0x7f,0x6f,0x00,0x40};
  5. unsigned char dispbuf[8]={0,0,0,0,0,0,10,10};
  6. unsigned char temp[8];
  7. unsigned char dispcount;
  8. unsigned char T0count;
  9. unsigned char timecount;
  10. bit flag;
  11. unsigned long x;
  12. void main(void)
  13. {
  14. unsigned char i;
  15. TMOD=0x15;
  16. TH0=0;
  17. TL0=0;
  18. TH1=(65536-4000)/256;
  19. TL1=(65536-4000)%256;
  20. TR1=1;
  21. TR0=1;
  22. ET0=1;
  23. ET1=1;
  24. EA=1;
  25. while(1)
  26. {
  27. if(flag==1)
  28. {
  29. flag=0;
  30. x=T0count*65536+TH0*256+TL0;
  31. for(i=0;i<8;i++)
  32. {
  33. temp[ i]=0;
  34. }
  35. i=0;
  36. while(x/10)
  37. {
  38. temp[ i]=x%10;
  39. x=x/10;
  40. i++;
  41. }
  42. temp[ i]=x;
  43. for(i=0;i<6;i++)
  44. {
  45. dispbuf[ i]=temp[ i];
  46. }
  47. timecount=0;
  48. T0count=0;
  49. TH0=0;
  50. TL0=0;
  51. TR0=1;
  52. }
  53. }
  54. }
  55. void t0(void) interrupt 1 using 0
  56. {
  57. T0count++;
  58. }
  59. void t1(void) interrupt 3 using 0
  60. {
  61. TH1=(65536-4000)/256;
  62. TL1=(65536-4000)%256;
  63. timecount++;
  64. if(timecount==250)
  65. {
  66. TR0=0;
  67. timecount=0;
  68. flag=1;
  69. }
  70. P0=dispcode[dispbuf[dispcount]];
  71. P2=dispbit[dispcount];
  72. dispcount++;
  73. if(dispcount==8)
  74. {
  75. dispcount=0;
  76. }
  77. }
復制代碼




13、LCD驅動程序

根據原理圖設計LCD1602液晶顯示電路的驅動程序：
  1. /********************************
  2. FILE NAME:        LCD1602.c
  3. CHIP TYPE:        AT89C51
  4. CLOCK FREQUENCY:  12MHZ
  5. IDE:              VSMStudio
  6. COMPILER:         IAR for 8051
  7. TIME:             7/ 2012
  8. ********************************/

  10. #include "ioAT89C51.h"
  11. #include "intrinsics.h"

  13. // Define P3 pins
  14. #define DATA_BUS  (P0);數據總線P0
  15. #define RS  (P2_bit.P2_0);P2.0
  16. #define RW (P2_bit.P2_1) ;P2.1
  17. #define E    (P2_bit.P2_2);P2.2

  19. // Define new types
  20. typedef unsigned char   uchar;無符號字符型
  21. typedef unsigned int    uint;無符號整型

  23. // Function Prototypes
  24. void check_busy(void);檢查忙信號
  25. void write_command(uchar com);寫指令
  26. void write_data(uchar data);寫數據
  27. void LCD_init(void);LCD初始化
  28. void string(uchar ad ,uchar *s);
  29. void lcd_test(void);測試函數
  30. void delay(uint);延時函數

  32. void main(void);主函數
  33. { LCD_init();
  34.    while(1)
  35.     { string(0x80,"Have a nice day!");
  36.       string(0xC0,"  Proteus VSM");
  37.       delay(100);
  38.       write_command(0x01);
  39.       delay(100);      
  40.     }
  41. }

  43. /*******************************************
  44.     LCD1602 Driver mapped as IO peripheral
  45. *******************************************/
  46. // Delay，延時
  47. void delay(uint j)
  48. { uchar i = 60;
  49.    for(; j>0; j--)
  50.     { while(--i);
  51.       i = 59;
  52.       while(--i);
  53.       i = 60;
  54.     }
  55. }

  57. // Test the Busy bit，測試忙位BF
  58. void check_busy(void)
  59. { do
  60.     { DATA_BUS = 0xff;
  61.       E = 0;
  62.       RS = 0;
  63.       RW = 1;
  64.       E = 1;高電平
  65.       __no_operation();
  66.     } while(DATA_BUS & 0x80);
  67.    E = 0;
  68. }

  70. // Write a command,寫指令
  71. void write_command(uchar com)
  72. { check_busy();
  73.    E = 0;
  74.    RS = 0;
  75.    RW = 0;
  76.    DATA_BUS = com;
  77.    E = 1;
  78.    __no_operation();
  79.    E = 0;下降沿
  80.    delay(1);
  81. }

  83. // Write Data,寫數據
  84. void write_data(uchar data)
  85. { check_busy();
  86.    E = 0;
  87.    RS = 1;
  88.    RW = 0;
  89.    DATA_BUS = data;
  90.    E = 1;
  91.    __no_operation();
  92.    E = 0;
  93.    delay(1);  
  94. }

  96. // Initialize LCD controller
  97. void LCD_init(void)
  98. { write_command(0x38); // 8-bits, 2 lines, 7x5 dots
  99.    write_command(0x0C); // no cursor, no blink, //enable display
  100.    write_command(0x06); // auto-INCrement on
  101.    write_command(0x01); // clear screen
  102.    delay(1);
  103. }

  105. // Display a string
  106. void string(uchar ad, uchar *s)
  107. { write_command(ad);
  108.    while(*s>0)
  109.     { write_data(*s++);
  110.       delay(100);
  111.     }
  112. }
復制代碼

  1. ; LCD Display Driver Demo.
  2. ; Timing code assumes 1.2MHz Clock

  4. ;LCD Registers addresses
  5. LCD_CMD_WR              EQU               00H
  6. LCD_DATA_WR              EQU              01H
  7. LCD_BUSY_RD              EQU              02H
  8. LCD_DATA_RD              EQU              03H

  10. ;LCD Commands
  11. LCD_CLS                                EQU              01
  12. LCD_HOME                      EQU              02
  13. LCD_SETMODE                  EQU              04
  14. LCD_SETVISIBLE              EQU              08
  15. LCD_SHIFT                      EQU              16
  16. LCD_SETFUNCTION              EQU              32
  17. LCD_SETCGADDR              EQU              64
  18. LCD_SETDDADDR              EQU              128
  19. ;Reset vector
  20.               ORG 0000h
  21.               JMP start;//Start of the program
  22.               ORG 0100h
  23. string1a:DB ' !! A M A Z I N G !! '
  24.               DB 0
  25. string1b:DB '!! A M A Z I N G !! '
  26.               DB 0
  27. string2:DB ' A virtual LM032L... '
  28.               DB 0
  29. string3:DB ' driven by a virtual '
  30.               DB 0
  31. string4:DB '   8051 processor!'
  32.               DB 0
  33. start:              MOV A,#038h; 8位2行，5*7點陣
  34.               CALL wrcmd
  35. loop: MOV A,#LCD_SETVISIBLE+6               ;Make the display & blink visible:開顯示，光標不閃爍
  36.               CALL wrcmd
  37.               MOV R7,#2
  38. loop2: MOV DPTR,#string1a
  39.               CALL wrstr
  40.               MOV DPTR,#200
  41.               CALL wtms
  42.               MOV A,#LCD_CLS                                          ;Clear screen
  43.               CALL wrcmd
  44.               MOV DPTR,#string1b
  45.               CALL wrstr
  46.               MOV DPTR,#200
  47.               CALL wtms
  48.               MOV A, #LCD_CLS              ;Clear screen
  49.               CALL wrcmd
  50.               DJNZ R7,loop2
  51.               MOV DPTR,#string1a
  52.               CALL wrstr
  53.               MOV DPTR,#400
  54.               CALL wtms
  55.               MOV A,#LCD_SETDDADDR+64
  56.               CALL wrcmd
  57.               MOV DPTR,#string2
  58.               CALL wrslow
  59.               MOV DPTR,#200
  60.               CALL wtms
  61.               MOV A,#LCD_CLS              ;Clear screen
  62.               CALL wrcmd
  63.               MOV DPTR,#string3
  64.               CALL wrslow
  65.     MOV A,#LCD_SETDDADDR+64
  66.               CALL wrcmd
  67.               MOV DPTR,#string4
  68.               CALL wrslow
  69. MOV A,#LCD_SETVISIBLE+7              ;Show the //blink cursor as well.
  70.               CALL wrcmd
  71.               MOV DPTR,#2000
  72.               CALL wtms
  73.               MOV A,#LCD_CLS                                          ;Clear screen
  74.               CALL wrcmd
  75.               JMP loop
  76. ;Sub routine to write null terminated string at DPTR in program ram.
  77. wrstr:              MOV R0,#LCD_DATA_WR
  78. wrstr1:              CLR A
  79.               MOVC A,@A+DPTR
  80.               JZ wrstr2
  81.               MOVX @R0,A
  82.               CALL wtbusy
  83.               INC DPTR
  84.               PUSH DPL
  85.               PUSH DPH
  86.               POP DPH
  87.               POP DPL            
  88.               JMP wrstr1
  89. wrstr2:              RET
  90. ;Sub routine to write null terminated string at DPTR in program ram. Slowly
  91. wrslow:              MOV R0,#LCD_DATA_WR
  92. wrslw1:              CLR A
  93.               MOVc A,@A+DPTR
  94.               JZ wrslw2
  95.               MOVX @R0,A
  96.               CALL wtbusy
  97.               INC DPTR
  98.               PUSH DPL
  99.               PUSH DPH
  100.     MOV DPTR,#100
  101.     CALL wtms
  102.               POP DPH
  103.               POP DPL            
  104.               JMP wrslw1
  105. wrslw2:              RET
  106. ;Sub routine to write command:
  107. wrcmd:              MOV R0,#LCD_CMD_WR
  108.               MOVX @R0,A
  109.               JMP wtbusy
  110. ;Sub routine to write character:
  111. wrchar:              MOV R0,#LCD_DATA_WR
  112.               MOVX @R0,A
  113. ;Subroutine to wait for busy clear
  114. wtbusy: MOV R1,#LCD_BUSY_RD
  115.               MOVX A,@r1
  116.               JB ACC.7,wtbusy
  117.               RET
  118. ;Wait for number of seconds in A
  119. wtsec:              PUSH ACC
  120.               CALL wtms
  121.               POP ACC
  122.               DEC A
  123.               JNZ wtsec
  124.               RET

  126. ;Wait for number of milliseconds in DPTR
  127. wtms:   XRL DPL,#0FFh                                          ;Can't do DEC DPTR, so do the loop by forming 2's complement
  128.               XRL DPH,#0FFh;and INCrementing instead.
  129.               INC DPTR
  130. wtms1:MOV TL0,#09Ch              ;100 ticks before overflow = 1ms at 1.2MHz Clock
  131.                 MOV TH0,#0FFh            
  132.                 MOV TMOD,#1                                          ;Timer 0 mode 1
  133.               SETB TCON.4                                          ;Timer 0 runs
  134. wtms2:              JNB TCON.5,wtms2            
  135.               CLR TCON.4                                          ;Timer 0 stops
  136.               CLR TCON.5
  137.               INC DPTR
  138.               MOV A,DPL
  139.               ORL A,DPH
  140.               JNZ wtms1
  141.               RET
  142.               END
復制代碼



完整的Word格式文檔51黑下載地址：
51單片機匯編語言及C語言經典實例.doc (2.68 MB, 下載次數: 53)



評分

參與人數 1黑幣 +50 收起 理由
admin + 50 共享資料的黑幣獎勵！

查看全部評分

回復

使用道具 舉報

ID:93809 發表于 2018-12-28 12:23 | 顯示全部樓層
謝謝提供資料分享贊一個
回復

使用道具 舉報

ID:298008 發表于 2019-12-21 20:03 | 顯示全部樓層
謝謝樓主分享！！
回復

使用道具 舉報

您需要登錄后才可以回帖 登錄 | 立即注冊

本版積分規則

小黑屋|51黑電子論壇 |51黑電子論壇6群 QQ 管理員QQ:125739409;技術交流QQ群281945664

Powered by 單片機教程網

快速回復 返回頂部 返回列表
主站蜘蛛池模板： 国产精品久久久久一区二区三区 | 黄色大片免费网站 | 国产乱码精品1区2区3区 | 一级视频在线免费观看 | 欧美黄色一级毛片 | 国产精品日产欧美久久久久 | 一级毛片在线播放 | 国产精久久久久久久 | 国产精品99一区二区 | 亚洲欧美精品 | 无码一区二区三区视频 | 天天天操 | 欧美视频区 | 本道综合精品 | 午夜精品在线观看 | 一区二区三区成人 | 老外黄色一级片 | 四虎影音 | 日韩在线不卡 | wwwxxx国产| 精品美女在线观看视频在线观看 | 99tv| 国产激情视频在线免费观看 | www.五月天婷婷.com | 精品国产视频 | 免费黄色的视频 | 色.com| 人人鲁人人莫人人爱精品 | 免费国产视频 | 亚洲视频三区 | 成人在线播放 | 国产精品国产成人国产三级 | 亚洲欧美中文日韩在线v日本 | 精品一区二区三区在线观看 | 精品一区二区久久久久久久网站 | 成人在线影视 | 国产一区二区av | 日韩高清不卡 | 国产区在线观看 | 玖玖视频国产 | 91久久北条麻妃一区二区三区 |