Skip to main content
shopping_basket Warenkorb 0
Einloggen

Ein Zugangskontrollsystem mit Sprecherüberprüfung

AndreaGalizia
0

Zwei-Faktor-Authentifizierung mit einem Riverdi IoT Display-Modul und dem Spracherkennungssystem EasyVR 3 Plus.

Wir sind es heute gewöhnt, Geräte mit einfachen Sprachbefehlen zu steuern. Dank Projekten wie Google Assistant oder Alexa können Sie mit einem virtuellen Assistenten nicht nur die Beleuchtung per Fernbedienung einschalten, sondern auch Informationen zum aktuellen Wetter erfragen oder eine Pizza bestellen.

Dieser Trend findet auch bei den Herstellern von Unterhaltungselektronik Beachtung, die Sprachsteuerungssysteme in ihre Module integrieren. Damit in einem Produkt vollwertige Assistenten (z. B. Google Assistant, Siri oder Alexa) zum Einsatz kommen können, muss ein voll funktionsfähiges Android- oder iOS-System darauf laufen. Dies zwingt die Entwickler, das Gerät mit ausreichender Rechenleistung auszustatten und erhöht die Produktentwicklungszeit sowohl im Hardwarebereich als auch bei der Programmierung drastisch.

Zwei-Faktor-Authentifizierung mit Sprecherüberprüfung

Diese bequeme Bedienung wollten wir auch im Bereich der digitalen Sicherheit anbieten. Deshalb haben wir eine Demo erstellt, die Ihnen zeigt, wie Sie eine Zwei-Faktor-Authentifizierung für Riverdi-Displays implementieren können. Als zweiter Faktor dient eine Sprecherüberprüfung, die mit der innovativen Technologie von Sensory umgesetzt wurde. Dies ist das erste Projekt dieser Art. 

In diesem Artikel beschreiben wir, wie wir mit dem intelligenten Riverdi IoT Display-Modul, der eigens zur bequemen Erstellung von Python-Anwendungen geschaffenen Programmierumgebung Zerynth und dem komplexen Spracherkennungsmodul EasyVR 3 Plus von Fortebit ein Raumzugangskontrollsystem mit Zwei-Faktor-Authentifizierung (Eingabe eines PIN-Code und laut ausgesprochenes individuelles Zugangspasswort) erstellen. Die Interaktion mit dem Benutzersystem erfolgt über eine grafische Benutzeroberfläche auf dem 5-Zoll-Grafikdisplay des Riverdi IoT Display-Moduls und mit über das EasyVR 3 Plus-Modul generierten Sprachnachrichten.

Blockdiagramm des implementierten Projekts

Bevor wir beginnen, den Code zu schreiben, analysieren wir zunächst das Blockdiagramm unserer Anwendung.

Wenn es um einfache grafische Oberflächen geht, sollten Sie sich die Zeit nehmen, eine klare und funktionale Beschreibung für jeden Bildschirm zu erstellen (wie weiter unten in Abbildung 1 gezeigt).

  1. Riverdi-Logo: Der erste Bildschirm zeigt das Logo von Riverdi und bestätigt, dass das Display hochgefahren wurde.
  2. Riverdi-Bildschirmschoner: Der Bildschirmschoner zeigt mit einer einfachen Grafik, die ständig in Bewegung bleibt, dass das Gerät inaktiv ist. Das Fortebit EasyVR-Modul aktiviert das Display, wenn man „Hello Device“ sagt. Der Auslösebefehl beruht auf einer sprecherunabhängigen (Speaker Independent, SI) Technologie, im Gegensatz zur Sprecherüberprüfung (Speaker Verification, SV), die beim Sprachpasswort zum Einsatz kommt.
  3. PIN-Pad: Als Nächstes muss der Benutzer einen PIN-Code eingeben (die entsprechende Aufforderung wird auch als Audio-Nachricht abgespielt). Wenn der PIN-Code falsch eingegeben wurde, erfolgt eine Aufforderung zur erneuten Eingabe. Bei Inaktivität wechselt die Anwendung in den Standardmodus des Bildschirmschoners. Durch Eingabe des korrekten PIN-Codes gelangt der Benutzer zum nächsten Teil der Autorisierung.
  4. Eingabe des Sprachpassworts: Der Benutzer muss ein individuelles Passwort aussprechen (Spracherkennung mit der sprecherabhängigen Option SD – Speaker Dependent). Wird das dem jeweiligen PIN-Code und Benutzer zugewiesene Passwort korrekt ausgesprochen, wird der Bildschirm „Aceess Granted“ angezeigt und das Steuerungsrelais für die elektromagnetische Sperre 5 Sekunden lang aktiviert. Danach wird die Tür wieder verriegelt und die Benutzeroberfläche zeigt wieder den Bildschirmschoner.

