Elektronisches Schließfach: Unterschied zwischen den Versionen

Aus HSHL Mechatronik
Zur Navigation springen Zur Suche springen
 
(123 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 1: Zeile 1:
[[Kategorie:Projekte]]  
[[Kategorie:Projekte]]  
[[Kategorie:ProjekteET MTR BSE WS2023]]
[[Kategorie:ProjekteET MTR BSE WS2023]]
<!-- Kopieren Sie diesen Header in Ihren Artikel, damit er aufgelistet wird.  -->
[[:Kategorie:ProjekteET_MTR_BSE_WS2023|WS 23/24: Fachpraktikum Elektrotechnik (MTR) und Angewandte Elektrotechnik (BSE)]]<br/>
 
'''Autoren: Kilian Engelhardt & Jörn-Hendrik Beleke''' <br/>
'''Autoren: Kilian Engelhardt & Jörn-Hendrik Beleke''' <br/>
'''Betreuer:''' [[Benutzer:Ulrich_Schneider|Prof. Schneider]]<br/>
'''Betreuer:''' [[Benutzer:Ulrich_Schneider|Prof. Schneider]]<br/>
Zeile 32: Zeile 33:
|-
|-
| 2
| 2
| Das Bedienpanel muss über ein LCD-Display und LEDs zur Visualisierung des Eingabestatus verfügen.
| Das Bedienpanel muss über ein LCD-Display zur Visualisierung des Eingabestatus verfügen.
| Hardware
| Hardware
| 04.10.2023
| 04.10.2023
Zeile 65: Zeile 66:
| Software
| Software
| 04.10.2023
| 04.10.2023
| Offen
| Erledigt
|-
|-
| 8
| 8
Zeile 71: Zeile 72:
| Software
| Software
| 04.10.2023
| 04.10.2023
| Offen
| Erledigt
|-
|-
| 9
| 9
Zeile 77: Zeile 78:
| Software
| Software
| 04.10.2023
| 04.10.2023
| Offen
| Erledigt
|-
|-
| 10
| 10
Zeile 83: Zeile 84:
| Software
| Software
| 04.10.2023
| 04.10.2023
| Offen
| Erledigt
|-
|-
| 11
| 11
Zeile 89: Zeile 90:
| Software
| Software
| 04.10.2023
| 04.10.2023
| Offen
| Erledigt
|-
|-
| 12
| 12
Zeile 95: Zeile 96:
| Software
| Software
| 04.10.2023
| 04.10.2023
| Offen
| Erledigt
|-
|-
|+ style = "text-align: left"|Tabelle 1: Auflistung der Anforderungen
|+ style = "text-align: left"|Tabelle 1: Auflistung der Anforderungen
Zeile 112: Zeile 113:
* '''Endschalter:''' Diese Komponente erfasst den geöffneten oder geschlossenen Zustand der Schließfachtür.
* '''Endschalter:''' Diese Komponente erfasst den geöffneten oder geschlossenen Zustand der Schließfachtür.


* '''Tastenfeld und Fingerabdrucksensor:''' Diese Komponenten erfassen die Eingabe des PIN-Codes und der biometrischen Daten.
* '''Tastenfeld:''' Das verwendete 4x4 Tastenfeld erfasst die Betätigung der Tasten und gibt das Zeichen der betätigten Taste als ASCII-Code aus.


* '''Fingerabdrucksensor:''' Der Fingerabdrucksensor erfasst die Eingabe von biometrischen Daten. Dazu nimmt der Sensor Bilder der Fingerabdrücke auf. Das verwendete Fingerabdruckmodul besitzt einen digitalen Signalprozessor, welcher das Berechnen und Speichern von Fingerabdruckbildern, die Merkmalsfindung und Fingerabdrucksuche durchführt. Zur Ausführung der Funktionen können Befehlspakete von einem Mikrocontroller über eine serielle Schnittstelle an den DSP Chip gesendet werden. Gespeicherte Fingerabdruckbilder werden auf dem OnBoard Speicher des Moduls hinterlegt.
* '''LCD-Display:''' Auf dem Display werden Anweisungen und der Eingabestatus für den Nutzer dargestellt.
* '''LCD-Display:''' Auf dem Display werden Anweisungen und der Eingabestatus für den Nutzer dargestellt.


Zeile 126: Zeile 129:
Die nachfolgenden Abbildungen 1.1 und 1.2 stellen eine Skizze des Systementwurfs sowie den Signalfluss des Systems dar.  
Die nachfolgenden Abbildungen 1.1 und 1.2 stellen eine Skizze des Systementwurfs sowie den Signalfluss des Systems dar.  


[[ Datei:SkizzeSystementwurf.png|900px|mini|links|Abbildung 1.1: Skizze des Systementwurfs, Original [[Datei:SkizzeSystementwurfSchließfach.pptx|mini]] ]]
<br/>
<br/>


 
[[Datei:Signal Systementwurf.png|900px|mini|links|Abbildung 1.2: Signalfluss des Systems, Original [[Datei:SkizzeSignalflussSchließfach.pptx|mini]] ]]
[[ Datei:SkizzeSystementwurf.png|900px|mini|links|Abbildung 1.1: Skizze des Systementwurfs]]
 
[[Datei:Signalfluss Systementwurf.png|900px|mini|rechts|Abbildung 1.2: Signalfluss des Systems]]


<br clear="all">
<br clear="all">
Zeile 155: Zeile 157:
*Betriebsspannung: 5V
*Betriebsspannung: 5V
*54 digitale Ein-/Ausgänge und 16 analoge Eingänge
*54 digitale Ein-/Ausgänge und 16 analoge Eingänge
|[[Datei:MEGA.png|rahmenlos|mini|zentriert|100px]]
|[[Datei:MEGA.png|rahmenlos|mini|zentriert|110px]] <ref>https://eu.robotshop.com/de/products/arduino-mega-2560-microcontroller</ref>
|-
|-
| 2
| 2
Zeile 161: Zeile 163:
|
|
*Betriebsspannung: 5V
*Betriebsspannung: 5V
|[[Datei:Fingerabdruck.jpg|rahmenlos|mini|zentriert|100px]]
|[[Datei:Fingerabdruck.jpg|rahmenlos|mini|zentriert|110px]]
|-
|-
| 3
| 3
Zeile 169: Zeile 171:
*NC oder NO je nach Verschaltung
*NC oder NO je nach Verschaltung
*Betriebsspannung: 5V
*Betriebsspannung: 5V
|[[Datei:MechEndschalter.jpg|rahmenlos|mini|zentriert|100px]]
|[[Datei:MechEndschalter.jpg|rahmenlos|mini|zentriert|110px]]
|-
|-
| 4
| 4
Zeile 177: Zeile 179:
*Blockierdrehmoment: 2 kg/cm
*Blockierdrehmoment: 2 kg/cm
*Maximaler Drehwinkel: 180°
*Maximaler Drehwinkel: 180°
|[[Datei:MG90SMicroServo.jpg|rahmenlos|mini|zentriert|100px]]
|[[Datei:MG90SMicroServo.jpg|rahmenlos|mini|zentriert|110px]]
|-
|-
| 5
| 5
Zeile 187: Zeile 189:
*Buchstaben A bis D
*Buchstaben A bis D
*Sonderzeichen * und #
*Sonderzeichen * und #
|[[Datei:Tastenfeld.jpg|rahmenlos|mini|zentriert|100px]]
|[[Datei:Tastenfeld.jpg|rahmenlos|mini|zentriert|110px]]
|-
|-
| 6
| 6
Zeile 195: Zeile 197:
*2 Zeichenreihen, 16 Zeichen pro Reihe
*2 Zeichenreihen, 16 Zeichen pro Reihe
*mit I2C HD44780 Modul, verlötet
*mit I2C HD44780 Modul, verlötet
|[[Datei:16x02LCDDisplay.jpg|rahmenlos|mini|zentriert|100px]]
|[[Datei:16x02LCDDisplay.jpg|rahmenlos|mini|zentriert|110px]]
|-
|-
| 7
| 7
Zeile 201: Zeile 203:
|
|
*Betriebsspannung: 5V
*Betriebsspannung: 5V
|[[Datei:Lautsprecher.jpg|rahmenlos|mini|zentriert|100px]]
|[[Datei:Lautsprecher.jpg|rahmenlos|mini|zentriert|110px]]
|-
|-
| 8
| 8
| Industriegehäuse
| Spannungsquelle
|
|
*Abmessungen: 250 x 350 x 150 mm
*9V-Block-Akku
*Material: ABS Kunststoff
|
|
[[Datei:Industriegehäuse.jpg|rahmenlos|mini|zentriert|100px]]
[[Datei:9vBlock.jpg|rahmenlos|mini|zentriert|110px]]
|-
|-
| 9
| 9
Zeile 216: Zeile 217:
*Herstellung mittels 3D-Druck
*Herstellung mittels 3D-Druck
*Ermöglicht Montage des Arduinos an Schließfachtür
*Ermöglicht Montage des Arduinos an Schließfachtür
|[In Bearbeitung]
*Material: PLA
*CAD-Datei: [[Datei:ArduinoMegaMontageplatte.sldprt|mini]]
|[[Datei:Montageplatte Arduino Mega.jpg|rahmenlos|mini|zentriert|110px]]
|-
|-
| 10
| 10
| Spannungsquelle
| Industriegehäuse
|
*Abmessungen: 250 x 350 x 150 mm
*Material: ABS Kunststoff
|
|
*9V-Block-Akku
[[Datei:Industriegehäuse.jpg|rahmenlos|mini|zentriert|110px]] <ref>https://www.arli24.de/industrieheimwerker/gehaeusetechnik/schaltschrank/106/arli-kunststoff-schaltschrank-ip65-210-x-280-x-130-mm</ref>
|[In Bearbeitung]
|}
|}


Zeile 243: Zeile 248:


==== Verdrahtung der Komponenten ====
==== Verdrahtung der Komponenten ====
Im Anschluss an die Montage der einzelnen Komponenten im Gehäuse mussten alle elektronischen Komponenten mit dem Arduino Mikrocontroller elektrisch verbunden werden. Dazu wurde der folgende Verdrahtungsplan nach Abbildung 2.2 für das Gesamtsystem angefertigt.
Im Anschluss an die Montage der einzelnen Komponenten im Gehäuse mussten alle elektronischen Komponenten mit dem Arduino Mikrocontroller elektrisch verbunden werden. Dazu wurde der folgende Verdrahtungsplan nach Abbildung 2.2 für das Gesamtsystem angefertigt. Die Komponenten sind entsprechend der Komponentenliste nummeriert.


<br/>
<br/>
[[Datei:Verdrahtungsplan Schließfach.png|1000px|mini|links|Abbildung 2.2: Verdrahtungsplan des Gesamtsystems]]
 
[[Datei:Verdrahtungsplan Schließfach.png|1000px|mini|links|Abbildung 2.2a: Verdrahtungsplan des Gesamtsystems, Original [[Datei:VerdrahtungsplanSchließfach.fzz|mini]] ]]
 
<br clear="all">
 
Dem obigen Verdrahtungsplan entsprechend wurden dann die Komponenten miteinander verbunden und mit Montagesockeln und Kabelbindern im Gehäuse befestigt, wie in Abbildung 2.2b gezeigt.
 
[[Datei:VerdrahtungSchließfach.jpg|300px|mini|links|Abbildung 2.2b: Verdrahtung des Gesamtsystems]]


<br clear="all">
<br clear="all">
Zeile 253: Zeile 265:
<br/>
<br/>


Die Umsetzung der Software für das Gesamtsystems des elektronischen Schließfachs erfolgt unter MATLAB Simulink. Da für dieses Projekt ein Arduino Mega 2560 als Mikrocontroller eingesetzt wird, wurde das "Simulink Support Package für Arduino Hardware" aus dem MATLAB Add-On Explorer zur einfachen Integration der Arduino-Hardware in Simulink installiert. Zusätzlich wird der Block "S-Function Builder" aus der Simulink Bibliothek zur Softwareentwicklung verwendet. Durch diesen Funktionsblock kann C++-Code in Simulink-Modellen integriert werden, was die Verwendung von Arduino-Bibliotheken zur Steuerung der Arduino-Hardware ermöglicht.
Die Umsetzung der Software für das Gesamtsystems des elektronischen Schließfachs erfolgt unter MATLAB Simulink. Da für dieses Projekt ein Arduino Mega 2560 als Mikrocontroller eingesetzt wird, wurde das "Simulink Support Package für Arduino Hardware" aus dem MATLAB Add-On Explorer zur einfachen Integration der Arduino-Hardware in Simulink installiert. Zusätzlich wird der Block "S-Function Builder" aus der Simulink Bibliothek zur Softwareentwicklung verwendet. Durch diesen Funktionsblock kann C++-Code in Simulink-Modellen integriert werden, was die Verwendung von Arduino-Bibliotheken zur Steuerung der Arduino-Hardware ermöglicht. Als Hilfestellung bei der Implementation der S-Funtions im Simulink-Modell wurde sich am folgenden Wiki-Artikel orientiert: https://wiki.hshl.de/wiki/index.php/Datei:S-Function_Tutorial.pdf
</br>
</br>
 
