Dateien nach "/" hochladen

reaktionstester.ino

@@ -0,0 +1,81 @@
+// Copyright Santhosh Venugopal™℗®© & Justus Wolff™℗®©
+// "Es war ein vergnügen die Kommentare zu schreiben" - Justus Wolff
+// "..." - Santosh (14 Jahre alt, ist still)
+#include <LiquidCrystal_I2C.h>
+#include <Wire.h>
+
+int led = 7; // pin Nummern für jwl. Komponente
+int bt = 8;
+long highscore = 999999; // speichert highscore in einer Variable
+LiquidCrystal_I2C lcd(0x27,16,2); // LCD deklarieren
+
+void setup() {
+  // put your setup code here, to run once:
+  pinMode(led, OUTPUT);
+  pinMode(bt, INPUT_PULLUP);  // pinmodes setzen (selbsterklärend)
+
+  randomSeed(analogRead(A1)); // Zufallsgenerator initialisieren
+  Serial.begin(9600);
+  Serial.println("Santhosh Justus Reaktionstester debug Information");
+  lcd.init();  // LCD initialisieren
+  lcd.clear();
+  lcd.backlight(); // backlight an machen (damit man auch was sieht)
+}
+
+void loop() {
+  lcd.setCursor(0, 0);
+  lcd.print("klick! sobald");
+  lcd.setCursor(0, 1);
+  lcd.print("LED leuchtet"); // gebrauchsanleitung für tester (sagt nur dass man taster klicken soll sobald LED leuchet (Meiner meinung nach zu viel information innerhalb eines kommentars jajaja...))
+  
+  int del = random(300, 3000); // Wartezeit für das Leuchten der LED
+  
+  Serial.println("--------------------------------------");  // extra Informationen im seriellen Monitor
+  Serial.print("Wartezeit:"); // debug
+  Serial.println(del); // debug
+  delay(del); // warten
+  
+  while (digitalRead(bt)==0) { // warten bis nicht mehr gedrückt
+    Serial.println("Versuch zu schummeln."); // debug
+    delay(random(300, 3000)); // zufällige Zeit warten bis zur nächsten Überprüfung
+  }
+  long t1 = millis(); // leider kann dies maximal bis 24,8 tage (gerundet) zählen bevor ein bit overflow passiert wodurch die reaktionszeit minus werden würde... :(
+  
+  digitalWrite(led, HIGH); // selbsterklärend (Bringt die LED zum leuchten gemäß des standards bzw. des weges angegeben vom lernbaustein auf seite 8, ungefähr 1/2 der seite der y achse, bitte verklagt mich nicht für diesen kriminell langen kommentar, danke, amen) ich verklag dich, justus!!
+  
+  while (digitalRead(bt)==1) {} // warten bis gedrückt
+  
+  t1 = millis()-t1; // berechnen der reaktionszeit
+  
+  digitalWrite(led, LOW); // hier keinen so laaaaaaaaaaaaaaaaaaaaaaangen kommentar wie oooooooooooooben
+  
+  Serial.print("Ergebnis: "); // debug
+  Serial.println(t1); // debug
+
+  lcd.clear(); // anzeigen der reaktionszeit
+  lcd.setCursor(0, 1);
+  lcd.print(t1);
+  lcd.print("ms");
+  lcd.setCursor(0, 0);
+  lcd.print("Reaktionszeit:");
+  
+  delay(100);
+  while (digitalRead(bt)==0) {} // warten bis nicht gedrückt
+  while (digitalRead(bt)==1) {} // warten bis gedrückt
+  delay(100);
+  
+  if (t1 < highscore) { // highscore logik, zeigt "highscore" falls Reaktionszeit am niedrigsten ist bzw. < highscore
+    highscore = t1;
+    Serial.println("Highscore");
+    lcd.clear();
+    lcd.setCursor(0,0);
+    lcd.print("--HIGHSCORE!!!--");
+    lcd.setCursor(0,1);
+    lcd.print("Zeit:");
+    lcd.print(t1);
+    Serial.println("wartet bis drücken");
+    while (digitalRead(bt)==1) {} // warten bis gedrückt
+  }
+  lcd.clear(); // cleanup bzw. im guten altem deutsch, A U F R Ä U M E N
+  delay(1000);
+}

