API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jul 18th, 2018
66
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 9.08 KB | None | 0 0
raw download clone embed print report
  1. //Reads 8x8 multiplex with 2 multiplexors
  2. //Multiplex test code by Antonin Gazda
  3.  
  4. const int pinIO = 9;
  5. const int pinA1 = 10;
  6. const int pinB1 = 11;
  7. const int pinC1 = 12;
  8.  
  9. const int pinA2 = 13;
  10. const int pinB2 = A0;
  11. const int pinC2 = A1;
  12.  
  13. int a0 ,a1 , a2, a3, a4, a5, a6, a7;
  14. int b0 ,b1 , b2, b3, b4, b5, b6, b7;
  15. int c0 ,c1 , c2, c3, c4, c5, c6, c7;
  16. int d0 ,d1 , d2, d3, d4, d5, d6, d7;
  17. int e0 ,e1 , e2, e3, e4, e5, e6, e7;
  18. int f0 ,f1 , f2, f3, f4, f5, f6, f7;
  19. int g0 ,g1 , g2, g3, g4, g5, g6, g7;
  20. int h0 ,h1 , h2, h3, h4, h5, h6, h7;
  21.  
  22. void setup() {
  23. pinMode(pinA1, OUTPUT);
  24. pinMode(pinB1, OUTPUT);
  25. pinMode(pinC1, OUTPUT);
  26. pinMode(pinIO, INPUT_PULLUP);
  27.  
  28. pinMode(pinA2, OUTPUT);
  29. pinMode(pinB2, OUTPUT);
  30. pinMode(pinC2, OUTPUT);
  31.  
  32. Serial.begin(9600);
  33. }
  34.  
  35. void checkState(){
  36. //set Multiplex to binary 0
  37. digitalWrite(pinA2 , LOW);
  38. digitalWrite(pinB2, LOW);
  39. digitalWrite(pinC2, LOW);
  40.  
  41. digitalWrite(pinA1, LOW);
  42. digitalWrite(pinB1, LOW);
  43. digitalWrite(pinC1, LOW);
  44. a0 = digitalRead(pinIO);
  45.  
  46. digitalWrite(pinA1, HIGH);
  47. digitalWrite(pinB1, LOW);
  48. digitalWrite(pinC1, LOW);
  49. a1 =! digitalRead(pinIO);
  50. digitalWrite(pinA1, LOW);
  51. digitalWrite(pinB1, HIGH);
  52. digitalWrite(pinC1, LOW);
  53. a2 =! digitalRead(pinIO);
  54. digitalWrite(pinA1, HIGH);
  55. digitalWrite(pinB1, HIGH);
  56. digitalWrite(pinC1, LOW);
  57. a3 =! digitalRead(pinIO);
  58. digitalWrite(pinA1, LOW);
  59. digitalWrite(pinB1, LOW);
  60. digitalWrite(pinC1, HIGH);
  61. a4 =! digitalRead(pinIO);
  62. digitalWrite(pinA1, HIGH);
  63. digitalWrite(pinB1, LOW);
  64. digitalWrite(pinC1, HIGH);
  65. a5 =! digitalRead(pinIO);
  66. digitalWrite(pinA1, LOW);
  67. digitalWrite(pinB1, HIGH);
  68. digitalWrite(pinC1, HIGH);
  69. a6 =! digitalRead(pinIO);
  70. digitalWrite(pinA1, HIGH);
  71. digitalWrite(pinB1, HIGH);
  72. digitalWrite(pinC1, HIGH);
  73. a7 =! digitalRead(pinIO);
  74. //set Multiplex to binary 1
  75. digitalWrite(pinA2, HIGH);
  76. digitalWrite(pinB2, LOW);
  77. digitalWrite(pinC2, LOW);
  78.  
  79. digitalWrite(pinA1, LOW);
  80. digitalWrite(pinB1, LOW);
  81. digitalWrite(pinC1, LOW);
  82. b1 =! digitalRead(pinIO);
  83. digitalWrite(pinA1, HIGH);
  84. digitalWrite(pinB1, LOW);
  85. digitalWrite(pinC1, LOW);
  86. b2 =! digitalRead(pinIO);
  87. digitalWrite(pinA1, LOW);
  88. digitalWrite(pinB1, HIGH);
  89. digitalWrite(pinC1, LOW);
  90. b3 =! digitalRead(pinIO);
  91. digitalWrite(pinA1, HIGH);
  92. digitalWrite(pinB1, HIGH);
  93. digitalWrite(pinC1, LOW);
  94. b4 =! digitalRead(pinIO);
  95. digitalWrite(pinA1, HIGH);
  96. digitalWrite(pinB1, LOW);
  97. digitalWrite(pinC1, HIGH);
  98. b5 =! digitalRead(pinIO);
  99. digitalWrite(pinA1, LOW);
  100. digitalWrite(pinB1, HIGH);
  101. digitalWrite(pinC1, HIGH);
  102. b6 =! digitalRead(pinIO);
  103. digitalWrite(pinA1, HIGH);
  104. digitalWrite(pinB1, HIGH);
  105. digitalWrite(pinC1, HIGH);
  106. b7 =! digitalRead(pinIO);
  107. //set Multiplex to binary 2
  108. digitalWrite(pinA2, LOW);
  109. digitalWrite(pinB2, HIGH);
  110. digitalWrite(pinC2, LOW);
  111.  
  112. digitalWrite(pinA1, LOW);
  113. digitalWrite(pinB1, LOW);
  114. digitalWrite(pinC1, LOW);
  115. c1 =! digitalRead(pinIO);
  116. digitalWrite(pinA1, HIGH);
  117. digitalWrite(pinB1, LOW);
  118. digitalWrite(pinC1, LOW);
  119. c2 =! digitalRead(pinIO);
  120. digitalWrite(pinA1, LOW);
  121. digitalWrite(pinB1, HIGH);
  122. digitalWrite(pinC1, LOW);
  123. c3 =! digitalRead(pinIO);
  124. digitalWrite(pinA1, HIGH);
  125. digitalWrite(pinB1, HIGH);
  126. digitalWrite(pinC1, LOW);
  127. c4 =! digitalRead(pinIO);
  128. digitalWrite(pinA1, HIGH);
  129. digitalWrite(pinB1, LOW);
  130. digitalWrite(pinC1, HIGH);
  131. c5 =! digitalRead(pinIO);
  132. digitalWrite(pinA1, LOW);
  133. digitalWrite(pinB1, HIGH);
  134. digitalWrite(pinC1, HIGH);
  135. c6 =! digitalRead(pinIO);
  136. digitalWrite(pinA1, HIGH);
  137. digitalWrite(pinB1, HIGH);
  138. digitalWrite(pinC1, HIGH);
  139. c7 =! digitalRead(pinIO);
  140.  
  141. //set Multiplex to binary 3
  142. digitalWrite(pinA2, HIGH);
  143. digitalWrite(pinB2, HIGH);
  144. digitalWrite(pinC2, LOW);
  145.  
  146. digitalWrite(pinA1, LOW);
  147. digitalWrite(pinB1, LOW);
  148. digitalWrite(pinC1, LOW);
  149. d1 =! digitalRead(pinIO);
  150. digitalWrite(pinA1, HIGH);
  151. digitalWrite(pinB1, LOW);
  152. digitalWrite(pinC1, LOW);
  153. d2 =! digitalRead(pinIO);
  154. digitalWrite(pinA1, LOW);
  155. digitalWrite(pinB1, HIGH);
  156. digitalWrite(pinC1, LOW);
  157. d3 =! digitalRead(pinIO);
  158. digitalWrite(pinA1, HIGH);
  159. digitalWrite(pinB1, HIGH);
  160. digitalWrite(pinC1, LOW);
  161. d4 =! digitalRead(pinIO);
  162. digitalWrite(pinA1, HIGH);
  163. digitalWrite(pinB1, LOW);
  164. digitalWrite(pinC1, HIGH);
  165. d5 =! digitalRead(pinIO);
  166. digitalWrite(pinA1, LOW);
  167. digitalWrite(pinB1, HIGH);
  168. digitalWrite(pinC1, HIGH);
  169. d6 =! digitalRead(pinIO);
  170. digitalWrite(pinA1, HIGH);
  171. digitalWrite(pinB1, HIGH);
  172. digitalWrite(pinC1, HIGH);
  173. d7 =! digitalRead(pinIO);
  174.  
  175. //set Multiplex to binary 4
  176. digitalWrite(pinA2, LOW);
  177. digitalWrite(pinB2, LOW);
  178. digitalWrite(pinC2, HIGH);
  179.  
  180. digitalWrite(pinA1, LOW);
  181. digitalWrite(pinB1, LOW);
  182. digitalWrite(pinC1, LOW);
  183. e1 =! digitalRead(pinIO);
  184. digitalWrite(pinA1, HIGH);
  185. digitalWrite(pinB1, LOW);
  186. digitalWrite(pinC1, LOW);
  187. e2 =! digitalRead(pinIO);
  188. digitalWrite(pinA1, LOW);
  189. digitalWrite(pinB1, HIGH);
  190. digitalWrite(pinC1, LOW);
  191. e3 =! digitalRead(pinIO);
  192. digitalWrite(pinA1, HIGH);
  193. digitalWrite(pinB1, HIGH);
  194. digitalWrite(pinC1, LOW);
  195. e4 =! digitalRead(pinIO);
  196. digitalWrite(pinA1, HIGH);
  197. digitalWrite(pinB1, LOW);
  198. digitalWrite(pinC1, HIGH);
  199. e5 =! digitalRead(pinIO);
  200. digitalWrite(pinA1, LOW);
  201. digitalWrite(pinB1, HIGH);
  202. digitalWrite(pinC1, HIGH);
  203. e6 =! digitalRead(pinIO);
  204. digitalWrite(pinA1, HIGH);
  205. digitalWrite(pinB1, HIGH);
  206. digitalWrite(pinC1, HIGH);
  207. e7 =! digitalRead(pinIO);
  208.  
  209. //set Multiplex to binary 5
  210. digitalWrite(pinA2, HIGH);
  211. digitalWrite(pinB2, LOW);
  212. digitalWrite(pinC2, HIGH);
  213.  
  214. digitalWrite(pinA1, LOW);
  215. digitalWrite(pinB1, LOW);
  216. digitalWrite(pinC1, LOW);
  217. f1 =! digitalRead(pinIO);
  218. digitalWrite(pinA1, HIGH);
  219. digitalWrite(pinB1, LOW);
  220. digitalWrite(pinC1, LOW);
  221. f2 =! digitalRead(pinIO);
  222. digitalWrite(pinA1, LOW);
  223. digitalWrite(pinB1, HIGH);
  224. digitalWrite(pinC1, LOW);
  225. f3 =! digitalRead(pinIO);
  226. digitalWrite(pinA1, HIGH);
  227. digitalWrite(pinB1, HIGH);
  228. digitalWrite(pinC1, LOW);
  229. f4 =! digitalRead(pinIO);
  230. digitalWrite(pinA1, HIGH);
  231. digitalWrite(pinB1, LOW);
  232. digitalWrite(pinC1, HIGH);
  233. f5 =! digitalRead(pinIO);
  234. digitalWrite(pinA1, LOW);
  235. digitalWrite(pinB1, HIGH);
  236. digitalWrite(pinC1, HIGH);
  237. f6 =! digitalRead(pinIO);
  238. digitalWrite(pinA1, HIGH);
  239. digitalWrite(pinB1, HIGH);
  240. digitalWrite(pinC1, HIGH);
  241. f7 =! digitalRead(pinIO);
  242.  
  243. //set Multiplex to binary 6
  244. digitalWrite(pinA2, LOW);
  245. digitalWrite(pinB2, HIGH);
  246. digitalWrite(pinC2, HIGH);
  247.  
  248. digitalWrite(pinA1, LOW);
  249. digitalWrite(pinB1, LOW);
  250. digitalWrite(pinC1, LOW);
  251. g1 =! digitalRead(pinIO);
  252. digitalWrite(pinA1, HIGH);
  253. digitalWrite(pinB1, LOW);
  254. digitalWrite(pinC1, LOW);
  255. g2 =! digitalRead(pinIO);
  256. digitalWrite(pinA1, LOW);
  257. digitalWrite(pinB1, HIGH);
  258. digitalWrite(pinC1, LOW);
  259. g3 =! digitalRead(pinIO);
  260. digitalWrite(pinA1, HIGH);
  261. digitalWrite(pinB1, HIGH);
  262. digitalWrite(pinC1, LOW);
  263. g4 =! digitalRead(pinIO);
  264. digitalWrite(pinA1, HIGH);
  265. digitalWrite(pinB1, LOW);
  266. digitalWrite(pinC1, HIGH);
  267. g5 =! digitalRead(pinIO);
  268. digitalWrite(pinA1, LOW);
  269. digitalWrite(pinB1, HIGH);
  270. digitalWrite(pinC1, HIGH);
  271. g6 =! digitalRead(pinIO);
  272. digitalWrite(pinA1, HIGH);
  273. digitalWrite(pinB1, HIGH);
  274. digitalWrite(pinC1, HIGH);
  275. g7 =! digitalRead(pinIO);
  276.  
  277. //set Multiplex to binary 7
  278. digitalWrite(pinA2, HIGH);
  279. digitalWrite(pinB2, HIGH);
  280. digitalWrite(pinC2, HIGH);
  281.  
  282. digitalWrite(pinA1, LOW);
  283. digitalWrite(pinB1, LOW);
  284. digitalWrite(pinC1, LOW);
  285. h1 =! digitalRead(pinIO);
  286. digitalWrite(pinA1, HIGH);
  287. digitalWrite(pinB1, LOW);
  288. digitalWrite(pinC1, LOW);
  289. h2 =! digitalRead(pinIO);
  290. digitalWrite(pinA1, LOW);
  291. digitalWrite(pinB1, HIGH);
  292. digitalWrite(pinC1, LOW);
  293. h3 =! digitalRead(pinIO);
  294. digitalWrite(pinA1, HIGH);
  295. digitalWrite(pinB1, HIGH);
  296. digitalWrite(pinC1, LOW);
  297. h4 =! digitalRead(pinIO);
  298. digitalWrite(pinA1, HIGH);
  299. digitalWrite(pinB1, LOW);
  300. digitalWrite(pinC1, HIGH);
  301. h5 =! digitalRead(pinIO);
  302. digitalWrite(pinA1, LOW);
  303. digitalWrite(pinB1, HIGH);
  304. digitalWrite(pinC1, HIGH);
  305. h6 =! digitalRead(pinIO);
  306. digitalWrite(pinA1, HIGH);
  307. digitalWrite(pinB1, HIGH);
  308. digitalWrite(pinC1, HIGH);
  309. h7 =! digitalRead(pinIO);
  310. }
  311.  
  312. void serialPrintAll(){
  313. Serial.print(a0);
  314. Serial.print(a1);
  315. Serial.print(a2);
  316. Serial.print(a3);
  317. Serial.print(a4);
  318. Serial.print(a5);
  319. Serial.print(a6);
  320. Serial.println(a7);
  321.  
  322. Serial.print(b0);
  323. Serial.print(b1);
  324. Serial.print(b2);
  325. Serial.print(b3);
  326. Serial.print(b4);
  327. Serial.print(b5);
  328. Serial.print(b6);
  329. Serial.println(b7);
  330.  
  331. Serial.print(c0);
  332. Serial.print(c1);
  333. Serial.print(c2);
  334. Serial.print(c3);
  335. Serial.print(c4);
  336. Serial.print(c5);
  337. Serial.print(c6);
  338. Serial.println(c7);
  339.  
  340. Serial.print(d0);
  341. Serial.print(d1);
  342. Serial.print(d2);
  343. Serial.print(d3);
  344. Serial.print(d4);
  345. Serial.print(d5);
  346. Serial.print(d6);
  347. Serial.println(d7);
  348.  
  349. Serial.print(e0);
  350. Serial.print(e1);
  351. Serial.print(e2);
  352. Serial.print(e3);
  353. Serial.print(e4);
  354. Serial.print(e5);
  355. Serial.print(e6);
  356. Serial.println(e7);
  357.  
  358. Serial.print(f0);
  359. Serial.print(f1);
  360. Serial.print(f2);
  361. Serial.print(f3);
  362. Serial.print(f4);
  363. Serial.print(f5);
  364. Serial.print(f6);
  365. Serial.println(f7);
  366.  
  367. Serial.print(g0);
  368. Serial.print(g1);
  369. Serial.print(g2);
  370. Serial.print(g3);
  371. Serial.print(g4);
  372. Serial.print(g5);
  373. Serial.print(g6);
  374. Serial.println(g7);
  375.  
  376. Serial.print(h0);
  377. Serial.print(h1);
  378. Serial.print(h2);
  379. Serial.print(h3);
  380. Serial.print(h4);
  381. Serial.print(h5);
  382. Serial.print(h6);
  383. Serial.println(h7);
  384. }
  385.  
  386. void loop() {
  387. serialPrintAll();
  388. checkState();
  389. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!