==== S-Functions ====
 
Insgesamt wurden vier S-Function Blöcke erstellt, um den Fingerabdrucksensor, das LCD-Display, das Tastenfeld und den EEPROM-Speicher des Arduinos in Simulink einzubinden. Der Quellcode für die jeweiligen S-Function Blöcke ist nachfolgend aufgeführt.
 
===== EEPROM Speicher =====
 
<div class="mw-collapsible mw-collapsed">
 
<syntaxhighlight lang="cpp" style="border: none; background-color: #EFF1C1; font-size:small">
 
/* Includes_BEGIN */
#ifndef MATLAB_MEX_FILE
 
#include <math.h>
#include <EEPROM.h>
 
#endif
/* Includes_END */
 
/* Externs_BEGIN */
 
/* Externs_END */
 
void EEPROM_Speicher_Start_wrapper(real_T *xD)
{
/* Start_BEGIN */
 
/* Start_END */
}
 
void EEPROM_Speicher_Outputs_wrapper(const uint8_T *EingabePIN,
                                    const uint8_T *PinStatus,
                                    uint8_T *PIN,
                                    const real_T *xD)
{
/* Output_BEGIN */
#ifndef MATLAB_MEX_FILE
 
for (int i = 0; i < 4; i++) // Auslesen der vier EEPROM Addressen
  {
 
    PIN[i] = EEPROM.read(i);
 
  }
 
if (PinStatus[0] == 1) // Wenn das Passwort geändert wurde:
  {
   
    for (int i = 0; i < 4; i++) // Updaten der vier EEPROM Addressen
    {
 
        EEPROM.update(i, EingabePIN[i]);
 
    }
 
  }
 
#endif
/* Output_END */
}
 
void EEPROM_Speicher_Update_wrapper(const uint8_T *EingabePIN,
                                    const uint8_T *PinStatus,
                                    uint8_T *PIN,
                                    real_T *xD)
{
/* Update_BEGIN */
 
/* Update_END */
}
 
void EEPROM_Speicher_Terminate_wrapper(real_T *xD)
{
/* Terminate_BEGIN */
 
/* Terminate_END */
}
 
</syntaxhighlight>
 
</pre>
</div>
<br clear = all>
 
===== leseFingerabdruck =====
 
<div class="mw-collapsible mw-collapsed">
 
<syntaxhighlight lang="cpp" style="border: none; background-color: #EFF1C1; font-size:small">
 
/* Includes_BEGIN */
#ifndef MATLAB_MEX_FILE
#include <Adafruit_Fingerprint.h>
#include <Wire.h>
#include <FingerprintFunctions.h>
#define mySerial Serial2
 
// Festlegen der Seriellen Schnittstelle des Fingerabdrucksensors auf Serial2
Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial);
 
// Anlegen der Programmvariablen
unsigned char state = 0;
 
#endif
/* Includes_END */
 
/* Externs_BEGIN */
 
/* Externs_END */
 
void leseFingerabdruck_Start_wrapper(real_T *xD)
{
/* Start_BEGIN */
#ifndef MATLAB_MEX_FILE
 
  delay(100);
 
  // Setzen der Baudrate für den seriellen Sensorport
  finger.begin(57600);
 
  // Überprüfen der Verbindung zum Fingerabdrucksensor
  delay(5);
  finger.verifyPassword();
 
  // Auslesen der Sensorparameter
  finger.getParameters();
  finger.getTemplateCount();
 
#endif
/* Start_END */
}
 
void leseFingerabdruck_Outputs_wrapper(const uint8_T *FingerEin,
                                      uint8_T *FingerStatus,
                                      const real_T *xD)
{
/* Output_BEGIN */
#ifndef MATLAB_MEX_FILE
 
 
    if (FingerEin[0] == 1)
    {
 
        finger.LEDcontrol(true); // Einschalten des Fingerabdrucksensors
        state = getFingerprintID(finger); // Auslesen und Abgleich des Fingerabdrucks mit Sensordatenbank
        if (state > 0 && state < 121) { FingerStatus[0] = 1; delay(100); }
 
    }
 
    else if (FingerEin[0] == 2)
    {
 
        finger.LEDcontrol(true); // Einschalten des Fingerabdrucksensors
        state = getFingerprintEnroll(finger); // erstes Bild vom Fingerabdruck erstellen
        if (state == 2) { FingerStatus[0] = 2; delay(100); }
    }
   
    else if (FingerEin[0] == 3)
    {
 
        finger.LEDcontrol(true); // Einschalten des Fingerabdrucksensors
        state = getFingerprintEnroll1(finger); // zweites Bild vom Fingerabdruck erstellen
        if (state == 3) { FingerStatus[0] = 3; delay(100); } // bei Übereinstimmung in Sensordatenbank speichern


    }
    else
    {
       
        finger.LEDcontrol(false); // Ausschalten des Fingerabdrucksensors wenn nicht benötigt
        FingerStatus[0] = 0;
   
    }
#endif
/* Output_END */
}
void leseFingerabdruck_Update_wrapper(const uint8_T *FingerEin,
                                      uint8_T *FingerStatus,
                                      real_T *xD)
{
/* Update_BEGIN */
/* Update_END */
}
void leseFingerabdruck_Terminate_wrapper(real_T *xD)
{
/* Terminate_BEGIN */
/* Terminate_END */
}
</syntaxhighlight>
</pre>
</div>
<br clear = all>
===== LCD Display =====
<div class="mw-collapsible mw-collapsed">
<syntaxhighlight lang="cpp" style="border: none; background-color: #EFF1C1; font-size:small">
/* Includes_BEGIN */
#ifndef MATLAB_MEX_FILE
#include <Wire.h>
#include <hd44780.h>
#include <hd44780ioClass/hd44780_I2Cexp.h>
// Anlegen der Displayvariablen
hd44780_I2Cexp lcd;
const char LCD_COLS = 16;
const char LCD_ROWS = 2;
unsigned char displaystate = 0;
#endif
/* Includes_END */
/* Externs_BEGIN */
/* Externs_END */
void LCD_Display_Start_wrapper(real_T *xD)
{
/* Start_BEGIN */
#ifndef MATLAB_MEX_FILE
int status;
    status = lcd.begin(LCD_COLS, LCD_ROWS); // Initialisierung des Displays
if(status)
{
hd44780::fatalError(status);
}
   
#endif
/* Start_END */
}
void LCD_Display_Outputs_wrapper(const uint8_T *DisplayStatus,
                                const real_T *xD)
{
/* Output_BEGIN */
#ifndef MATLAB_MEX_FILE
if ( displaystate != DisplayStatus[0] ) // Wenn sich der Displaystatus ändert
 
  {
 
    displaystate = DisplayStatus[0];
    switch(displaystate) // wird zwischen verschiedenen Displayausgaben gewechselt
    {
       
        case 0:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Bitte mit Taste");
    lcd.setCursor(0,1);
        lcd.print("A / B anmelden");
        break;
        case 1:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Bitte geben Sie");
    lcd.setCursor(0,1);
        lcd.print("den PIN ein!");
        break;
        case 2:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Eingabe korrekt");
        break;
       
        case 3:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("PIN falsch bitte");
        lcd.setCursor(0,1);
        lcd.print("erneut versuchen");
        break;
        case 4:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Funktionsauswahl");
    lcd.setCursor(0,1);
        lcd.print("Taste A / B / C");
        break;
        case 5:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Schloss wird");
    lcd.setCursor(0,1);
        lcd.print("entsperrt");
        break;
        case 6:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Zum Verriegeln");
    lcd.setCursor(0,1);
        lcd.print("[1] dr\365cken");
        break;
        case 7:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Finger auflegen");
    lcd.setCursor(0,1);
        lcd.print("und [1] dr\365cken");
        break;
        case 8:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Fingerabdruck");
    lcd.setCursor(0,1);
        lcd.print("wird gepr\365ft");
        break;
        case 9:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Fingerabdruck");
    lcd.setCursor(0,1);
        lcd.print("nicht erkannt");
        break;
        case 10:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("ALARM: ZUGRIFF");
    lcd.setCursor(0,1);
        lcd.print("VERWEIGERT");
        break;
        case 11:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Abdruck wird");
    lcd.setCursor(0,1);
        lcd.print("erneut gepr\365ft");
        break;
        case 12:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Fingerabdruck");
    lcd.setCursor(0,1);
        lcd.print("wurde gewechselt");
        break;
        case 13:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Finger ab- und");
    lcd.setCursor(0,1);
        lcd.print("auflegen [1]");
        break;
        case 14:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Zum PIN wechseln");
    lcd.setCursor(0,1);
        lcd.print("[1] dr\365cken");
        break;
        case 15:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Bitte 1. Ziffer");
    lcd.setCursor(0,1);
        lcd.print("vom PIN eingeben");
        break;
        case 16:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Bitte 2. Ziffer");
    lcd.setCursor(0,1);
        lcd.print("vom PIN eingeben");
        break;
        case 17:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Bitte 3. Ziffer");
    lcd.setCursor(0,1);
        lcd.print("vom PIN eingeben");
        break;
        case 18:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Bitte 4. Ziffer");
    lcd.setCursor(0,1);
        lcd.print("vom PIN eingeben");
        break;
        case 19:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("PIN erfolgreich");
    lcd.setCursor(0,1);
        lcd.print("gewechselt");
        break;
        case 20:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("T\365r ge\357ffnet");
    lcd.setCursor(0,1);
        lcd.print("Bitte schlie\342en");
        break;
    }
 
  }
#endif
/* Output_END */
}
void LCD_Display_Update_wrapper(const uint8_T *DisplayStatus,
                                real_T *xD)
{
/* Update_BEGIN */
/* Update_END */
}
void LCD_Display_Terminate_wrapper(real_T *xD)
{
/* Terminate_BEGIN */
/* Terminate_END */
}
</syntaxhighlight>
</pre>
</div>
<br clear = all>
===== Tastenfeld =====
<div class="mw-collapsible mw-collapsed">
<syntaxhighlight lang="cpp" style="border: none; background-color: #EFF1C1; font-size:small">
/* Includes_BEGIN */
#ifndef MATLAB_MEX_FILE
#include <Keypad.h>
const byte ROWS = 4; // rows
const byte COLS = 4; // columns
//Definition der Symbole des Tastenfelds
char hexaKeys[ROWS][COLS] = {
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};
byte rowPins[ROWS] = {9, 8, 7, 6}; //Pinbelegung der Reihen des Tastenfelds
byte colPins[COLS] = {5, 4, 3, 2}; //Pinbelegung der Spalten des Tastenfelds
//Initialisierung der Tastenfeldklasse
Keypad customKeypad = Keypad( makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS);
#endif
/* Includes_END */
/* Externs_BEGIN */
/* Externs_END */
void Tastenfeld_Start_wrapper(real_T *xD)
{
/* Start_BEGIN */
#ifndef MATLAB_MEX_FILE
#endif
/* Start_END */
}
void Tastenfeld_Outputs_wrapper(const uint8_T *TasteStatus,
                                uint8_T *Taste,
                                uint8_T *nTaste,
                                const real_T *xD)
{
/* Output_BEGIN */
#ifndef MATLAB_MEX_FILE
  if (TasteStatus[0] == 0 && nTaste[0] > 0) { nTaste[0] = 0; } // Reset des Tastencounters
  char customKey = customKeypad.getKey(); // Auslesen der Taste bei Betätigung
  if (customKey) {
    Taste[0] = customKey; // Speichern der Taste in Variable
    nTaste[0] += 1; // Erhöhung des Tastencounters
  }
#endif
/* Output_END */
}
void Tastenfeld_Update_wrapper(const uint8_T *TasteStatus,
                              uint8_T *Taste,
                              uint8_T *nTaste,
                              real_T *xD)
{
/* Update_BEGIN */
/* Update_END */
}
void Tastenfeld_Terminate_wrapper(real_T *xD)
{
/* Terminate_BEGIN */
/* Terminate_END */
}
</syntaxhighlight>
</pre>
</div>
<br clear = all>
</br>
==== Simulink Modell ====
Die drei verbleibenden Komponenten Endschalter, Piezo-Lautsprecher und Servo-Motor konnten Funktionsblöcken aus der Standard Simulink und Arduino Support Package Bibliothek direkt ausgelesen bzw. angesteuert werden. Da der Endschalter an PIN 11 des Arduinos angeschlossen ist, wurde ein Digital Input Block für PIN 11 verwendet, um den Status des Endschalters (Tür geöffnet / geschlossen) auszulesen. Weil der Endschalter als Öffner betrieben ist, gibt der Block eine 1 bei geöffneter Tür und 0 bei geschlossener Tür als Ausgabewert aus. Zur Verwendung des Piezo-Lautsprechers an PIN 12 benötigt es einen PWM-Signal Block, welcher auf eine feste Frequenz von 245.1 Hz eingestellt wurde. Dieser Block kann mit einem Eingabewert zwischen 0 und 255 für einen Pulsweitenmodulation von 0 bis 100% angesteuert werden. Der verwendete Block "Standard Servo Write" aus der Arduino Bibliothek benötigt einen Eingabewert in Grad, um den Servomotor an PIN 10 entsprechend zu drehen. In diesem Modell gibt es die beiden Fälle 0° für die Sperrung und 90° zur Entsperrung der Tür.
<br/>
<br/>
Die Anfertigung der Software für das Gesamtsystem befindet sich noch in Bearbeitung.
 
