API tools faq
paste
Advertisement
Guest User

Untitled

a guest
May 21st, 2019
136
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 20.35 KB | None | 0 0
raw download clone embed print report
  1. ////////////////////////////////////////////////////////////////////
  2. // Zeiten speicherung: (nicht relevant)
  3. // nts = Zeit von Licht Nr. 1 (String)
  4. // stet = Zeit vom Ton Nr. 1 (String)
  5. // stz3 = Zeit vom Ton Nr. 2 (String)
  6. // stz4 = Zeit vom Licht Nr. 2 (String)
  7. // stz8 = Zeit vom Licht Nr. 3 (String)
  8. // stz9 = Zeit vom Ton Nr. 3 (String)
  9. // Pins:
  10. // 3 == Rot
  11. // 4 = Blau
  12. // 5 = Grün
  13. ////////////////////////////////////////////////////////////////////
  14.  
  15.  
  16.  
  17.  
  18.  
  19. // name: Reaktionstest_Tag1
  20. // authors: [Robin, Abanoub]
  21. // version: 3.0
  22. // description: 'Dieses Programm ermittelt die Reaktionszeit (in mehreren Versuchen), die benötigt wird um einen Taster nach einem Licht oder Ton Signal zu drücken.'
  23.  
  24. #include <Wire.h> /* Einbinden der */
  25. #include <LiquidCrystal_I2C.h> /* Bibliotheken für das */
  26. LiquidCrystal_I2C Display(0x27,16,2); /* monochrome LCD-Display */
  27.  
  28. // Deklarieren der Variablen (Namensgebung der Variablen bitte nicht beachten)
  29. int taster_neu_neu_neu = 6; // Dies ist der Taster, mit dem die Farbe der LED ausgewählt werden kann
  30. int taster = 13; // Dies ist der Taster, der für den Reaktionstest gebraucht wird
  31.  
  32. int led = 5; // Der Pin, an den die grüne LED angeschlossen ist
  33. int ton = 12; // Der Pin, der zum Gate des Transistors führt
  34.  
  35. ////////////////////////////////////////////////////////////////////
  36. // Methoden für das Display erstellen um Befehle zu vereinfachen
  37. void cc() {
  38. Display.clear(); // Mit 'cc();' kann man nun das Display leeren
  39. }
  40. void sc() {
  41. Display.setCursor(0,0); // Mit 'sc();' setzt man den Cursor wieder auf 0,0
  42. }
  43. void bl() {
  44. Display.backlight(); // Mit 'bl();' kann man die Hintergrundbeleuchtung des Displays aktivieren
  45. }
  46. void nb() {
  47. Display.noBacklight(); // Mit 'nb();' schaltet man die Hintergrundbeleuchtung des Displays aus
  48. }
  49. void resetDisplay() { // Mit der Methode 'resetDisplay()' werden (die oben beschriebenen) Methoden auf einmal ausgeführt
  50. cc(); // #Clear
  51. sc(); // #Cursor
  52. bl(); // #Backlight
  53. }
  54. ////////////////////////////////////////////////////////////////////
  55. // Methode für den Tasterstatus
  56. void ts() {
  57. int neue_eingabe20 = digitalRead(taster);
  58. }
  59. ////////////////////////////////////////////////////////////////////
  60. void setup() { // Die Methode 'setup' wird nur einmal (beim Starten des Programms) ausgeführt
  61. Serial.begin(9600); // Setzt die Baudrate auf 9600 (für die Konsole / den seriellen Monitor)
  62. pinMode(led, OUTPUT); // PinMode der oben deklarierten Variable (5) auf Output setzten (da eine LED angeschlossen ist)
  63. pinMode(3, OUTPUT); // PinMode (3) auf Output setzten (da eine LED angeschlossen ist)
  64. pinMode(4, OUTPUT); // PinMode (4) auf Output setzten (da eine LED angeschlossen ist)
  65. digitalWrite(led, HIGH); // Zum Testen und sichergehen, dass die LED funktioniert wird (die Grüne) während dem Laden angeschaltet
  66. //////////////////////////////////
  67. // Die anderen zwei Pins werden am Anfang auf Low gesetzt
  68. digitalWrite(3, LOW);
  69. digitalWrite(4, LOW);
  70. //////////////////////////////////
  71. Display.init(); // Initialisieren des Displays (dies muss einmal in der Setup Methode geschehen, damit man das Display verwenden kann
  72. pinMode(13, INPUT_PULLUP); // PinMode (13) auf Input_Pullup setzten (da ein Taster angeschlossen ist)
  73. pinMode(6, INPUT_PULLUP); // PinMode (6) auf Input_Pullup setzten (da ein Taster angeschlossen ist)
  74. pinMode(10, INPUT_PULLUP); // PinMode (10) auf Input_Pullup setzten (da ein Taster angeschlossen ist)
  75. pinMode(9, INPUT_PULLUP); // PinMode (9) auf Input_Pullup setzten (da ein Taster angeschlossen ist)
  76. Display.clear(); // Das Display wird einmal am Anfang geleert
  77. Display.backlight(); // Die Hintergrundbeleuchtung des Displays wird angeschalten
  78. int z = 400; // Diese Variable bestimmt die Zeit zwischen den 'Loading' Nachrichten (siehe unten)
  79. Display.setCursor(0,0); // Der Cursor des Displays wird auf 0,0 gesetzt
  80.  
  81. ////////////////////////////////////////////////////////////////////
  82. /* Loading 'Animation' wird auf dem LCD Display gezeigt */
  83. Display.print("Loading (T1)"); // #Text
  84. delay(z); // #Delay
  85. Display.clear(); // #Clear
  86. Display.setCursor(0,0); // #Cursor
  87. Display.print("Loading. (T1)"); // #Text
  88. delay(z); // #Delay
  89. Display.clear(); // #Clear
  90. Display.setCursor(0,0); // #Cursor
  91. Display.print("Loading.. (T1)");
  92. delay(z);
  93. Display.clear();
  94. Display.setCursor(0,0);
  95. Display.print("Loading... (T1)");
  96. delay(z);
  97. Display.clear();
  98. Display.setCursor(0,0);
  99. Display.print("Loading");
  100. delay(z);
  101. Display.clear();
  102. Display.setCursor(0,0);
  103. Display.print("Loading. (T1)");
  104. delay(z);
  105. Display.clear();
  106. Display.setCursor(0,0);
  107. Display.print("Loading.. (T1)");
  108. delay(z);
  109. Display.clear();
  110. Display.setCursor(0,0);
  111. Display.print("Loading... (T1)");
  112. delay(z);
  113. Display.clear();
  114. Display.setCursor(0,0);
  115. Display.print("Loading (T1)");
  116. delay(z);
  117. Display.clear();
  118. Display.setCursor(0,0);
  119. Display.print("Loading. (T1)");
  120. delay(z);
  121. Display.clear();
  122. Display.setCursor(0,0);
  123. Display.print("Loading.. (T1)");
  124. delay(z);
  125. Display.clear();
  126. Display.setCursor(0,0);
  127. Display.print("Loading... (T1)");
  128. delay(z);
  129. Display.clear();
  130. ////////////////////////////////////////////////////////////////////
  131.  
  132. sc(); // Hier wird der Cursor des Displays wieder auf 0,0 gesetzt
  133. bl(); // Hier wird nochmal (zur Sicherheit) die Hintergrundbeleuchtung des Displays aktiviert
  134. digitalWrite(led, LOW); // Die LED (die zum Testen) angeschaltet wurde, wird hier wieder ausgeschaltet
  135. Display.print("Willkommen zum"); // Der Text wird auf dem Display angezeigt (kurz '#Text')
  136. Display.setCursor(0,1); // Der Cursor wird in die zweite Zeile gesetzt (Cursor setzten kurz '#Cursor')
  137. Display.print("Reaktionstest."); // #Text
  138.  
  139. delay(3000); // Delay von drei Sekunden
  140. cc(); // Display leeren (kurz '#Clear')
  141. sc(); // Cursor auf 0,0 setzten
  142.  
  143. // Drei booleans erstellen (später für die Farbwahl wichtig) (alle werden auf 'falsch' (false) gesetzt)
  144. boolean gruen = false;
  145. boolean rot = false;
  146. boolean blau = false;
  147. boolean taster_status = false;
  148.  
  149. Display.print("Bitte"); // #Text
  150. Display.setCursor(0,1); // #Cursor
  151. Display.print("Farbe waehlen."); // #Text
  152.  
  153.  
  154. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  155.  
  156.  
  157. int ss1 = digitalRead(10); // #Taster
  158. int ss2 = digitalRead(9); // #Taster
  159. int ss3 = digitalRead(taster_neu_neu_neu); // #Taster
  160. while(ss1 == 1 && ss2 == 1 && ss3 == 1) { // Solange kein Taster gedrückt ist, bleibt das Programm in der while-Schleife
  161. delay(1);
  162. // Debug Tasterstatus (nicht relevant)
  163. // Serial.println("Nicht gedrückt");
  164. ss1 = digitalRead(10); // #Taster
  165. ss2 = digitalRead(9); // #Taster
  166. ss3 = digitalRead(taster_neu_neu_neu); // #Taster
  167. }
  168.  
  169. // Hier wird dann abgefragt, welcher der Taster gedrückt wurde und der Integer 'led' wird auf den entsprechenden Wert (Pin) gesetzt
  170.  
  171. if(digitalRead(10) == 0) {
  172. rot = true; // Setzten des booleans für die Farbe
  173. led=3; // 'led' wird auf 3 gesetzt, da Pin 3 an das Beinchen der RGB LED für die Farbe Rot angeschlossen ist
  174. cc(); // #Clear
  175. sc(); // #Cursor
  176. Display.println("Rot"); // #Text
  177. } else if(digitalRead(9) == 0) {
  178. blau = true; // Setzten des booleans für die Farbe
  179. led=4; // 'led' wird auf 4 gesetzt, da Pin 4 an das Beinchen der RGB LED für die Farbe Blau angeschlossen ist
  180. cc(); // #Clear
  181. sc(); // #Cursor
  182. Display.println("Blau"); // #Text
  183. } else {
  184. gruen = true; // Setzten des booleans für die Farbe
  185. led=5; // 'led' wird auf 5 gesetzt, da Pin 5 an das Beinchen der RGB LED für die Farbe Grün angeschlossen ist
  186. cc(); // #Clear
  187. sc(); // #Cursor
  188. Display.println("Gruen"); // #Text
  189. }
  190. delay(3000); // #Delay
  191.  
  192. ////////////////////////////////////////////////////////////////////
  193. cc(); // #Clear
  194. sc(); // #Cursor
  195. Display.print("Bereit?"); // #Text
  196. Display.setCursor(0,1); // #Cursor
  197. Display.print("[Knopf druecken]"); // #Text
  198.  
  199. }
  200. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  201. void loop() { // Die Methode 'loop' ist sozusagen eine unendlich Schleife
  202.  
  203. // Solange der Taster nicht gedrückt wird, wartet das Programm eine Millisekunde (kurz '#Taster')
  204. // Wenn er dann gedrückt wird, springt das Programm sofort aus der while-Schleife heraus
  205. int eingabe= digitalRead(taster); // Auslesen des Tasterstaus
  206. while(eingabe == 1) {
  207. delay(1); // #Delay
  208. eingabe = digitalRead(taster); // Aktualisieren des Tasterstatus
  209. }
  210.  
  211. cc(); // #Clear
  212. sc(); // #Cursor
  213. Display.print("Achtung es geht"); // #Text
  214. Display.setCursor(0,1); // #Cursor
  215. Display.print("gleich los!"); // #Text
  216. delay(3000); // #Delay
  217. cc(); // #Clear
  218. sc(); // #Cursor
  219. Display.print("START!"); // #Text
  220.  
  221.  
  222. ///////////////////////////////////////////////////////////////////////////////////////
  223.  
  224. //// Zufallszahl + Delay //// (kurz '#Random')
  225. // Generieren einer zufälligen Zahl
  226. randomSeed(analogRead(A1));
  227. float rz = 0;
  228. // Zwischen 5000 und 10.000
  229. rz = random(5000, 10001);
  230. delay(rz); // Wartet zwischen 5000 und 10.000 Millisekunden (Zufallszahl)
  231. // Debug random Zahl (nicht relevant)
  232. // Serial.println(rz);
  233. digitalWrite(led, HIGH);
  234. float st1 = millis();
  235.  
  236. // #Taster
  237. int ein2 = digitalRead(taster);
  238. while(ein2 == 1) {
  239. delay(1);
  240. ein2 = digitalRead(taster);
  241. }
  242.  
  243. digitalWrite(led, LOW);
  244. float ts2 = millis();
  245. float nt1 = ts2 - st1;
  246. cc(); // #Clear
  247. sc(); // #Cursor
  248. String nts;
  249. nts = String(nt1);
  250. Display.print("Zeit wurde"); // #Text
  251. Display.setCursor(0,1); // #Cursor
  252. Display.print("gespeichert!"); // #Text
  253. delay(3000); // #Delay
  254.  
  255.  
  256. // Nach diesem Prinzip funktioniert jedes Signal (entweder mit einem Licht- oder Tonsignal)
  257. // Deshalb sind die weiteren Abläufe auch nicht ausführlich kommentiert; relevant wird es dann wieder ab Zeile 448
  258.  
  259. ///////////////////////////////////////////////////////////////////////////////////////
  260.  
  261.  
  262. // nts ist nun die erste Zeit vom Licht (nicht relevant)
  263.  
  264. cc(); // #Clear
  265. sc(); // #Cursor
  266. Display.print("START!"); // #Text
  267.  
  268. //// #Random ////
  269. randomSeed(analogRead(A1));
  270. float rz2 = 0;
  271. rz2 = random(5000, 10001);
  272. delay(rz2);
  273.  
  274. tone(ton, 393); // Abspielen eines Tons mit einer Frenquenz von 393 Hz (kurz '#Ton')
  275.  
  276. float stt1 = millis();
  277. int ein3 = digitalRead(taster);
  278. while(ein3 == 1) {
  279. delay(1);
  280. ein3 = digitalRead(taster);
  281. }
  282.  
  283. noTone(ton); // Stoppen des Tons
  284. float stt2 = millis();
  285. float ntt2 = stt2 - stt1;
  286. cc();
  287. bl();
  288. sc();
  289. String stet;
  290. stet = String(ntt2);
  291. Display.print("Zeit wurde"); // #Text
  292. Display.setCursor(0,1); // #Cursor
  293. Display.print("gespeichert!"); // #Text
  294. delay(3000); // #Delay
  295.  
  296.  
  297. // stet ist nun die erste Zeit vom Ton (nicht relevant)
  298.  
  299.  
  300. cc();
  301. sc();
  302. Display.print("START!");
  303. randomSeed(analogRead(A1));
  304. float rz3 = 0;
  305. rz3 = random(5000, 10001);
  306. delay(rz3);
  307. tone(ton, 393); // #Ton
  308.  
  309. float start3 = millis();
  310. int ein4 = digitalRead(taster);
  311. while(ein4 == 1) {
  312. delay(1);
  313. ein4 = digitalRead(taster);
  314. }
  315.  
  316. noTone(ton);
  317. float stop3 = millis();
  318. float zeit3 = stop3 - start3;
  319. cc();
  320. bl();
  321. sc();
  322. String stz3;
  323. stz3 = String(zeit3);
  324. Display.print("Zeit wurde");
  325. Display.setCursor(0,1);
  326. Display.print("gespeichert!");
  327. delay(3000);
  328.  
  329. // stz3 ist nun die erste Zeit vom Ton (nicht relevant)
  330.  
  331.  
  332. cc();
  333. sc();
  334. Display.print("START!");
  335. randomSeed(analogRead(A1));
  336. float rz4 = 0;
  337. rz4 = random(5000, 10001);
  338. delay(rz4);
  339. digitalWrite(led, HIGH);
  340.  
  341. float start4 = millis();
  342. int ein5 = digitalRead(taster);
  343. while(ein5 == 1) {
  344. delay(1);
  345. ein5 = digitalRead(taster);
  346. }
  347.  
  348. digitalWrite(led, LOW);
  349. float stop4 = millis();
  350. float zeit6 = stop4 - start4;
  351. cc();
  352. bl();
  353. sc();
  354. String stz4;
  355. stz4 = String(zeit6);
  356. Display.print("Zeit wurde");
  357. Display.setCursor(0,1);
  358. Display.print("gespeichert!");
  359. delay(3000);
  360.  
  361.  
  362. // stz4 ist nun die erste Zeit vom Licht (nicht relevant)
  363. cc();
  364. sc();
  365. Display.print("START!");
  366. randomSeed(analogRead(A1));
  367. float rz8 = 0;
  368. rz8 = random(5000, 10001);
  369. delay(rz8);
  370. digitalWrite(led, HIGH);
  371.  
  372. float start8 = millis();
  373. int ein8 = digitalRead(taster);
  374. while(ein8 == 1) {
  375. delay(1);
  376. ein8 = digitalRead(taster);
  377. }
  378.  
  379. digitalWrite(led, LOW);
  380. float stop8 = millis();
  381. float zeit8 = stop8 - start8;
  382. cc();
  383. bl();
  384. sc();
  385. String stz8;
  386. stz8 = String(zeit8);
  387. Display.print("Zeit wurde");
  388. Display.setCursor(0,1);
  389. Display.print("gespeichert!");
  390. delay(3000);
  391.  
  392.  
  393.  
  394. // stz8 ist nun die erste Zeit vom Licht (nicht relevant)
  395.  
  396. cc();
  397. sc();
  398. Display.print("START!");
  399. randomSeed(analogRead(A1));
  400. float rz9 = 0;
  401. rz9 = random(5000, 10001);
  402. delay(rz9);
  403. tone(ton, 393); // #Ton
  404.  
  405. float start9 = millis();
  406. int ein9 = digitalRead(taster);
  407. while(ein9 == 1) {
  408. delay(1);
  409. ein9 = digitalRead(taster);
  410. }
  411.  
  412. noTone(ton);
  413. float stop9 = millis();
  414. float zeit9 = stop9 - start9;
  415. cc();
  416. bl();
  417. sc();
  418. String stz9;
  419. stz9 = String(zeit9);
  420. Display.print("Zeit wurde");
  421. Display.setCursor(0,1);
  422. Display.print("gespeichert!");
  423. delay(3000);
  424.  
  425.  
  426. // stz3 ist nun die erste Zeit vom Ton (nicht relevant)
  427.  
  428. cc();
  429. sc();
  430. Display.print("Geschafft!");
  431. int ein112 = digitalRead(taster);
  432. while(ein112 == 1) {
  433. delay(1);
  434. ein112 = digitalRead(taster);
  435. }
  436.  
  437. // --> nicht relevant
  438. // nts = Zeit von Licht Nr. 1 (String)
  439. // stet = Zeit vom Ton Nr. 1 (String)
  440. // stz3 = Zeit vom Ton Nr. 2 (String)
  441. // stz4 = Zeit vom Licht Nr. 2 (String)
  442. // stz8 = Zeit vom Licht Nr. 3 (String)
  443. // stz9 = Zeit vom Ton Nr. 3 (String)
  444.  
  445.  
  446. ///////////////////////////////////////////////////////////////////////////////////////
  447.  
  448. // Neue Variablen deklarieren und die Werte der alten übergeben (damit es übersichtlicher ist)
  449. String licht1 = nts;
  450. String ton1 = stet;
  451. String ton2 = stz3;
  452. String licht2 = stz4;
  453. String licht3 = stz8;
  454. String ton3 = stz9;
  455.  
  456.  
  457. ///////////////////////////////////////////////////////////////////////////////////////
  458.  
  459.  
  460. //////////////////////////////////
  461. // Ausgeben der Reaktionszeiten //
  462.  
  463. cc(); // #Clear
  464. sc(); // #Cursor
  465. Display.print("Zeit Licht1:"); // #Text
  466. Display.setCursor(0,1); // #Cursor
  467. Display.print(licht1); // #Text (Zeit ausschreiben)
  468. delay(4000); // #Delay
  469.  
  470.  
  471. cc();
  472. sc();
  473. Display.print("Zeit Ton1:");
  474. Display.setCursor(0,1);
  475. Display.print(ton1);
  476. delay(4000);
  477.  
  478.  
  479.  
  480. cc();
  481. sc();
  482. Display.print("Zeit Ton2:");
  483. Display.setCursor(0,1);
  484. Display.print(ton2);
  485. delay(4000);
  486.  
  487.  
  488. cc();
  489. sc();
  490. Display.print("Zeit Licht2:");
  491. Display.setCursor(0,1);
  492. Display.print(licht2);
  493. delay(4000);
  494.  
  495.  
  496.  
  497. cc();
  498. sc();
  499. Display.print("Zeit Licht3:");
  500. Display.setCursor(0,1);
  501. Display.print(licht3);
  502. delay(4000);
  503.  
  504.  
  505. cc();
  506. sc();
  507. Display.print("Zeit Ton3:");
  508. Display.setCursor(0,1);
  509. Display.print(ton3);
  510. delay(4000);
  511.  
  512. //////////////////////////////////
  513.  
  514. // Durchschnitt berechnen und ausgeben //
  515.  
  516.  
  517. // Strings (Licht) werden in Integer umgewandelt (sonst kann man damit ja nicht rechnen)
  518. int l1int = licht1.toInt();
  519. int l2int = licht2.toInt();
  520. int l3int = licht3.toInt();
  521.  
  522. // Durchschnitt berechnen (Licht)
  523. int durchschnitt_licht = l1int + l2int + l3int;
  524. double dfl = durchschnitt_licht / 3;
  525.  
  526.  
  527.  
  528. cc(); // #Clear
  529. sc(); // #Cursor
  530. Display.print("Durchschn. Licht"); // #Text
  531. Display.setCursor(0,1); // #Cursor
  532. Display.print(dfl); // Ausgeben des Durchschnittes für die Reaktionen (Licht)
  533. delay(4000);
  534.  
  535. // Strings (Ton) werden in Integer umgewandelt (sonst kann man damit ja nicht rechnen)
  536. int t1int = ton1.toInt();
  537. int t2int = ton2.toInt();
  538. int t3int = ton3.toInt();
  539.  
  540. // Durchschnitt berechnen (Ton)
  541. int durchschnitt_ton = t1int + t2int + t3int;
  542. double dft = durchschnitt_ton / 3;
  543.  
  544.  
  545. cc(); // #Clear
  546. sc(); // #Cursor
  547. Display.print("Durchschn. Ton"); // #Text
  548. Display.setCursor(0,1); // #Cursor
  549. Display.print(dft); // Ausgeben des Durchschnittes für die Reaktionen (Licht)
  550.  
  551. delay(4000); // #Delay
  552. cc(); // #Clear
  553. sc(); // #Cursor
  554. Display.print("Fertig!"); // #Text
  555.  
  556. ////////////////////////////////////////////////////////////////
  557. // An Frau Baur: //
  558.  
  559. /* Liebe Frau Baur,
  560. *
  561. * bitte achten sie nicht auf die Namensgebung der Variablen ;)
  562. *
  563. * Das Programm für Tag 2 funktioniert nach genau dem selben
  564. * Prinzip, deshalb habe ich dies nicht kommentiert.
  565. * Ich hoffe das ist in Ordnung für Sie.
  566. *
  567. * Beste Grüße,
  568. * Robin und Abanoub
  569. *
  570. * PS: Bei Fragen einfach eine E-Mail an 'r.hettmer0205@gmail.com' schreiben.
  571. *
  572. */
  573. ////////////////////////////////////////////////////////////////
  574.  
  575.  
  576. //
  577. //
  578. // <!-- ENDE --!>
  579. //
  580. //
  581.  
  582.  
  583. ////////////////////////////////////////////////////////////////
  584. // --> nicht relevant
  585. // Unendliche for-Schleife (damit es nicht wieder im 'loop()' startet)
  586. // Man könnte das Programm natürlich nur im 'setup()' schreiben, aber so kann man das ja auch gut lösen
  587. for(long n=0; n==1; n=n-1) {
  588. sehr_langer_delay();
  589. }
  590. }
  591.  
  592. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  593.  
  594. // --> nicht relevant
  595. void langerDelay() {
  596. delay(100000);
  597. delay(100000);
  598. delay(100000);
  599. delay(100000);
  600. delay(100000);
  601. delay(100000);
  602. delay(100000);
  603. delay(100000);
  604. delay(100000);
  605. delay(100000);
  606. delay(100000);
  607. delay(100000);
  608. delay(100000);
  609. delay(100000);
  610. }
  611. void sehr_langer_delay() {
  612. langerDelay();
  613. langerDelay();
  614. langerDelay();
  615. }
  616. ////////////////////////////////////////////////////////////////
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!