reaktionstesterbase.ino

@@ -1,83 +1,68 @@
-// Copyright Justus Wolff™℗®©
+// Copyright Justus Wolff™℗®© & Santhosh Venugopal™℗®©
-// Schnell zusammengekleistert vom eigentlichem code den ich (Justus) und Santosh verwenden würden,
+// gemacht auf Wunsch von Frau Bürgel dass wir einen Grundcode anfertigen sollen.
-// auf Wunsch von Frau Bürgel dass wir einen Grundcode anfertigen sollen.
+// Also einfach der Code mit den zeilen für die Highscore funktion entfernt.
-// Also einfach der Code mit den zeilen für die Highscore funktion auskommentiert.
 
-#include <LiquidCrystal_I2C.h>
+#include <LiquidCrystal_I2C.h> // Abhängikeit vom dem Projekt um das LCD zu verwenden
-#include <Wire.h>
+#include <Wire.h> // Abhängikeit von der Library "LiquidCrystal I2C"
 
-int led = 7; // pin Nummern für jwl. Komponente
+int led = 7; // Pin nummer der LED
-int bt = 8;
+int bt = 8; // Pin nummer des Tasters
-// long highscore = 999999; // speichert highscore in einer Variable
+LiquidCrystal_I2C lcd(0x27,16,2); // LCD klasse der Bibliothek deklarieren
-LiquidCrystal_I2C lcd(0x27,16,2); // LCD deklarieren
 