Nach Einbindung der einzelnen Komponenten in das Simulink Modell müssen diese noch miteinander logisch verknüpft werden, um die gewünschten Funktionen zu bieten. Bei diesem Projekt eignet sich Simulink Stateflow hervorragend für die logische Steuerung des Modells, da dies ermöglicht, die Ein- und Ausgangsvariablen der Komponenten über verschiedene Zustände (States) mit Übergangsbedingungen zu steuern. Alle Funktionsblöcke der einzelnen Komponenten werden an das sogenannte Stateflow-Chart angeschlossen, wodurch sich das in Abbildung 2.3a dargestellte Simulink Gesamtmodell ergibt.


<br/>
<br/>
Durch nachfolgende Programmablaufpläne (Abbildung 2.3a bis 2.3e) wird die vorläufige Planung des Hauptprogramms und der Unterfunktionen dargestellt.
[[Datei:SimulinkmodellSchließfach.png|1500px|mini|links|Abbildung 2.3a: Simulink Gesamtmodell elektronisches Schließfach, Original [[Datei:Schliessfach Simulink.zip|mini]] ]]
<br clear = all>


<br/>
<br/>
Um die Ein- und Ausgangsvariablen der S-Function-Blöcke im Stateflow-Chart nutzen zu können, mussten diese mit convert Blöcken versehen werden. Für die Eingangsvariablen musste zusätzlich ein Unit Delay Block (1/z) eingefügt werden, um den "algebraic loop error" in Simulink zu umgehen. Dieser tritt auf, wenn eine Input Variable in der gleichen Zeit zu der sie eingelesen wird für die Berechnung eines Outputs genutzt werden soll. Es muss somit eine kurze zeitliche Verschiebung für die Inputvariable eingefügt werden. Für das Tastenfeld wurde zusätzlich eine Matlab Funktion zur Umwandlung der Ausgabewerte in ASCII-Code in der jeweiligen Taste entsprechende Werte umgewandelt. Der Code der Tastenwertumwandlung ist zum ausklappen nachfolgend dargestellt.
<br/>
<div class="mw-collapsible mw-collapsed">
<syntaxhighlight lang="cpp" style="border: none; background-color: #EFF1C1; font-size:small">
function y = fcn(u)
if (u >= 48) && (u <= 57) %% Umwandlung für 0-9
    u = u - 48;     
end 
if (u >= 65) && (u <= 68) %% Umwandlung für A-D in 10-13
    u = u - 55;     
end 
if (u==35) %% Umwandlung von Raute in 15
    u = 15;
end
if (u==42) %% Umwandlung von Stern in 14
    u = 14;
end
y = u;
</syntaxhighlight>
</pre>
</div>
<br clear = all>
<br/>
Durch folgende Programmablaufpläne (Abbildung 2.4a bis 2.4e) wird die Planung des Hauptprogramms und der Unterfunktionen dargestellt. Der gezeigte Programmablauf mit Unterfunktionen soll im Stateflow-Chart umgesetzt werden.
<br/>
==== Programmablaufplan Hauptprogramm ====
==== Programmablaufplan Hauptprogramm ====
<div class="mw-collapsible mw-collapsed">
<div class="mw-collapsible mw-collapsed">


[[Datei:SchließfachMain.png|1200px|mini|links|Abbildung 2.3a: PAP Hauptprogramm]]
[[Datei:SchließfachMain.png|1200px|mini|links|Abbildung 2.4a: PAP Hauptprogramm, Original [[Datei:Programmablaufplan Schliessfach.zip|mini]] ]]
 
</pre>
</div>
<br clear = all>
 
===== Programmablaufplan Unterfunktionen =====
<div class="mw-collapsible mw-collapsed">
 
[[Datei:Alarmfunktion.png|800px|mini|links|Abbildung 2.4b: PAP Alarmfunktion]]
[[Datei:Entsperrung.png|800px|mini|rechts|Abbildung 2.4c: PAP Entsperrungsfunktion]]
<br clear = all>
[[Datei:PIN-Änderung.png|800px|mini|links|Abbildung 2.4d: PAP PIN-Änderung]]
[[Datei:FingerabdruckHinzu.png|800px|mini|rechts|Abbildung 2.4e: PAP Fingerabdruck wechseln]]


</pre>
</pre>
Zeile 271: Zeile 883:
<br clear = all>
<br clear = all>


==== Programmablaufplan Unterfunktionen ====
==== Stateflow Chart ====
In Abbildung 2.5 wird eine grobe Übersicht über das Stateflow-Chart geboten. Die einzelnen Funktionen wurden schrittweise unter Verwendung der "Monitor & Tune" Funktion von Simulink vor der Implementierung auf Fehler überprüft und diese behoben.
 
<div class="mw-collapsible mw-collapsed">
<div class="mw-collapsible mw-collapsed">


[[Datei:Alarmfunktion.png|800px|mini|links|Abbildung 2.3b: PAP Alarmfunktion]]
[[Datei:StateflowChart.jpg|1200px|mini|links|Abbildung 2.4a: Stateflow-Chart Hauptprogramm]]
[[Datei:Entsperrung.png|800px|mini|rechts|Abbildung 2.3c: PAP Entsperrungsfunktion]]
 
</pre>
</div>
<br clear = all>
<br clear = all>
[[Datei:PIN-Änderung.png|800px|mini|links|Abbildung 2.3d: PAP PIN-Änderung]]
[[Datei:FingerabdruckHinzu.png|800px|mini|rechts|Abbildung 2.3e: PAP Fingerabdruck hinzufügen]]


