API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 27th, 2015
87
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 12.21 KB | None | 0 0
raw download clone embed print report
  1. #include "LedControl.h"
  2. #define DISP 8
  3. LedControl lc = LedControl(DISP, DISP + 2, DISP + 1, 1);
  4.  
  5.  
  6. int secondes_pour_P1;
  7. int secondes_pour_P2;
  8. int minutes_pour_P1=5;
  9. int increment_P1=0;
  10. int minutes_pour_P2=5;
  11. int increment_P2=0;
  12. int etat_bouton_P1 = LOW;
  13. int etat_bouton_P2 = LOW;
  14. int etat_bouton3 = LOW;
  15. int bouton_P1 = 6;
  16. int bouton_P2 = 7;
  17. int bouton3 = 13;
  18. bool gameover = false;
  19. float temps_P1 = 0;
  20. float temps_P2 = 0;
  21. bool est_le_tour_de_P1 = false;
  22. bool est_le_tour_de_P2 = false;
  23. float derniere_comp_P1 = millis();
  24. float derniere_comp_P2 = millis();
  25. int fin_partie=0;
  26. bool whiteleft = true;
  27. int minuteP1H = minutes_pour_P1 / 10;
  28. int minuteP1L = minutes_pour_P1 - minuteP1H * 10;
  29. int minuteP2H = minutes_pour_P2 / 10;
  30. int minuteP2L = minutes_pour_P2 - minuteP2H * 10;
  31. int secondP1H = secondes_pour_P1 / 10;
  32. int secondP1L = secondes_pour_P1 - 10 * secondP1H;
  33. int secondP2H = secondes_pour_P2 / 10;
  34. int secondP2L = secondes_pour_P2 - 10 * secondP2H;
  35. int buzzer = A1; //A1
  36. int compteur = -1;
  37. bool pair = false;
  38.  
  39. void setup() {
  40.  
  41. Serial.begin(9600);
  42. pinMode(bouton_P1, INPUT);
  43. pinMode(bouton_P2, INPUT);
  44. pinMode(bouton3, INPUT);
  45. pinMode(buzzer, OUTPUT);
  46.  
  47. digitalWrite(bouton_P1, LOW);
  48. digitalWrite(bouton_P2, LOW);
  49. digitalWrite(bouton3, LOW);
  50.  
  51. pinMode(DISP, OUTPUT);
  52. pinMode(DISP + 1, OUTPUT);
  53. pinMode(DISP + 2, OUTPUT);
  54.  
  55. lc.shutdown(0, false);
  56. lc.setIntensity(0, 8);
  57. lc.clearDisplay(0);
  58.  
  59. }
  60.  
  61. void loop() {
  62.  
  63. affichage_increment_P1();
  64.  
  65. delay(150);
  66.  
  67. if (digitalRead(bouton_P2) == HIGH) {
  68. minutes_pour_P1++;
  69. }
  70.  
  71. if (digitalRead(bouton_P1) == HIGH) {
  72. minutes_pour_P1--;
  73. }
  74.  
  75. if (minutes_pour_P1 <= 0) {
  76. temps_P1 = 30000;
  77. minutes_pour_P1 = 0;
  78. secondes_pour_P1 = 30;
  79. }
  80.  
  81. else { secondes_pour_P1 = 0;}
  82.  
  83. if (digitalRead(bouton3) == HIGH) {
  84. lc.clearDisplay(0);
  85. delay(150);
  86.  
  87. configure_incP1();}
  88.  
  89. else {loop();}
  90.  
  91. }
  92.  
  93.  
  94. void configure_incP1() {
  95. affichage_increment_P1();
  96.  
  97. delay(150);
  98.  
  99. if (digitalRead(bouton_P1) == HIGH && digitalRead(bouton_P2) == HIGH) {
  100.  
  101. loop();
  102. }
  103.  
  104. if (digitalRead(bouton_P2) == HIGH) {
  105. increment_P1++;
  106. }
  107.  
  108. if (digitalRead(bouton_P1) == HIGH) {
  109. increment_P1--;
  110. }
  111.  
  112. if (increment_P1 < 0) {
  113. increment_P1 = 0;
  114. }
  115.  
  116. if (digitalRead(bouton3) == HIGH) {
  117. lc.clearDisplay(0);
  118. delay(150);
  119.  
  120. configure_minP2();}
  121.  
  122. else { configure_incP1();}
  123. }
  124.  
  125.  
  126. void configure_minP2() {
  127. affichage_increment_P2();
  128. delay(150);
  129.  
  130. if (digitalRead(bouton_P1) == HIGH && digitalRead(bouton_P2) == HIGH) {
  131.  
  132. configure_incP1();
  133. }
  134.  
  135. if (digitalRead(bouton_P2) == HIGH) {
  136. minutes_pour_P2++;
  137. }
  138.  
  139. if (digitalRead(bouton_P1) == HIGH) {
  140. minutes_pour_P2--;
  141. }
  142.  
  143. if (minutes_pour_P2 <= 0) {
  144. temps_P2 = 30000;
  145. minutes_pour_P2 = 0;
  146. secondes_pour_P2 = 30;
  147. }
  148. else { secondes_pour_P2 = 0;}
  149.  
  150. if (digitalRead(bouton3) == HIGH) {
  151. lc.clearDisplay(0);
  152. delay(150);
  153.  
  154. configure_incP2();}
  155.  
  156. else {configure_minP2();}
  157.  
  158. }
  159.  
  160.  
  161. void configure_incP2() {
  162. affichage_increment_P2();
  163.  
  164. delay(150);
  165.  
  166. if (digitalRead(bouton_P1) == HIGH && digitalRead(bouton_P2) == HIGH) {
  167.  
  168. configure_minP2();
  169. }
  170.  
  171. if (digitalRead(bouton_P2) == HIGH) {
  172. increment_P2++;
  173. }
  174.  
  175. if (digitalRead(bouton_P1) == HIGH) {
  176. increment_P2--;
  177. }
  178.  
  179. if (increment_P2 < 0) {
  180. increment_P2 = 0;
  181. }
  182.  
  183. if (digitalRead(bouton3) == HIGH) {
  184. lc.clearDisplay(0);
  185. delay(150);
  186.  
  187. temps_P1 = (minutes_pour_P1 * 60000);
  188. temps_P2 = (minutes_pour_P2 * 60000);
  189. if (temps_P1 == 0) {
  190. temps_P1 = 30000;
  191. }
  192. if (temps_P2 == 0) {
  193. temps_P2 = 30000;
  194. }
  195.  
  196. increment_P1 = increment_P1 * 1000;
  197. increment_P2 = increment_P2 * 1000;
  198.  
  199. digitalWrite(bouton3, LOW);
  200. delay(50);
  201. game();
  202. }
  203.  
  204. else { configure_incP2();}
  205. }
  206.  
  207.  
  208. void game() {
  209.  
  210. fin_partie = 0;
  211. etat_bouton_P1 = digitalRead(bouton_P1);
  212. etat_bouton_P2 = digitalRead(bouton_P2);
  213. etat_bouton3 = digitalRead(bouton3);
  214.  
  215. minutes_pour_P1 = floor(temps_P1 / 60000);
  216. secondes_pour_P1 = floor(temps_P1 / 1000) - minutes_pour_P1 * 60;
  217.  
  218. minutes_pour_P2 = floor(temps_P2 / 60000);
  219. secondes_pour_P2 = floor(temps_P2 / 1000) - minutes_pour_P2 * 60;
  220.  
  221. if (!est_le_tour_de_P1 && !est_le_tour_de_P2 && etat_bouton_P1 == LOW && etat_bouton_P2 == LOW) {
  222.  
  223. affichagelc();
  224.  
  225. }
  226.  
  227.  
  228. if (etat_bouton_P1 == HIGH && etat_bouton_P2 == LOW) {
  229.  
  230.  
  231. digitalWrite(buzzer, HIGH);
  232.  
  233. increment_joueur_1();}
  234.  
  235.  
  236.  
  237. if (etat_bouton_P2 == HIGH && etat_bouton_P1 == LOW) {
  238.  
  239. digitalWrite(buzzer, HIGH);
  240.  
  241. increment_joueur_2();
  242. }
  243.  
  244. if (etat_bouton3 == HIGH && est_le_tour_de_P1) {
  245.  
  246. pauseP1();
  247. }
  248.  
  249.  
  250. if (etat_bouton3 == HIGH && est_le_tour_de_P2) {
  251.  
  252. pauseP2();
  253. }
  254.  
  255. if (est_le_tour_de_P1) {
  256.  
  257. Update_temps_P1();
  258.  
  259. }
  260. else if (!(!est_le_tour_de_P1 && !est_le_tour_de_P2)) {
  261. Update_temps_P2();
  262. }
  263.  
  264. else {
  265. delay(150);
  266. game();
  267. }
  268.  
  269. }
  270.  
  271.  
  272. void Update_temps_P1() {
  273.  
  274.  
  275.  
  276. temps_P1 -= ((millis() - derniere_comp_P1));
  277. derniere_comp_P1 = millis();
  278.  
  279.  
  280. if (temps_P1 <= 0) {
  281. gameover = true;
  282.  
  283. gameOver();
  284. }
  285.  
  286.  
  287. affichagelc();
  288.  
  289. game();
  290.  
  291.  
  292. }
  293.  
  294.  
  295. void Update_temps_P2() {
  296.  
  297.  
  298.  
  299. temps_P2 -= ((millis() - derniere_comp_P2));
  300. derniere_comp_P2 = millis();
  301.  
  302.  
  303.  
  304. if (temps_P2 <= 0) {
  305. gameover = true;
  306. gameOver();
  307. }
  308.  
  309. affichagelc();
  310. game();
  311. }
  312.  
  313.  
  314. void Au_tour_de_P1() {
  315. digitalWrite(buzzer, LOW);
  316. if (est_le_tour_de_P1) {
  317. return;
  318. }
  319.  
  320. est_le_tour_de_P2 = false;
  321. est_le_tour_de_P1 = true;
  322. compteur++;
  323. pair = !pair;
  324. derniere_comp_P1 = millis();
  325. game();
  326. }
  327.  
  328.  
  329. void Au_tour_de_P2() {
  330. digitalWrite(buzzer, LOW);
  331. if (est_le_tour_de_P2) {
  332. return;
  333. }
  334.  
  335. est_le_tour_de_P1 = false;
  336. est_le_tour_de_P2 = true;
  337. compteur++;
  338. pair=!pair;
  339. derniere_comp_P2 = millis();
  340. game();
  341. }
  342.  
  343.  
  344.  
  345. void gameOver() {
  346.  
  347. etat_bouton_P1 = digitalRead(bouton_P1);
  348. etat_bouton_P2 = digitalRead(bouton_P2);
  349. etat_bouton3 = digitalRead(bouton3);
  350.  
  351. if (etat_bouton3 == HIGH) {
  352. compteur = -1;
  353. pair=false;
  354. temps_P1 = 0;
  355. temps_P2 = 0;
  356. est_le_tour_de_P1 = false;
  357. est_le_tour_de_P2 = false;
  358. secondes_pour_P1 = 0;
  359. secondes_pour_P2 = 0;
  360. minutes_pour_P1=5;
  361. increment_P1=0;
  362. minutes_pour_P2=5;
  363. increment_P2=0;
  364.  
  365. delay(150);
  366. loop();
  367. }
  368.  
  369.  
  370. if (temps_P1 <= 0 && etat_bouton3 == LOW) {
  371.  
  372.  
  373. digitalWrite(buzzer, HIGH);
  374. delay(100);
  375.  
  376. digitalWrite(buzzer, LOW);
  377. delay(100);
  378.  
  379.  
  380. gameOver(); }
  381.  
  382.  
  383.  
  384. if (temps_P2 <= 0 && etat_bouton3 == LOW) {
  385.  
  386.  
  387. digitalWrite(buzzer, HIGH);
  388. delay(100);
  389.  
  390. digitalWrite(buzzer, LOW);
  391. delay(100);
  392.  
  393.  
  394. gameOver();
  395. }
  396.  
  397. }
  398.  
  399.  
  400. void increment_joueur_1() {
  401.  
  402.  
  403. if (est_le_tour_de_P1) {
  404. temps_P1 = temps_P1 + (increment_P1);
  405.  
  406. Au_tour_de_P2();
  407. }
  408.  
  409. else {
  410.  
  411. Au_tour_de_P2();}
  412.  
  413. }
  414.  
  415.  
  416. void increment_joueur_2() {
  417. if (est_le_tour_de_P2) {
  418.  
  419. temps_P2 = temps_P2 + (increment_P2);
  420.  
  421.  
  422. Au_tour_de_P1();}
  423.  
  424. else {
  425.  
  426. Au_tour_de_P1();}}
  427.  
  428.  
  429.  
  430.  
  431.  
  432.  
  433.  
  434.  
  435.  
  436. void affichagelc() {
  437. minuteP1H = minutes_pour_P1 / 10;
  438. minuteP1L = minutes_pour_P1 - minuteP1H * 10;
  439. minuteP2H = minutes_pour_P2 / 10;
  440. minuteP2L = minutes_pour_P2 - minuteP2H * 10;
  441. secondP1H = secondes_pour_P1 / 10;
  442. secondP1L = secondes_pour_P1 - 10 * secondP1H;
  443. secondP2H = secondes_pour_P2 / 10;
  444. secondP2L = secondes_pour_P2 - 10 * secondP2H;
  445.  
  446. if (minuteP1H == 0) {
  447.  
  448. lc.setChar(0, 7, ' ', false);
  449. }
  450. else {lc.setDigit(0, 7, minuteP1H, false);}
  451.  
  452.  
  453. lc.setDigit(0, 5, secondP1H, false);
  454. if (minuteP2H == 0) {
  455.  
  456. lc.setChar(0, 3, ' ', false);
  457. }
  458. else {lc.setDigit(0, 3, minuteP2H, false);}
  459. lc.setDigit(0, 4, secondP1L, false);
  460. lc.setDigit(0, 1, secondP2H, false);
  461. lc.setDigit(0, 0, secondP2L, false);
  462.  
  463.  
  464. switch (minuteP1L) {
  465. case 0: lc.setRow(0, 6, B11111110);
  466. break;
  467. case 1: lc.setRow(0, 6, B10110000);
  468. break;
  469. case 2: lc.setRow(0, 6, B11101101);
  470. break;
  471. case 3: lc.setRow(0, 6, B11111001);
  472. break;
  473. case 4: lc.setRow(0, 6, B10110011);
  474. break;
  475. case 5: lc.setRow(0, 6, B11011011);
  476. break;
  477. case 6: lc.setRow(0, 6, B11011111);
  478. break;
  479. case 7: lc.setRow(0, 6, B11110000);
  480. break;
  481. case 8: lc.setRow(0, 6, B11111111);
  482. break;
  483. case 9: lc.setRow(0, 6, B11111011);
  484. break;
  485. }
  486.  
  487.  
  488. switch (minuteP2L) {
  489. case 0: lc.setRow(0, 2, B11111110);
  490. break;
  491. case 1: lc.setRow(0, 2, B10110000);
  492. break;
  493. case 2: lc.setRow(0, 2, B11101101);
  494. break;
  495. case 3: lc.setRow(0, 2, B11111001);
  496. break;
  497. case 4: lc.setRow(0, 2, B10110011);
  498. break;
  499. case 5: lc.setRow(0, 2, B11011011);
  500. break;
  501. case 6: lc.setRow(0, 2, B11011111);
  502. break;
  503. case 7: lc.setRow(0, 2, B11110000);
  504. break;
  505. case 8: lc.setRow(0, 2, B11111111);
  506. break;
  507. case 9: lc.setRow(0, 2, B11111011);
  508. break;
  509. }}
  510.  
  511.  
  512.  
  513.  
  514.  
  515. void pauseP1() {
  516.  
  517.  
  518. lc.clearDisplay(0);
  519. lc.setChar(0, 7, 'P', false);
  520. lc.setChar(0, 6, '1', false);
  521. lc.setChar(0, 4, '5', false);
  522. lc.setRow(0, 3, B00001111);
  523. lc.setDigit(0, 2, 0, false);
  524. lc.setChar(0, 1, 'P', false);
  525.  
  526. delay(300);
  527. int estpauseP1 = 1;
  528.  
  529. etat_bouton_P1 = digitalRead(bouton_P1);
  530. etat_bouton_P2 = digitalRead(bouton_P2);
  531. etat_bouton3 = digitalRead(bouton3);
  532.  
  533.  
  534. est_le_tour_de_P1 = false;
  535. est_le_tour_de_P2 = false;
  536.  
  537.  
  538. if (etat_bouton3 == HIGH && estpauseP1 == 1) {
  539.  
  540. delay(250);
  541. derniere_comp_P1 = millis();
  542. est_le_tour_de_P1 = true;
  543. game();
  544. }
  545.  
  546. if (etat_bouton3 == LOW && etat_bouton_P1 == HIGH && etat_bouton_P2 == HIGH) {
  547. softReset();
  548.  
  549. fin_partie = 1;
  550. delay(250);
  551. loop();
  552. }
  553.  
  554.  
  555. else {
  556.  
  557. pauseP1();
  558.  
  559. }
  560. }
  561.  
  562.  
  563. void pauseP2() {
  564.  
  565. lc.clearDisplay(0);
  566. lc.setChar(0, 7, 'P', false);
  567. lc.setChar(0, 6, '2', false);
  568. lc.setChar(0, 4, '5', false);
  569. lc.setRow(0, 3, B00001111);
  570. lc.setDigit(0, 2, 0, false);
  571. lc.setChar(0, 1, 'P', false);
  572. delay(300);
  573. int estpauseP2 = 1;
  574.  
  575. etat_bouton_P1 = digitalRead(bouton_P1);
  576. etat_bouton_P2 = digitalRead(bouton_P2);
  577. etat_bouton3 = digitalRead(bouton3);
  578.  
  579.  
  580.  
  581. est_le_tour_de_P1 = false;
  582. est_le_tour_de_P2 = false;
  583.  
  584.  
  585. if (etat_bouton3 == HIGH && estpauseP2 == 1) {
  586.  
  587. delay(250);
  588. derniere_comp_P2 = millis();
  589. est_le_tour_de_P2 = true;
  590. game();
  591. }
  592.  
  593. if (etat_bouton3 == LOW && etat_bouton_P1 == HIGH && etat_bouton_P2 == HIGH) {
  594. softReset();
  595. fin_partie = 1;
  596.  
  597. delay(250);
  598. loop();
  599. }
  600.  
  601. else {
  602.  
  603. pauseP2();
  604.  
  605. }
  606. }
  607.  
  608.  
  609. void softReset(){
  610. asm volatile (" jmp 0");
  611. }
  612.  
  613.  
  614. void affichage_increment_P1() {
  615.  
  616.  
  617. lc.setChar(0, 7, 'P', false);
  618. lc.setChar(0, 6, '1', false);
  619. lc.setChar(0, 5, ' ', false);
  620. lc.setChar(0, 4, '0', false);
  621. if (minutes_pour_P1 <= 9) {
  622.  
  623. lc.setDigit(0, 4, '0', false);
  624. lc.setDigit(0, 3, minutes_pour_P1, false);
  625. }
  626. if (minutes_pour_P1 >= 10) {
  627. lc.setDigit(0, 4, minutes_pour_P1 / 10, false);
  628. lc.setDigit(0, 3, minutes_pour_P1 - (minutes_pour_P1 / 10) *10, false);
  629. }
  630.  
  631. lc.setRow(0, 2, B00000001);
  632.  
  633. if (increment_P1 <=9){
  634. lc.setChar(0, 1, ' ', false);
  635. lc.setDigit(0, 0, increment_P1, false);
  636. }
  637. if (increment_P1 >= 10){
  638. lc.setDigit(0, 1, increment_P1 / 10, false);
  639. lc.setDigit(0, 0, increment_P1 - (increment_P1 / 10) * 10, false);
  640. }
  641.  
  642.  
  643.  
  644. }
  645.  
  646.  
  647.  
  648.  
  649. void affichage_increment_P2() {
  650.  
  651. lc.setChar(0, 7, 'P', false);
  652. lc.setChar(0, 6, '2', false);
  653. lc.setChar(0, 5, ' ', false);
  654. lc.setChar(0, 4, '0', false);
  655. if (minutes_pour_P2 <= 9) {
  656. lc.setDigit(0, 4, '0', false);
  657. lc.setDigit(0, 3, minutes_pour_P2, false);
  658. }
  659. if (minutes_pour_P2 >= 10) {
  660. lc.setDigit(0, 4, minutes_pour_P2 / 10, false);
  661. lc.setDigit(0, 3, minutes_pour_P2 - (minutes_pour_P2 / 10) *10, false);
  662. }
  663.  
  664. lc.setRow(0, 2, B00000001);
  665.  
  666. if (increment_P2 <=9){
  667. lc.setChar(0, 1, ' ', false);
  668. lc.setDigit(0, 0, increment_P2, false);
  669. }
  670. if (increment_P2 >= 10){
  671. lc.setDigit(0, 1, increment_P2 / 10, false);
  672. lc.setDigit(0, 0, increment_P2 - (increment_P2 / 10) * 10, false);
  673. }
  674.  
  675.  
  676.  
  677. }
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!