Zwei-Faktor-Authentifizierung:

Abbildung 1: Blockdiagramm des implementierten Zugangsmoduls

Ausgewählte Hardwarelösung

Im vorherigen Abschnitt konnten wir das Bedienmodul des implementierten Zugangsmoduls recht gut definieren. Betrachten wir nun die zur Umsetzung der Konstruktion nötige Ausrüstung, so können wir die entsprechenden Anforderungen genau definieren:

  • EasyVR-Modul zur Implementierung von Spracherkennungsalgorithmen und Generierung von Sprachnachrichten,
  • ein integriertes Modul mit einem Mikrocontroller und einem hochwertigen 5-Zoll-Display,
  • einfache Erweiterungsmöglichkeiten ohne zusätzliche Lötverbindungen (optimalerweise sollte der im Lieferumfang des EasyVR-Moduls enthaltene microBUS-Steckverbinder verfügbar sein),
  • optionale Unterstützung bestimmter Zusatzgeräte in Frameworks mit einfacher Code-Erstellung in höheren Programmiersprachen (z. B. Python).

Berücksichtigen wir alle Anforderungen für die Umsetzung des Projektes (ein qualitativ hochwertiges Display mit kapazitivem Touchscreen, verfügbare microBUS-Anschlüsse und Kompatibilität mit der Programmierumgebung Zerynth, mit der wir Anwendungen direkt in Python vorbereiten können), so landen wir schnell beim Riverdi IoT Display-Modul mit integriertem LCD-Display-System (5 Zoll Bildschirmdiagonale und Bildschirmauflösung 800x480), dem Grafik-Controller Bridgetek BT81x und dem bekannten Mikroprozessor ESP32. Bei allen intelligenten IoT-Displays von Riverdi ist eine Lizenz für Zerynth Studio im Lieferumfang enthalten, sodass wir mit dem Modul sofort arbeiten können, nachdem wir es ausgepackt haben. Hier eine kurze Zusammenfassung und Charakterisierung unserer Hardware-Entscheidungen:

Riverdi IoT-Display: Dieses Modul ist das Herzstück unseres Projekts. Dank dem kapazitiven 5-Zoll-Display mit einer Auflösung von 800x480 und dem Grafik-Controller BT815 können wir ganz einfach in kurzer Zeit eine grafische Benutzeroberfläche erstellen, ohne alle Komponenten der Benutzeroberfläche selbst erstellen zu müssen. Letztendlich werden wir das Modul als ästhetisch gestaltetes Wandmodul montieren (siehe Abbildung 2).

Abbildung 2: Riverdi IoT Display-Modul

EasyVR 3 Plus: Dieses Modul dient zur Umsetzung von Spracherkennungs- und Sprachanalyseaufgaben, zur Wiedergabe von zuvor aufgezeichneten Audiobeispielen und als Ergänzung für die grafische Benutzeroberfläche auf dem Display. Eine wichtige Funktion des EasyVR-Moduls ist die Aufteilung der Befehle in „Sprecherunabhängig“ („Speaker Independent“, SI), „Sprecherabhängig“ („Speaker Dependent“, SD) und „Sprecherüberprüfung“ („Speaker Verification“, SV). Standardmäßig sind im Modul grundlegende, für Automatisierungssysteme typische SI-Befehle und allgemeine Befehle zur Festlegung von Anweisungen, Zahlen oder Aktionsbefehlen vorprogrammiert. Außerdem gibt es die Möglichkeit, über die eigens zu diesem Zweck entwickelte Software QT2SI Lite personalisierte SI-Anweisungen hochzuladen.