</br>
===== Subcharts =====
Aufgrund des Umfangs des Stateflow-Charts empfiehlt es sich, die States und Übergangsbedingungen der Funktionen einzeln zu betrachten, da sich diese im Zusammenhang nicht sinnvoll abbilden lassen. Die nachfolgenden Abbildungen 2.5a bis 2.5f zeigen die einzelnen Subcharts der Funktionen im Detail.
<div class="mw-collapsible mw-collapsed">
[[Datei:Eingabe FA.png|600px|mini|links|Abbildung 2.5a: Subchart Eingabe Fingerabdruck]]
[[Datei:Eingabe PIN.png|600px|mini|rechts|Abbildung 2.5b: Subchart Eingabe PIN]]
<br clear = all>
Wird aus dem Ausgangsstatus die entsprechende Taste A (Taste == 10) oder Taste B (Taste == 11) gedrückt, wird die jeweilige Entsperrfunktion mit PIN oder Fingerabdruck aktiviert und eine entsprechende Displayausgabe erscheint. Die Raute-Taste (Taste == 15) agiert hierbei als "zurück"-Taste. Bei der Fingerabdruckeingabe (Abbildung 2.5a) muss anschließend die Taste 1 betätigt werden, nachdem der Finger auf dem Sensor platziert wurde. Anschließend wird die Fingerabdruckerkennung des Sensors während dieses Zustands mehrfach pro Sekunde aktiviert. Findet der Sensor in einem bestimmten Zeitraum keine Übereinstimmung mit der Datenbank, wird ein Ton auf dem Piezo-Lautsprecher abgespielt und der Zähler für eine falsche Eingabe erhöht. Bei drei falschen Eingaben geht das Programm in die Alarmfunktion über und resettet den Zähler. Bei einer richtigen Eingabe wird ebenfalls der Zähler resettet, es wird entsprechende Displayausgabe gezeigt und man gelangt in die Funktionsauswahl.
</br></br>
Die PIN-Eingabe (Abbildung 2.5b läuft ähnlich ab wie die Fingerabdruckeingabe, mit dem einzigen Unterschied, dass ein Zähler für die Tastendrücke gestartet wird, um mit dem Wert der gedrückten Taste auch die Anzahl der Tastendrücke zu berücksichtigen. Ist nach vier Tastendrücken mindestens ein Wert der Tasten ungleich zum hinterlegten PIN Code, wird ebenfalls der Zähler für falsche Eingaben erhöht und die Funktion springt zum Ausgangspunkt zurück.
</br>
</br>
[[Datei:StateflowAlarmfunktion.png|500px|mini|links|Abbildung 2.5c: Subchart Alarmfunktion]]
[[Datei:StateflowEntsperrfunktion.png|500px|mini|rechts|Abbildung 2.5d: Subchart Entsperrfunktion]]
<br clear = all>
Wie bereits erwähnt, wird die Alarmfunktion (Abbildung 2.5c) aktiviert, wenn drei falsche Eingaben des Fingerabdrucks oder PINs stattfinden. Auf dem Display wird anschließend eine entsprechende Warnung dargestellt und abwechselnd für eine Sekunde ein Ton auf dem Piezo Lautsprecher abgespielt und eine Sekunde ausgeschaltet. Nach fünf Wiederholungen bzw. zehn Sekunden führt die Alarmfunktion zum Ausgangszustand des Stateflow-Charts zurück.
</br>
</br>
Die Entsperrfunktion (Abbildung 2.5d) wird mit der Taste A (Taste == 10) in der Funktionsauswahl aktiviert. Der Servomotor wird auf einen Winkel von 90° gestellt, um das Schließfach zu entsperren. Solange der Endschalter betätigt bzw. die Tür geschlossen ist, kann diese wieder bei Betätigung der Taste 1 gesperrt werden, während eine entsprechende Displayausgabe stattfindet. Bei erneuter Sperrung des Schließfachs gelangt der Algorithmus automatisch in den Ausgangszustand.
</br>
</br>
[[Datei:FA wechseln.png|600px|mini|links|Abbildung 2.5e: Subchart Fingerabdruck wechseln]]
[[Datei:PIN wechseln.png|1200px|mini|rechts|Abbildung 2.5f: Subchart PIN wechseln]]
<br clear = all>
In Abbildung 2.5e ist die Funktion zum Fingerabdruck wechseln dargestellt. Diese wird in der Funktionsauswahl mit der Taste C (Taste == 12) ausgewählt. Ähnlich wie bei der Fingerabdruckeingabe muss der Finger platziert werden und die Taste 1 betätigt werden. Anschließend wird der Fingerabdrucksensor aktiviert, um zwei Fotos aufzunehmen. Wenn die Merkmale übereinstimmen, wird der aktive Fingerabdruck in der Datenbank ausgetauscht. Wenn bei einer der beiden Zwischenschritten kein Fingerabdruck erkannt wird, kann dieser Vorgang beliebig oft wiederholt werden oder mit der "zurück"-Taste Raute (Taste == 15) beendet werden. Während des gesamten Vorgangs erscheinend entsprechende Ausgaben auf dem Display.
</br>
</br>
Wird in der Funktionsauswahl die Taste B (Taste == 11) betätigt, so gelangt man zur Funktion PIN wechseln (Abbildung 2.5f). Diese wird ebenfalls mit der Taste 1 gestartet, oder mit der Raute-Taste abgebrochen. Auf dem Display wird angezeigt, welche Stelle des PINs eingegeben werden soll. Es läuft erneut ein Tastendruckzähler, um die Anzahl der gedrückten Tasten zu bestimmen. Es können jetzt die vier Stellen des PINs über das Tastenfeld eingegeben werden, welche anschließend im EEPROM Speicher des Arduinos hinterlegt werden. Anschließend führt der Algorithmus zurück zur Funktionsauswahl. In der Funktionsauswahl kann als letztes noch die Taste d (Taste == 13) betätigt werden, um in den Ausgangszustand des Stateflow-Charts zurück zu gelangen.
</pre>
</pre>
</div>
</div>
Zeile 285: Zeile 929:


== Komponententest ==
== Komponententest ==
=== Test der Einzelkomponenten ===
=== Test der aktiven Einzelkomponenten ===
==== Fingerabdrucksensor ====
Die Funktion des Fingerabdrucksensors wurde mithilfe eines Sketches der Arduino-Bibliothek "Adafruit Fingerprint Sensor" überprüft, der Testaufbau dazu ist in Abbildung 3.3a abgebildet. Es konnte erfolgreich ein Fingerabdruck eingelesen und verifiziert werden, siehe Abbildung 3.3b.
 
<br/>
[[Datei:Fingerabdruck Test.jpg|400px|mini|links|Abbildung 3.3a: Testaufbau des Fingerabdrucksensors]]
[[Datei:Fingerabdruck Testausgabe.png|400px|mini|zentriert|Abbildung 3.3a: Ausgabe des seriellen Monitors]]
 
<br clear="all">


==== Servomotor ====
==== Servomotor ====
Zeile 305: Zeile 957:
<br clear="all">
<br clear="all">


==== Fingerabdrucksensor ====
==== LCD Display ====
Die Funktion des Fingerabdrucksensors wurde mithilfe eines Sketches der Arduino-Bibliothek "Adafruit Fingerprint Sensor" überprüft. Der Testaufbau ist in Abbildung 3.3a dargestellt. Es konnte erfolgreich ein Fingerabdruck eingelesen und verifiziert werden, siehe Abbildung 3.3b.
Eine Funktionsprüfung des 16x02 LCD Displays mit HD44780 I2C-Modul wurde mithilfe der Arduino-Bibliothek "HD44780" ermöglicht. Auf Abbildung 3.4 ist die Textausgabe auf dem LCD-Display gezeigt.  


<br/>
<br/>
[[Datei:Fingerabdruck Test.jpg|400px|mini|links|Abbildung 3.3a: Testaufbau des Fingerabdrucksensors]]
[[Datei:LCD Display Test.jpg|400px|mini|links|Abbildung 3.4: Testaufbau des Displays mit Textausgabe]]
[[Datei:Fingerabdruck Testausgabe.png|400px|mini|zentriert|Abbildung 3.3a: Ausgabe des seriellen Monitors]]


<br clear="all">
<br clear="all">


==== LCD Display ====
==== Tastenfeld ====
 
Die Funktion des Tastenfelds konnte ebenfalls durch die Verwendung einer Arduino-Bibliothek "Adafruit Keypad" getestet werden. Dazu wurde das Tastenfeld an 8 digitale I/O-Pins (Pin 2 bis Pin 9) des Arduinos angeschlossen, siehe Abbildung 3.5a. Testweise wurden alle Tasten betätigt und die Betätigung auf dem seriellen Monitor ausgegeben (Abbildung 3.5b).


<br/>
<br/>
[[Datei:Tastenfeld Testaufbau.jpg|400px|mini|links|Abbildung 3.5a: Testaufbau Tastenfeld]]
[[Datei:Tastenfeld Ausgabe.png|400px|mini|zentriert|Abbildung 3.5b: Ausgabe auf dem seriellen Monitor]]


<br clear="all">


==== Tastenfeld ====
=== Test des Gesamtsystems ===
<br/>
Nachdem die Umsetzung der Hard- und Software des Systems fertiggestellt wurde, konnte das Gesamtsystem getestet werden. Dazu wurde die Hardware-Monitoring Funktion von Matlab/Simulink verwendet, um den Programmablauf und die Ein- und Ausgangssignale des Simulink Modells im laufenden Betrieb zu überwachen. Zuerst wurden die beiden Eingabefunktionen für PIN und Fingerabdruck getestet. Für die Eingabe des PINs war auffällig, dass die Tasten des Tastenfelds etwas fester betätigt werden müssen, weil sonst manche Eingaben nicht registriert werden. Ansonsten funktionierten die Eingaben des PINs und Fingerabdrucks einwandfrei. Generell konnte jedoch festgestellt werden, dass der Bildschirm flackerte. Bei einer Fehlersuche konnte festgestellt werden, dass der Display wiederholt neu beschrieben wurde. Dies konnte durch hinzufügen einer if-Abfrage bei Änderung des Displaystatus behoben werden.
<br/>
<br/>
Als nächster Schritt wurde die Alarmfunktion des Schließfachs getestet. Dazu wurde jeweils drei mal ein falscher PIN bzw. Fingerabdruck eingegeben. Die Alarmfunktion wurde korrekt nach drei falschen Eingaben ausgeführt. Es konnte jedoch festgestellt werden, dass der Counter für falsche Eingaben bei einer korrekten Eingabe nicht zurückgesetzt wurde, was nachträglich behoben wurde.
<br/>
<br/>
Als letztes sollten noch die drei Funktionen Entsperren des Schließfachs (A), PIN wechseln (B) und Fingerabdruck wechseln (C) überprüft werden. Die Entsperrungsfunktion öffnete das Schließfach erfolgreich, jedoch konnte das Verriegeln auch bei geöffneter Tür durchgeführt werden, was durch das Hinzufügen einer Bedingung 'Endschalter geschlossen' zur Sperrung behoben wurde. Die Funktion zur PIN-Änderung konnte bei nachträglicher Implementierung der EEPROM-Speicherung den PIN auch im spannungslosen Zustand erfolgreich speichern. Beim Testen der Funktion "Fingerabdruck wechseln" gab es keine Probleme oder Auffälligkeiten. Somit konnte das System als funktionsfähig bewertet werden.
<br/>
<br/>
Im Anschluss an den Gesamttest wurde das System entsprechend der Anforderungsliste aus Tabelle 1 geprüft und die Ergebnisse in der folgenden Tabelle 3 festgehalten.
<br/>
{| class="wikitable"
! style="font-weight: bold;" | Nr.
! style="font-weight: bold;" | Beschreibung
! style="font-weight: bold;" | Kommentar
! style="font-weight: bold;" | Datum
! style="font-weight: bold;" | Status
|-
| 1
| Das elektronische Schließfach muss ein Bedienpanel mit Fingerabdruckerkennung und Tasten zur PIN-Code-Eingabe besitzen.
| Ein Tastenfeld und Fingerabdrucksensor ist auf der Vorderseite des Gehäuses vorhanden.
| 29.11.2023
| Erledigt
|-
| 2
| Das Bedienpanel muss über ein LCD-Display zur Visualisierung des Eingabestatus verfügen.
| Ein LCD-Display ist ebenfalls an der Gehäusevorderseite angebracht.
| 29.11.2023
| Erledigt
|-
| 3
| Für das Schließfach muss eine Spannungsquelle bereitgestellt werden.
| Als Spannungsquelle wird eine 9V-Block Batterie eingesetzt, welche ausreichend Energie für das System bereitstellt.
| 14.01.2024
| Erledigt
|-
| 4
| Als Mikrocontroller muss ein Arduino eingesetzt werden.
| Ein Arduino Mega 2560 wird als Mikrocontroller für das Projekt eingesetzt.
| 29.11.2023
| Erledigt
|-
| 5
| Als Schließmechanismus muss ein Servomotor mit Sperrriegel eingesetzt werden.
| Der Servomotor wurde mit dem Sperrriegel des Gehäuses verschraubt, um als Schließmechanismus zu agieren.
| 29.11.2023
| Erledigt
|-
| 6
| Für das Schließfach muss ein Gehäuse angefertigt werden.
| Es wurde ein Schaltschrankgehäuse aus ABS Kunststoff in den Abmaßen 250 x 350 x 150 mm bestellt und entsprechend bearbeitet.
| 29.11.2023
| Erledigt
|-
| 7
| Der Algorithmus muss die Signale der Fingerabdruck- und PIN-Code-Eingabe erfassen und verarbeiten.
| Eine Eingabe des PINs und Fingerabdrucks wird vom Algorithmus korrekt erkannt und zur Entriegelung des Schließfachs verarbeitet.
| 14.01.2024
| Erledigt
|-
| 8
| Der Schließmechanismus muss durch den Algorithmus betätigt werden.
| Durch den Algorithmus wird der Motor erfolgreich angesteuert und die Tür verriegelt oder entsperrt.
| 14.01.2024
| Erledigt
|-
| 9
| Der Algorithmus muss über eine Funktion zur Änderung des PIN-Codes bzw. Fingerabdrucks verfügen.
| Durch die Funktionen B und C in der Funktionsauswahl kann der gespeicherte PIN bzw. Fingerabdruck geändert werden.
| 14.01.2024
| Erledigt
|-
| 10
| Auf dem LCD Display muss der Eingabestatus durch den Algorithmus visualisiert werden.
| Der Algorithmus stellt 20 verschiedene Ausgaben für den jeweiligen Eingabestatus auf dem Bildschirm dar.
| 14.01.2024
| Erledigt
|-
| 11
| Der Algorithmus muss eine Alarmfunktion für wiederholt falsche Eingaben besitzen.
| Bei drei falschen PIN- oder Fingerabdruckeingaben wird die Alarmfunktion des Schließfachs aktiviert.
| 14.01.2024
| Erledigt
|-
| 12
| Die Umsetzung des Algorithmus muss unter Matlab/Simulink erfolgen.
| Der Algorithmus wurde mithilfe von Simulink und Simulink Stateflow realisiert.
| 14.01.2024
| Erledigt
|-
|+ style = "text-align: left"|Tabelle 3: Prüfung der Anforderungen
|}


== Ergebnis ==


<br/>
=== Hardwareentwicklung: ===
Als Lösung des hardwaretechnischen Aufbaus wurden die unter Kapitel 4, der Komponentenspezifikation aufgelisteten Komponenten zu einem System zusammengebaut. Dazu wurde das vorgefertigte Gehäuse mit Aussparungen versehen, sodass die Bedienungskomponenten des Schließfachs (Fingerabdrucksensor, LCD-Display, Fingerabdrucksensor) von außen bedient werden konnten. Alle Komponenten wurden auf der Innenseite der Schließfachtür mit Kunststoffwinkeln, Schrauben oder Montageklebeband montiert, mit Ausnahme des Endschalters. Eine Verdrahtung der Komponenten wurde mit entsprechenden Kabeln, Montagesockeln und Kabelbindern durchgeführt. Diese Lösung eignete sich am besten für das System, da so alle Komponenten mit geringem Aufwand an der optimalen Position montiert werden konnten.
</br>


=== Test des Gesamtsystems ===
=== Softwareentwicklung: ===
<br/>
Durch die Verwendung von Matlab/Simulink zur modellbasierten Programmierung des Systems musste für die Umsetzung der Software häufig Recherche und Ideenfindung betrieben werden. Als vermutlich beste Lösung wurde ein Simulink Modell mit Bausteinen aus dem Arduino-Support Package und dem S-Function Block erstellt. Die Nutzung von S-Functions ermöglichte eine Implementierung von C++ Code und Bibliotheken in Simulink, sodass der Fingerabdrucksensor, das LCD-Display und das Tastenfeld ins Simulink Modell eingebunden werden konnten. Für dieses Projekt eignete sich besonders die Verwendung von Simulink Stateflow Charts, da sich das elektronische Schließfach sehr gut in Zuständen darstellen lässt, wie beispielsweise die Zustände Tür geöffnet/geschlossen oder PIN Eingabe korrekt/falsch etc. Die Stateflow Charts ermöglichen eine modellbasierte Programmierung der Funktionalitäten des Systems durch Zustände, Übergangsfunktionen und Setzen von Variablen, welches sich beispielsweise hervorragend dazu eignet, beim Übergang von Zuständen wie "PIN-Eingabe" zu "PIN falsch" eine entsprechende Bildschirmausgabe zu setzen oder einen Counter zu erhöhen. Eine weitere Herausforderung war, den PIN dauerhaft zu speichern, da unter Simulink angelegte Variablen nur temporär gespeichert werden. Da der PIN des Schließfachs auch im ausgeschalteten bzw. spannungslosen Zustand gespeichert werden sollte, eignete sich die Implementierung des Arduino EEPROM Speichers hervorragend für diese Aufgabe. Die im EEPROM gespeicherten Daten bleiben auch im spannungslosen Zustand erhalten.
</br>
</br>
Das Ergebnis des Projekts ist somit ein funktionsfähiges elektronisches Schließfach mit den gewünschten Funktionen. Eine Demonstration findet im YouTube Video statt, welches unter dem gleichnamigen Kapitel zu finden ist.
</br>


== Ergebnis ==
Als Verbesserungsoptionen wäre die softwareseitige Implementierung einer zusätzlichen Funktion zur Speicherung von mehreren Fingerabdrucken möglich. Zusätzlich könnte ein Standby-Modus eingebaut werden, welcher das System in einen schlafenden Zustand versetzt, wenn keine Betätigung stattfindet. Mithilfe eines Standby-Modus könnte Energie eingespart werden, um die begrenzte Laufzeit der Spannungsquelle zu erhöhen. Außerdem könnte hardwareseitig auch ein Upgrade der Spannungsquelle auf einen Akku mit größerer Kapazität sinnvoll sein. Die Verwendung eines besseren Tastenfeld könnte ebenfalls von Vorteil sein, da die Tasten des verwendeten Tastenfelds stark betätigt werden müssen, um eine Eingabe zu registrieren.


== Zusammenfassung ==
== Zusammenfassung ==
=== Lessons Learned ===
=== Lessons Learned ===
Im Rahmen des GET Fachpraktikums konnten die Studierenden eigenständig neue Erkenntnisse und Fähigkeiten zu den verschiedenen Aufgabenbereichen innerhalb eines Projekts erarbeiten oder vertiefen. Zu diesen Bereichen gehörten beispielsweise:
</br>
</br>
Projektplanung und -entwicklung: Sämtliche Planungs- und Entwicklungsschritte von der Erstellung der Anforderungen und des Projektplans, Entwicklung des Systementwurfs, Bestellung von Bauteilen, Planung der Umsetzung von Hard- und Software bis hin zum Systemtest wurden im Verlauf des Projekts erlernt und angewendet.
</br>
</br>
Technische Dokumentation: Im Verlauf des Projekts wurde die für das System relevante technische Dokumentation erstellt und genutzt. Besonders der Verdrahtungsplan stellte sich als sehr nützlich heraus, da diesem beim ständigen Umbauen, Testen und der finalen Montage stets die korrekte Pinbelegung des Systems entnommen werden konnte.
</br>
</br>
Modellbasierte Programmierung mit Matlab/Simulink und Stateflow: Die Studierenden konnten ihre Fähigkeiten im modellbasierter Programmierung mit Funktionsblöcken unter Matlab/Simulink vertiefen und zusätzlich die Anwendung von Stateflow erlernen, da sich Stateflow besonders für das Projekt "elektronisches Schließfach" eignete. Zudem wurden die Fähigkeiten in hardwarenaher Fehlersuche mit der in Simulink integrierten "Monitor & Tune" Funktion erlernt. Desweiteren kamen die Studierenden zu der Erkenntnis, dass Softwareentwicklung oftmals mehr Zeit in Anspruch nimmt, als im Voraus eingeplant wurde. Daher ist es besonders wichtig, für das Projekt einen großzügigen Zeitpuffer einzuplanen.
</br>
</br>
Hard- und softwareseitige Problemlösung: Die Lösung von entwicklungstechnischen Problemen durch entsprechende Recherche, wie beispielsweise die dauerhafte Speicherung von Daten (PIN) im spannungslosen Zustand mithilfe der Verwendung des EEPROM Speichers, führten zu verbesserten Problemlösungskompetenzen.
</br>
</br>
Zusammenfassend kann also festgehalten werden, dass die Studierenden im Zuge des des GET-Fachpraktikums ein funktionierendes mechatronisches System als Projekt entwickeln konnten, welches die Themen der Projektplanung, Hard- und Softwareentwicklung und Dokumentation beinhaltete. Es konnten somit wichtige Erkenntnisse und Fähigkeiten in den genannten Aufgabenbereichen gewonnen werden.


== Projektunterlagen ==
== Projektunterlagen ==
Zeile 338: Zeile 1.108:


<br/>
<br/>
[[Datei:Projektplan Elektronisches Schließfach.png|2000px|mini|links|Abbildung 4.1: Projektplan Elektronisches Schließfach]]
[[Datei:Projektplan Elektronisches Schließfach.png|1600px|mini|links|Abbildung 4.1: Projektplan Elektronisches Schließfach, Original [[Datei:Projektplan Schließfach.zip|mini]] ]]


<br clear="all">
<br clear="all">
=== Projektdaten ===
Hier finden sie alle Projektdaten hinterlegt in einem ZIP-Archiv: [[Datei:ProjektdatenElektronischesSchliessfach.zip|mini]]


== YouTube Video ==
== YouTube Video ==
Der folgende Link führt sie zum Demonstrationsvideo dieses Projekts: https://www.youtube.com/watch?v=1acwHDea3j0


== Weblinks ==
== Weblinks ==
== Literatur ==


<!-- Fügen Sie diesen Footer hinzu.  -->
<!-- Fügen Sie diesen Footer hinzu.  -->
----
----
→ zurück zur Übersicht: [[:Kategorie:ProjekteET_MTR_BSE_WS2023|WS 23/24: Angewandte Elektrotechnik (BSE)]]
→ zurück zur Übersicht: [[:Kategorie:ProjekteET_MTR_BSE_WS2023|WS 23/24: Angewandte Elektrotechnik (BSE)]]
== Abbildungsverzeichnis ==

Aktuelle Version vom 17. Januar 2024, 21:52 Uhr

WS 23/24: Fachpraktikum Elektrotechnik (MTR) und Angewandte Elektrotechnik (BSE)

Autoren: Kilian Engelhardt & Jörn-Hendrik Beleke
Betreuer: Prof. Schneider


Einleitung

Das Projekt "Elektronisches Schließfach" entsteht im Rahmen des Praktikums "Fachpraktikum Elektrotechnik" im Studiengang "Mechatronik (MTR)".


Ziel des genannten Projekts ist die Entwicklung eines Schließfachs zum Verstauen privater Gegenstände, welches komfortabel durch die Eingabe eines PIN-Codes oder biometrischer Daten durch eine Fingerabdruckerkennung auf einem Bedienfeld durch den Besitzer entsperrt werden kann. Zusätzlich verfügt das Schließfach über Zahlentasten , wodurch die Öffnung des Schließfachs durch weitere Personen mit der Eingabe eines PIN-Codes ermöglicht wird. Zur Entsperrung des Verschlussriegels soll ein Servomotor eingesetzt werden. Über ein LCD-Display werden Anweisungen und der Eingabestatus für den Bediener dargestellt. Eine erfolgreiche sowie mehrfach fehlerhafte Eingabe soll akustisch durch einen Ton bzw. Alarm eines Summers und visuell durch das Leuchten von LEDS bestätigt werden. Zusätzlich wird eine Funktion zur Änderung des Zahlencodes und Fingerabdrucks implementiert.

Anforderungen

Die Anforderungen an das Projekt werden in der nachfolgenden Tabelle 1 aufgezeigt. Dabei sind diese in die Bereiche Hardware, Mechanik und Software unterteilt.

Nr. Beschreibung Bereich Datum Status
1 Das elektronische Schließfach muss ein Bedienpanel mit Fingerabdruckerkennung und Tastern zur PIN-Code-Eingabe besitzen. Hardware 04.10.2023 Erledigt
2 Das Bedienpanel muss über ein LCD-Display zur Visualisierung des Eingabestatus verfügen. Hardware 04.10.2023 Erledigt
3 Für das Schließfach muss eine Spannungsquelle bereitgestellt werden. Hardware 04.10.2023 Erledigt
4 Als Mikrocontroller muss ein Arduino eingesetzt werden. Hardware 04.10.2023 Erledigt
5 Als Schließmechanismus muss ein Servomotor mit Sperrriegel eingesetzt werden. Hardware 04.10.2023 Erledigt
6 Für das Schließfach muss ein Gehäuse angefertigt werden. Mechanik 04.10.2023 Erledigt
7 Der Algorithmus muss die Signale der Fingerabdruck- und PIN-Code-Eingabe erfassen und verarbeiten. Software 04.10.2023 Erledigt
8 Der Schließmechanismus muss durch den Algorithmus betätigt werden. Software 04.10.2023 Erledigt
9 Der Algorithmus muss über eine Funktion zur Änderung des PIN-Codes bzw. Fingerabdrucks verfügen. Software 04.10.2023 Erledigt
10 Auf dem LCD Display muss der Eingabestatus durch den Algorithmus visualisiert werden. Software 04.10.2023 Erledigt
11 Der Algorithmus muss eine Alarmfunktion für wiederholt falsche Eingaben besitzen. Software 04.10.2023 Erledigt
12 Die Umsetzung des Algorithmus muss unter Matlab/Simulink erfolgen. Software 04.10.2023 Erledigt
Tabelle 1: Auflistung der Anforderungen

Funktionaler Systementwurf/Technischer Systementwurf

Zur näheren Erläuterung wird der Systementwurf in Komponenten unterteilt:


  • Gehäuse: Das Gehäuse beinhaltet alle folgenden Komponenten und bietet die grundlegende Funktion eines Schließfachs in Kombination mit dem Schließmechanismus.
  • Schließmechanismus: Als Schließmechanismus wird ein Servomotor eingesetzt, welcher das Schließfach über einen Verschlussriegel öffnet oder sperrt.
  • Endschalter: Diese Komponente erfasst den geöffneten oder geschlossenen Zustand der Schließfachtür.
  • Tastenfeld: Das verwendete 4x4 Tastenfeld erfasst die Betätigung der Tasten und gibt das Zeichen der betätigten Taste als ASCII-Code aus.
  • Fingerabdrucksensor: Der Fingerabdrucksensor erfasst die Eingabe von biometrischen Daten. Dazu nimmt der Sensor Bilder der Fingerabdrücke auf. Das verwendete Fingerabdruckmodul besitzt einen digitalen Signalprozessor, welcher das Berechnen und Speichern von Fingerabdruckbildern, die Merkmalsfindung und Fingerabdrucksuche durchführt. Zur Ausführung der Funktionen können Befehlspakete von einem Mikrocontroller über eine serielle Schnittstelle an den DSP Chip gesendet werden. Gespeicherte Fingerabdruckbilder werden auf dem OnBoard Speicher des Moduls hinterlegt.
  • LCD-Display: Auf dem Display werden Anweisungen und der Eingabestatus für den Nutzer dargestellt.
  • Summer: Dieser Lautsprecher informiert den Nutzer akustisch über den Eingabestatus.
  • Arduino: An den Arduino Mikrocontroller sind die genannten elektrischen Komponenten angebunden. Der Mikrocontroller führt den Algorithmus aus, welcher die Eingaben des Nutzers auf dem Bedienpanel erfasst, verarbeitet und entsprechende Aktionen durch die Komponenten steuert.
  • Spannungsquelle: Als Spannungsquelle für den Arduino mit Platine wird eine 9V-Block-Batterie eingesetzt.


Die nachfolgenden Abbildungen 1.1 und 1.2 stellen eine Skizze des Systementwurfs sowie den Signalfluss des Systems dar.


Abbildung 1.1: Skizze des Systementwurfs, Original Datei:SkizzeSystementwurfSchließfach.pptx


Abbildung 1.2: Signalfluss des Systems, Original Datei:SkizzeSignalflussSchließfach.pptx


Komponentenspezifikation

In der nachfolgenden Tabelle 2 sind alle für das Projekt verwendeten Komponenten aufgelistet, welche anhand des Systementwurfs ausgewählt wurden.


Tabelle 2: Komponentenliste
Nr. Komponentenbezeichnung Beschreibung Bild
1 Arduino MEGA
  • ATmega2560 Prozessor
  • Versorgungsspannung: 7V-12V (empfohlen)
  • Betriebsspannung: 5V
  • 54 digitale Ein-/Ausgänge und 16 analoge Eingänge
mini
mini
[1]
2 Fingerabdrucksensor JM 101
  • Betriebsspannung: 5V
mini
mini
3 Mechanischer Endschalter
  • Ausführung: Wechslerkontakt
  • NC oder NO je nach Verschaltung
  • Betriebsspannung: 5V
mini
mini
4 MG90S Micro Servo
  • Betriebsspannung: 5V
  • Blockierdrehmoment: 2 kg/cm
  • Maximaler Drehwinkel: 180°
mini
mini
5 4x4 Tastenfeld
  • Betriebsspannung: 5V
  • 16 Tasten:
  • Zahlen 0 bis 9
  • Buchstaben A bis D
  • Sonderzeichen * und #
mini
mini
6 16x02 I2C LCD Modul
  • Betriebsspannung: 5V
  • 2 Zeichenreihen, 16 Zeichen pro Reihe
  • mit I2C HD44780 Modul, verlötet
mini
mini
7 Piezo Lautsprecher
  • Betriebsspannung: 5V
mini
mini
8 Spannungsquelle
  • 9V-Block-Akku
mini
mini
9 Montageplatte Arduino Mega
mini
mini
10 Industriegehäuse
  • Abmessungen: 250 x 350 x 150 mm
  • Material: ABS Kunststoff
mini
mini
[2]

Umsetzung (HW/SW)

Hardware

Montage der Komponenten

Nach den Funktionstests der Einzelkomponenten (siehe Kapitel Komponententest) wurden diese im Gehäuse verbaut. Dazu mussten entsprechende Aussparungen für den Fingerabdrucksensor, das Tastenfeld und das LCD-Display an der Schließfachtür angefertigt werden, siehe Abbildung 2.1a.

Um den Servomotor am Schließmechanismus zu befestigen, wurden Bohrungen in den Verschlussriegel des Schließmechanismus eingebracht. Mittels Schrauben wurde dann ein im Lieferumfang enthaltenes Verbindungsstück mit dem Motor und den Bohrungen verbunden. Wie in Abbildung 2.1b dargestellt, wurde der Motor anschließend über passend zugesägte Kunststoffwinkel an der Innenseite der Schließfachtür angebracht.

Der Endschalter (Abbildung 2.1c) wurde an der Innenkante des Gehäuses angebracht, sodass dieser betätigt wird, wenn die Tür geschlossen ist.


Abbildung 2.1a: Schließfachtür von außen
Abbildung 2.1b: Schließfachtür von innen
Abbildung 2.1c: Endschalter an Gehäuseinnenkante


Verdrahtung der Komponenten

Im Anschluss an die Montage der einzelnen Komponenten im Gehäuse mussten alle elektronischen Komponenten mit dem Arduino Mikrocontroller elektrisch verbunden werden. Dazu wurde der folgende Verdrahtungsplan nach Abbildung 2.2 für das Gesamtsystem angefertigt. Die Komponenten sind entsprechend der Komponentenliste nummeriert.


Abbildung 2.2a: Verdrahtungsplan des Gesamtsystems, Original Datei:VerdrahtungsplanSchließfach.fzz


Dem obigen Verdrahtungsplan entsprechend wurden dann die Komponenten miteinander verbunden und mit Montagesockeln und Kabelbindern im Gehäuse befestigt, wie in Abbildung 2.2b gezeigt.

Abbildung 2.2b: Verdrahtung des Gesamtsystems


Software


Die Umsetzung der Software für das Gesamtsystems des elektronischen Schließfachs erfolgt unter MATLAB Simulink. Da für dieses Projekt ein Arduino Mega 2560 als Mikrocontroller eingesetzt wird, wurde das "Simulink Support Package für Arduino Hardware" aus dem MATLAB Add-On Explorer zur einfachen Integration der Arduino-Hardware in Simulink installiert. Zusätzlich wird der Block "S-Function Builder" aus der Simulink Bibliothek zur Softwareentwicklung verwendet. Durch diesen Funktionsblock kann C++-Code in Simulink-Modellen integriert werden, was die Verwendung von Arduino-Bibliotheken zur Steuerung der Arduino-Hardware ermöglicht. Als Hilfestellung bei der Implementation der S-Funtions im Simulink-Modell wurde sich am folgenden Wiki-Artikel orientiert: https://wiki.hshl.de/wiki/index.php/Datei:S-Function_Tutorial.pdf

S-Functions

Insgesamt wurden vier S-Function Blöcke erstellt, um den Fingerabdrucksensor, das LCD-Display, das Tastenfeld und den EEPROM-Speicher des Arduinos in Simulink einzubinden. Der Quellcode für die jeweiligen S-Function Blöcke ist nachfolgend aufgeführt.

EEPROM Speicher
/* Includes_BEGIN */
#ifndef MATLAB_MEX_FILE

#include <math.h>
#include <EEPROM.h>

#endif
/* Includes_END */

/* Externs_BEGIN */

/* Externs_END */

void EEPROM_Speicher_Start_wrapper(real_T *xD)
{
/* Start_BEGIN */

/* Start_END */
}

void EEPROM_Speicher_Outputs_wrapper(const uint8_T *EingabePIN,
                                     const uint8_T *PinStatus,
                                     uint8_T *PIN,
                                     const real_T *xD)
{
/* Output_BEGIN */
#ifndef MATLAB_MEX_FILE

for (int i = 0; i < 4; i++) // Auslesen der vier EEPROM Addressen
  {

    PIN[i] = EEPROM.read(i);

  }

if (PinStatus[0] == 1) // Wenn das Passwort geändert wurde:
  {
    
    for (int i = 0; i < 4; i++) // Updaten der vier EEPROM Addressen
    {

        EEPROM.update(i, EingabePIN[i]);

    }

  }

#endif
/* Output_END */
}

void EEPROM_Speicher_Update_wrapper(const uint8_T *EingabePIN,
                                    const uint8_T *PinStatus,
                                    uint8_T *PIN,
                                    real_T *xD)
{
/* Update_BEGIN */

/* Update_END */
}

void EEPROM_Speicher_Terminate_wrapper(real_T *xD)
{
/* Terminate_BEGIN */

/* Terminate_END */
}


leseFingerabdruck
/* Includes_BEGIN */
#ifndef MATLAB_MEX_FILE
#include <Adafruit_Fingerprint.h>
#include <Wire.h>
#include <FingerprintFunctions.h>
#define mySerial Serial2

// Festlegen der Seriellen Schnittstelle des Fingerabdrucksensors auf Serial2
Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial);