-void setup() {
+void setup() { // normale setup funktion, läuft einmal am start vom Arduino
-  // put your setup code here, to run once:
+  pinMode(led, OUTPUT); // Setze pinmodus der LED auf output
-  pinMode(led, OUTPUT);
+  pinMode(bt, INPUT_PULLUP); // Setze pinmode des Tasters auf input (pullup)
-  pinMode(bt, INPUT_PULLUP);  // pinmodes setzen (selbsterklärend)
 
-  randomSeed(analogRead(A1)); // Zufallsgenerator initialisieren
+  randomSeed(analogRead(A1)); // Zufallsgenerator initialisieren mithilfe von noise von dem analogen pin A1
-  Serial.begin(9600);
+  Serial.begin(9600); // Initialisiere das Serial System. Serial wird in diesem Projekt verwendet um zu debuggen, es gibt hilfreiche informationen bei runtime aus
-  Serial.println("Santhosh Justus Reaktionstester debug Information");
+  Serial.println("Santhosh Justus Reaktionstester debug Information"); // Basis information ausgeben in Serial
   lcd.init();  // LCD initialisieren
-  lcd.clear();
+  lcd.clear(); // LCD clearen (leeren also keine zeichen, leeres display)
   lcd.backlight(); // backlight an machen
 }
 
-void loop() {
+void loop() { // normale loop funktion, läuft immer wieder. Wie "while (1) {setup();}"
-  lcd.setCursor(0, 0);
+  lcd.setCursor(0, 0); // cursor links oben hinsetzen
-  lcd.print("klicke sobald");
+  lcd.print("klicke sobald"); // Teil einer kleinen erklärsnachricht an den Nutzer
-  lcd.setCursor(0, 1);
+  lcd.setCursor(0, 1); // setze cursor links auf die zweite Zeile
-  lcd.print("Die LED leuchtet"); // gebrauchsanleitung für tester
+  lcd.print("Die LED leuchtet"); // Vervollständigt die erklärsnachricht
   
-  int del = random(300, 3000); // Wartezeit für das Leuchten der LED
+  int del = random(300, 3000); // Bestimme wartezeit bis die LED leuchtet (zwischen 300ms und 3s)
   
-  Serial.println("--------------------------------------");  // extra Informationen im seriellen Monitor
+  Serial.println("--------------------------------------");  // Seperator in serial damit verschiedene "Test runden" unterschieden werden können
-  Serial.print("Wartezeit:"); // debug
+  Serial.print("Wartezeit:"); // debug, gebe die oben bestimmte Wartezeit in serial aus
-  Serial.println(del); // debug
+  Serial.println(del); // debug, vervollständigt die vorherige zeile
-  delay(del); // warten
+  delay(del); // wir "delay"'en (get it?) das programm, also warten die obige bestimmte wartezeit
   
-  while (digitalRead(bt)==0) { // warten bis nicht mehr gedrückt
+  while (digitalRead(bt)==0) { // Schleife des anti-cheats. Überprüft wird ob der knopf bereits gedrückt wird obwohl die LED nicht mal an ist als versuch zu schummeln.
-    Serial.println("Versuch zu schummeln."); // debug
+    Serial.println("Versuch zu schummeln."); // debug, informiere dass der tester/nutzer versucht hat zu schummeln.
-    delay(random(300, 3000)); // zufällige Zeit warten bis zur nächsten Überprüfung
+    delay(random(300, 3000)); // wir warten zwischen einer zufälligen zeit von 300ms zu 3s bis wir die anti cheat überprüfung neu machen.
   }
-  long t1 = millis();
+  long t1 = millis(); // Speichere jetzige Zeit (wie lange das programm bereits läuft, reicht aber aus um die reaktionszeit zu berechnen indem wir später delta zwischen zwei punkten in der zeit berechnen)
   
-  digitalWrite(led, HIGH);
+  digitalWrite(led, HIGH); // Bringe LED zum aufleuchten
   
+  while (digitalRead(bt)==1) {} // warten bis der Taster gedrückt wird.
+  
+  t1 = millis()-t1; // hier wird delta zwischen dem zeitpunkt von vorhin und der jetzigen zeit berechnet was dann die reaktionszeit ist.
+  
+  digitalWrite(led, LOW); // Mache LED aus
+  
+  Serial.print("Ergebnis: "); // debug, gebe die reaktionszeit in serial aus
+  Serial.println(t1); // debug, vervollständigt die vorherige zeile
+
+  lcd.clear(); // cleare das LCD von der erklärsnachricht (leeres LCD)
+  lcd.setCursor(0, 1); // Setze cursor links, zweite zeile
+  lcd.print(t1); // gebe berechnete reaktionszeit (also delta) aus
+  lcd.print("ms"); // gebe danach noch ms aus um das zeitformat dem nutzer mitzuteilen
+  lcd.setCursor(0, 0); // setze cursor links, erste zeile
+  lcd.print("Reaktionszeit:"); // gebe "Reaktionszeit:" auf dem LCD aus
+  
+  delay(100); // warte 100ms
+  while (digitalRead(bt)==0) {} // warten bis nicht gedrückt, da der arduino so schnell ist dass der nutzer vielleicht noch den knopf als reaktion gedrückt hält
   while (digitalRead(bt)==1) {} // warten bis gedrückt
+  delay(100); // warte 100ms
   
-  t1 = millis()-t1; // berechnen der reaktionszeit
+  lcd.clear(); // cleare das LCD (also leere es)
-  
+  delay(1000); // warte 1s
-  digitalWrite(led, LOW);
-  
-  Serial.print("Ergebnis: "); // debug
-  Serial.println(t1); // debug
-
-  lcd.clear(); // anzeigen der reaktionszeit
-  lcd.setCursor(0, 1);
-  lcd.print(t1);
-  lcd.print("ms");
-  lcd.setCursor(0, 0);
-  lcd.print("Reaktionszeit:");
-  
-  delay(100);
-  while (digitalRead(bt)==0) {} // warten bis nicht gedrückt
-  while (digitalRead(bt)==1) {} // warten bis gedrückt
-  delay(100);
-  
-  /*if (t1 < highscore) { // highscore logik, zeigt "highscore" falls Reaktionszeit am niedrigsten ist bzw. < highscore
-    highscore = t1;
-    Serial.println("Highscore");
-    lcd.clear();
-    lcd.setCursor(0,0);
-    lcd.print("--HIGHSCORE!!!--");
-    lcd.setCursor(0,1);
-    lcd.print("Zeit:");
-    lcd.print(t1);
-    Serial.println("wartet bis drücken");
-    while (digitalRead(bt)==1) {} // warten bis gedrückt
-  }*/
-  lcd.clear(); // cleanup
-  delay(1000);
 }

reaktionstesterclean.ino

@@ -3,40 +3,10 @@
 #include <LiquidCrystal_I2C.h>
 #include <Wire.h>
 
-// Bonus code
+uint8_t led = 7; // pin Nummern für jwl. Komponente
-class pixeldraw {
+uint8_t bt = 8;
-  private:
+uint32_t highscore = -1; // wer hier einen bitoverflow hinbekommt verdient den respekt
-  LiquidCrystal_I2C* lcd;
+uint8_t godmode = 0;
-  void constructbuf(int x, int y, byte* buf) {
-    buf[y] = B10000 >> x;
-    return buf;
-  }
-  public:
-  pixeldraw(LiquidCrystal_I2C* _lcd) {
-    lcd = _lcd;
-  }
-
-  void setpix(int _x, int _y) {
-    // calculate cell x and y
-    int cellx = _x/5;
-    int celly = _y/8;
-    int x = _x%5; // calculate modulo
-    int y = _y%8; // calculate modulo
-
-    byte buf[8] = { // load from cellbuf
-      0,0,0,0,0,0,0,0
-    };
-    constructbuf(x,y,buf);
-    lcd->createChar(cellx+(celly*16), buf);
-    lcd->clear();
-    lcd->setCursor(cellx, celly);
-    lcd->write(byte(cellx+(celly*16)));
-  }
-};
-
-int led = 7; // pin Nummern für jwl. Komponente
-int bt = 8;
-long highscore = 999999; // speichert highscore in einer Variable
 LiquidCrystal_I2C lcd(0x27,16,2); // LCD deklarieren
 
 void setup() {
@@ -50,37 +20,54 @@ void setup() {
   lcd.init();  // LCD initialisieren
   lcd.clear();
   lcd.backlight(); // backlight an machen
-  pixeldraw drawer(&lcd);
-  for (int y=0;y<(8*8);y++) {
-    for (int x=0;x<(16*5);x++) {
-      drawer.setpix(x, y);
-      delay(1);
 }
+
+void handlecmds() {
+  if (!Serial.available()) {return;}
+
+  String cmd = Serial.readString();
+  if (cmd == "godmode enable\n") {
+    godmode = 1;
+    Serial.println("Okidoki, du citri!");
+  }
+  if (cmd == "godmode disable\n") {
+    godmode = 0;
+    Serial.println("Whad de fug, bong ding ow");
+  }
+  if (cmd == "ich bin ein cheater\n") {
+    godmode = 2;
+    Serial.println(">:(");
+  }
+  if (cmd == "ich bin KEIN cheater\n") {
+    godmode = 0;
+    Serial.println("aight bet");
   }
 }
 
 void loop() {
+  handlecmds();
   lcd.setCursor(0, 0);
   lcd.print("klicke sobald");
   lcd.setCursor(0, 1);
   lcd.print("Die LED leuchtet"); // gebrauchsanleitung für tester
   
-  int del = random(300, 3000); // Wartezeit für das Leuchten der LED
+  uint16_t del = random(300, 3000); // Wartezeit für das Leuchten der LED
   
   Serial.println("--------------------------------------");  // extra Informationen im seriellen Monitor
   Serial.print("Wartezeit:"); // debug
   Serial.println(del); // debug
   delay(del); // warten
   
-  while (digitalRead(bt)==0) { // warten bis nicht mehr gedrückt
+  while (digitalRead(bt)==0 || godmode == 2) { // warten bis nicht mehr gedrückt
+    handlecmds();
     Serial.println("Versuch zu schummeln."); // debug
     delay(random(300, 3000)); // zufällige Zeit warten bis zur nächsten Überprüfung
   }
-  long t1 = millis();
+  uint32_t t1 = millis();
   
   digitalWrite(led, HIGH);
   
-  while (digitalRead(bt)==1) {} // warten bis gedrückt
+  while (digitalRead(bt)==1 && godmode == 0) {} // warten bis gedrückt
   
   t1 = millis()-t1; // berechnen der reaktionszeit