Abbildung 3: Spracherkennungsmodul EasyVR 3 (Plus)

Relay Click: Auf dem Modul befindet sich die MikroBUS-Platine (820-9858) von MikroElektronika mit zwei Relaisausgängen und Statussignalisierung über LEDs. Nach der Implementierung wird der Relaisausgang in unserem Projekt für die Steuerung der elektromagnetischen Verriegelung verantwortlich sein. 

Abbildung 4: Relaisplatine „Relay Click“

Und die Montage des gesamten Systems? Könnte nicht einfacher sein! 

Verbinden Sie das „Relay Click“ und die EasyVR-Module wie auf den Markierungen der Leiterplatte angegeben mit den microBUS-Anschlüssen des Riverdi IoT Display-Moduls, schließen Sie das dadurch entstandene Set mit einem micro-USB-Kabel an den Computer an – und fertig! Jetzt können wir die Software vorbereiten.

Entwicklungsumgebung

Zerynth ist eine Programmierumgebung zur schnellen, einfachen und bequemen Erstellung von Python-Software (es können auch Funktionen in C implementiert werden) auf den gängigsten eingebetteten Systemen. Die Vorbereitung des Zugangsmoduls wird durch eine große Anzahl unterstützter Hardwareplattformen (einschließlich des Riverdi IoT-Displays) und gebrauchsfertiger Softwarebibliotheken (z. B. auch eine Bibliothek, die den Betrieb des EasyVR-Moduls ermöglicht) erheblich beschleunigt und erleichtert.

Abbildung 5: In Zerynth Studio integrierter Code-Editor

EasyVR Commander: Zur Verwaltung des EasyVR-Moduls (zum Beispiel zur Erstellung eigener Sprachbefehle, zum Hochladen von Audiobeispielen oder zur Konfiguration des Moduls) wurde eine spezielle Anwendung namens EasyVR Commander mit einer einfachen und intuitiven grafischen Benutzeroberfläche entwickelt (siehe Abbildung 6).

Abbildung 6: Das Hauptfenster des EasyVR Commander

Konfiguration des EasyVR-Moduls

Wir beginnen die Konfiguration mit dem Modul Fortebit EasyVR 3. Es wird über den im Lieferumfang enthaltenen USB-UART-Signalwandler mit dem Computer verbunden. Zunächst starten wir EasyVR Commander, wählen dann den seriellen Anschluss aus und klicken auf die Schaltfläche „Verbinden“. Die Anwendung liest automatisch die aktuell im Modul programmierten Befehlsgruppen aus und zeigt sie als Liste an (siehe Abbildung 7).

Abbildung 7: Liste der im EasyVR-Modul ausgelesenen Befehlsgruppen

Dem Konzept entsprechend, für das wir uns entschieden haben, werden die Passwörter der Benutzer in einer speziellen Gruppe „Passwort“ (mit der Nummer 16) gespeichert. Hier können bis zu fünf Passwörter zur Speicherung und Erkennung mit der Technologie „Sprecherüberprüfung“ („Speaker Verification“, SV) gespeichert werden (im Gegensatz zur sprecherabhängigen Technologie sind mit SV gespeicherte Passwörter stärker von einer vollständigen Beseitigung der Hintergrundgeräusche und dem richtigen Abstand zum Mikrofon abhängig). Zur Reaktivierung des Systems, wenn der Bildschirmschoner zu sehen ist, verwenden wir Befehle aus der Gruppe „Grammatik“, in der der Benutzer eigene, mit der Software QuickT2SI erstellte SI-Befehle speichern kann (dieses Modul kann mit der Software EasyVR 3 Commander zusätzlich installiert werden). Der Modulhersteller zeigt in einem kurzen Anleitungsvideo, wie man Befehlssätze in den Abschnitt „Grammatik“ hochlädt:

Alternativ zur Erstellung eines eigenen „Grammatik“-Befehlssatzes können auch die gebrauchsfertigen Befehlssätze auf der Herstellerwebseite des EasyVR-Moduls verwendet werden.

Abbildung 8: Eine Reihe von Audiobeispielen, die in Gruppe 1 festgelegt sind.

Die genaue Konfiguration der Spracherkennungsparameter und der Parameter für z. B. die Position des Mikrofons in Bezug auf den Benutzer finden Sie auf der Registerkarte „Erkennungseinstellungen“ (siehe die folgende Abbildung 9).

Abbildung 9: Fenster „Erkennungseinstellungen“

Zerynth: Installation der Programmierumgebung und Virtualisierung des Geräts

Da die gewählte Hardwarelösung rundum vollständig ist, können wir nun direkt zu den Softwareproblemen übergehen. Zunächst laden wir die integrierte und plattformübergreifende Entwicklungsumgebung „Zerynth Studio“ (für Windows, Linux und MacOS verfügbar) herunter. Die Installation verläuft den Standards für das ausgewählte Betriebssystem entsprechend. Beim erstmaligen Start des Installationsprogramms muss man der Lizenzvereinbarung zustimmen und die Installationsmethode auswählen (online oder offline, sofern der Benutzer zuvor Bibliotheks-Repositorys heruntergeladen hat). Abgeschlossen wird die Installation mit der Auswahl der Softwareversion (zum Zeitpunkt der Erstellung des Artikels ist die letzte verfügbare Version R2.3.0). Danach schließen wir das Riverdi IoT-Display über ein Micro-USB-Kabel an den Computer an. Im nächsten Schritt erstellen wir eine neue virtuelle Maschine. Wählen Sie dazu das Gerät aus dem Drop-down-Menü „Geräteinfo“ aus, klicken Sie auf die Schaltfläche „Erstellen“, um eine neue virtuelle Maschine zu erstellen, und dann auf die Schaltfläche „Virtualisieren“, um Ihr Gerät zu virtualisieren (siehe Abbildung 10).

Abbildung 10: Registrierung und Virtualisierung des neuen
Riverdi IoT-Displays in der Zerynth-Umgebung

Nach Abschluss der Gerätevirtualisierung können wir mit der Programmierung beginnen!

Software für das Riverdi IoT Display-Modul

Damit der erstellte Code besser lesbar ist, können Sie seine Struktur in zwei separate Dateien aufteilen: „main.py“ enthält den Code für die Hauptfunktionen des Programms und „gui.py“ den Code für die Benutzeroberfläche. Die Bearbeitung des Codes beginnt mit dem Import der „main.py“-Dateibibliotheken, die den Grafik-Controller BT81x und das Spracherkennungsmodul EasyVR unterstützen:

from riverdi.displays.bt81x import ctp50

from bridgetek.bt81x import bt81x

from fortebit.easyvr import easyvr

Im nächsten Schritt erfolgt die Konfiguration der seriellen Schnittstellen, wobei SERIAL1 für die Kommunikation mit dem EasyVR-Modul verantwortlich ist:

streams.serial()

 

ser = streams.serial(SERIAL1, baud=9600, set_default=False)

evr = easyvr.EasyVR(ser)

 

Für den Startbildschirm und den Bildschirmschoner ergänzen wir die Grafikressourcen unseres Projekts mit vorbereiteten Grafiken im PNG-Format:

 

new_resource('images/gui_riverdi_logo.png')

new_resource('images/screensaver.png')

Im Abschnitt „SoundTable“ gibt es bei unserem Projekt eine Reihe von Audiobeispielen zur Verwendung mit Easy VR 3 Commander. Darin werden die Sprachnachrichten für den Benutzer gespeichert, z. B. „Access denied“, „Please say your password“ usw. Da wir nicht die Bestellnummern der Audiobeispiele verwenden möchten, weisen wir den einzelnen Aufnahmen klar definierte Variablen zu:

SND_Access_denied=1

SND_Access_granted=2