// Anlegen der Programmvariablen
unsigned char state = 0;

#endif
/* Includes_END */

/* Externs_BEGIN */

/* Externs_END */

void leseFingerabdruck_Start_wrapper(real_T *xD)
{
/* Start_BEGIN */
#ifndef MATLAB_MEX_FILE

  delay(100);

  // Setzen der Baudrate für den seriellen Sensorport
  finger.begin(57600);
  
  // Überprüfen der Verbindung zum Fingerabdrucksensor
  delay(5);
  finger.verifyPassword();

  // Auslesen der Sensorparameter
  finger.getParameters();
  finger.getTemplateCount();

#endif
/* Start_END */
}

void leseFingerabdruck_Outputs_wrapper(const uint8_T *FingerEin,
                                       uint8_T *FingerStatus,
                                       const real_T *xD)
{
/* Output_BEGIN */
#ifndef MATLAB_MEX_FILE


    if (FingerEin[0] == 1) 
    {

        finger.LEDcontrol(true); // Einschalten des Fingerabdrucksensors
        state = getFingerprintID(finger); // Auslesen und Abgleich des Fingerabdrucks mit Sensordatenbank
        if (state > 0 && state < 121) { FingerStatus[0] = 1; delay(100); }

    }

    else if (FingerEin[0] == 2)
    {

        finger.LEDcontrol(true); // Einschalten des Fingerabdrucksensors
        state = getFingerprintEnroll(finger); // erstes Bild vom Fingerabdruck erstellen
        if (state == 2) { FingerStatus[0] = 2; delay(100); }
 
    }
    
    else if (FingerEin[0] == 3)
    {

        finger.LEDcontrol(true); // Einschalten des Fingerabdrucksensors
        state = getFingerprintEnroll1(finger); // zweites Bild vom Fingerabdruck erstellen
        if (state == 3) { FingerStatus[0] = 3; delay(100); } // bei Übereinstimmung in Sensordatenbank speichern

    }

    else
    {
        
        finger.LEDcontrol(false); // Ausschalten des Fingerabdrucksensors wenn nicht benötigt
        FingerStatus[0] = 0;
    
    }


#endif
/* Output_END */
}

