Morsecode + RFID Rätsel

Autor:	Justin Ebbesmeier, Timo Kofler, Jan Steffens
Betreuer:	Prof. Schneider

Schwierigkeitsstufe

Das Rätsel ist in der Schwierigkeitsstufe Mittel einzuordnen.
Der mechatronische Aufbau hat den Schwierigkeitsgrad Mittel.

Einführung

Im Rahmen unseres Elektrotechnik Praktikums wurde uns in Gruppen die Aufgabe zugeteilt ein "Escape Box Rätsel" zu entwerfen.

Diese Rätsel sollen nachfolgend miteinander verbunden werden.

Auflagen für dieses Vorhaben war das Benutzen eines Arduino Microcontrollers in Kombination mit verschiedenen Sensoren und/ oder Aktoren.

Am Ende sollen alle Projekte gemeinsam auf einer Messe vorgestellt werden.

Einleitung

Dieses Rätsel besteht aus zwei kleinen Rätseln.

Als erstes wird über einen Knopfdruck ein Morsecode akustisch abgespielt, dieser kann in einen 4-stelligen Code umgewandelt werden, welcher durch die richtige Eingabe eine Box öffnet in der sich 10 nummerierte RFID Karten befinden.

Diese sind von 0 - 9 beschriftet. Die Karten werden dann der Reihe nach an einen Scanner gehalten und je nach dem welche Karte benutzt wird leuchtet eine von 4 LED´s.

Das bedeutet, wenn eine richtige Karte an den Scanner gehalten wird, bestimmt die LED den Stellenwert der Zahl im Zahlenschloss.

Mit diesem Code kann dann die nächste Station angefangen werden.

Für dieses Rätsel werden fünf Minuten eingeplant. Sollten diese fünf Minuten überschritten werden, gilt das Rätsel als NICHT gelöst!

Anforderungen

Tabelle 1: Anforderungsliste

ID	Inhalt	Prio	Ersteller	Datum	Geprüft von	Datum
1	Ein Morsecode wird durch einen Knopfdruck akustisch wiedergegeben.	1	Timo Kofler	11.10.24	Jan Steffens	17.10.24
2	Der Morsecode muss mit Hilfe einer Legende in einen 4-stelligen numerischen Code umgewandelt werden.	1	Timo Kofler	11.10.24	Jan Steffens	17.10.24
3	Der 4-stellige Code öffnet ein Zahlenschloss zu einer Box, in der sich 10 mit Aufklebern nummerierte RFID-Karten befinden.	1	Timo Kofler	11.10.24	Jan Steffens	17.10.24
4	Die RFID-Karten sind von 0 bis 9 nummeriert.	1	Timo Kofler	11.10.24	Jan Steffens	17.10.24
5	RFID-Karten werden der Reihe nach an einen Scanner gehalten.	1	Timo Kofler	11.10.24	Jan Steffens	17.10.24
6	Je nach gescannter Karte leuchtet eine von 5 LEDs.	1	Timo Kofler	11.10.24	Jan Steffens	17.10.24
7	Wird die richtige Karte gescannt, leuchtet eine von vier grünen LEDS auf.	1	Timo Kofler	20.11.24	Justin Ebbesmeier	09.01.25
8	Wird die falsche Karte gescannt, leuchtet eine rote LED auf.	1	Timo Kofler	20.11.24	Justin Ebbesmeier	09.01.25
9	Die leuchtende LED gibt den Stellenwert der Ziffer im Code für das zweite Zahlenschloss an.	1	Timo Kofler	11.10.24	Jan Steffens	17.10.24
10	Der durch die LEDs zugewiesene Code kann benutzt werden, um das Schloss für die nächste Station zu öffnen.	1	Timo Kofler	11.10.24	Jan Steffens	17.10.24
11	Wenn die vorgegebene Zeit abgelaufen ist, soll signalisiert werden, dass das Rätsel nicht gelöst wurde.	2	Timo Kofler	20.11.24	Justin Ebbesmeier	09.01.25
12	Die Ergebnisse werden im SVN gesichert	2	Timo Kofler	17.10.24	Jan Steffens	17.10.24

