emu51.h 4.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250
  1. #define bit0 0x01
  2. #define bit1 0x02
  3. #define bit2 0x04
  4. #define bit3 0x08
  5. #define bit4 0x10
  6. #define bit5 0x20
  7. #define bit6 0x40
  8. #define bit7 0x80
  9. typedef unsigned char BYTE;
  10. typedef unsigned short int WORD;
  11. BYTE SFR[0x100]; // internal memory and sfr area 256 bytes
  12. BYTE EXT_RAM[0x10000]; // external memory 64kB
  13. BYTE *Acc = &SFR[0xe0]; // 8-bit accumlator
  14. WORD *DPTR = (WORD *) &SFR[0x82]; // 16-bit register
  15. BYTE *DPH = &SFR[0x83]; // high byte of DPTR
  16. BYTE *DPL = &SFR[0x82]; // low byte of DPTR
  17. BYTE *B = &SFR[0xf0]; // B register
  18. BYTE *SP = &SFR[0x81]; // Stack Pointer
  19. BYTE *PSW = &SFR[0xd0]; // Program Status Word
  20. BYTE *P0 = &SFR[0x80]; // Port one
  21. BYTE *P1 = &SFR[0x90]; //
  22. BYTE *P2 = &SFR[0xa0]; //
  23. BYTE *P3 = &SFR[0xb0]; //
  24. BYTE *SBUF = &SFR[0x99]; //
  25. BYTE *IE = &SFR[0xa8]; //
  26. BYTE *SCON = &SFR[0x98]; //
  27. BYTE *TH1 = &SFR[0x8d]; //
  28. BYTE *TH0 = &SFR[0x8c]; //
  29. BYTE *TL1 = &SFR[0x8b]; //
  30. BYTE *TL0 = &SFR[0x8a]; //
  31. BYTE *TMOD = &SFR[0x89]; //
  32. BYTE *TCON = &SFR[0x88]; //
  33. BYTE *PCON = &SFR[0x87]; //
  34. BYTE *R = &SFR[0x00]; //
  35. WORD PC = 0x0000; //
  36. // initialize emulator
  37. void init_8051(void)
  38. {
  39. *Acc = 0;
  40. *DPTR = 0;
  41. *P1 = 0xff;
  42. PC = 0x0000;
  43. *SP = 0x07;
  44. }
  45. BYTE check_C(void)
  46. {
  47. if ( *PSW & bit7 )
  48. {
  49. return 1;
  50. }
  51. else
  52. {
  53. return 0;
  54. }
  55. }
  56. BYTE check_AC(void)
  57. {
  58. if ( *PSW & bit6 )
  59. {
  60. return 1;
  61. }
  62. else
  63. {
  64. return 0;
  65. }
  66. }
  67. BYTE check_OV(void)
  68. {
  69. if ( *PSW & bit2 )
  70. {
  71. return 1;
  72. }
  73. else
  74. {
  75. return 0;
  76. }
  77. }
  78. void set_C(void)
  79. {
  80. *PSW = *PSW | bit7;
  81. }
  82. void set_AC(void)
  83. {
  84. *PSW = *PSW | bit6;
  85. }
  86. void set_OV(void)
  87. {
  88. *PSW = *PSW | bit2;
  89. }
  90. void clr_C(void)
  91. {
  92. *PSW = *PSW & 0x7f;
  93. }
  94. void clr_AC(void)
  95. {
  96. *PSW = *PSW & 0xbf;
  97. }
  98. void clr_OV(void)
  99. {
  100. *PSW = *PSW & 0xfb;
  101. }
  102. BYTE check_P(void)
  103. {
  104. if ( *PSW & bit0 )
  105. {
  106. return 1;
  107. }
  108. else
  109. {
  110. return 0;
  111. }
  112. }
  113. void set_P(void)
  114. {
  115. *PSW = *PSW | bit0;
  116. }
  117. void clr_P(void)
  118. {
  119. *PSW = *PSW & 0xfe;
  120. }
  121. void setB(BYTE bit)
  122. {
  123. BYTE tmpB;
  124. BYTE tmpbit;
  125. tmpbit = bit & 0xf8;
  126. tmpB = bit & 0x07;
  127. if ( bit >= 128 )
  128. {
  129. // bit set in SFR area
  130. SFR[tmpB] = SFR[tmpB] | ( 1 << tmpbit );
  131. }
  132. else
  133. {
  134. // bit set in int. RAM
  135. tmpB = ( tmpB >> 3 ) + 32;
  136. SFR[tmpB] = SFR[tmpB] | ( 1 << tmpbit );
  137. }
  138. }
  139. void clrB(BYTE bit)
  140. {
  141. BYTE tmpB;
  142. BYTE tmpbit;
  143. tmpbit = bit & 0xf8;
  144. tmpB = bit & 0x07;
  145. if ( bit >= 128 )
  146. {
  147. // bit clear in SFR area
  148. SFR[tmpB] = SFR[tmpB] & ~( 1 << tmpbit );
  149. }
  150. else
  151. {
  152. // bit clear in int. RAM
  153. tmpB = ( tmpB >> 3 ) + 32;
  154. SFR[tmpB] = SFR[tmpB] & ~( 1 << tmpbit );
  155. }
  156. }
  157. BYTE checkB(BYTE bit)
  158. {
  159. BYTE tmpB;
  160. BYTE tmpbit;
  161. tmpbit = bit & 0xf8;
  162. tmpB = bit & 0x07;
  163. if ( bit >= 128 )
  164. {
  165. // bit chack in SFR area
  166. if ( SFR[tmpB] & ~( 1 << tmpbit ))
  167. {
  168. return 1;
  169. }
  170. else
  171. {
  172. return 0;
  173. }
  174. }
  175. else
  176. {
  177. // bit check in int. RAM
  178. tmpB = ( tmpB >> 3 ) + 32;
  179. if ( SFR[tmpB] & ~( 1 << tmpbit ))
  180. {
  181. return true;
  182. }
  183. else
  184. {
  185. return false;
  186. }
  187. }
  188. }
  189. BYTE check_RS0(void)
  190. {
  191. if ( *PSW & bit3 )
  192. {
  193. return 1;
  194. }
  195. else
  196. {
  197. return 0;
  198. }
  199. }
  200. void set_RS0(void)
  201. {
  202. *PSW = *PSW | bit3;
  203. }
  204. void clr_RS0(void)
  205. {
  206. *PSW = *PSW & 0xf7;
  207. }
  208. BYTE check_RS1(void)
  209. {
  210. if ( *PSW & bit4 )
  211. {
  212. return 1;
  213. }
  214. else
  215. {
  216. return 0;
  217. }
  218. }
  219. void set_RS1(void)
  220. {
  221. *PSW = *PSW | bit4;
  222. }
  223. void clr_RS1(void)
  224. {
  225. *PSW = *PSW & 0xef;
  226. }