void leseFingerabdruck_Update_wrapper(const uint8_T *FingerEin,
                                      uint8_T *FingerStatus,
                                      real_T *xD)
{
/* Update_BEGIN */

/* Update_END */
}

void leseFingerabdruck_Terminate_wrapper(real_T *xD)
{
/* Terminate_BEGIN */

/* Terminate_END */
}


LCD Display
/* Includes_BEGIN */
#ifndef MATLAB_MEX_FILE

#include <Wire.h>
#include <hd44780.h>
#include <hd44780ioClass/hd44780_I2Cexp.h>

// Anlegen der Displayvariablen
hd44780_I2Cexp lcd;

const char LCD_COLS = 16;
const char LCD_ROWS = 2;

unsigned char displaystate = 0;

#endif
/* Includes_END */

/* Externs_BEGIN */

/* Externs_END */

void LCD_Display_Start_wrapper(real_T *xD)
{
/* Start_BEGIN */
#ifndef MATLAB_MEX_FILE	

 int status;

    status = lcd.begin(LCD_COLS, LCD_ROWS); // Initialisierung des Displays
	if(status)
	{
		hd44780::fatalError(status);
	}
    
#endif
/* Start_END */
}

void LCD_Display_Outputs_wrapper(const uint8_T *DisplayStatus,
                                 const real_T *xD)
{
/* Output_BEGIN */
#ifndef MATLAB_MEX_FILE
if ( displaystate != DisplayStatus[0] ) // Wenn sich der Displaystatus ändert
  
  {
   
    displaystate = DisplayStatus[0]; 

    switch(displaystate) // wird zwischen verschiedenen Displayausgaben gewechselt
    {
        
        case 0:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Bitte mit Taste");
    	lcd.setCursor(0,1);
        lcd.print("A / B anmelden");
        break;

        case 1:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Bitte geben Sie");
    	lcd.setCursor(0,1);
        lcd.print("den PIN ein!");
        break;

        case 2:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Eingabe korrekt");
        break;
        
        case 3:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("PIN falsch bitte");
        lcd.setCursor(0,1);
        lcd.print("erneut versuchen");
        break;

        case 4:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Funktionsauswahl");
    	lcd.setCursor(0,1);
        lcd.print("Taste A / B / C");
        break;

        case 5:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Schloss wird");
    	lcd.setCursor(0,1);
        lcd.print("entsperrt");
        break;

        case 6:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Zum Verriegeln");
    	lcd.setCursor(0,1);
        lcd.print("[1] dr\365cken");
        break;

        case 7:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Finger auflegen");
    	lcd.setCursor(0,1);
        lcd.print("und [1] dr\365cken");
        break;

        case 8:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Fingerabdruck");
    	lcd.setCursor(0,1);
        lcd.print("wird gepr\365ft");
        break;
 
        case 9:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Fingerabdruck");
    	lcd.setCursor(0,1);
        lcd.print("nicht erkannt");
        break;

        case 10:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("ALARM: ZUGRIFF");
    	lcd.setCursor(0,1);
        lcd.print("VERWEIGERT");
        break;

        case 11:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Abdruck wird");
    	lcd.setCursor(0,1);
        lcd.print("erneut gepr\365ft");
        break;

        case 12:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Fingerabdruck");
    	lcd.setCursor(0,1);
        lcd.print("wurde gewechselt");
        break;

        case 13:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Finger ab- und");
    	lcd.setCursor(0,1);
        lcd.print("auflegen [1]");
        break;

        case 14:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Zum PIN wechseln");
    	lcd.setCursor(0,1);
        lcd.print("[1] dr\365cken");
        break;

        case 15:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Bitte 1. Ziffer");
    	lcd.setCursor(0,1);
        lcd.print("vom PIN eingeben");
        break;

        case 16:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Bitte 2. Ziffer");
    	lcd.setCursor(0,1);
        lcd.print("vom PIN eingeben");
        break;

        case 17:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Bitte 3. Ziffer");
    	lcd.setCursor(0,1);
        lcd.print("vom PIN eingeben");
        break;

        case 18:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Bitte 4. Ziffer");
    	lcd.setCursor(0,1);
        lcd.print("vom PIN eingeben");
        break;

        case 19:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("PIN erfolgreich");
    	lcd.setCursor(0,1);
        lcd.print("gewechselt");
        break;

        case 20:
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("T\365r ge\357ffnet");
    	lcd.setCursor(0,1);
        lcd.print("Bitte schlie\342en");
        break;

     }
  
  }

#endif
/* Output_END */
}

void LCD_Display_Update_wrapper(const uint8_T *DisplayStatus,
                                real_T *xD)
{
/* Update_BEGIN */

/* Update_END */
}

void LCD_Display_Terminate_wrapper(real_T *xD)
{
/* Terminate_BEGIN */

/* Terminate_END */
}


Tastenfeld
/* Includes_BEGIN */
#ifndef MATLAB_MEX_FILE

#include <Keypad.h>

const byte ROWS = 4; // rows
const byte COLS = 4; // columns

//Definition der Symbole des Tastenfelds
char hexaKeys[ROWS][COLS] = {
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};
byte rowPins[ROWS] = {9, 8, 7, 6}; //Pinbelegung der Reihen des Tastenfelds
byte colPins[COLS] = {5, 4, 3, 2}; //Pinbelegung der Spalten des Tastenfelds

//Initialisierung der Tastenfeldklasse
Keypad customKeypad = Keypad( makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS);

#endif
/* Includes_END */

/* Externs_BEGIN */

/* Externs_END */

void Tastenfeld_Start_wrapper(real_T *xD)
{
/* Start_BEGIN */
#ifndef MATLAB_MEX_FILE	

#endif
/* Start_END */
}

void Tastenfeld_Outputs_wrapper(const uint8_T *TasteStatus,
                                uint8_T *Taste,
                                uint8_T *nTaste,
                                const real_T *xD)
{
/* Output_BEGIN */
#ifndef MATLAB_MEX_FILE

  if (TasteStatus[0] == 0 && nTaste[0] > 0) { nTaste[0] = 0; } // Reset des Tastencounters

  char customKey = customKeypad.getKey(); // Auslesen der Taste bei Betätigung

  if (customKey) { 
    Taste[0] = customKey; // Speichern der Taste in Variable
    nTaste[0] += 1; // Erhöhung des Tastencounters
  }


#endif
/* Output_END */
}