Funktionaler Systementwurf/Technischer Systementwurf

Tabelle 2: Bill of Material (BOM)

Nummer	Anzahl	Beschreibung	Link
1	1	Arduino	https://www.conrad.de/de/p/arduino-65139-board-uno-rev3-smd-breadboard-cable-core-atmega328-616724.html
2	4	LEDS	Wird von uns bereitgestellt
3	1	RFID Modul	https://www.reichelt.de/entwicklerboards-rfid-modul-nxp-mfrc-522-debo-rfid-rc522-p192147.html?PROVID=2788&gad_source=1&gclid=CjwKCAjw9p24BhB_EiwA8ID5Bt-n0VjbWTSm4mQIhDs4GjckShVXT1jw0RvUv7PT6xsPvC2VaEnWmxoCfX4QAvD_BwE
4	40	Jumper Kabel	https://www.conrad.de/de/p/40pin-jumper-dupont-kabel-male-female-trennbar-laenge-0-50-m-817271407.html
5	1	Piezo	https://www.conrad.de/de/p/joy-it-com-ky012apb-sensorkit-1-st-1695383.html
6	1	Breadboard	ist im Arduino enthalten
7	1	Taster	https://www.conrad.de/de/p/az-delivery-ky-004-taster-modul-sensor-taste-kopf-schalter-schluesselschalter-850037708.html
8	1	Pull Down Widerstand	Wird von uns bereitgestekllt
9	10	RFID Karten	https://www.conrad.de/de/p/rfid-karte-mifare-classic-1k-10-stueck-802417540.html
10	1	Spannungsversorgung	über USB
11	1	Zusätzliches Schloss	https://www.conrad.de/de/p/abus-abvs48807-vorhaengeschloss-41-5-mm-blau-zahlenschloss-752038.html
12	1	Aufkleber	https://www.conrad.de/de/p/zahlen-20x18-mm-0-9-wetterfest-folie-transparent-schwarz-2-bl-897571814.html

Systementwurf

Im folgenden Abschnitt wird der funktionale Systementwurf beschrieben und anhand von Abbildungen dargestellt.
Das dargestellte System basiert auf einem mehrstufigen Rätselprozess mit zwei kleinen Rätseln, die nacheinander gelöst werden müssen, um eine Box zu öffnen und den Zugang zur nächsten Station zu ermöglichen (siehe Abb. 02 ).
Der dazu gehörige Aufbau auf dem Breadboard für dieses Rätsel ist in Abbildung 03 illustriert.

Abb. 02: Systementwurf Morsecode + RFID Rätsel

Abb. 03: Schaltskizze Arduino

1. Erstes Rätsel - Morsecode:

• Über einen Taster wird der Morsecode akustisch abgespielt.
• Der Benutzer muss den Morsecode entschlüsseln und in einen vierstelligen Code umwandeln.
• Der richtige vierstellige Code öffnet eine Box, in der sich 10 nummerierte RFID-Karten befinden.

2. Zweites Rätsel - RFID Karten:

• Nachdem die Box geöffnet wurde, findet der Benutzer 10 RFID-Karten, nummeriert von 0 bis 9.
• Die Karten werden der Reihe nach an einen RFID-Scanner gehalten.
• Abhängig von der gescannten Karte leuchten vier LEDs, die den Stellenwert der jeweiligen Ziffer im finalen Code für das Zahlenschloss anzeigen.
• Wenn die richtige Karte gescannt wird, leuchtet die zugehörige grüne LED, die die Position der Ziffer im finalen Code bestätigt.
• Falls die falsche Karte verwendet wird oder die Karte nicht Teil des Codes ist, leuchtet eine rote LED auf.
• Sobald alle Ziffern korrekt eingegeben wurden, kann mit dem ermittelten Code die nächste Station gestartet werden.

Technischer Systementwurf

In Abbildung 04 wird der Ablauf unseres Rätsels symbolisch dargestellt:

Erstes Rätsel:

• Taster: Der Benutzer drückt einen Knopf, um den Ablauf zu starten.
• Software: Das System verarbeitet den Tastendruck und startet eine Piezo-Ausgabe.
• Piezo-Ausgabe: Der Morsecode wird akustisch abgespielt. Der Benutzer hört die Signale und muss sie interpretieren.
• Code-Interpretation: Der Benutzer entschlüsselt den Morsecode und wandelt ihn in einen vierstelligen Code um.
• Schloss öffnen: Nach Eingabe des richtigen Codes wird eine Box entriegelt, in der sich nummerierte RFID-Karten befinden.

Zweites Rätsel:

• Erhaltene Karten scannen: Der Benutzer scannt die RFID-Karten der Reihe nach mit einem RFID-Scanner.
• Software: Das System erfasst die Daten der gescannten Karten und steuert die LED-Anzeige.
• LEDs leuchten: Die LEDs zeigen an, ob die Karte korrekt ist:
  • Grüne LED: Leuchtet, wenn die Karte die richtige Zahl an der richtigen Stelle im Code darstellt.
  • Rote LED: Leuchtet, wenn die Karte falsch ist oder nicht zum Code gehört.
• Ziffernreihenfolge bestimmen: Der Benutzer verwendet die LED-Anzeigen, um die richtige Reihenfolge der Ziffern im Code zu bestimmen.
• Schloss öffnen: Sobald alle Ziffern richtig bestimmt wurden, öffnet sich das Schloss und die nächste Station des Rätsels kann betreten werden.

Abb. 04: Technischer Systementwurf

In Abbildung 05 ist das Gehäuse zu sehen, in dem sich der für das Projekt benötigte Arduino befindet.
Dieses besitzt:

• Durchführungen: Zwei rechteckige Durchführungen sind vorgesehen, eine für die Stromversorgung und eine für den USB-Anschluss, der mit dem Rechner verbunden wird.

• LED-Anzeigen: Fünf runde Öffnungen auf der Vorderseite ermöglichen die Installation von vier grünen LEDs und einer roten LED zur visuellen Anzeige.

• RFID-Modul: Ein Symbol kennzeichnet den Platz für das RFID-Modul, welches für die Erkennung der RFID-Karten verantwortlich ist.

• Taster: Im hinteren Bereich des Gehäuses befindet sich ein vorgesehener Platz für die Montage eines Tasters.

Das Gehäuse wird zudem mithilfe von Magneten mit einem Deckel verschlossen, der in Abbildung 06 zu sehen ist. In diesen Deckel hinein wird die Legende zu den Morsecodes gedruckt, damit das Ablesen und Zusammenstellen des Codes vereinfacht wird. Die CAD Modelle wurden im Laufe des Projektes mit dem Programm "Solidworks" modelliert und anschließend gedruckt.

Abb. 05: Abbildung Gehäuse

Abb. 06: Abbildung Deckel

Komponentenspezifikation

RFID Modul DEBO RFID RC522 mit eingebautem NXP MFRC-522 Chip

1. Technische Grundlagen RFID

Abb. : RFID Modul

Ein RFID- oder Radiofrequenz-Identifikationssystem besteht aus zwei Hauptkomponenten: einem Tag, der an dem zu identifizierenden Objekt angebracht ist, und einem Lesegerät, das den Tag liest.

Das Lesegerät besteht aus einem Hochfrequenzmodul und einer Antenne, die ein hochfrequentes elektromagnetisches Feld erzeugt.

Das Tag ist ein passives Gerät und besteht aus einem Mikrochip, der Informationen speichert und verarbeitet und einer Antenne, die Signale empangen und senden kann.

Wenn das Tag in die Nähe des Lesegeräts gebracht wird, erzeugt das Lesegerät ein elektromagnetisches Feld. Dadurch wandern Elektronen durch die Antenne des Tags und versorgen anschließend den Chip mit Strom.

Daraufhin sendet der Tag seine gespeicherten Informationen in Form eines weiteren Funksignals an das Lesegerät zurück. Das Lesegerät erkennt dies und sendet die Daten an unseren Mikrocontroller.

Die Abbildung __ zeigt einen solchen RFID-Sensor

2. Hauptkomponenten

• NXP MFRC-522 Chip: Der Herzstück des Moduls, das die Kommunikation mit den RFID-Tags ermöglicht
• Hochfrequenzmodul: Erzeugt das elektromagnetische Feld zur Kommunikation mit dem RFID-Tag.
• Antenne: Empfängt und sendet Signale zum und vom RFID-Tag

Video: Funktionsweise RFID-Sensor und Tag

Tabelle 3: Technische Daten (RFID)

Model	RFID Modul MFRC-522
Europäische Artikelnummer	4250236813158
Artikelnummer	SBC-RFID-RC522
Kompatibel mit	Raspberry Pi®, Raspberry Pi® 2 B, Raspberry Pi® 3 B, Raspberry Pi® A+
	Raspberry Pi® B+, Raspberry Pi® A, B
	Arduino, Banana Pi, Cubieboard
Masse (BxHxT)	40 x 8 x 60 mm
Lieferumfang	1x Modul, 1x RFID Karte, 1x RFID Chip
Frequenz	13,56 MHz
Kommunikation	Serial Peripheral Interface
RFID Protokoll	Mifare
Spannungsversorgung	DC 3,3V

3. Pinbelegung

Sensor	Arduino Pins
VCC	3,3 V
RST	9
GND	GND
MISO	12
MOSI	11
SCK	13
SDA	10
IRQ	unbelegt

Bedeutung der Abkürzungen

• VCC - Versorgungsspannung
• RST (Reset) - Reset
• GND (Ground) - Masse
• MISO (Master In Slave Out) - Daten vom Slave zum Master
• MOSI (Master Out Slave In) - Daten vom Master zum Slave
• SCK (Serial Clock) - Serielle Uhr
• SDA (Serial Data) - Serielle Daten
• IRQ (Interrupt Request) - Interrupt-Anforderungen

4. Besonderheiten

• Das RFID-Modul arbeitet mit einer Betriebsspannung von 3,3V.
• Das Modul kommuniziert über die SPI-Schnittstelle, daher müssen die Pins MOSI, MISO, SCK und SDA korrekt verbunden sein.
• Der IRQ-Pin ist optional und wird verwendet, um Interrupts zu generieren.
• Die Reichweite des Moduls beträgt etwa 3-5 cm.

Aktives Piezo Buzzer Modul KY-012

1.Technische Grundlagen Piezo Modul

Abb. : Piezo

Ein Piezo-Buzzer-System besteht in erster Linie aus einem Piezokristall, der durch elektrische Spannung verformt wird und dadurch Schallwellen erzeugt.

Das Modul besteht aus einem piezoelektrischen Schallwandler, der in einem widerstandsfähigen Gehäuse montiert ist.

Ein internes elektrisches Oszillationssystem erzeugt einen kontinuierlichen Ton bei Aktivierung durch die Versorgungsspannung. Dadurch ist die Nutzung dieses Moduls besonders einfach, da keine externe Ansteuerung durch eine Rechteckspannung erforderlich ist.

Die Abbildung __ zeigt ein solches Piezo Modul.

2.Hauptkomponenten

• Piezokristall: Das Herzstück des Moduls, das durch elektrische Spannung verformt wird, um Vibrationen zu erzeugen.
• Interner Spannungswandler: Vereinfacht die Ansteuerung, da eine externe Rechteckspannung nicht erforderlich ist.
• Schallgehäuse: Verstärkt die erzeugten Schallwellen und schützt den Piezo-Kristall vor Beschädigungen.

Tabelle 4: Technische Daten (Piezo)

Modell	Aktives Piezo Buzzer Modul
Europäische Artikelnummer	4250236816814
Artikelnummer	COM-KY012
Funktion	Mit Spannung betrieben, erzeugt der aktive Buzzer einen Ton
Betriebsspannung	Min. 3,3V
Abmessungen	15 x 25 x 12mm
Lieferumfang	Aktives Piezo Buzzer Modul

Umsetzung (HW/SW)

Vorbereitung

Bevor das Rätsel losgehen kann ist es wichtig, nach jeder Kompilierung alle Karten in der richtigen Reihenfolge von 0 bis 9 nacheinander einzuscannen.

In dem unteren Video wird einmal dargestellt, wie dies ablaufen soll.

Video: Vorbereitung des Rätsels

Programmplanung

Abb. 07: Programmablaufplan Hauptprogramm Morsecode+RFID Rätsel

Abb. 08: Programmablaufplan Unterprogramm Morsecode Rätsel

Abb. 09: Programmablaufplan Unterprogramm RFID Rätsel

Im folgenden wird der C++ Code gezeigt, mit dem unser Projekt einwandfrei läuft.

/*****************************************************************************
Autoren:   Justin Ebbesmeier, Timo Kofler, Jan Steffens                      *
Programm:  Morsecode + RFID Rätsel                                           *
Modul:     Fachpraktikum Elektrotechnik                                      *
Betreuer:  Professor Schneider                                               *
Semester:  Wintersemester 2024/2025                                          *
*****************************************************************************/

#include <SPI.h>
#include <MFRC522.h>

// Pin-Definitionen
const int piezoPin = 8;  // Pin für den Piezo-Lautsprecher
const int buttonPin = 7; // Pin für den Taster

#define RST_PIN 9   // Reset-Pin für MFRC522
#define SS_PIN 10   // Slave Select-Pin für MFRC522

MFRC522 rfid(SS_PIN, RST_PIN);

// Liste von RFID-Karten-IDs wird zur Laufzeit eingelesen
String rfidTags[10];


int LED1 = 2;
int LED2 = 3; 
int LED3 = 4; 
int LED4 = 5; 
int LEDRot = 6; 


void setup() {
  // LED pins deklarieren
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  pinMode(LED3, OUTPUT);
  pinMode(LED4, OUTPUT);
  pinMode(LEDRot, OUTPUT);

  // Setze den Piezo-Pin als Ausgang
  pinMode(piezoPin, OUTPUT);

  // Setze den Button-Pin als Eingang mit internem Pull-Up-Widerstand
  pinMode(buttonPin, INPUT_PULLUP);
  
  Serial.begin(9600);
  SPI.begin();
  rfid.PCD_Init();
  Serial.println("RFID Reader bereit. Halte eine Karte an den Sensor, um IDs zu speichern.");

  // IDs der Karten einlesen
  for (int i = 0; i < 10; i++) {
    Serial.print("Bitte Karte ");
    Serial.print(i);
    Serial.println(" scannen.");

    while (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) {
      // Warten, bis eine Karte gelesen wird
    }

    // RFID-Karten-ID auslesen und in einen String umwandeln
    String cardID = "";
    for (byte j = 0; j < rfid.uid.size; j++) {
      cardID += String(rfid.uid.uidByte[j], HEX);
    }
    cardID.toUpperCase();

    rfidTags[i] = cardID;
    Serial.print("Karte ");
    Serial.print(i);
    Serial.print(" gespeichert: ");
    Serial.println(cardID);

    // Karte loslassen
    rfid.PICC_HaltA();
  }

  Serial.println("Alle Karten gespeichert. Sie können jetzt Funktionen testen.");

}

void Morsecode() {
  int buttonState = digitalRead(buttonPin);

  // 1 ------------------------------------------------------------------------------
  delay(1000); // 1s Verzögerung
  tone(piezoPin, 1000, 1000); // Spiele einen Ton 
  delay(300);
  noTone(piezoPin);          // Stoppe den Ton
  delay(1000);

  tone(piezoPin, 1000, 1000); // Spiele einen Ton
  delay(1500);
  noTone(piezoPin);          // Stoppe den Ton
  delay(1000);

  tone(piezoPin, 1000, 1000); // Spiele einen Ton
  delay(1500);
  noTone(piezoPin);          // Stoppe den Ton
  delay(1000);

  tone(piezoPin, 1000, 1000); // Spiele einen Ton
  delay(1500);
  noTone(piezoPin);          // Stoppe den Ton
  delay(1000);

  tone(piezoPin, 1000, 1000); // Spiele einen Ton
  delay(1500);
  noTone(piezoPin);          // Stoppe den Ton
  delay(1000);

  //Zeichen für neue Zahl ---------------------------------------------------------------
  delay(2000);
  //-----------------------------------------------------------------------------------

  // 9 ---------------------------------------------------------------------------------
  tone(piezoPin, 1000, 1000); // Spiele einen Ton
  delay(1500);
  noTone(piezoPin);          // Stoppe den Ton
  delay(1000);

  tone(piezoPin, 1000, 1000); // Spiele einen Ton
  delay(1500);
  noTone(piezoPin);          // Stoppe den Ton
  delay(1000);

  tone(piezoPin, 1000, 1000); // Spiele einen Ton
  delay(1500);
  noTone(piezoPin);          // Stoppe den Ton
  delay(1000);

  tone(piezoPin, 1000, 1000); // Spiele einen Ton
  delay(1500);
  noTone(piezoPin);          // Stoppe den Ton
  delay(1000);

  tone(piezoPin, 1000, 1000); // Spiele einen Ton
  delay(300);
  noTone(piezoPin);          // Stoppe den Ton
  delay(1000);


  //Zeichen für neue Zahl ---------------------------------------------------------------
  delay(2000);
  //-----------------------------------------------------------------------------------

  // 0 --------------------------------------------------------------------------------
  tone(piezoPin, 1000, 1000); // Spiele einen weiteren Ton mit 1000 Hz für 1000 ms
  delay(1500);
  noTone(piezoPin);          // Stoppe den Ton
  delay(1000);

  tone(piezoPin, 1000, 1000); // Spiele einen weiteren Ton mit 1000 Hz für 1000 ms
  delay(1500);
  noTone(piezoPin);          // Stoppe den Ton
  delay(1000);

  tone(piezoPin, 1000, 1000); // Spiele einen weiteren Ton mit 1000 Hz für 1000 ms
  delay(1500);
  noTone(piezoPin);          // Stoppe den Ton
  delay(1000);

  tone(piezoPin, 1000, 1000); // Spiele einen weiteren Ton mit 1000 Hz für 1000 ms
  delay(1500);
  noTone(piezoPin);          // Stoppe den Ton
  delay(1000);

  tone(piezoPin, 1000, 1000); // Spiele einen weiteren Ton mit 1000 Hz für 1000 ms
  delay(1500);
  noTone(piezoPin);          // Stoppe den Ton
  delay(1000);

  //Zeichen für neue Zahl ---------------------------------------------------------------
  delay(2000);
  //-----------------------------------------------------------------------------------

  // 5 --------------------------------------------------------------------------------
  tone(piezoPin, 1000, 1000); // Spiele einen Ton
  delay(300);
  noTone(piezoPin);          // Stoppe den Ton
  delay(1000);

  tone(piezoPin, 1000, 1000); // Spiele einen Ton
  delay(300);
  noTone(piezoPin);          // Stoppe den Ton
  delay(1000);

  tone(piezoPin, 1000, 1000); // Spiele einen Ton
  delay(300);
  noTone(piezoPin);          // Stoppe den Ton
  delay(1000);

  tone(piezoPin, 1000, 1000); // Spiele einen Ton
  delay(300);
  noTone(piezoPin);          // Stoppe den Ton
  delay(1000);

  tone(piezoPin, 1000, 1000); // Spiele einen Ton
  delay(300);
  noTone(piezoPin);          // Stoppe den Ton
  delay(1000);

  //Zeichen für neue Zahl ---------------------------------------------------------------
  delay(2000);
  //-------------------------------------------------------------------------------------
}