SND_Hello=3

SND_Please_repeat=4

SND_Please_say_your_password=5

SND_Hello_give_command=6

SND_Please_say_name=7

SND_Pwd_activated=8

Als Nächstes initialisieren die „main.py“-Dateiverknüpfungen den an den SPI-Bus angeschlossenen BT81x-Controller:

bt81x.init(SPI0, D4, D33, D34)

In der letzten Phase der Vorbereitung passen wir die Konfiguration des EasyVR-Moduls an die Anforderungen unserer Anwendung an. Hierbei konfigurieren wir zum Beispiel die Genauigkeit (und damit auch die Befehlserkennungsgeschwindigkeit), die Eingabesprache und den Zeitüberschreitungswert:

evr.setLevel(2)

evr.setLanguage(evr.ENGLISH)

evr.setKnob(evr.STRICTER)

evr.setCommandLatency(evr.MODE_FAST)

evr.setTimeout(6)

evr.setTimeout(6)

Damit haben wir die Initialisierung abgeschlossen. Mit den nächsten Codezeilen erstellen Sie eine einfache Schleife, die den Erkennungsprozess des EasyVR-Moduls ausführt:

while not evr.detect():

    print("EasyVR not detected!")

print("EasyVR detected")

id = evr.getID()

print("EasyVR version id: %s" % id)

Wenn das EasyVR-Modul erfolgreich erkannt wurde, überprüfen wir den Inhalt des Modulspeichers durch folgende Eingabe im Terminal:

mask = evr.getGroupMask()

if mask != None:

    for group in range(evr.PASSWORD + 1): #all groups: 0 to 16

        if mask & 0x01 != 0:

            count = evr.getCommandCount(group)

            if group == evr.TRIGGER:

                print("Trigger: "+ str(count))

            elif group == evr.PASSWORD:

                print("Password: " + str(count))

            else:

                print("Group " + str(group) + ": " + str(count))

            for idx in range(count):

                (name, train) = evr.dumpCommand(group, idx)

                if not evr.isConflict():

                    print("%d %s Trained %d times, OK" % (idx,name,train))

                else:

                    confl = evr.getWord()

                    if confl >= 0:

                        print("%d %s Trained  %d times, Similar to Word %d" % (idx,name,train,confl))

                    else:

                        confl = evr.getCommand()

                        print("%d %s Trained  %d times, Similar to Command %d" % (idx,name,train,confl))

        mask >>= 1

Abbildung 11: Den Speicherinhalt des EasyVR-Moduls anzeigen

Wir können das erste Fenster unserer Benutzeroberfläche zeichnen! Bevor Sie fortfahren, sollten Sie sich mit der Dokumentation der Zerynth-API für den BT81x-Controller vertraut machen:

Um unsere Arbeit zu beschleunigen, erstellen wir eine Funktion, mit der das Image in den internen RAM-Speicher des BT81x-Controllers geladen wird (ab Adresse 0 im RAM_G-Speicherbereich):

def loadImage(image):

    bt81x.load_image(0, 0, image)

Während sich die folgenden Argumente auf die Adresse im RAM beziehen, stehen die Zusatzoptionen bzw. die Variable für das geladene Bild.

Das gespeicherte Bild wird mit der Funktion „showLogo ()“ in der Datei „gui.py“ angezeigt. Wir starten diese Funktion, indem wir den Bildschirm freimachen:

def showLogo():

 

    bt81x.dl_start()

    bt81x.clear_color(rgb=(0xff, 0xff, 0xff))

    bt81x.clear(1, 1, 1)

Erstellen Sie anschließend ein Bitmap-Klassenobjekt und zeichnen Sie das Bild mit „draw ()“ auf das Display (die Bildkoordinaten werden als Argument angegeben):

image = bt81x.Bitmap(1, 0, (bt81x.ARGB4, 642 * 2), (bt81x.BILINEAR, bt81x.BORDER, bt81x.BORDER, 642, 144))

 

image.prepare_draw()

 

