Advertisement
Guest User

Untitled

a guest
Dec 12th, 2019
90
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 6.46 KB | None | 0 0
  1. //input for ROM
  2. int IN_1 = 0; //LSB
  3. int IN_2 = 1;
  4. int IN_3 = 2;
  5. int IN_4 = 3;
  6.  
  7. //output from ROM
  8. int OUT_1 = 4; //LSB
  9. int OUT_2 = 5;
  10. int OUT_3 = 6;
  11. int OUT_4 = 7;
  12. int OUT_5 = 8;
  13. int OUT_6 = 9;
  14. int OUT_7 = 10;
  15. int OUT_8 = 11;
  16.  
  17. //output for seg decoder
  18. int OUTPUT1 = A0; //LSB
  19. int OUTPUT2 = A1;
  20. int OUTPUT3 = A2;
  21. int OUTPUT4 = A3;
  22.  
  23. int counter = 0;
  24.  
  25. void setup() {
  26. Serial.begin(9600);
  27. pinMode(IN_1, OUTPUT);
  28. pinMode(IN_2, OUTPUT);
  29. pinMode(IN_3, OUTPUT);
  30. pinMode(IN_4, OUTPUT);
  31. pinMode(OUT_1, INPUT);
  32. pinMode(OUT_2, INPUT);
  33. pinMode(OUT_3, INPUT);
  34. pinMode(OUT_4, INPUT);
  35. pinMode(OUT_5, INPUT);
  36. pinMode(OUT_6, INPUT);
  37. pinMode(OUT_7, INPUT);
  38. pinMode(OUT_8, INPUT);
  39. pinMode(OUTPUT1, OUTPUT);
  40. pinMode(OUTPUT2, OUTPUT);
  41. pinMode(OUTPUT3, OUTPUT);
  42. pinMode(OUTPUT4, OUTPUT);
  43. }
  44.  
  45. void loop() {
  46.  
  47. checkROM();
  48.  
  49. Serial.print("COUNTER: ");
  50. Serial.println(counter);
  51. int input1, input2, input3, input4;
  52. switch(counter){
  53. case 0:
  54. input1 = 0;
  55. input2 = 0;
  56. input3 = 0;
  57. input4 = 0;
  58.  
  59. break;
  60. case 1:
  61. input1 = 1;
  62. input2 = 0;
  63. input3 = 0;
  64. input4 = 0;
  65. break;
  66. case 2:
  67. input1 = 0;
  68. input2 = 1;
  69. input3 = 0;
  70. input4 = 0;
  71. break;
  72. case 3:
  73. input1 = 1;
  74. input2 = 1;
  75. input3 = 0;
  76. input4 = 0;
  77. break;
  78. case 4:
  79. input1 = 0;
  80. input2 = 0;
  81. input3 = 1;
  82. input4 = 0;
  83. break;
  84. case 5:
  85. input1 = 1;
  86. input2 = 0;
  87. input3 = 1;
  88. input4 = 0;
  89. break;
  90. case 6:
  91. input1 = 0;
  92. input2 = 1;
  93. input3 = 1;
  94. input4 = 0;
  95. break;
  96. case 7:
  97. input1 = 1;
  98. input2 = 1;
  99. input3 = 1;
  100. input4 = 0;
  101. break;
  102. }
  103.  
  104. digitalWrite(IN_4, input4);
  105. digitalWrite(IN_3, input3);
  106. digitalWrite(IN_2, input2);
  107. digitalWrite(IN_1, input1);
  108.  
  109. Serial.print("Input address: ");
  110. Serial.print(input4);
  111. Serial.print(input3);
  112. Serial.print(input2);
  113. Serial.println(input1);
  114.  
  115. checkROM();
  116.  
  117. delay(500);
  118.  
  119. checkROM();
  120. //get address from D region
  121. int add_1 = digitalRead(OUT_1);
  122. int add_2 = digitalRead(OUT_2);
  123. int add_3 = digitalRead(OUT_3);
  124.  
  125. Serial.print("D-region address: ");
  126. Serial.print(add_3);
  127. Serial.print(add_2);
  128. Serial.println(add_1);
  129.  
  130. // get operation (two bits)
  131. // massave ba to? yep
  132. int op_1 = digitalRead(OUT_4);
  133. int op_2 = digitalRead(OUT_5);
  134.  
  135. Serial.print("Operation: ");
  136. Serial.print(op_2);
  137. Serial.println(op_1);
  138.  
  139. //set address of D-region
  140. digitalWrite(IN_4, HIGH);
  141. digitalWrite(IN_3, add_3);
  142. digitalWrite(IN_2, add_2);
  143. digitalWrite(IN_1, add_1);
  144.  
  145. Serial.print("D-region address: ");
  146. Serial.print("1");
  147. Serial.print(add_3);
  148. Serial.print(add_2);
  149. Serial.println(add_1);
  150.  
  151. Serial.print("D-region");
  152. checkROM();
  153.  
  154. //get four bit outputs
  155. int output_1; //lsb
  156. int output_2;
  157. int output_3;
  158. int output_4;
  159.  
  160. // delay(250);
  161.  
  162. if(op_2 == HIGH){
  163.  
  164. //LSB
  165. int carry = LOW;
  166. if(digitalRead(OUT_5) == HIGH && digitalRead(OUT_1) == HIGH){
  167. output_1 = LOW;
  168. carry = HIGH;
  169. } else if((digitalRead(OUT_5) == HIGH && digitalRead(OUT_1) == LOW) ||
  170. (digitalRead(OUT_5) == LOW && digitalRead(OUT_1) == HIGH)){
  171. output_1 == HIGH;
  172. } else { //both are LOW
  173. output_1 = LOW;
  174. }
  175.  
  176. //2ND SB
  177. if(digitalRead(OUT_6) == HIGH && digitalRead(OUT_2) == HIGH){
  178. if(carry = HIGH){
  179. output_2 = HIGH;
  180. } else{
  181. output_2 = LOW;
  182. }
  183. carry = HIGH;
  184. } else if((digitalRead(OUT_6) == HIGH && digitalRead(OUT_2) == LOW) ||
  185. (digitalRead(OUT_6) == LOW && digitalRead(OUT_2) == HIGH)){
  186. if(carry = HIGH){
  187. output_2 = LOW;
  188. carry = HIGH;
  189. } else{
  190. output_2 = HIGH;
  191. carry = LOW;
  192. }
  193. } else { //both are LOW
  194. if(carry = HIGH){
  195. output_2 = HIGH;
  196. carry = LOW;
  197. } else{
  198. output_2 = LOW;
  199. carry = LOW;
  200. }
  201. }
  202. //3RD SB
  203. if(digitalRead(OUT_7) == HIGH && digitalRead(OUT_3) == HIGH){
  204. if(carry = HIGH){
  205. output_3 = HIGH;
  206. } else{
  207. output_3 = LOW;
  208. }
  209. carry = HIGH;
  210. } else if((digitalRead(OUT_7) == HIGH && digitalRead(OUT_3) == LOW) ||
  211. (digitalRead(OUT_7) == LOW && digitalRead(OUT_3) == HIGH)){
  212. if(carry = HIGH){
  213. output_3 = LOW;
  214. carry = HIGH;
  215. } else{
  216. output_3 = HIGH;
  217. carry = LOW;
  218. }
  219. } else { //both are LOW
  220. if(carry = HIGH){
  221. output_3 = HIGH;
  222. carry = LOW;
  223. } else{
  224. output_3 = LOW;
  225. carry = LOW;
  226. }
  227. }
  228.  
  229. //4TH SB
  230. if(digitalRead(OUT_8) == HIGH && digitalRead(OUT_4) == HIGH){
  231. if(carry = HIGH){
  232. output_4 = HIGH;
  233. } else{
  234. output_4 = LOW;
  235. }
  236. carry = HIGH;
  237. } else if((digitalRead(OUT_8) == HIGH && digitalRead(OUT_4) == LOW) ||
  238. (digitalRead(OUT_8) == LOW && digitalRead(OUT_4) == HIGH)){
  239. if(carry = HIGH){
  240. output_4 = LOW;
  241. carry = HIGH;
  242. } else{
  243. output_4 = HIGH;
  244. carry = LOW;
  245. }
  246. } else { //both are LOW
  247. if(carry = HIGH){
  248. output_4 = HIGH;
  249. carry = LOW;
  250. } else{
  251. output_4 = LOW;
  252. carry = LOW;
  253. }
  254. }
  255. }
  256.  
  257. if(op_2 == LOW && op_1 == LOW){
  258. output_1 = digitalRead(OUT_5);
  259. output_2 = digitalRead(OUT_6);
  260. output_3 = digitalRead(OUT_7);
  261. output_4 = digitalRead(OUT_8);
  262. } else if (op_2 == LOW && op_1 == HIGH){
  263. output_1 = digitalRead(OUT_1);
  264. output_2 = digitalRead(OUT_2);
  265. output_3 = digitalRead(OUT_3);
  266. output_4 = digitalRead(OUT_4);
  267. }
  268.  
  269. checkROM();
  270.  
  271. //display outputs
  272. digitalWrite(OUTPUT4, output_4);
  273. digitalWrite(OUTPUT3, output_3);
  274. digitalWrite(OUTPUT2, output_2);
  275. digitalWrite(OUTPUT1, output_1);
  276.  
  277.  
  278. counter++;
  279. if(counter > 7) counter = 0;
  280. delay(500);
  281. }
  282.  
  283. void checkROM(){
  284. Serial.print("ROM OUTPUTS: ");
  285. Serial.print(digitalRead(OUT_8));
  286. Serial.print(digitalRead(OUT_7));
  287. Serial.print(digitalRead(OUT_6));
  288. Serial.print(digitalRead(OUT_5));
  289. Serial.print(digitalRead(OUT_4));
  290. Serial.print(digitalRead(OUT_3));
  291. Serial.print(digitalRead(OUT_2));
  292. Serial.print(digitalRead(OUT_1));
  293. Serial.println();
  294. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement