Visualisierte Gesichtsmaske

Autoren: Thomas Miska & Timo Schmidt
Betreuer: Prof. Göbel

→ zurück zur Übersicht: WS 20/21: Angewandte Elektrotechnik (BSE)

Einleitung

Dieser Artikel steht im Zusammenhang mit dem Praktikums angewandte Elektrotechnik des Studiengangs Business and Systems Engineering. Ziel des Praktikums ist es ein Mechatronisches Projekt zu planen, entwickeln und durchzuführen. Das Praktikum beinhaltet folgende drei Disziplinen:

Physik
Elektrotechnik
Systemtheorie

Aufgrund des COVID-19 Virus, sind die sozialen Kontakte eingeschränkt und die Menschen sind im öffentlichen Bereich mit Masken verdeckt. In der menschlichen Kommunikation sind gerade Gesichtszüge wichtig. Daher wird eine Gesichtsmaske mit einer LED-Matrix erweitert, die auf einer einfachen Visuellen Basis, diese Einschränkung ein wenig aufhebt. Die LED-Matrix wird ein sprechenden Mund abbilden, der über ein Mikrofon gesteuert wird.

Dieser Artikel wurde anhand der Wiki-Vorlage von Prof. Dr.-Ing. Ulrich Schneider erstellt ^[1].

Anforderungen

Die Maske sollte folgende wesentliche Anforderungen erfüllen:

Standard Gesichtsmaske mit einem Fach für die Elektronik herstellen
Ansteuerung der LED Matrix (sprechender Mund)
Erfassung der Mikrofondaten
Erstellung des Algorithmus zur einfachen Visuellen Darstellung der Spracheingabe.

Weitere Anforderungen:

Echtzeitanforderung: Die Darstellung darf nicht merklich verzögert werden.
Platzbedarf: Das System muss in die Maske passen
Gewicht: Die Maske darf nicht zu schwer werden.
Energiebedarf: Die Maske muss unter den Bedingungen Gewicht und Platzbedarf eine ausreichende Energieversorgung haben.

Funktionaler Systementwurf/Technischer Systementwurf

Komponentenspezifikation

Für die Umsetzung dieses Projektes ist folgende Hardware mit genannten Spezifikationen notwendig:

5 V Powerbank
- Die Powerbank sollte mindestens 5000 mAh haben, damit eine ausreichende Laufzeit gewährleistet werden kann.
USB Typ A Stecker auf Mini USB
- Leitungslänge muss mindestens 1 m beträgen
div. Leitungen min. 0,14 mm²
- Die Leitungen müssen in drei Farben vorrätig sein mit einer jeweiligen Länge von 2 m. Durch die verschiedenen Farben kann einer Verpolung vorbeugen.
Mikrocontroller
- Arduino Nano, ohne angelötete Headerpins
LED-Matrix
- 8x8 Pixel, WS2812B Led's
330 Ω Widerstand
- Mindestandforderung: Kohleschichtwiderstand, 250 mW, 5% Toleranz
Mikrofon
- Iduino 1485297

Umsetzung Hardware

Für den Aufbau der Elektronik in der Maske ist die nachfolgende fritzing Skizze genutzt worden.
Der Arduino wird über ein Mini-USB Stecker mit Spannung versorgt.
Die Spannungsversorgung der LED-Matrix erfolgt über den Vin-Pin des Arduinos. Hier liegt die Spannung an, die über die USB-Buchse des Arduinos angeschlossen wird. Der Input der LED-Matrix wird mit dem digitalen I/O 6 des Arduino verbunden. Bei der Auswahl des I/Os ist zu beachten, dass dieser ein PWM-Pin ist. In die Signalleitung wird noch ein 330 Ω Widerstand eingelötet um den Stromfluss zu begrenzen und den Chip auf den LEDs zu schützen.
Das Mikrofon erhält seine Spannungsversorgung über den 5 V Pin des Arduinos. Die Signalleitung des Mikrofons wird am Eingang A0 abgefragt.

Um eine möglichst geringe Baugröße zu erreichen wird auf die Verwendung einer Platine verzichtet. Die LED-Matrix wird direkt an den Arduino gelötet. Auch der Widerstand wird direkt in die Leitung eingelötet. Dadurch entsteht eine kompakte Bauweise.
In der nachfolgenden Abbildung ist der Aufbau der Maske von hinten (links) und vorne (rechts) dargestellt. In dem grünen Schrumpfschlauch verbirgt sich der 330 Ω Widerstand, der Datenleitung. Die 5 V sind mit einer roten Ader vom Arduino zur Matrix geführt. Die Masse (GND) wird mit einer schwarzen Leitung verbunden.
Das Mikrofon wird über Adern angeschlossen die an einer Seite an den Arduino gelötet werden und an der andren eine Dupont-Busche auf gecrimpt haben. So kann das Mikrofon an und abgesteckt werden.
Der Akku wird mit einem USB Kabel mit der Maske verbunden, so kann dieser bequem in der Hosentasche verstaut werden.

Ansicht des Aufbaus von hinten
Ansicht des Aufbaus von vorne

Programmablaufplan

Umsetzung Software

Zur Umsetzung des Projektes als Software, wurde das Programm in der Arduino IDE geschrieben, die angelehnt an einem hochgeladenem Code im Internet^[2].
Dazu wurden die folgenden Bibliotheken verwendet:

Die Umsetzung erfolgt so, dass das Mikrofon ein Pegel als Analogwert aufnimmt. Dieser Pegel wird in eine Lautstärke umgewandelt. Anhand von Abzweigungen mit der Bedingung zu der Lautstärke lassen sich somit verschiedene Mundbewegungen darstellen. Die einzelnen Mundbewegungen sind in einer Matrix abgelegt, die entsprechend der Abzweigung verwendet werden. Für das lächeln auf der Matrix wird ein hoher Lautstärkepegel verwendet, der zum Beispiel mit einem schnalzen der Zunge ausgelöst wird. Anschließend wird über die Library, welche den Code zur Ansteuerung der WS2812B Matrix enthält, die Matrix auf der LED-Matrix dargestellt.

Nachfolgend einige Passagen des Softwarecodes:

Header:

////////////////////////////////////////////////////////////////////////////
//
//   Project     : Visualisierte Gesichtsmaske
//   File        : Facemask
//   Description : Ansteuerung der LED Matrix (WS2812) über ein Mikrofon an
//                 einem Arduino Nano. Ansteuerung erfolgt als sprechender
//                 Mund in Abhängigkeit des Volumenpegels der über das Mikro
//                 kommt
//
//   Created On: 19/10/2020
//   Source:     https://create.arduino.cc/projecthub/DKARDU/how-to-make-led-face-mask-a3c897 
//   Edited By:  Thomas Miska, Timo Schmidt
////////////////////////////////////////////////////////////////////////////

Verwendete Bibliotheken

// Libraries
#include <Adafruit_NeoPixel.h>
#include <Adafruit_NeoMatrix.h>
#include <gamma.h>

Beispiel einer Matrix

const PROGMEM uint8_t mouth_0[8][8] = {
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {6,6,6,6,6,6,6,6},
    {6,6,6,6,6,6,6,6},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0}
};

Matrix ausgeben

void drawImage(short image_addr){
    for(int x = 0; x<8; x++){
        for(int y = 0; y<8; y++){
            uint8_t index = pgm_read_byte(image_addr+x+y*8);
            matrix.drawPixel(x, y, palette[index]); 
        }
    }
    // LED Matrix ausgeben
    matrix.show();
}

Algorithmus für die Visualisierung des sprechenden Mundes auf der LED Matrix

if(millis() > smiletimer) smiling = false;
    if(smiling){
        drawImage(mouth_smile);
    } else if(vol < 180){
        drawImage(mouth_0);
    } else if(vol < 187){
        drawImage(mouth_1);
    } else if(vol < 193){
        drawImage(mouth_2);
    } else if(vol < 207){
        drawImage(mouth_3);
    } else {
        drawImage(mouth_4);
    }

Eine Umsetzung in Simulink wurde vergebens Versucht. Die Abhängigkeiten zu den Adafruit Bibliotheken haben Probleme bereitet, sodass auch eine Verwendung in einer S-Function aus zeitlichen Gründen weiter nicht möglich war. Die S-Function Umsetzung verlief auch in Kompilierfehler.

Systemtest

Um das System zu testen wurde eine Systemtest durchgeführt.
Aufgrund des kleinen Umfangs an Komponenten wurde auf ein Komponententest und Integrationstest verzichtet.
Nachfolgend das Ergebnis des Systemtests:

Testfall-ID	Testfall-Name	Vorbedingungen und Eingänge	Aktionen	Erwartetes Ergebnis	Ergebnis	Bewertung	Kommentar
001	Schwellwertetest 1	kein Ton < 180	keine Geräuschumgebung	"LED-Matrix: Mund gerade Linie"	Parameter wird korrekt dargestellt	i. O.
002	Schwellwertetest 2	ganz leiser Ton (180 <= x < 187)	Flüstern	"LED-Matrix: Mund kleiner Kreis"	Parameter wird korrekt dargestellt	i. O.
003	Schwellwertetest 3	leiser Ton (187 <= x < 193)	leise sprechen	"LED-Matrix: Mund etwas größerer Kreis"	Parameter wird korrekt dargestellt	i. O.
004	Schwellwertetest 4	mittlerer Ton (193 <= x < 207)	normales reden ohne hochtöne	"LED-Matrix: Mund mittlerer Kreis"	Parameter wird korrekt dargestellt	i. O.
005	Schwellwertetest 5	leicht lauter Ton (207 <= x < 300)	Normales Sprechen	"LED-Matrix: Mund großer Kreis"	Parameter wird korrekt dargestellt	i. O.
006	Schwellwertetest 6	lauter Ton (> 300)	Schnalzen mit der Zunge	"LED-Matrix: Lächeln"	Parameter wird korrekt dargestellt	i. O.	"Schnalzen muss laut sein und korrekt ausgeführt werden"

Ergebnis

Die Umsetzung des Projektes ist erfolgreich. Die LED Matrix in Verbindung des Mikrofons wird mit einem Sprechen angesteuert und simuliert ein sprechenden Mund, die durch dem gewählten Stoff sehr gut durchscheint. Bei korrekter Ausführung einer Schnalzenden Zunge wird ein Lächeln ausgegeben. Das Gewicht wurde durch die Auslegung eines externen Akkus, welcher durch ein langes Kabel Verbunden wird reduziert. Durch der Nutzung einer PowerBank, kann diese sehr schnell ausgetauscht werden, sodass auch die Verwendung über den Tag hinaus kein Problem darstellen soll.

Lessons Learned

Beim Projekt gab es einige Schwierigkeiten die Bewältigt werden mussten:

Umsetzung in MATLAB/Simulink erwies sich als zu aufwendig, für einen kleinen Nutzungsvorteil (Parametrisierung).
Stromabgabe des Akkus muss ausreichend sein, um das System mit einer konstanten Spannung zu versorgen. Einbrechende Spannung sorgt für nicht nachvollziehbare Fehler.
Der Softwarecode muss performant sein, damit die Umsetzung vom gesprochenen Ton bis hin zur Matrix Darstellung ohne sichtliche Verzögerung erfolgt.

Ausblick/Verbesserungen

Um das Projekt noch weiter zu optimieren, gibt es noch Möglichkeiten, das System stark zu verbessern:

Stoff wählen, der eine bessere Filterung besitzt, jedoch genug Licht durchlässt.
Statt einer PowerBank ein kleinen Akku mit ausreichend Kapazität in die Maske einbringen und ein USB Anschluss zum Aufladen einbauen
Ein Schalter zum ausschalten des Systems
Schutzmaßnahmen um die elektrischen Bauteile vor der Feuchtigkeit des Atems umsetzen.
Taster um die Farbe zu wechseln
Anbindung eines Moduls, um z. B. eine Handyapp zu entwickeln um alle Einstellungen der Maske vorzunehmen.
Erstellung einer Platine mit allen Komponenten.
Erfassung der Umbgebungsgeräusche
- herausfiltern der Umgebungsgeräusche
- automatische Anpassung der Sensitivität

Projektunterlagen

Projektplan

Zur Strukturierung des Projektes wird ein Projektplan als Roadmap erstellt. Die Erstellung der Roadmap erfolgt in Jira. Als Ansatz zur Umsetzung wurde eine Agile Softwareentwicklung angestrebt. Zur Unterstützung der agilen Softwareentwicklung wurde ein KanBan Board in Jira verwendet.

Projektdurchführung

Anhand der Tickets die als Aufgabenpakete in Jira definiert wurden, werden die Aufgaben abgearbeitet.

YouTube Video

Weblinks

SVN-Verzeichnis vom Projekt

Literatur

↑ Ulrich Schneider (2020) Wiki-Vorlage: [1] Letzter Aufruf: 15.10.2020.
↑ DKARDU (2020) Projekt-Vorlage: [2] Letzter Aufruf: 29.12.2020