image.draw(((bt81x.display_conf.width - 642)//2, (bt81x.display_conf.height - 144)//2), vertex_fmt=0)

Zum Schluss schließen Sie den Rahmen und ersetzen die aktuelle Display-Liste:

bt81x.display()

bt81x.swap_and_empty()

 

The main.py file puts the gui.loadImage () and gui.showLogo () functions:

 

gui.loadImage('gui_riverdi_logo.png')

gui.showLogo()

sleep(3000)

Das Ergebnis ist in Abbildung 12 dargestellt.


Figure 12. The effect of calling the loadImage () and showLogo () methods

Die Variable „screenLayout“ gibt an, welches Element der Benutzeroberfläche gerade angezeigt wird, und ist für den Übergang zwischen aufeinanderfolgenden Bildschirmen verantwortlich. Die Bildschirmauswahl erfolgt über die folgende Programmschleife:

    if screenLayout == 1:

        gui.loadImage("screensaver.png")

 

        #screensaver logo parameters

        screensaver_logo_width = 300

        screensaver_logo_height = 75

        evr.recognizeWord(4)

        cnt = 0

Nun ist es Zeit, die Wartefunktion des Bildschirmschoners auf den Befehl „Hello Device“ einzurichten, indem wir die Erkennung von Grammatikbefehlen der Gruppe 4 aktivieren:

    while screenLayout == 1:

        if evr.hasFinished():

            if evr.getWord() == 0:

                screenLayout = 2

                break

            evr.recognizeWord(4)

        else:

            cnt += 1

            sleep(100)

            if (cnt == 20):

                x = random(1,bt81x.display_conf.width - screensaver_logo_width)

                y = random(1,bt81x.display_conf.height - screensaver_logo_height)

                gui.showScreensaver(x,y)

                cnt = 0

In der Hauptschleife mit „while“ für die Bedingung „screenLayout = 1“ überprüfen wir in regelmäßigen Abständen die fehlerfreie Erkennung des Ausdrucks „Hello Device“ und aktualisieren den Inhalt des Bildschirmschoners. Wenn die Eingabe erkannt wird, ändert sich der Wert der Variable „screenLayout“ und die „while ()“-Schleife wird unterbrochen. Der Hauptteil von „showScreensaver (x, y)“ ist eine modifizierte Version von „showImage ()“:

def showScreensaver(x,y):

    

    bt81x.dl_start()

    bt81x.clear_color(rgb=(0x00, 0x00, 0x00))

    bt81x.clear(1, 1, 1)

    

    image = bt81x.Bitmap(1, 0, (bt81x.ARGB4, (300) * 2), (bt81x.BILINEAR, bt81x.BORDER, bt81x.BORDER, 300, 75))

    image.prepare_draw()

    image.draw((x, y), vertex_fmt=0)

    

    bt81x.display()

    bt81x.swap_and_empty()


Abbildung 13: Bildschirmschoner

Nun ist es Zeit für die erste Art der Überprüfung: die PIN-Eingabe über die Bildschirmtastatur. Es folgt nun ein Fragment der Datei „main.py“, das für die Anzeige dieses Teils der Benutzeroberfläche verantwortlich ist:

    counter = 0

    while (screenLayout == 2):

        if (wait == True):

            wait = False

            sleep(2000)

        gui.pinScreen(pin)

        if counter == 500:

            screenLayout = 1

        sleep(10)

        counter += 1

    pin=""

 „gui.pinScreen ()“ hat die Aufgabe, das Zahlenfeld auf dem Bildschirm anzuzeigen. Dies lässt sich ohne Weiteres mit der Methode „bt81x.add_keys ()“ erreichen: 

    bt81x.track(430, 50, 350, 70, 0)

    bt81x.add_keys(430, 50, 350, 70, 30, 0, "123")

    bt81x.add_keys(430, 130, 350, 70, 30, 0, "456")

    bt81x.add_keys(430, 210, 350, 70, 30, 0, "789")

    bt81x.add_keys(430, 290, 350, 70, 30, 0, ".0C")

Die numerische Tastatur wird mit der Schaltfläche „Verbinden“ ergänzt. Dann weisen wir ihr das Feld TAG zu, damit wir die Schaltflächen später bedienen können:

    btn = bt81x.Button(430, 370, 350, 70, 30, 0, "Connect")

    bt81x.tag(1)

    bt81x.add_button(btn)

Abbildung 14: Benutzeroberfläche mit numerischem Tastenfeld

Die Tasten müssen durch den in der Datei „main.py“ definierten Ereignishandler für Rückrufe vom Touchscreen unterstützt werden. In diesem Fall ist die Funktion „pressed ()“ für alle Ereignisse verantwortlich:

bt81x.touch_loop(((-1, pressed), ))

Body function pressed ():

 

def pressed(tag, tracked, tp):

    

    global screenLayout

    global pin

    global wait

    global counter

    global user2 

 

    #if we are in pinscreen

    if (screenLayout == 2):

 

        counter = 0

        user2  = False

   

        if ((tag != 67) and (tag !=1)):

            if  (len(pin) >= 4):

                return

            pin = pin + str(chr(tag))

 

        elif ((tag == 67) and (len(pin) > 0)):

            pin = pin[:-1]

       

        elif ((tag == 1) and ((pin == valid_pin) or (pin == valid_pin2))):

            if pin == valid_pin2:

                user2  = True

            screenLayout = 4

 

        elif (len(pin) > 0):

            wait = True

            pin = ""

            gui.showMessage("Access Denied")

 

            #go to screensaver

            evr.playSound(SND_Access_denied, evr.VOL_FULL)

Jedes Mal, wenn Sie den Bildschirm berühren und die Funktion „pressed ()“ aufrufen, wird die Zählervariable zur Erkennung der Leerlaufzeit des Geräts zurückgesetzt. Durch Auswahl der Schaltfläche „Verbinden“ wird der eingegebene vierstellige PIN-Code bestätigt. Wenn er mit keinem der vorher angegebenen PIN-Codes übereinstimmt, wird auf dem Bildschirm des Geräts eine kurze Meldung angezeigt, dass der Zugang verweigert wird (siehe Abbildung 15).

Abbildung 15: Bildschirmmeldung bei falscher PIN-Eingabe

Die Anzeige der Zugangsverweigerung oder -gewährung erfolgt über die Funktion „showMessage ()“. Sie enthält nur die Leerung des Bildschirms und die Anzeige einer einfachen Bildschirmnachricht, deren Inhalt durch das Funktionsargument übergeben wurde:

def showMessage(text):

    

    # start

    bt81x.dl_start()

    bt81x.clear(1, 1, 1)

    

    #text

    txt = bt81x.Text(400, 240, 31, bt81x.OPT_CENTERX | bt81x.OPT_CENTERY, text, )

    bt81x.add_text(txt)

    

    # display

    bt81x.display()

    bt81x.swap_and_empty()

Nach einer korrekten PIN-Eingabe fahren wir mit der Sprachverifizierung fort. Zunächst soll das System den Benutzer mit einer Sprachnachricht und einer Textnachricht auf dem Display zur Eingabe eines Passworts auffordern (siehe Abbildung 16).

 if screenLayout == 4:

        gui.showMessage("Enter Voice Password")

        evr.playSound(SND_Please_say_your_password, evr.VOL_FULL)


Abbildung 16: Eine Meldung, die den Benutzer zur Eingabe des Passworts auffordert

Aktivieren Sie in der Hauptschleife des Programms die Erkennung von Befehlen der sechzehnten Gruppe (Passwörter) und warten Sie auf das Rückmeldungssignal. Wenn der Wert „-1“ erreicht wird, konnte entweder die gesprochene Phrase nicht erkannt werden oder es ist eine Zeitüberschreitung aufgetreten:

        while screenLayout == 4:

            evr.recognizeCommand(16)

            while not evr.hasFinished():

                sleep(100)

Die „while ()“-Schleife kann nur freigegeben werden, indem der resultierende Wert auf ein mögliches falsches Passwort oder eine Zeitüberschreitung überprüft wird. In diesen Fällen werden wir informiert, dass wir keinen Zugang erhalten und das Passwort erneut eingeben sollen:

           if ((evr.getCommand() == -1) and (not evr.isTimeout())):   

                gui.showMessage("Access Denied")

                evr.playSound(SND_Access_denied, evr.VOL_FULL)

                sleep(1000)

                break

Für jeden Benutzer erfolgt die Autorisierung über einen Satz konsistenter Daten, d. h. eines PIN-Codes und eines dem Benutzer zugewiesenen Sprachkennworts. Daher muss überprüft werden, welcher PIN-Code welchem Sprachpasswort zugewiesen ist:

            if ((user2 and (evr.getCommand() != 2) and (evr.getCommand() != -1)) or ((not user2) and  ((evr.getCommand() != 5) and (evr.getCommand() != -1)))):

                gui.showMessage("Access Denied")

                evr.playSound(SND_Access_denied, evr.VOL_FULL)

                sleep(1000)

                break

Wenn eine Zeitüberschreitung auftritt, gelangen Sie über die Benutzeroberfläche zum Bildschirm für die PIN-Eingabe:

 

            if evr.isTimeout():

                #if time out go to pin screen

                screenLayout = 2

                break

Wenn keine der oben genannten Bedingungen erfüllt ist und das Passwort der PIN des Benutzers entspricht, folgt die nächste Phase. Nun erhält der Benutzer nach erfolgreicher Verifizierung Zugang zu dem verschlossenen Raum (die elektromagnetische Sperre wird für 5 Sekunden entriegelt):

    if screenLayout == 5:

        gui.showMessage("Access Granted")

        evr.playSound(SND_Access_granted, evr.VOL_FULL)

        sleep(1000)

 

        relay_on()

        for i in range(5):

            time = str(5-i)

            gui.showMessage("time left: " + time)

            sleep(1000)

        relay_off()

        screenLayout = 1

Abbildung 17: Bildschirm zeigt an, dass der Zugriff gewährt wird

An dieser Stelle sollten Sie sich einen Moment mit dem Relaismodul „Relay Click“ befassen. Sofern keine spezielle Hardwarekonfiguration erforderlich ist, müssen wir im Programmcode den entsprechenden Steuerungs-Pin für den Ausgang auswählen und einfache Steuerungsfunktionen für ihn erstellen. Das Diagramm mit der Pinbelegung des Moduls „Relay Click“ sehen Sie in Abbildung 18.

Abbildung 18: Pinbelegung des „Relay Click“

Im fertigen Projekt wird die elektromagnetische Sperre über das Relais RL1 gesteuert. Das Modul „Relay Click“ wurde an den microBUS1-Steckplatz des Riverdi IoT Display-Moduls angeschlossen. Abbildung 19 zeigt die Pinbelegung des Steckplatzes.

Abbildung 19: Pinbelegung des microBUS1-Steckplatzes

Die Steuerung des RL1-Relais wird daher durch Ableitung von D23 implementiert:

pinMode(D23, OUTPUT)

 

def relay_on():

    digitalWrite(D23, HIGH)

    

def relay_off():

    digitalWrite(D23, LOW)


Die vollständige Funktionsweise des abgeschlossenen Projekts ist in folgendem Video zu sehen:

Fazit

Wir hoffen, dass Sie der Demo leicht folgen konnten und nun sehen, wie einfach die Programmierung von Riverdi IoT-Displays und Fortebit EasyVR 3 Plus in Python ist. Wenn Sie Riverdi IoT-Displays erwerben möchten, besuchen Sie die offizielle Website

----------------------------------------------------------

Ressourcen:

I’ve learned early on in my career that I love to be at the forefront of innovation. To see new technologies emerge, and be a part of their creation. From the first days on the internet and the Silicon Valley revolution to The Internet of Things — I’ve seen it all, and I’ve done it all. Now, I’m ready to use this knowledge to help young companies thrive. I have over 35 years of experience in driving revenue, encouraging new ideas, and fostering client relationships.

Recommended Articles

DesignSpark Electrical Logolinkedin