Hallo zusammen,
leider bin ich (noch) nicht wirklich viel hier unterwegs, deshalb bin ich nicht so sicher, wie ich mein Problem hier schildern und angehen soll.
Ich bin Hobby Programmierer, habe aber dennoch ein umfangreicheres Programm für den Arduino Mega geschrieben.
Hierbei werden nacheinander 6 Funktionen (Rätsel ) aufgerufen und abgefragt. Wobei die erste Funktion lediglich den "Override Status" von 5 Kippschaltern prüft und dann ggf. die zugehörige Folge-Funktion nicht mehr aufruft.
Die letzte Funktion prüft, ob alle 4 Funktionen (Rätsel R1-R4) korrekt gelößt worden sind und zieht dann einen finalen Port auf Masse. Diese Prüfung geschieht allerdings nur, wenn dies über einen RFID Chip initiiert wird (RFID Chip erkannt).
In Summe funktionert mein Programm. Wenn ich alle Funktionen (Rätsel) nacheinander bearbeite und löse, dann öffnet sich die Türe.
Aber: werden die Rätsel parallel bearbeitet (zahlreiche Inputs gedrückt werden etc.), kommt es immer wieder zu Problemen. Vor allem wird dann kein RFID Chip mehr erkannt. Es gibt auch den Fall, dass in der Funktion "verify_MA_des_Monats_Raetsel()" nicht alle Tasten des Tastenfeldes erkannt werden (bzw. kein Kontroll Tone ausgegeben wird).
Ich habe bereits einige Tests durchgeführt, bin aber etwas ratlos, wie ich die "Problemstellen" am besten identifizieren oder eingrenzen kann...ansonsten hätte ich hier auch nur den reduzierten Code / Funktion gepostet.
Leider bin ich mir auch nicht sicher, ob die HW 100% richtig bzw. prozesssicher verbaut / verlötet ist. Da es aber während der "step-by-step" Verwendung funktioniert, tendiere ich eher zu SW Problemen.
Ich drücke die Daumen, dass mir jemand von euch ein paar Ideen hat oder vielleicht direkt einen Fehler im Code findet.
Vielen Dank.
Gruß
Christian
//--------------------------------------------------------------------------------------------------------------------------------
// Kontrollraum Overrides
//--------------------------------------------------------------------------------------------------------------------------------
// Defintion benötigter Kontrollraum Overrides
const int R1_override = 28; // Kontrollraum Override für Rätsel 1 = Controller Rätsel
const int R2_override = 30; // Kontrollraum Override für Rätsel 2 = Diskokugel Rätsel
const int R3_override = 32; // Kontrollraum Override für Rätsel 3 = Bildschirm Rätsel
const int R4_override = 34; // Kontrollraum Override für Rätsel 4 = MA des Monats Rätsel
const int R5_override = 36; // Kontrollraum Override für Rätsel 5 = RFID Auslöser
boolean R1_override_status = false; // Kontrollraum Override für Rätsel 1 Default = false (NOT Solved)
boolean R2_override_status = false; // Kontrollraum Override für Rätsel 2 Default = false (NOT Solved)
boolean R3_override_status = false; // Kontrollraum Override für Rätsel 3 Default = false (NOT Solved)
boolean R4_override_status = false; // Kontrollraum Override für Rätsel 4 Default = false (NOT Solved)
boolean R5_override_status = false; // Kontrollraum Override für Rätsel 5 Default = false (NOT Solved)
//--------------------------------------------------------------------------------------------------------------------------------
// R1: Controller / Heizungsrätsel
//--------------------------------------------------------------------------------------------------------------------------------
// Globale Variablen
int counter = 0; // Indexzähler für cheat Code
boolean correct = false; // Cheat Code correct verifier
const int taste[4] = {2, 3, 4, 5}; // Array um alle 4 Buttons in For Schleife zu prüfen
const int tastenwert[4] = {0, 1, 2, 3}; // Array um Tastenwert zu definieren & speichern
// Dreieck = 0
// Kreis = 1
// Kreuz = 2
// Viereck = 3
// Lösung Cheat Code = 0 3 1 1 2 1 2 0 1 3
int code[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // Code Tabelle => Default Empty
const int cheat_LSG[10] = {0, 3, 1, 1, 2, 1, 2, 0, 1, 3}; // Lösungscode
// Defintion benötigter IN- & Outputs Controller / Heizungsrätsel
const int R1_Solved = 8; // Controller Rätsel Solved => Relais auf LOW ziehen // Controller Rätsel NOT Solved => Relais auf HIGH ziehen
const int button_dreieck = 2; // Button Dreieck an PIN 2 grüne Litze
const int button_kreis = 3; // Button Kreis an PIN 3 rote Litze
const int button_kreuz = 4; // Button Kreuz an PIN 4 weiße Litze
const int button_viereck = 5; // Button Viereck an PIN 5 blaue Litze
// PIN 6 = Ton für PS Controller Rätsel
//--------------------------------------------------------------------------------------------------------------------------------
// R2: Diskokugel Rätsel
//--------------------------------------------------------------------------------------------------------------------------------
// Globale Variablen
#include "pitches.h" // Bib für Töne
int i=0; // Zählvariable für Schleife Schalterabfrage
int j=0; // Zählvariable für Schleife Schalterabfrage
int k=0; // Zählvariable für Schleife Schalterabfrage
boolean start = true;
byte leds = 0;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Globale Variablen DiskoRätsel neu
//Lösung => Gelb (1) - Blau (2) - Rot (3) - Grün (4)
const int taste_DK[4] = {25, 27, 29, 31}; // Array um alle 4 Buttons (über Ihre PIN Lokation) in For Schleife zu prüfen
const int DK_cheat_LSG[4] = {1, 2, 3, 4}; // Lösungsarray / Reihenfolge Gelb (1) - Blau (2) - Rot (3) - Grün (4)
int DK_cheat_counter = 0; // Counter für Lösungsarray Vergleich "Point" auf Position 1 (Stelle 0) setzten
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Defintion benötigter IN- & Outputs Diskokugel Rätsel
const int R2_Solved = 9; // Diskokugel Rätsel Solved => Relais auf LOW ziehen // Diskokugel Rätsel NOT Solved => Relais auf HIGH ziehen
const int ledBel = 23; // Dauerplus für Button Beleuchtung
//Lösung => Gelb - Blau - Rot - Grün
const int buttonYellowPin = 25; // wird buttonYellowPin => 1. Schalter
const int buttonBluePin = 27; // wird buttonBluePin => 2. Schalter
const int buttonRedPin = 29; // wird buttonRedPin => 3. Schalter
const int buttonGreenPin = 31; // wird buttonGreenPin => 4. Schalter
/*not needed to define PIN 35*/ // PIN 35 wird für Ton Ausgabe verwendet
//--------------------------------------------------------------------------------------------------------------------------------
// R3: Bildschirm Rätsel
//--------------------------------------------------------------------------------------------------------------------------------
// Globale Variablen
// Defintion benötigter IN- & Outputs Bildschirm Rätsel
const int R3_Solved = 10; // Bildschirm Rätsel Solved => Relais auf LOW ziehen // Bildschirm Rätsel NOT Solved => Relais auf HIGH ziehen
const int Steckdose = 37; // Input PIN über Steckdose
//--------------------------------------------------------------------------------------------------------------------------------
// R4: MA_des_Monats Rätsel
//--------------------------------------------------------------------------------------------------------------------------------
// Globale Variablen
#include <Keypad.h>
const byte ROWS = 4; //four rows
const byte COLS = 4; //four columns
//define the cymbols on the buttons of the keypads
char hexaKeys[ROWS][COLS] = { // Spiegelverkehrt, sodass es mit neuem PINPAD passt
{'1','4','7','*'},
{'2','5','8','0'},
{'3','6','9','#'},
{'A','B','C','D'}
};
byte rowPins[COLS] = {14, 15, 16, 17}; //connect to the row pinouts of the keypad
byte colPins[ROWS] = {18, 19, 20, 21}; //connect to the column pinouts of the keypad
// old byte rowPins[ROWS] = {14, 15, 16, 17}; //connect to the row pinouts of the keypad
// old byte colPins[COLS] = {18, 19, 20, 21}; //connect to the column pinouts of the keypad
//byte rowPins[ROWS] = {9, 8, 7, 6}; //connect to the row pinouts of the keypad
//byte colPins[COLS] = {5, 4, 3, 2}; //connect to the column pinouts of the keypad
//initialize an instance of class NewKeypad
Keypad customKeypad = Keypad( makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS);
char keycode[5] = "2637#"; // Char Array Lösungscode 2-6-3-7
int keycode_1[4] = {0,0,0,0}; // Char Array Code Tabelle => Default Empty
char key_pressed=0;
int R4_i = 0; // Zählvariable für 5 Ziffern inkl. #
// Defintion benötigter IN- & Outputs MA_des_monats Rätsel Rätsel
const int R4_Solved = 11; // MA_des_Monats Rätsel Solved => Relais auf LOW ziehen // MA_des_Monats Rätsel NOT Solved => Relais auf HIGH ziehen
//--------------------------------------------------------------------------------------------------------------------------------
// R5: RFID_PAD
//--------------------------------------------------------------------------------------------------------------------------------
// Globale Variablen
/*----------------------------------------------------------------------------
* * This is a MFRC522 library example; see https://github.com/miguelbalboa/rfid
* for further details and other examples.
* NOTE: The library file MFRC522.h has a lot of useful info. Please read it.
* Released into the public domain.
* ----------------------------------------------------------------------------
* This sample shows how to read and write data blocks on a MIFARE Classic PICC
* (= card/tag).
* BEWARE: Data will be written to the PICC, in sector #1 (blocks #4 to #7).
* Typical pin layout used:
* -----------------------------------------------------------------------------------------
* MFRC522 Arduino Arduino Arduino Arduino Arduino
* Reader/PCD Uno Mega Nano v3 Leonardo/Micro Pro Micro
* Signal Pin Pin Pin Pin Pin Pin
* -----------------------------------------------------------------------------------------
* RST/Reset RST 9 5 D9 RESET/ICSP-5 RST
* SPI SS SDA(SS) 10 53 D10 10 10
* SPI MOSI MOSI 11 / ICSP-4 51 D11 ICSP-4 16
* SPI MISO MISO 12 / ICSP-1 50 D12 ICSP-1 14
* SPI SCK SCK 13 / ICSP-3 52 D13 ICSP-3 15
*/
#include <SPI.h>
#include <MFRC522.h>
// Defintion benötigter IN- & Outputs RFID_PAD
#define RST_PIN 49 // Configurable, see typical pin layout above => PIN CHECK
#define SS_PIN 53 // Configurable, see typical pin layout above => PIN CHECK
MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance.
MFRC522::MIFARE_Key key;
const int Get_together = 45; // 27.05 corrected: Get_together Rätsel Solved => Open door => Signal PIN auf LOW ziehen => Stromfluss unterbrechen
//const int Get_together = 45; // 27.05 corrected: Get_together Rätsel Solved => Open door => Signal PIN auf HIGH ziehen // Get_together Rätsel NOT Solved => lock door => Signal PIN auf LOW ziehen
const int LEDOutputRED = 47; // LED Output RED über old Output 7
//--------------------------------------------------------------------------------------------------------------------------------
void setup()
{
//Temp. Elemente zur Diagnose
Serial.begin(9600);
//--------------------------
// Defintion benötigter IN- & Outputs für Kontrollraum Overrides
pinMode(R1_override, INPUT_PULLUP);
pinMode(R2_override, INPUT_PULLUP);
pinMode(R3_override, INPUT_PULLUP);
pinMode(R4_override, INPUT_PULLUP);
pinMode(R5_override, INPUT_PULLUP);
// Defintion benötigter IN- & Outputs Controller / Heizungsrätsel
pinMode(R1_Solved, OUTPUT);
pinMode(button_dreieck, INPUT_PULLUP);
pinMode(button_kreis, INPUT_PULLUP);
pinMode(button_kreuz, INPUT_PULLUP);
pinMode(button_viereck, INPUT_PULLUP);
// Defintion benötigter IN- & Outputs Diskokugel Rätsel
pinMode(R2_Solved, OUTPUT);
pinMode(ledBel, OUTPUT);
pinMode(buttonYellowPin, INPUT_PULLUP);
pinMode(buttonBluePin, INPUT_PULLUP);
pinMode(buttonRedPin, INPUT_PULLUP);
pinMode(buttonGreenPin, INPUT_PULLUP);
// Defintion benötigter IN- & Outputs Bildschirm Rätsel
pinMode(R3_Solved, OUTPUT);
pinMode(Steckdose, INPUT_PULLUP);
// Defintion benötigter IN- & Outputs MA_des_Monats Rätsel
pinMode(R4_Solved, OUTPUT);
// Defintion benötigter IN- & Outputs RFID_PAD
pinMode(LEDOutputRED, OUTPUT);
pinMode(Get_together, OUTPUT);
// Default Werte zum Rätselstart Controller / Heizungsrätsel
digitalWrite(R1_Solved, HIGH); // Controller Rätsel NOT Solved => Relais auf HIGH ziehen
// Default Werte zum Rätselstart Diskokugel Rätsel
digitalWrite(R2_Solved, HIGH); // Diskokugel Rätsel NOT Solved => Relais auf HIGH ziehen
digitalWrite(ledBel, HIGH); // Button Beleuchtung einschalten
// Default Werte zum Rätselstart Bildschirm Rätsel
digitalWrite(R3_Solved, HIGH); // Bilschirm Rätsel NOT Solved => Relais auf HIGH ziehen
// Default Werte zum Rätselstart MA_des_Monats Rätsel
digitalWrite(R4_Solved, HIGH); // MA_des_Monats Rätsel NOT Solved => Relais auf HIGH ziehen
// Default Werte zum Rätselstart RFID_PAD
digitalWrite(Get_together, HIGH); // Get_together Rätsel NOT Solved => Open closed => Strom für Magnete einschalten
digitalWrite(LEDOutputRED, LOW); // RFID Rätsel NOT Solved => rote LED ausschalten
while (!Serial); // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4)
SPI.begin(); // Init SPI bus
mfrc522.PCD_Init(); // Init MFRC522 card
// Prepare the key (used both as key A and as key B)
// using FFFFFFFFFFFFh which is the default at chip delivery from the factory
for (byte ii = 0; ii < 6; ii++)
{
key.keyByte[ii] = 0xFF;
}
Serial.println(F("Scan a MIFARE Classic PICC to demonstrate read and write."));
Serial.println();
Serial.println(F("BEWARE: Data will be written to the PICC, in sector #1"));
}
void loop()
{
verify_Kontrollraum_Status(); // Kontrollraum Overrides abfragen
if (R1_override_status == false) // Controller Rätsel abfragen, aber nur falls Override nicht gesetzt ist
verify_Controller_Raetsel();
if (R2_override_status == false) // Diskokugel Rätsel abfragen, aber nur falls Override nicht gesetzt ist
verify_Diskokugel_Raetsel();
if (R3_override_status == false) // Bildschirm Rätsel abfragen, aber nur falls Override nicht gesetzt ist
verify_Bildschirm_Raetsel();
if (R4_override_status == false) // MA des Monats Rätsel abfragen, aber nur falls Override nicht gesetzt ist
verify_MA_des_Monats_Raetsel();
if (R5_override_status == false) // RFID PAD abfragen, aber nur falls Override nicht gesetzt ist
verify_RFID_PAD();
}
//--------------------------------------------------------------------------------------------------------------------------------
// Funktionen Kontrollraum Overrides prüfen
//--------------------------------------------------------------------------------------------------------------------------------
void verify_Kontrollraum_Status()
{
if (digitalRead(R1_override) == LOW) // Kontrollraum Overrides Rätsel 1 abfragen
{
digitalWrite(R1_Solved, LOW); // Controller Rätsel Solved => Relais auf LOW ziehen
R1_override_status = true;
}
if (digitalRead(R1_override) == HIGH && R1_override_status == true)
{
digitalWrite(R1_Solved, HIGH); // RESET Controler Rätsel NOT Solved => Relais auf HIGH ziehen
R1_override_status = false;
}
if (digitalRead(R2_override) == LOW) // Kontrollraum Overrides Rätsel 2 abfragen
{
digitalWrite(R2_Solved, LOW); // Diskokugel Rätsel Solved => Relais auf LOW ziehen
R2_override_status = true;
}
if (digitalRead(R2_override) == HIGH && R2_override_status == true)
{
digitalWrite(R2_Solved, HIGH); // Diskokugel Rätsel NOT Solved => Relais auf HIGH ziehen
R2_override_status = false;
}
if (digitalRead(R3_override) == LOW) // Kontrollraum Overrides Rätsel 3 abfragen
{
digitalWrite(R3_Solved, LOW); // Bildschirm Rätsel Solved => Relais auf LOW ziehen
R3_override_status = true;
}
if (digitalRead(R3_override) == HIGH && R3_override_status == true)
{
digitalWrite(R3_Solved, HIGH); // RESET Bildschirm Rätsel NOT Solved => Relais auf HIGH ziehen
R3_override_status = false;
}
if (digitalRead(R4_override) == LOW) // Kontrollraum Overrides Rätsel 4 abfragen
{
digitalWrite(R4_Solved, LOW); // MA des Monats Rätsel Solved => Relais auf LOW ziehen
R4_override_status = true;
}
if (digitalRead(R4_override) == HIGH && R4_override_status == true)
{
digitalWrite(R4_Solved, HIGH); // RESET MA des Monats Rätsel NOT Solved => Relais auf HIGH ziehen
R4_override_status = false;
}
if (digitalRead(R5_override) == LOW) // Kontrollraum Overrides Rätsel 5 abfragen
{
digitalWrite(Get_together, LOW); // Get_together Rätsel Solved => Open door => Signal PIN auf LOW ziehen
R5_override_status = true;
}
if (digitalRead(R5_override) == HIGH && R5_override_status == true)
{
digitalWrite(Get_together, HIGH); // RESET RFID PAD Rätsel NOT Solved => Relais auf HIGH ziehen
R5_override_status = false;
}
}
//--------------------------------------------------------------------------------------------------------------------------------
// Ende Funktionen Kontrollraum Overrides prüfen
//--------------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------------
// Funktionen R1: Controller / Heizungsrätsel
//--------------------------------------------------------------------------------------------------------------------------------
void verify_Controller_Raetsel()
{
get_Keypressed();
if (counter == 10) // Cheat Code vollständig
{
digitalWrite(R1_Solved, LOW); // Controller Rätsel Solved => Relais auf LOW ziehen
counter = 0; // Counter zurückstellen
tone(33, NOTE_A5, 200); // Ton (PIN 33) für 200 ms
delay(250);
tone(33, NOTE_A5, 200); // Ton (PIN 33) für 200 ms
delay(250);
tone(33, NOTE_A5, 200); // Ton (PIN 33) für 200 ms
delay(250);
}
}
void get_Keypressed()
{
const unsigned long bouncetime = 150;
static unsigned long tastmillis = 0;
static boolean isKey = false;
if (millis() - tastmillis > bouncetime) // BounceTime abgelaufen!
{
tastmillis = millis();
if (isKey == true) // Taste war gedrückt?
{
tone(6, NOTE_A5, 200); // Ton (PIN 6) für 200 ms
for (byte b = 0; b < 4; b++) // durchlaufe alle Tasten
{
if (digitalRead(taste[b]) == LOW) return; // Wenn eine Taste gedrückt -> raus (falls Taste gegrückt gehalten wird)
}
isKey = false; // Es war keine Taste gedrückt
}
else
{
for (byte b = 0; b < 4; b++) // Frage Tasten
{
if (digitalRead(taste[b]) == LOW) // abgefragte Taste gedrückt?
{
Serial.print("Tastencode: ");
Serial.println(tastenwert[b]); // Zeige TastenCode
Serial.println(b);
code[counter] = tastenwert[b]; // aktueller TastenCode in Code Array gespeichert
correct_key(b); // prüfe, ob correct Taste gedrückt worden ist
isKey = true; // Merke, das Taste gedrückt => Entprellen starten
}
}
}
}
}
void correct_key(int aa)
{
//int code[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // Code Tabelle => Default Empty
//const int cheat_LSG[10] = {0, 3, 1, 1, 2, 1, 2, 0, 1, 3}; // Lösungscode
if(aa == cheat_LSG[counter]) // cheat_LSG[10] = {0, 3, 1, 1, 2, 1, 2, 0, 1, 3};
counter++; // korrekte Taste gedrückt, "pointer" an nächste Stelle setzen
else if (aa== 1 && digitalRead(R1_Solved)== LOW)
{
digitalWrite(R1_Solved, HIGH); // RESET Funktion => Dreick dann Kreis drücken => Controller Rätsel NOT Solved => Relais auf HIGH ziehen
counter=0; // korrekte Taste NICHT gedrückt, zurück auf Anfang springen
}
else
counter=0; // korrekte Taste NICHT gedrückt, zurück auf Anfang springen
Serial.println(counter);
}
//--------------------------------------------------------------------------------------------------------------------------------
// ENDE Funktionen R1: Controller / Heizungsrätsel
//--------------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------------
// Funktionen R2: Diskokugel Rätsel
//--------------------------------------------------------------------------------------------------------------------------------
void verify_Diskokugel_Raetsel() // Diskokugel Rätsel abfragen
{
//Lösung => Gelb - Blau - Rot - Grün
get_Buttonpressed(); // Button abfragen
if (DK_cheat_counter == 4) // Cheat Code vollständig
{
tone(33, NOTE_A5, 200); // Ton (PIN 33) für 200 ms
delay(250);
tone(33, NOTE_A5, 200); // Ton (PIN 33) für 200 ms
delay(250);
tone(33, NOTE_A5, 200); // Ton (PIN 33) für 200 ms
delay(250);
digitalWrite(R2_Solved, LOW); // Diskokugel Rätsel Solved => Relais auf LOW ziehen
DK_cheat_counter = 0; // Counter zurückstellen
}
}
void get_Buttonpressed() // Detektieren, welcher Diskukugel Button gedrückt wurde
{
const unsigned long bouncetime_DK = 150;
static unsigned long tastmillis_DK = 0;
static boolean isKey_DK = false;
if (millis() - tastmillis_DK > bouncetime_DK) // BounceTime abgelaufen!
{
tastmillis_DK = millis();
if (isKey_DK == true) // Taste war gedrückt?
{
disko_kugel_blinken();
for (byte b_DK = 0; b_DK < 4; b_DK++) // durchlaufe alle Tasten
{
if (digitalRead(taste_DK[b_DK]) == LOW) return; // Wenn eine Taste gedrückt -> raus (falls Taste gegrückt gehalten wird)
}
isKey_DK = false; // Es war keine Taste gedrückt
}
else
{
for (byte b_DK = 0; b_DK < 4; b_DK++) // Frage Tasten
{
if (digitalRead(taste_DK[b_DK]) == LOW) // abgefragte Taste gedrückt?
{
Serial.print("gedrückter Button: ");
Serial.println(taste_DK[b_DK]); // Zeige TastenCode
correct_button(b_DK+1); // prüfe, ob correct Taste gedrückt worden ist
isKey_DK = true; // Merke, das Taste gedrückt => Entprellen starten
}
}
}
}
}
void correct_button(int a)
{
if(a == DK_cheat_LSG[DK_cheat_counter]) //DK_cheat_LSG[4] = {1, 2, 3, 4};
DK_cheat_counter++; // korrekte Taste gedrückt, "pointer" an nächste Stelle setzen
else if (a== 1)
digitalWrite(R2_Solved, HIGH); // RESET Funktion => 2 mal gelb drücken => Diskokugel Rätsel NOT Solved => Relais auf HIGH ziehen
else
DK_cheat_counter=0; // korrekte Taste NICHT gedrückt, zurück auf Anfang springen
}
void disko_kugel_blinken() // sobald Taste gedrückt wurde, Hintergrundbelechtung blinken lassen => User Rückmeldung
{
digitalWrite(ledBel, LOW); // Button Beleuchtung ausschalten
delay(200); // warten / blinken
digitalWrite(ledBel, HIGH); // Button Beleuchtung einschalten
delay(200);
//digitalWrite(ledBel, LOW); // Button Beleuchtung ausschalten
//delay(200); // warten / blinken
//digitalWrite(ledBel, HIGH); // Button Beleuchtung einschalten
//delay(200);
//digitalWrite(ledBel, LOW); // Button Beleuchtung ausschalten
//delay(200); // warten / blinken
//digitalWrite(ledBel, LOW); // Button Beleuchtung einschalten
}
//--------------------------------------------------------------------------------------------------------------------------------
// ENDE Funktionen R2: Diskokugel Rätsel
//--------------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------------
// Funktionen R3: Bildschirm Rätsel
//--------------------------------------------------------------------------------------------------------------------------------
void verify_Bildschirm_Raetsel() // Bildschirm Rätsel abfragen
{
if (digitalRead(Steckdose) == LOW)
{
digitalWrite(R3_Solved, LOW); // Bildschirm Rätsel Solved => Relais auf LOW ziehen
/*
//hier fehlt noch die Abfrage, dass es nicht die Ganze Zeit piepst.
tone(33, NOTE_A5, 200); // Ton (PIN 33) für 200 ms
delay(250);
tone(33, NOTE_A5, 200); // Ton (PIN 33) für 200 ms
delay(250);
tone(33, NOTE_A5, 200); // Ton (PIN 33) für 200 ms
delay(250);
*/
}
else
digitalWrite(R3_Solved, HIGH); // Bildschirm Rätsel NOT Solved => Relais auf HIGH ziehen
}
//--------------------------------------------------------------------------------------------------------------------------------
// ENDE Funktionen R3: Bildschirm Rätsel
//--------------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------------
// Funktionen R4: MA_des_Monats Rätsel
//--------------------------------------------------------------------------------------------------------------------------------
void verify_MA_des_Monats_Raetsel() // MA des Monats Rätsel abfragen
{
key_pressed = customKeypad.getKey(); // gedrückte Taste abfragen
if (key_pressed) // gedrückte Taste verarbeiten
{
Serial.println(key_pressed);
tone(13, NOTE_A5, 200); // Ton (PIN 13) für 200 ms
keycode[R4_i]= key_pressed; // gedrückte Taste in keycode speichern
R4_i++; // hochzählen
}
if(key_pressed=='#') // '#' Taste => abfrage starten & Rest "Zählfunktion"
{
compare();
}
}
void compare ()
{
if (strncmp(keycode,"2637", 4) == 0 ) // Array mit Lösungscode 2-6-3-7 vergleichen
{
digitalWrite(R4_Solved, LOW); // MA_des_Monats Rätsel Solved => Relais auf LOW ziehen
tone(33, NOTE_A5, 200); // Ton (PIN 33) für 200 ms
delay(250);
tone(33, NOTE_A5, 200); // Ton (PIN 33) für 200 ms
delay(250);
tone(33, NOTE_A5, 200); // Ton (PIN 33) für 200 ms
delay(250);
R4_i=0;
}
else
{
digitalWrite(R4_Solved, HIGH); // MA_des_Monats Rätsel NOT Solved => Relais auf HIGH ziehen
R4_i=0;
}
}
//--------------------------------------------------------------------------------------------------------------------------------
// ENDE Funktionen R4: MA_des_Monats Rätsel
//--------------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------------
// Funktionen R5: RFID_PAD
//--------------------------------------------------------------------------------------------------------------------------------
void verify_RFID_PAD() //RFID PAD abfragen
{
if (mfrc522.PICC_IsNewCardPresent() && mfrc522.PICC_ReadCardSerial()) //nur wenn Karte gefunden und gelesen werdnen kann
{
///Diagnose START ----wird noch entfernt/////////////////////////////////////////
// Show some details of the PICC (that is: the tag/card)
Serial.print(F("Card UID:"));
for (byte i = 0; i < mfrc522.uid.size; i++)
{
Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
Serial.print(mfrc522.uid.uidByte[i], HEX);
}
Serial.println();
///Diagnose ENDE----wird noch entfernt/////////////////////////////////////////
if (digitalRead(R1_Solved) == LOW && digitalRead(R2_Solved) == LOW)
{
if (digitalRead(R3_Solved) == LOW && digitalRead(R4_Solved) == LOW)
{
digitalWrite(Get_together, LOW); // Get_together Rätsel Solved => Open door => Signal PIN auf LOW ziehen
}
else
{
digitalWrite(Get_together, HIGH); // Get_together Rätsel NOT Solved => CLOSE door => Signal PIN auf HIGH lassen
}
}
else
{
digitalWrite(Get_together, HIGH); // Get_together Rätsel NOT Solved => CLOSE door => Signal PIN auf HIGH lassen
}
// Versetzt die gelesene Karte in einen Ruhemodus, um nach anderen Karten suchen zu können
mfrc522.PICC_HaltA();
}
}
//--------------------------------------------------------------------------------------------------------------------------------
// ENDE Funktionen R5: RFID_PAD
//--------------------------------------------------------------------------------------------------------------------------------