void loop() {
  int buttonState = digitalRead(buttonPin);

  if (buttonState == LOW) {
    Morsecode();
  }




  // Prüfen, ob eine Karte gelesen werden kann
  if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) {
    return;
  }

  // RFID-Karten-ID auslesen und in einen String umwandeln
  String cardID = "";
  for (byte i = 0; i < rfid.uid.size; i++) {
    cardID += String(rfid.uid.uidByte[i], HEX);
  }
  cardID.toUpperCase();

  Serial.println("Karte erkannt: " + cardID);

  // Karte in der Liste suchen und zugehörige Aktion ausführen
  int action = -1;
  for (int i = 0; i < 10; i++) {
    if (cardID == rfidTags[i]) {
      action = i;
      break;
    }
  }


  // Aktionen mit einer switch-case-Funktion ausführen
  switch (action) {
    case 0:   // Position der Zahl mit hilfe der LEDs ausgeben 

      digitalWrite(LEDRot, HIGH);
      delay(1000);
      digitalWrite(LEDRot, LOW);

      break;
    case 1:
              // Position der Zahl mit hilfe der LEDs ausgeben 
      digitalWrite(LED3, HIGH);
      delay(1000);
      digitalWrite(LED3, LOW);

      break;
    case 2:
      // Position der Zahl mit hilfe der LEDs ausgeben 

      digitalWrite(LEDRot, HIGH);
      delay(1000);
      digitalWrite(LEDRot, LOW);

      break;
    case 3:
      // Position der Zahl mit hilfe der LEDs ausgeben 

      digitalWrite(LEDRot, HIGH);
      delay(1000);
      digitalWrite(LEDRot, LOW);

      break;
    case 4:
      // Position der Zahl mit hilfe der LEDs ausgeben 

      digitalWrite(LED1, HIGH);
      delay(1000);
      digitalWrite(LED1, LOW);


      break;
    case 5:
      // Position der Zahl mit hilfe der LEDs ausgeben 

      digitalWrite(LEDRot, HIGH);
      delay(1000);
      digitalWrite(LEDRot, LOW);

      break;
    case 6:
      // Position der Zahl mit hilfe der LEDs ausgeben 

      digitalWrite(LED4, HIGH);
      delay(1000);
      digitalWrite(LED4, LOW);

      break;
    case 7:
      // Position der Zahl mit hilfe der LEDs ausgeben 

      digitalWrite(LEDRot, HIGH);
      delay(1000);
      digitalWrite(LEDRot, LOW);

      break;
    case 8:
      // Position der Zahl mit hilfe der LEDs ausgeben 

      digitalWrite(LEDRot, HIGH);
      delay(1000);
      digitalWrite(LEDRot, LOW);

      break;
    case 9:
      // Position der Zahl mit hilfe der LEDs ausgeben 

      digitalWrite(LED2, HIGH);
      delay(1000);
      digitalWrite(LED2, LOW);


      break;
    default:
      // unbekannte Karte 
      break;
  }    

  // Karte loslassen
  rfid.PICC_HaltA();

}

Komponententest

Tabelle 3: Geprüfte Anforderungen