void Tastenfeld_Update_wrapper(const uint8_T *TasteStatus,
                               uint8_T *Taste,
                               uint8_T *nTaste,
                               real_T *xD)
{
/* Update_BEGIN */

/* Update_END */
}

void Tastenfeld_Terminate_wrapper(real_T *xD)
{
/* Terminate_BEGIN */

/* Terminate_END */
}



Simulink Modell

Die drei verbleibenden Komponenten Endschalter, Piezo-Lautsprecher und Servo-Motor konnten Funktionsblöcken aus der Standard Simulink und Arduino Support Package Bibliothek direkt ausgelesen bzw. angesteuert werden. Da der Endschalter an PIN 11 des Arduinos angeschlossen ist, wurde ein Digital Input Block für PIN 11 verwendet, um den Status des Endschalters (Tür geöffnet / geschlossen) auszulesen. Weil der Endschalter als Öffner betrieben ist, gibt der Block eine 1 bei geöffneter Tür und 0 bei geschlossener Tür als Ausgabewert aus. Zur Verwendung des Piezo-Lautsprechers an PIN 12 benötigt es einen PWM-Signal Block, welcher auf eine feste Frequenz von 245.1 Hz eingestellt wurde. Dieser Block kann mit einem Eingabewert zwischen 0 und 255 für einen Pulsweitenmodulation von 0 bis 100% angesteuert werden. Der verwendete Block "Standard Servo Write" aus der Arduino Bibliothek benötigt einen Eingabewert in Grad, um den Servomotor an PIN 10 entsprechend zu drehen. In diesem Modell gibt es die beiden Fälle 0° für die Sperrung und 90° zur Entsperrung der Tür.

Nach Einbindung der einzelnen Komponenten in das Simulink Modell müssen diese noch miteinander logisch verknüpft werden, um die gewünschten Funktionen zu bieten. Bei diesem Projekt eignet sich Simulink Stateflow hervorragend für die logische Steuerung des Modells, da dies ermöglicht, die Ein- und Ausgangsvariablen der Komponenten über verschiedene Zustände (States) mit Übergangsbedingungen zu steuern. Alle Funktionsblöcke der einzelnen Komponenten werden an das sogenannte Stateflow-Chart angeschlossen, wodurch sich das in Abbildung 2.3a dargestellte Simulink Gesamtmodell ergibt.


Abbildung 2.3a: Simulink Gesamtmodell elektronisches Schließfach, Original Datei:Schliessfach Simulink.zip



Um die Ein- und Ausgangsvariablen der S-Function-Blöcke im Stateflow-Chart nutzen zu können, mussten diese mit convert Blöcken versehen werden. Für die Eingangsvariablen musste zusätzlich ein Unit Delay Block (1/z) eingefügt werden, um den "algebraic loop error" in Simulink zu umgehen. Dieser tritt auf, wenn eine Input Variable in der gleichen Zeit zu der sie eingelesen wird für die Berechnung eines Outputs genutzt werden soll. Es muss somit eine kurze zeitliche Verschiebung für die Inputvariable eingefügt werden. Für das Tastenfeld wurde zusätzlich eine Matlab Funktion zur Umwandlung der Ausgabewerte in ASCII-Code in der jeweiligen Taste entsprechende Werte umgewandelt. Der Code der Tastenwertumwandlung ist zum ausklappen nachfolgend dargestellt.


function y = fcn(u)

if (u >= 48) && (u <= 57) %% Umwandlung für 0-9 
    u = u - 48;       
end  

if (u >= 65) && (u <= 68) %% Umwandlung für A-D in 10-13
    u = u - 55;      
end  

if (u==35) %% Umwandlung von Raute in 15
    u = 15;
end

if (u==42) %% Umwandlung von Stern in 14
    u = 14;
end

y = u;



Durch folgende Programmablaufpläne (Abbildung 2.4a bis 2.4e) wird die Planung des Hauptprogramms und der Unterfunktionen dargestellt. Der gezeigte Programmablauf mit Unterfunktionen soll im Stateflow-Chart umgesetzt werden.


Programmablaufplan Hauptprogramm

Abbildung 2.4a: PAP Hauptprogramm, Original Datei:Programmablaufplan Schliessfach.zip


Programmablaufplan Unterfunktionen
Abbildung 2.4b: PAP Alarmfunktion
Abbildung 2.4c: PAP Entsperrungsfunktion


Abbildung 2.4d: PAP PIN-Änderung
Abbildung 2.4e: PAP Fingerabdruck wechseln


Stateflow Chart

In Abbildung 2.5 wird eine grobe Übersicht über das Stateflow-Chart geboten. Die einzelnen Funktionen wurden schrittweise unter Verwendung der "Monitor & Tune" Funktion von Simulink vor der Implementierung auf Fehler überprüft und diese behoben.

Abbildung 2.4a: Stateflow-Chart Hauptprogramm



Subcharts

Aufgrund des Umfangs des Stateflow-Charts empfiehlt es sich, die States und Übergangsbedingungen der Funktionen einzeln zu betrachten, da sich diese im Zusammenhang nicht sinnvoll abbilden lassen. Die nachfolgenden Abbildungen 2.5a bis 2.5f zeigen die einzelnen Subcharts der Funktionen im Detail.

Abbildung 2.5a: Subchart Eingabe Fingerabdruck
Abbildung 2.5b: Subchart Eingabe PIN


Wird aus dem Ausgangsstatus die entsprechende Taste A (Taste == 10) oder Taste B (Taste == 11) gedrückt, wird die jeweilige Entsperrfunktion mit PIN oder Fingerabdruck aktiviert und eine entsprechende Displayausgabe erscheint. Die Raute-Taste (Taste == 15) agiert hierbei als "zurück"-Taste. Bei der Fingerabdruckeingabe (Abbildung 2.5a) muss anschließend die Taste 1 betätigt werden, nachdem der Finger auf dem Sensor platziert wurde. Anschließend wird die Fingerabdruckerkennung des Sensors während dieses Zustands mehrfach pro Sekunde aktiviert. Findet der Sensor in einem bestimmten Zeitraum keine Übereinstimmung mit der Datenbank, wird ein Ton auf dem Piezo-Lautsprecher abgespielt und der Zähler für eine falsche Eingabe erhöht. Bei drei falschen Eingaben geht das Programm in die Alarmfunktion über und resettet den Zähler. Bei einer richtigen Eingabe wird ebenfalls der Zähler resettet, es wird entsprechende Displayausgabe gezeigt und man gelangt in die Funktionsauswahl.