ID	Inhalt	Bereich	Autoren	Geprüft am	Status
1	Ein Morsecode wird durch einen Knopfdruck akustisch wiedergegeben.	Hardware/Software	Timo Kofler, Jan Steffens, Justin Ebbesmeier	14.01.25	i.O.
2	Der Morsecode muss mit Hilfe einer Legende in einen 4-stelligen numerischen Code umgewandelt werden.	Software	Timo Kofler, Jan Steffens, Justin Ebbesmeier	14.01.25	i.O.
3	Der 4-stellige Code öffnet ein Zahlenschloss zu einer Box, in der sich 10 mit Aufklebern nummerierte RFID-Karten befinden.	Hardware	Timo Kofler, Jan Steffens, Justin Ebbesmeier	14.01.25	i.O.
4	Die RFID-Karten sind von 0 bis 9 nummeriert.	Hardware	Timo Kofler, Jan Steffens, Justin Ebbesmeier	14.01.25	i.O.
5	RFID-Karten werden der Reihe nach an einen Scanner gehalten.	Hardware/Software	Timo Kofler, Jan Steffens, Justin Ebbesmeier	14.01.25	i.O.
6	Je nach gescannter Karte leuchtet eine von 5 LEDs.	Hardware/Software	Timo Kofler, Jan Steffens, Justin Ebbesmeier	14.01.25	i.O.
7	Wird die richtige Karte gescannt, leuchtet eine von vier grünen LEDS auf.	Software	Timo Kofler, Jan Steffens, Justin Ebbesmeier	14.01.25	i.O.
8	Wird die falsche Karte gescannt, leuchtet eine rote LED auf.	Software	Timo Kofler, Jan Steffens, Justin Ebbesmeier	14.01.25	i.O.
9	Die leuchtende LED gibt den Stellenwert der Ziffer im Code für das zweite Zahlenschloss an.	Software	Timo Kofler, Jan Steffens, Justin Ebbesmeier	14.01.25	i.O.
10	Der durch die LEDs zugewiesene Code kann benutzt werden, um das Schloss für die nächste Station zu öffnen.	Hardware/Software	Timo Kofler, Jan Steffens, Justin Ebbesmeier	14.01.25	i.O.
11	Wenn die vorgegebene Zeit abgelaufen ist, soll signalisiert werden, dass das Rätsel nicht gelöst wurde.	Extern	Timo Kofler, Jan Steffens, Justin Ebbesmeier	14.01.25	i.O.
12	Die Ergebnisse werden im SVN gesichert	Software	Timo Kofler, Jan Steffens, Justin Ebbesmeier	14.01.25	i.O.

Zusammenfassung

Lessons Learned

In unserem Projekt haben wir sowohl Software entwickelt als auch 3D-gedruckt. Ebenfalls wurde eine ausführliche Dokumentation des Projektes angefertigt.

Dadurch ist vor allem aufgefallen, wie wichtig gute Kommunikation ist.

Denn jeder braucht klare Aufgaben damit alles im richtigen Zeitpunkt fertig wird.

Man muss die Zeit richtig einplanen und richtige Prioritäten setzen.

Dazu ist aufgefallen, dass häufiges Testen und gegenseitiges prüfen zu deutlich besseren Ergebnissen führt.

Dies ist vor allem in dem Teil des Programmierens und des 3D – Drucks aufgefallen.

Dazu ist es sehr hilfreich viel und genau zu dokumentieren, denn diese Dokumentation hat uns selbst geholfen, wenn mal etwas nicht ganz klar war.

Diese verschiedenen Aufgaben und Herausforderungen haben einen kleinen Einblick gegeben wie es ist ein Projekt zu managen und auf was man genau achten muss.

Projektunterlagen

Projektplan

Abb. : Projekplanung mit dem Programm Gantt

Projektdateien im ZIP-Format

CAD-Dateien

• Dieses ZIP-Archiv enthält alle relevanten CAD-Dateien für das Projekt. Die Dateien können verwendet werden, um die Konstruktionen und Modelle in einer CAD-Software zu öffnen und weiter zu bearbeiten. Bitte stellen Sie sicher, dass Sie über eine geeignete Software verfügen, um die Dateien zu extrahieren und anzuzeigen.

Datei:CAD Dateien.zip

Quellen

• Arduino lernen - Anleitungen mit Praxisaufgaben und Beispielen (8.Auflage)
• What is RFID? How It Works? Interface RC522 RFID Module with Arduino - https://lastminuteengineers.com/how-rfid-works-rc522-arduino-tutorial/#:~:text=The%20RC522%20RFID%20reader%20module,over%20I2C%20and%20UART%20protocols.
• Datenblatt Piezo - https://asset.conrad.com/media10/add/160267/c1/-/de/001695383DS01/datenblatt-1695383-joy-it-com-ky012apb-sensorkit-1-st.pdf
• Datenblatt RFID Sensor - https://cdn-reichelt.de/documents/datenblatt/A300/SBC-RFID-RC522_DB.pdf

---

→ zurück zur Übersicht: WS 24/25: Escape Game