Die PIN-Eingabe (Abbildung 2.5b läuft ähnlich ab wie die Fingerabdruckeingabe, mit dem einzigen Unterschied, dass ein Zähler für die Tastendrücke gestartet wird, um mit dem Wert der gedrückten Taste auch die Anzahl der Tastendrücke zu berücksichtigen. Ist nach vier Tastendrücken mindestens ein Wert der Tasten ungleich zum hinterlegten PIN Code, wird ebenfalls der Zähler für falsche Eingaben erhöht und die Funktion springt zum Ausgangspunkt zurück.

Abbildung 2.5c: Subchart Alarmfunktion
Abbildung 2.5d: Subchart Entsperrfunktion


Wie bereits erwähnt, wird die Alarmfunktion (Abbildung 2.5c) aktiviert, wenn drei falsche Eingaben des Fingerabdrucks oder PINs stattfinden. Auf dem Display wird anschließend eine entsprechende Warnung dargestellt und abwechselnd für eine Sekunde ein Ton auf dem Piezo Lautsprecher abgespielt und eine Sekunde ausgeschaltet. Nach fünf Wiederholungen bzw. zehn Sekunden führt die Alarmfunktion zum Ausgangszustand des Stateflow-Charts zurück.

Die Entsperrfunktion (Abbildung 2.5d) wird mit der Taste A (Taste == 10) in der Funktionsauswahl aktiviert. Der Servomotor wird auf einen Winkel von 90° gestellt, um das Schließfach zu entsperren. Solange der Endschalter betätigt bzw. die Tür geschlossen ist, kann diese wieder bei Betätigung der Taste 1 gesperrt werden, während eine entsprechende Displayausgabe stattfindet. Bei erneuter Sperrung des Schließfachs gelangt der Algorithmus automatisch in den Ausgangszustand.

Abbildung 2.5e: Subchart Fingerabdruck wechseln
Abbildung 2.5f: Subchart PIN wechseln


In Abbildung 2.5e ist die Funktion zum Fingerabdruck wechseln dargestellt. Diese wird in der Funktionsauswahl mit der Taste C (Taste == 12) ausgewählt. Ähnlich wie bei der Fingerabdruckeingabe muss der Finger platziert werden und die Taste 1 betätigt werden. Anschließend wird der Fingerabdrucksensor aktiviert, um zwei Fotos aufzunehmen. Wenn die Merkmale übereinstimmen, wird der aktive Fingerabdruck in der Datenbank ausgetauscht. Wenn bei einer der beiden Zwischenschritten kein Fingerabdruck erkannt wird, kann dieser Vorgang beliebig oft wiederholt werden oder mit der "zurück"-Taste Raute (Taste == 15) beendet werden. Während des gesamten Vorgangs erscheinend entsprechende Ausgaben auf dem Display.

Wird in der Funktionsauswahl die Taste B (Taste == 11) betätigt, so gelangt man zur Funktion PIN wechseln (Abbildung 2.5f). Diese wird ebenfalls mit der Taste 1 gestartet, oder mit der Raute-Taste abgebrochen. Auf dem Display wird angezeigt, welche Stelle des PINs eingegeben werden soll. Es läuft erneut ein Tastendruckzähler, um die Anzahl der gedrückten Tasten zu bestimmen. Es können jetzt die vier Stellen des PINs über das Tastenfeld eingegeben werden, welche anschließend im EEPROM Speicher des Arduinos hinterlegt werden. Anschließend führt der Algorithmus zurück zur Funktionsauswahl. In der Funktionsauswahl kann als letztes noch die Taste d (Taste == 13) betätigt werden, um in den Ausgangszustand des Stateflow-Charts zurück zu gelangen.


Komponententest

Test der aktiven Einzelkomponenten

Fingerabdrucksensor

Die Funktion des Fingerabdrucksensors wurde mithilfe eines Sketches der Arduino-Bibliothek "Adafruit Fingerprint Sensor" überprüft, der Testaufbau dazu ist in Abbildung 3.3a abgebildet. Es konnte erfolgreich ein Fingerabdruck eingelesen und verifiziert werden, siehe Abbildung 3.3b.


Abbildung 3.3a: Testaufbau des Fingerabdrucksensors
Abbildung 3.3a: Ausgabe des seriellen Monitors


Servomotor

Um die Funktion des Servomotors zu testen, wurde dieser in der Ausgangsstellung von 0° am Verschlussriegel im geschlossenen Zustand (waagerecht) montiert. Um den Verschlussriegel zu öffnen, musste dieser vom Servomotor um 90° gedreht werden. Dazu wurde ein Simulink-Modell erstellt, welches in Abbildung 3.1a und 3.1b dargestellt ist.


Abbildung 3.1a: Simulink-Modell Servo, 0° Ausgangsstellung
Abbildung 3.1b: Simulink-Modell Servo, 90° gedreht



Durch das maximale Drehmoment des Motors von 2kg/cm konnte der Verschlussriegel erfolgreich um 90° gedreht und somit in den geöffneten Zustand versetzt werden, wie in Abbildung 3.2a und 3.2b gezeigt.


Abbildung 3.2a: Servomotor in 0° Ausgangsstellung
Abbildung 3.2b: Servomotor in 90° Stellung


LCD Display

Eine Funktionsprüfung des 16x02 LCD Displays mit HD44780 I2C-Modul wurde mithilfe der Arduino-Bibliothek "HD44780" ermöglicht. Auf Abbildung 3.4 ist die Textausgabe auf dem LCD-Display gezeigt.


Abbildung 3.4: Testaufbau des Displays mit Textausgabe


Tastenfeld

Die Funktion des Tastenfelds konnte ebenfalls durch die Verwendung einer Arduino-Bibliothek "Adafruit Keypad" getestet werden. Dazu wurde das Tastenfeld an 8 digitale I/O-Pins (Pin 2 bis Pin 9) des Arduinos angeschlossen, siehe Abbildung 3.5a. Testweise wurden alle Tasten betätigt und die Betätigung auf dem seriellen Monitor ausgegeben (Abbildung 3.5b).


Abbildung 3.5a: Testaufbau Tastenfeld
Abbildung 3.5b: Ausgabe auf dem seriellen Monitor


Test des Gesamtsystems


Nachdem die Umsetzung der Hard- und Software des Systems fertiggestellt wurde, konnte das Gesamtsystem getestet werden. Dazu wurde die Hardware-Monitoring Funktion von Matlab/Simulink verwendet, um den Programmablauf und die Ein- und Ausgangssignale des Simulink Modells im laufenden Betrieb zu überwachen. Zuerst wurden die beiden Eingabefunktionen für PIN und Fingerabdruck getestet. Für die Eingabe des PINs war auffällig, dass die Tasten des Tastenfelds etwas fester betätigt werden müssen, weil sonst manche Eingaben nicht registriert werden. Ansonsten funktionierten die Eingaben des PINs und Fingerabdrucks einwandfrei. Generell konnte jedoch festgestellt werden, dass der Bildschirm flackerte. Bei einer Fehlersuche konnte festgestellt werden, dass der Display wiederholt neu beschrieben wurde. Dies konnte durch hinzufügen einer if-Abfrage bei Änderung des Displaystatus behoben werden.

Als nächster Schritt wurde die Alarmfunktion des Schließfachs getestet. Dazu wurde jeweils drei mal ein falscher PIN bzw. Fingerabdruck eingegeben. Die Alarmfunktion wurde korrekt nach drei falschen Eingaben ausgeführt. Es konnte jedoch festgestellt werden, dass der Counter für falsche Eingaben bei einer korrekten Eingabe nicht zurückgesetzt wurde, was nachträglich behoben wurde.

Als letztes sollten noch die drei Funktionen Entsperren des Schließfachs (A), PIN wechseln (B) und Fingerabdruck wechseln (C) überprüft werden. Die Entsperrungsfunktion öffnete das Schließfach erfolgreich, jedoch konnte das Verriegeln auch bei geöffneter Tür durchgeführt werden, was durch das Hinzufügen einer Bedingung 'Endschalter geschlossen' zur Sperrung behoben wurde. Die Funktion zur PIN-Änderung konnte bei nachträglicher Implementierung der EEPROM-Speicherung den PIN auch im spannungslosen Zustand erfolgreich speichern. Beim Testen der Funktion "Fingerabdruck wechseln" gab es keine Probleme oder Auffälligkeiten. Somit konnte das System als funktionsfähig bewertet werden.

Im Anschluss an den Gesamttest wurde das System entsprechend der Anforderungsliste aus Tabelle 1 geprüft und die Ergebnisse in der folgenden Tabelle 3 festgehalten.

Nr. Beschreibung Kommentar Datum Status
1 Das elektronische Schließfach muss ein Bedienpanel mit Fingerabdruckerkennung und Tasten zur PIN-Code-Eingabe besitzen. Ein Tastenfeld und Fingerabdrucksensor ist auf der Vorderseite des Gehäuses vorhanden. 29.11.2023 Erledigt
2 Das Bedienpanel muss über ein LCD-Display zur Visualisierung des Eingabestatus verfügen. Ein LCD-Display ist ebenfalls an der Gehäusevorderseite angebracht. 29.11.2023 Erledigt
3 Für das Schließfach muss eine Spannungsquelle bereitgestellt werden. Als Spannungsquelle wird eine 9V-Block Batterie eingesetzt, welche ausreichend Energie für das System bereitstellt. 14.01.2024 Erledigt
4 Als Mikrocontroller muss ein Arduino eingesetzt werden. Ein Arduino Mega 2560 wird als Mikrocontroller für das Projekt eingesetzt. 29.11.2023 Erledigt
5 Als Schließmechanismus muss ein Servomotor mit Sperrriegel eingesetzt werden. Der Servomotor wurde mit dem Sperrriegel des Gehäuses verschraubt, um als Schließmechanismus zu agieren. 29.11.2023 Erledigt
6 Für das Schließfach muss ein Gehäuse angefertigt werden. Es wurde ein Schaltschrankgehäuse aus ABS Kunststoff in den Abmaßen 250 x 350 x 150 mm bestellt und entsprechend bearbeitet. 29.11.2023 Erledigt
7 Der Algorithmus muss die Signale der Fingerabdruck- und PIN-Code-Eingabe erfassen und verarbeiten. Eine Eingabe des PINs und Fingerabdrucks wird vom Algorithmus korrekt erkannt und zur Entriegelung des Schließfachs verarbeitet. 14.01.2024 Erledigt
8 Der Schließmechanismus muss durch den Algorithmus betätigt werden. Durch den Algorithmus wird der Motor erfolgreich angesteuert und die Tür verriegelt oder entsperrt. 14.01.2024 Erledigt
9 Der Algorithmus muss über eine Funktion zur Änderung des PIN-Codes bzw. Fingerabdrucks verfügen. Durch die Funktionen B und C in der Funktionsauswahl kann der gespeicherte PIN bzw. Fingerabdruck geändert werden. 14.01.2024 Erledigt
10 Auf dem LCD Display muss der Eingabestatus durch den Algorithmus visualisiert werden. Der Algorithmus stellt 20 verschiedene Ausgaben für den jeweiligen Eingabestatus auf dem Bildschirm dar. 14.01.2024 Erledigt
11 Der Algorithmus muss eine Alarmfunktion für wiederholt falsche Eingaben besitzen. Bei drei falschen PIN- oder Fingerabdruckeingaben wird die Alarmfunktion des Schließfachs aktiviert. 14.01.2024 Erledigt
12 Die Umsetzung des Algorithmus muss unter Matlab/Simulink erfolgen. Der Algorithmus wurde mithilfe von Simulink und Simulink Stateflow realisiert. 14.01.2024 Erledigt
Tabelle 3: Prüfung der Anforderungen

Ergebnis

Hardwareentwicklung:

Als Lösung des hardwaretechnischen Aufbaus wurden die unter Kapitel 4, der Komponentenspezifikation aufgelisteten Komponenten zu einem System zusammengebaut. Dazu wurde das vorgefertigte Gehäuse mit Aussparungen versehen, sodass die Bedienungskomponenten des Schließfachs (Fingerabdrucksensor, LCD-Display, Fingerabdrucksensor) von außen bedient werden konnten. Alle Komponenten wurden auf der Innenseite der Schließfachtür mit Kunststoffwinkeln, Schrauben oder Montageklebeband montiert, mit Ausnahme des Endschalters. Eine Verdrahtung der Komponenten wurde mit entsprechenden Kabeln, Montagesockeln und Kabelbindern durchgeführt. Diese Lösung eignete sich am besten für das System, da so alle Komponenten mit geringem Aufwand an der optimalen Position montiert werden konnten.

Softwareentwicklung:

Durch die Verwendung von Matlab/Simulink zur modellbasierten Programmierung des Systems musste für die Umsetzung der Software häufig Recherche und Ideenfindung betrieben werden. Als vermutlich beste Lösung wurde ein Simulink Modell mit Bausteinen aus dem Arduino-Support Package und dem S-Function Block erstellt. Die Nutzung von S-Functions ermöglichte eine Implementierung von C++ Code und Bibliotheken in Simulink, sodass der Fingerabdrucksensor, das LCD-Display und das Tastenfeld ins Simulink Modell eingebunden werden konnten. Für dieses Projekt eignete sich besonders die Verwendung von Simulink Stateflow Charts, da sich das elektronische Schließfach sehr gut in Zuständen darstellen lässt, wie beispielsweise die Zustände Tür geöffnet/geschlossen oder PIN Eingabe korrekt/falsch etc. Die Stateflow Charts ermöglichen eine modellbasierte Programmierung der Funktionalitäten des Systems durch Zustände, Übergangsfunktionen und Setzen von Variablen, welches sich beispielsweise hervorragend dazu eignet, beim Übergang von Zuständen wie "PIN-Eingabe" zu "PIN falsch" eine entsprechende Bildschirmausgabe zu setzen oder einen Counter zu erhöhen. Eine weitere Herausforderung war, den PIN dauerhaft zu speichern, da unter Simulink angelegte Variablen nur temporär gespeichert werden. Da der PIN des Schließfachs auch im ausgeschalteten bzw. spannungslosen Zustand gespeichert werden sollte, eignete sich die Implementierung des Arduino EEPROM Speichers hervorragend für diese Aufgabe. Die im EEPROM gespeicherten Daten bleiben auch im spannungslosen Zustand erhalten.

Das Ergebnis des Projekts ist somit ein funktionsfähiges elektronisches Schließfach mit den gewünschten Funktionen. Eine Demonstration findet im YouTube Video statt, welches unter dem gleichnamigen Kapitel zu finden ist.

Als Verbesserungsoptionen wäre die softwareseitige Implementierung einer zusätzlichen Funktion zur Speicherung von mehreren Fingerabdrucken möglich. Zusätzlich könnte ein Standby-Modus eingebaut werden, welcher das System in einen schlafenden Zustand versetzt, wenn keine Betätigung stattfindet. Mithilfe eines Standby-Modus könnte Energie eingespart werden, um die begrenzte Laufzeit der Spannungsquelle zu erhöhen. Außerdem könnte hardwareseitig auch ein Upgrade der Spannungsquelle auf einen Akku mit größerer Kapazität sinnvoll sein. Die Verwendung eines besseren Tastenfeld könnte ebenfalls von Vorteil sein, da die Tasten des verwendeten Tastenfelds stark betätigt werden müssen, um eine Eingabe zu registrieren.

Zusammenfassung

Lessons Learned

Im Rahmen des GET Fachpraktikums konnten die Studierenden eigenständig neue Erkenntnisse und Fähigkeiten zu den verschiedenen Aufgabenbereichen innerhalb eines Projekts erarbeiten oder vertiefen. Zu diesen Bereichen gehörten beispielsweise:

Projektplanung und -entwicklung: Sämtliche Planungs- und Entwicklungsschritte von der Erstellung der Anforderungen und des Projektplans, Entwicklung des Systementwurfs, Bestellung von Bauteilen, Planung der Umsetzung von Hard- und Software bis hin zum Systemtest wurden im Verlauf des Projekts erlernt und angewendet.

Technische Dokumentation: Im Verlauf des Projekts wurde die für das System relevante technische Dokumentation erstellt und genutzt. Besonders der Verdrahtungsplan stellte sich als sehr nützlich heraus, da diesem beim ständigen Umbauen, Testen und der finalen Montage stets die korrekte Pinbelegung des Systems entnommen werden konnte.

Modellbasierte Programmierung mit Matlab/Simulink und Stateflow: Die Studierenden konnten ihre Fähigkeiten im modellbasierter Programmierung mit Funktionsblöcken unter Matlab/Simulink vertiefen und zusätzlich die Anwendung von Stateflow erlernen, da sich Stateflow besonders für das Projekt "elektronisches Schließfach" eignete. Zudem wurden die Fähigkeiten in hardwarenaher Fehlersuche mit der in Simulink integrierten "Monitor & Tune" Funktion erlernt. Desweiteren kamen die Studierenden zu der Erkenntnis, dass Softwareentwicklung oftmals mehr Zeit in Anspruch nimmt, als im Voraus eingeplant wurde. Daher ist es besonders wichtig, für das Projekt einen großzügigen Zeitpuffer einzuplanen.

Hard- und softwareseitige Problemlösung: Die Lösung von entwicklungstechnischen Problemen durch entsprechende Recherche, wie beispielsweise die dauerhafte Speicherung von Daten (PIN) im spannungslosen Zustand mithilfe der Verwendung des EEPROM Speichers, führten zu verbesserten Problemlösungskompetenzen.

Zusammenfassend kann also festgehalten werden, dass die Studierenden im Zuge des des GET-Fachpraktikums ein funktionierendes mechatronisches System als Projekt entwickeln konnten, welches die Themen der Projektplanung, Hard- und Softwareentwicklung und Dokumentation beinhaltete. Es konnten somit wichtige Erkenntnisse und Fähigkeiten in den genannten Aufgabenbereichen gewonnen werden.

Projektunterlagen

Projektplan

Zur Planung der Projektdurchführung wurde der folgende Gantt-Projektplan (Abbildung 4.1) mit den einzelnen Projektvorgängen und Meilensteinen erstellt.


Abbildung 4.1: Projektplan Elektronisches Schließfach, Original Datei:Projektplan Schließfach.zip


Projektdaten

Hier finden sie alle Projektdaten hinterlegt in einem ZIP-Archiv: Datei:ProjektdatenElektronischesSchliessfach.zip

YouTube Video

Der folgende Link führt sie zum Demonstrationsvideo dieses Projekts: https://www.youtube.com/watch?v=1acwHDea3j0

Weblinks


→ zurück zur Übersicht: WS 23/24: Angewandte Elektrotechnik (BSE)

Abbildungsverzeichnis