Gesichtsverfolgungskamera: Unterschied zwischen den Versionen
(11 dazwischenliegende Versionen von 2 Benutzern werden nicht angezeigt) | |||
Zeile 1: | Zeile 1: | ||
[[Kategorie:Projekte]] | [[Kategorie:Projekte]] | ||
[[Kategorie:ProjekteET MTR BSE WS2020]] | [[Kategorie:ProjekteET MTR BSE WS2020]] | ||
Zeile 6: | Zeile 5: | ||
[[Datei:Plakat-Gesichtsverfolgungskamera.png|550px|thumb|right|Abb. Werbeplakat für Projektmesse]] | [[Datei:Plakat-Gesichtsverfolgungskamera.png|550px|thumb|right|Abb. Werbeplakat für Projektmesse]] | ||
<!-- Kopieren Sie diesen Header in Ihren Artikel, damit er aufgelistet wird. --> | <!-- Kopieren Sie diesen Header in Ihren Artikel, damit er aufgelistet wird. --> | ||
Zeile 13: | Zeile 11: | ||
→ zurück zur Übersicht: [[:Kategorie: | → zurück zur Übersicht: [[:Kategorie:ProjekteET_MTR_BSE_WS2022|WS 22/23: Angewandte Elektrotechnik (BSE)]] | ||
== Einleitung == | == Einleitung == | ||
Zeile 150: | Zeile 145: | ||
<div style="width:1200px; height:400px; overflow:auto; border: 2px solid #088"> | <div style="width:1200px; height:400px; overflow:auto; border: 2px solid #088"> | ||
<syntaxhighlight lang="matlab" style="border: none; background-color: #EFF1C1; font-size: | <syntaxhighlight lang="matlab" style="border: none; background-color: #EFF1C1; font-size:small"> | ||
%% ***********************************************************************\ | %% ***********************************************************************\ | ||
% | % | ||
Zeile 218: | Zeile 213: | ||
<div style="width:1400px; height:300px; overflow:auto; border: 2px solid #088"> | <div style="width:1400px; height:300px; overflow:auto; border: 2px solid #088"> | ||
< | <syntaxhighlight lang="matlab" style="border: none; background-color: #EFF1C1; font-size:small"> | ||
% Gesishterkennung mit Viola Cascade Algorithm | % Gesishterkennung mit Viola Cascade Algorithm | ||
Zeile 293: | Zeile 288: | ||
. | . | ||
. | . | ||
</syntaxhighlight> | |||
</pre> | </pre> | ||
</div> | </div> | ||
Zeile 320: | Zeile 315: | ||
<div style="width:1400px; height:300px; overflow:auto; border: 2px solid #088"> | <div style="width:1400px; height:300px; overflow:auto; border: 2px solid #088"> | ||
< | <syntaxhighlight lang="matlab" style="border: none; background-color: #EFF1C1; font-size:small"> | ||
while run_loop && frame_Count <4000 | while run_loop && frame_Count <4000 | ||
. | . | ||
Zeile 383: | Zeile 377: | ||
posy= readPosition(tiltServo); | posy= readPosition(tiltServo); | ||
valy = BmitteY; % Mitte Punkt des ROI wert wird kopiert | valy = BmitteY; % Mitte Punkt des ROI wert wird kopiert | ||
Zeile 416: | Zeile 409: | ||
step(videoPlayer, video_Frame); | step(videoPlayer, video_Frame); | ||
run_loop = isOpen(videoPlayer); | run_loop = isOpen(videoPlayer); | ||
pause(pause_time); | |||
end | end | ||
Zeile 423: | Zeile 416: | ||
release(point_Tracker); | release(point_Tracker); | ||
release(face_Detector); | release(face_Detector); | ||
</syntaxhighlight> | |||
</pre> | </pre> | ||
</div> | </div> | ||
Zeile 477: | Zeile 470: | ||
== Ergebnis == | == Ergebnis == | ||
Bei dem Projekt konnten nahezu alle gestellten Anforderungen umgesetzt werden. Die Gesichtsverfolgungskamera erfüllt die wichtigsten Funktionen, auch wenn sie nicht, wie geplant, mit Simulink, sondern mit Matlab selbst gesteuert wird. Das Ergebnis des Projekts kann untenstehend im Youtube-Video betrachtet werden. | |||
== Zusammenfassung == | == Zusammenfassung == | ||
Während der Durchführung des Projekts konnten diverse Fähigkeiten und erworbenes Wissen aus unterschiedlichen Modulen des Studiengangs angewendet werden. So konnten die Kenntnisse aus dem semesterbegleitenden Modul "Mechatronische Systeme II", sowie Kenntnisse aus Modulen vergangener Semester aufgefrischt und und in der Praxis angewandt werden. Hilfreich war das Wissen aus Fächern wie z.B.: | |||
* CAD Praktikum | |||
* GET I und GET II | |||
* Informatik I und Informatik II | |||
* Grundlagen elektrischer Schaltungen und Bauelemente | |||
=== Lessons Learned === | === Lessons Learned === | ||
Es konnten durch das Projekt diverse Kenntnisse aus dem Studium in der Praxis erprobt werden. Dazu gehörten unter anderem: | |||
* Projektplanung und Kostenkalkulation | |||
* Auswahl geeigneter Komponenten für die Umsetzung | |||
* Programmierung eines Mikrokontrollers und schreiben eines Programmes in Matlab | |||
* Konstruieren und anschließendes 3D-Drucken mit einem CAD Programm | |||
* Planen und zeichnen eines Schaltplans | |||
* Löten und verbinden des zuvor entworfenen Schaltplans | |||
Lediglich die Umsetzung des Programms in Simulink hat nicht funktioniert. Die Auswertung der aufgenommenen Bilder war nicht möglich, da für Simulink die Visiontoolbox nicht zur Verfügung stand. Das Programm konnte stattdessen jedoch in Matlab geschrieben werden. | |||
== Projektunterlagen == | == Projektunterlagen == | ||
=== Projektplan === | === Projektplan === | ||
[[Datei:Projektplanung Screenshot.png|left|thumb]] | |||
<br> | |||
<br> | |||
<br> | |||
<br> | |||
<br> | |||
<br> | |||
<br> | |||
<br> | |||
<br> | |||
=== Projektdurchführung === | === Projektdurchführung === | ||
Nach der Ideenfindung und dem Brainstorming wurde eine genaue Idee ausgearbeitet. Es wurde überlegt welche Komponenten für die Durchführung eines solchen Projekts benötigt würden und nachdem ein Plan für das Projekt bestand wurden die Bauteile bestellt. Die Komponenten wurde, wie zuvor beschrieben, auf ihre Funktionalität überprüft. Ebenso wurden die Teile für das Gehäuse kontrolliert und anschließend alles miteinander aufgebaut. Nachdem das Modell fertig war wurde an der Ausarbeitung der Software gearbeitet. | |||
== YouTube Video == | == YouTube Video == |
Aktuelle Version vom 10. Januar 2023, 12:13 Uhr
Autoren: Suryaa Kalamani-Ramamoorthy & Aaron-Lasse Paelmke
Betreuer: Prof. Ulrich Schneider
→ zurück zur Übersicht: WS 22/23: Angewandte Elektrotechnik (BSE)
Einleitung
Das Projekt "Gesichtsverfolgungskamera" wird im Rahmen des GET Fachpraktikums im 5. Semester des Studiengangs Mechatronik der HSHL am Campus Lippstadt durchgeführt. Ziel des Projekts ist die Umsetzung eines Systems, das mittels einer Webcam Gesichter erfasst und Mikrokontroller gesteuert dem erfassten Gesicht folgt und es im Fokus behält. Die Durchführung des Projekts soll die erlernten Kenntnisse der Fächer Informatik, Physik, Grundlagen der Elektrotechnik I, Grundlagen der Elektrotechnik II, Elektronische Bauelemente und Grundschaltungen, Aufbau-/ und Verbindungstechnik sowie Mess-/ und Regelungstechnik festigen, vertiefen und neue Erkenntnisse fördern.
Anforderungen
Nr. | Anforderung |
---|---|
1 | Allgemein |
1.1 | Die Kamera soll Gesichter erkennen und ein einmal erfasstes Gesicht so lange verfolgen, wie es sich im Sichtfeld aufhält. |
1.2 | Falls sich mehrere Gesichter im Sichtfeld aufhalten soll nur ein Gesicht erfasst und verfolgt werden. |
1.3 | Das System soll den aktuellen Status über LEDs darstellen. |
1.4 | Zur Steuerung des Systems soll das Programm mit Simulink umgesetzt werden. |
2 | Bildanalyse und Auswertung |
2.1 | Die von der Webcam erfassten Bilder sollen mittels eines Algorithmus auf Gesichter gescannt werden. Von den Gesichtern soll der Mittelpunkt erfasst und mit dem Mittelpunkt des Bildes verglichen werden. |
2.2 | Anhand der Position des erfassten Gesichts soll der Systemstatus ermittelt werden (Gesicht erkannt und zentriert / Gesicht erkannt, nicht zentriert / Gesicht nicht erkannt). |
3 | Ausgabe |
3.1 | Es soll permanent der Status über LEDs angezeigt werden (Gesicht erkannt und zentriert: Grüne LED / Gesicht erkannt, nicht zentriert: Gelbe LED / Gesicht nicht erkannt: Rote LED). |
3.2 | Die Servomotoren sollen über den Arduino UNO angesteuert werden und so immer versuchen ein erfasstes Gesicht zu zentrieren. |
Die Tabelle beschreibt die Anforderungen an das Projekt Gesichtserfassungskamera.
Funktionaler Systementwurf/Technischer Systementwurf
Bei den Abbildungen handelt es sich um Skizzen, die sowohl den technischen, als auch den funktionalen Systementwurf verdeutlichen sollen.
Die von der Webcam erfassten Bilder sollen an einen PC übermittelt werden, auf dem eine Software zur Gesichtserkennung läuft. Die Aufnahmen der Webcam sollen auf Gesichter gescannt werden. Die Position des Gesichts auf den Fotos der Webcam soll zentriert werden, wodurch sich ableiten lässt, in welche Richtung sich die Webcam bewegen muss, damit das Gesicht zentriert wird. Zwischen dem PC und dem Arduino UNO Mikrokontroller soll ein Datenaustausch stattfinden, um die Informationen, wie der Arduino die zwei Servomotoren ansteuern soll zu übertragen.
-
Abb. 1: Funktionaler Systementwurf
-
Abb. 2: Verkabelungsdiagramm
-
Abb. 3: Skizze des Aufbaus
Abbildung 2 zeigt den Verkabelungsplan der Gesichtsverfolgungskamera. Im Folgenden wird die Schaltung erklärt, sowie die Vorgehensweise beim Aufbau betrachtet.
Zunächst wurde die Schaltung auf einem Breadboard aufgebaut und auf ihre Funktion geprüft. Auf diese Weise wurde ebenfalls die Funktion der verwendeten Aktoren kontrolliert. Die Aufgabe der Schaltung ist das Versorgen der Servomotoren mit einer Betriebsspannung von 5 V, sowie das Verbinden der LEDs mit den vorgesehenen Pins des Arduino Mikrokontrollers.
Eingespeist werden 9 V über ein Netzteil. Parallel an die Buchse angeschlossen sind sowohl ein Spannungsbegrenzer, als auch die Eingangspins des Arduino UNO. Auf Pin VIN wurden die 9 V gelegt, auf den Pin GND wurde GND gelegt. Der Spannungsbegrenzer verringert die Spannung von 9 V auf 5 V und ermöglicht somit einen sicheren Betrieb der Servomotoren, deren maximale Betriebsspannung bei 6 V liegt. Die PWM Signale für die Motoren wurden von den Pins 8 und 9 des Arduino abgegriffen.
Je nach Status des Programms gibt der Arduino UNO Signale an die LEDs aus. Die Signale der LEDs wurden an den digitalen Ausgangspins 2, 3 und 4 entnommen. Jeweils die Anode der LED wurde an den Pin mit dem Signal angesteuert, wobei die Grüne LED auf Pin 4 gelegt ist, die Gelbe auf Pin 3 und die Rote auf Pin 2. Ein Vorwiderstand von 220 Ohm schützt die LEDs vor einer zu hohen Betriebsspannung. Die Anoden der LEDs wurden auf GND am Arduino Mikrokontroller gelegt.
Komponentenspezifikation
Für das Projekt "Gesichtsverfolgungskamera" kamen diverse Bauteile zum Einsatz. Diese werden im Folgenden aufgeführt und näher betrachtet. Für die einzelnen Komponenten werden ihre Eigenschaften und Spezifikationen dargestellt und beschrieben, sowie auf ihre Funktion im Projekt eingegangen.
Arduino UNO
Bei dem Arduino UNO (Abb. 4) handelt es sich um einen Mikrokontroller. Dieser Mikrokontroller basiert auf dem ATmega328P. Der Arduino UNO zeichnet sich durch 14 digitale Ein-/ und Ausgangspins aus, von denen 6 als PWM-Ausgänge genutzt werden können. Der Arduino verfügt über einen 16 MHz Keramikresonator, einen USB-Slot, eine Spannungsbuchse und einen ICSP Header. Überdies verfügt der Arduino zusätzlich über einen Resett-Knopf.
MG-90S Servomotoren
Die Servomotoren zeichnen sich durch eine kompakte Baugröße aus. Das Getriebe der Servomotoren besteht aus Metallzahnrädern und zeichnet sich dadurch durch eine vergrößerte Lebensdauer im Vergleich zu Plastikzahnrädern aus. Ebenso kann ein größeres Drehmoment übertragen werden. Der Operationsbereich der Motoren beträgt insgesamt 180 Grad (90 Grad in jede Richtung). Die Servomotoren werden mit einer Spannung von 4,8 V bis zu 6 V betrieben. Im Anwendungsfall der Gesichtserkennungskamera beträgt die angelegte Spannung 5 V. Nebenstehend ist in Abb. 6 ein Servomotor des Typs dargestellt.
Webcam
Bei der Verwendeten Webcam handelt es sich um die HD Pro PC Webcam (Model No. AWCAMHD15) des Herstellers Advent. Die verwendete Webcam zeichnet sich durch die Fähigkeit aus Videos in full HD aufzunehmen. Die Aufnahme funktioniert über den internen HD1080P CMOS Sensor. Der Sensor besitzt eine Auflösung von bis zu 2 Megapixel für Videoaufnahmen. Objekte die weiter als 3 cm entfernt sind können Fokussiert werden. Die mögliche Framerate der Webcam beträgt bis zu 30 fps.
LEDs
Bei den verwendeten LEDs handelt es sich um gewöhnliche Leuchtdioden in den Farben Grün, Gelb und Rot. Wie nebenstehend, in Abbildung 7, den Kennlinien der LEDs zu entnehmen ist, liegen die Schwellenspannungen der LEDs eng beieinander. Dieses ähnliche Schaltverhalten führt dazu, dass alle LEDs an der gleichen Spannung mit gleich dimensionierten Vorwiderständen betrieben werden können. Wie zuvor beschrieben werden die LEDs von den digitalen Ausgangspins 2, 3 und 4 des Arduino UNO angesteuert.
Umsetzung (HW/SW)
Hardware
Das Adruino-Gehäuse, der Kamerahalter, die Halterung für die Servomotoren und das Stativ wurden mit der CAD-Software Solidworks entworfen und mittels additiver Fertigung (3D-Druck) gefertigt. Die folgenden Abbildungen sind ein Ausschnitt aus den CAD-Entwürfen.
-
Abb. 8: CAD Ansicht Gehäuse
-
Abb. 9: CAD Ansicht Halter für Servomotoren
-
Abb. 10: CAD Ansicht Kamerastativ
-
Abb. 11: CAD Ansicht Webcamhalter
Montage
Die Grundplatte des Gehäuses (Abb. 8) ist der Arduino UNO Mikrokontroller. Dieser wird mittels Schrauben im Gehäuse befestigt. An der Rückseite des Gehäuses befinden sich zwei Steckplätze für die Anschlüsse der Versorgungsspannung und des USB Typ B Steckers, mit dem die Verbindung zwischen Arduino und PC hergestellt wird. Die Verdrahtung des Projekts wurde im Gehäuse versteckt.
Auf die Grundplatte wurde das Stativ aufgeschraubt. Auf dem Stativ wurde einer der Servomotoren mit einem Halter befestigt, um ab hier den gesamten oberen Teil des Modells Schwenkbar zu gestalten. Der Servomotor, der für die Schwenkbewegung verantwortlich ist wurde zusammen mit dem Servomotor der die Webcam neigt an dem Motorhalter montiert. Auch der Webcamhalter wurde mittels einer Welle, um neigbar gelagert zu sein, an dem Motorhalter angebracht. Bewegt wird die Konstruktion des Webcamhalters über einen Stab und eine Hebel, die an die Welle des zweiten Servomotors angeschlossen sind.
Software
Im folgenden ist das Programm für die Steuerung der Gesichtsverfolgungskamera dargestllt. Der Code ist im SVN unter folgendem Link zu finden: SVN_Ordner
Matlab/Simulink 2019b Documentation von MathWorks ist die in diesem Projekt hauptsächlich verwendete Software.
Kommunikation
Zu Beginn ist die Kommunikation zwischen der Hardware und dem Computer erforderlich. In diesem Projekt werden zahlreiche Toolboxen und Bibliotheken verwendet, z.B. die Image Acquisition Toolbox, um Bilder von der Webkamera zu erhalten, die Computer Vision Toolbox für die Bildverarbeitung und die Kommunikationsschnittstelle zwischen dem Arduino Mikrocontroller und dem Computer.
Im folgenden Softwareskript gibt die Header-Datei einen Überblick darüber, welche Tools und Bibliotheken verwendet werden. Anschließend wird die Kommunikationsschnittstelle dieses Projekts erläutert, z. B. der Handshake des Servomotors und die Auswahl der Bildauflösung.
%% ***********************************************************************\
%
% Modul : Gesichtverfolgungskamera.m
%
% Datum : 20.10.2022
%
% Beschreibung : Die vollständige Implementierung von Bildverarbeitung
% und Gesichverfolgung
%
% Implementierung : MATLAB R2019b
%
% Toolbox : 1. Matlab Webcam Support package,
% 2. Adruino support package for matlab,
% 3. Computer Vission toolbox
%
% Autor : Kalamani, Suryaa und Laase, Aaron
%
% Bemerkung :
%
% Letzte Änderung : 07.12.2022
%
%*************************************************************************/
%%
% Workplace aufräumen
clear all
clc
%% Objekt erstenn - Kommunikation zwischen Matlab und Arduino
if ~exist('a_Obj', 'var')
a_Obj = arduino('COM3','Uno','Libraries','Servo');
% Pin belege 8 und 9 entspechricht die Pan und Tilt Servo
panServo = servo(a_Obj,'D8');
tiltServo = servo(a_Obj,'D9');
%% Kommunikation für Linux oder Mac OS
%a_Obj = arduino('/dev/tty.usbmodem2101','Uno','Libraries','Servo');
%/dev/tty.usbmodem2101 For mac
end
%% Start Position Motoren - Handshake
writePosition(tiltServo,0);
writePosition(tiltServo,0.70);
%% Kamera bereitstellen
Kamera_ID = 2; % Je nach USB Schnittstellen und Port, muss die richtige Kamera ID ausgewählt werden
Kamera = webcam(Kamera_ID); % Zugriff auf Kamera durch Kamera Aquisation Toolbox
% Kamera.AvailableResolution - Mit der Funktion die passende Aufloesung auswaehlen
Kamera.Resolution = '1280x720'; %'1280x720'; %'640x480'
% Zur Bildverarbeitung und Darstellugn wird das Videoplayer Objekt erstellt
videoPlayer = vision.VideoPlayer('Position',[100 100 1280 720]);
Bildverarbeitung
Nach einem erfolgreichen Handshake zwischen dem Computer und der Hardware werden Makros für die Bildverarbeitung und weitere Vorgänge initialisiert und eine while-Schleife für eine Anzahl von n Bildern wird initialisiert.
Die folgenden Skripte erläutern jedes Makro und seine Funktion bei der Bildverarbeitung. Der Viola-Jones-Algorithmus zur Gesichtserkennung wird in diesem Projekt als Teil der Gesichtserkennung verwendet, die Attribute wie Nasen, Augen, Münder oder Oberkörper von Personen verwendet, um Gesichter zu erkennen. [1]
Einzelheiten über die Verwendung dieser Funktionen finden Sie in der Matlab-Dokumentation Viola_Cascade_Facetracking.
% Gesishterkennung mit Viola Cascade Algorithm
face_Detector = vision.CascadeObjectDetector();
point_Tracker = vision.PointTracker('MaxBidirectionalError', 2);
run_loop = true; % Speicherplatz reservierung zum Geshcitererkeunng und Schleifenbedingungen
number_of_Points = 0;
frame_Count = 0;
%% Makros - Einstellung
servomaxx_UpperLimit = 300/360; % Pan Servo Maximum und Minimum Winkel
servomaxx_LowerLimit = 60/360;
servomaxy_UpperLimit = 80/360; % Tilt Servo Maximum und Minimum Winkel
servomaxy_LowerLimit = 55/360;
screenmaxx = 1280; % Frame Grosse in X
screenmaxy = 720; % Frame Grosse in Y
distancex = 1; % Servo Rotationsschritt in X Richtung
distancey = 1; % Servo Rotationsschritt in X Richtung
incx = 240; % Inkrement der Kamerabewegung in der X-Achse
incy = 155; % Inkrement der Kamerabewegung in der Y-Achse
while run_loop && frame_Count <4000
%% Bildverarbeitung - Gesichterkennung
video_Frame = snapshot(Kamera); % Bildframe des Kamera wird gespeichert
gray_Frame = rgb2gray(video_Frame); % Bild in grayscale umgewandelt
frame_Count = frame_Count+1;
if number_of_Points <10 % Anzahl der erkannte Punkte im Bild
face_Rectangle = face_Detector.step(gray_Frame);
if ~isempty(face_Rectangle)
points = detectMinEigenFeatures(gray_Frame, 'ROI', face_Rectangle(1, :));
xy_Points = points.Location;
number_of_Points = size(xy_Points, 1);
release(point_Tracker);
initialize(point_Tracker, xy_Points, gray_Frame);
previous_Points = xy_Points;
rectangle = bbox2points(face_Rectangle(1,:));
face_Polygon = reshape(rectangle', 1, []);
video_Frame = insertShape(video_Frame, 'Polygon', face_Polygon, 'LineWidth', 3);
video_Frame = insertMarker(video_Frame, xy_Points, '+', 'Color', 'white');
end
else
[xy_Points, isFound] = step(point_Tracker, gray_Frame);
new_Points = xy_Points(isFound, :);
old_Points = previous_Points(isFound,:);
number_of_Points = size(new_Points, 1 );
if number_of_Points >= 10
[xform, old_Points, new_Points] = estimateGeometricTransform(old_Points, new_Points, 'similarity', 'MaxDistance', 4);
rectangle = transformPointsForward(xform, rectangle);
face_Polygon = reshape(rectangle', 1, []);
tic
video_Frame = insertShape(video_Frame, 'Polygon', face_Polygon, 'LineWidth', 3);
video_Frame = insertMarker(video_Frame, new_Points, '+', 'Color', 'white');
t3 = toc;
previous_Points = new_Points;
setPoints(point_Tracker, previous_Points);
end
end
.
.
.
Objektverfolgung mit Servo Motoren
Sobald ein Gesicht im Bild erkannt wird, wird die mittlere Position des Objekts (in diesem Fall die Bounding Box) relativ zu den Bildkoordinaten berechnet und als Eingabe für die Verfolgung verwendet.
Das Konzept der Verfolgung mit zwei Servomotoren ist in Abbildung 9 dargestellt, eine der Schwenk- und Neigebewegungen der Kamera. Immer, wenn sich das Objekt außerhalb des grünen Kastens befindet, wird der entsprechende Motor angewiesen, sich zu bewegen, um das Objekt in der Mitte des Bildes oder des grünen Kastens zu positionieren.
Bei jedem Bild, auch nach einer leichten Bewegung des Servomotors, wird das Objekt verfolgt und seine Position berechnet, wodurch ein Regelkreis entsteht. Die Schwenk- und Neigebewegungen der Servomotoren haben einen Bewegungsbereich, eine Ober- und eine Untergrenze, innerhalb derer sie sich bewegen dürfen. Wenn sich das Objekt außerhalb der grünen Box befindet und einer der Servomotoren seine Grenzen erreicht, werden beide Motoren auf ihre ursprüngliche Position zurückgesetzt und die Verfolgung des Objekts wird beendet.
Abbildung 10 zeigt ein vereinfachtes PAP dieses Projekts, um die Funktionsweise besser zu verstehen.
-
Abb. 10: PAP Gesichverfolgungskamera
Das folgende Skript stellt den Algorithmus zur Gesichtsverfolgung und die Bedingungen dar, unter denen die Servomotoren gesteuert werden.
while run_loop && frame_Count <4000
.
.
.
.
if isempty(face_Rectangle)
writeDigitalPin(a_Obj, 'D4', 0);
writeDigitalPin(a_Obj, 'D2', 1);
end
if(~isempty(face_Rectangle))
%LED Zustand zeigen
writeDigitalPin(a_Obj, 'D2', 0);
%writeDigitalPin(a_Obj, 'D4', 1);
%% Position des Boxs wird hier kopiert
BoxPos = mean(rectangle);
BmitteX = BoxPos(1);
BmitteY = BoxPos(2);
% Lese Die Position des Pan Servos, Regelkreis
posx= readPosition(panServo);
posx_deg = posx *360;
valx = BmitteX; % Mitte Punkt des ROI wert wird kopiert
if valx < screenmaxx/2 - incx
if posx < servomaxx_UpperLimit % Parameter umwandelung 0 bis 360 Gard ist in Matlab auf Sigmoid Funktion dargestellt (0 bis 1)
posx = posx + distancex/25
else posx = 0.5;
end
elseif valx > screenmaxx/2 +incx
if posx >= servomaxx_LowerLimit
posx = posx - distancex/25; % 100 ist der Passende Wert nach dem Fine tuning
else posx = 0.5; % Grenze uberschritten, Kamera auf Start Position zuerucksetze
end
end
% Redundanz, Arbeitsbereich des Servo Motor wird beschraenkt
if posx > 0.1 && posx <0.9
writePosition(panServo, posx)
end
if valx > screenmaxx/2 - incx || valx < screenmaxx/2 + incx
writeDigitalPin(a_Obj, 'D3', 0);
writeDigitalPin(a_Obj, 'D4', 1);
end
if valx < screenmaxx/2 - incx || valx > screenmaxx/2 + incx
writeDigitalPin(a_Obj, 'D3', 1);
writeDigitalPin(a_Obj, 'D4', 0);
end
%% Tilt Bewegung
posy= readPosition(tiltServo);
valy = BmitteY; % Mitte Punkt des ROI wert wird kopiert
if valy < screenmaxy/2 - incy
if posy < servomaxy_UpperLimit % Parameter umwandelung 0 bis 360 Gard ist in Matlab auf Sigmoid Funktion dargestellt (0 bis 1)
posy = posy + distancey/45;
else posy = 0.7; % Grenze uberschritten, Kamera auf Start Position zuerucksetzen
end
elseif valy > screenmaxy/2 +incy
if posy > servomaxy_LowerLimit
posy = posy - distancey/45; % 120 ist der Passende Wert nach dem Fine tuning
else posy = 0.7;
end
end
% Redundanz, Arbeitsbereich des Servo Motor wird beschraenkt
if posy > 0.4 && posy <0.8
writePosition(tiltServo, posy);
end
if valy > screenmaxy/2 - incy || valy < screenmaxy/2 + incy
writeDigitalPin(a_Obj, 'D3', 0);
writeDigitalPin(a_Obj, 'D4', 1);
end
if valy < screenmaxy/2 - incx || valy > screenmaxy/2 + incy
writeDigitalPin(a_Obj, 'D3', 1);
writeDigitalPin(a_Obj, 'D4', 0);
end
end
step(videoPlayer, video_Frame);
run_loop = isOpen(videoPlayer);
pause(pause_time);
end
clear cam;
release(videoPlayer);
release(point_Tracker);
release(face_Detector);
Komponententest
Bevor die Bauteile miteinander verlötet wurden und das Gehäuse des Systems aufgebaut wurde, sind sowohl elektrische als auch mechanische Komponenten auf ihre Funktionalität und Passgenauigkeit überprüft worden. In den Folgenden Unterkapiteln werden die Arbeitsschritte beschrieben.
Elektrische Komponenten
Um die elektrischen Komponenten zu testen war ein Versuchsaufbau erforderlich. Für einige Bauteile reichte schon ein simpler Aufbau einer Schaltung auf einem Breadboard, für andere musste der Arduino UNO hinzugezogen werden.
Zunächst wurden die ohmschen Widerstände mit einem Multimeter in einer Widerstandsmessung auf ihren Wert kontrolliert und es wurde verglichen, ob die Abweichung innerhalb der zulässigen Toleranz liegt.
Im Anschluss daran wurde ein Versuch auf dem Breadboard aufgebaut, mit dem die LEDs unter Verwendung der zuvor getesteten Widerstände angesteuert wurden. Bei dem Versuchsaufbau auf dem Breadboard wurde ebenfalls der Spannungsbegrenzer auf seine Funktion getestet.
Die Servomotoren zu überprüfen erforderte ein einfaches Skript, den Arduino UNO und den zuvor getesteten Spannungsbegrenzer. Mit diesem wurde die Versorgungsspannung für die Servomotoren bereitgestellt. Das PWM Signal zur Ansteuerung dieser wurde über das Skript und den Arduino UNO ausgegeben. Mit dem Programm wurden die Motoren langsam zwischen ihren Anschlägen verfahren.
Die Webcam wurde lediglich über den USB Port mit einem Computer verbunden. Anschließend wurde kontrolliert ob Bilder und Videos in gewünschter Qualität aufgezeichnet werden können.
Mechanische Komponenten
Das Gehäuse, der Webcamhalter, der Halter für die Servomotoren und das Stativ wurden auf Maßhaltigkeit kontrolliert. Anschließend wurde die Passgenauigkeit der Teile überprüft, als das Modell probelhalber zusammen gesetzt wurde. Da alle mechanischen und elektrischen Komponenten den Anforderungen entsprachen wurde das Modell nach Schaltplan verkabelt und anschließend zusammengesetzt.
Nr. | Anforderung | Anforderung erfüllt | Anforderung nicht erfüllt | Bemerkung |
---|---|---|---|---|
1 | Allgemein | |||
1.1 | Die Kamera soll Gesichter erkennen und ein einmal erfasstes Gesicht so lange verfolgen, wie es sich im Sichtfeld aufhält. | X |
||
1.2 | Falls sich mehrere Gesichter im Sichtfeld aufhalten soll nur ein Gesicht erfasst und verfolgt werden. | X |
||
1.3 | Das System soll den aktuellen Status über LEDs darstellen. | X |
||
1.4 | Zur Steuerung des Systems soll das Programm mit Simulink umgesetzt werden. | X |
Die Umsetzung mit Simulink war nicht möglich, da die Visiontoolbox nicht für Simulink zur Verfügung steht und somit die Auswertung der aufgenommenen Bilder nicht möglich war. Die Steuerung wurde stattdessen mit Matlab realisiert. | |
2 | Bildanalyse und Auswertung | |||
2.1 | Die von der Webcam erfassten Bilder sollen mittels eines Algorithmus auf Gesichter gescannt werden. Von den Gesichtern soll der Mittelpunkt erfasst und mit dem Mittelpunkt des Bildes verglichen werden. | X |
||
2.2 | Anhand der Position des erfassten Gesichts soll der Systemstatus ermittelt werden (Gesicht erkannt und zentriert / Gesicht erkannt, nicht zentriert / Gesicht nicht erkannt). | X |
||
3 | Ausgabe | |||
3.1 | Es soll permanent der Status über LEDs angezeigt werden (Gesicht erkannt und zentriert: Grüne LED / Gesicht erkannt, nicht zentriert: Gelbe LED / Gesicht nicht erkannt: Rote LED). | X |
||
3.2 | Die Servomotoren sollen über den Arduino UNO angesteuert werden und so immer versuchen ein erfasstes Gesicht zu zentrieren. | X |
Ergebnis
Bei dem Projekt konnten nahezu alle gestellten Anforderungen umgesetzt werden. Die Gesichtsverfolgungskamera erfüllt die wichtigsten Funktionen, auch wenn sie nicht, wie geplant, mit Simulink, sondern mit Matlab selbst gesteuert wird. Das Ergebnis des Projekts kann untenstehend im Youtube-Video betrachtet werden.
Zusammenfassung
Während der Durchführung des Projekts konnten diverse Fähigkeiten und erworbenes Wissen aus unterschiedlichen Modulen des Studiengangs angewendet werden. So konnten die Kenntnisse aus dem semesterbegleitenden Modul "Mechatronische Systeme II", sowie Kenntnisse aus Modulen vergangener Semester aufgefrischt und und in der Praxis angewandt werden. Hilfreich war das Wissen aus Fächern wie z.B.:
- CAD Praktikum
- GET I und GET II
- Informatik I und Informatik II
- Grundlagen elektrischer Schaltungen und Bauelemente
Lessons Learned
Es konnten durch das Projekt diverse Kenntnisse aus dem Studium in der Praxis erprobt werden. Dazu gehörten unter anderem:
- Projektplanung und Kostenkalkulation
- Auswahl geeigneter Komponenten für die Umsetzung
- Programmierung eines Mikrokontrollers und schreiben eines Programmes in Matlab
- Konstruieren und anschließendes 3D-Drucken mit einem CAD Programm
- Planen und zeichnen eines Schaltplans
- Löten und verbinden des zuvor entworfenen Schaltplans
Lediglich die Umsetzung des Programms in Simulink hat nicht funktioniert. Die Auswertung der aufgenommenen Bilder war nicht möglich, da für Simulink die Visiontoolbox nicht zur Verfügung stand. Das Programm konnte stattdessen jedoch in Matlab geschrieben werden.
Projektunterlagen
Projektplan
Projektdurchführung
Nach der Ideenfindung und dem Brainstorming wurde eine genaue Idee ausgearbeitet. Es wurde überlegt welche Komponenten für die Durchführung eines solchen Projekts benötigt würden und nachdem ein Plan für das Projekt bestand wurden die Bauteile bestellt. Die Komponenten wurde, wie zuvor beschrieben, auf ihre Funktionalität überprüft. Ebenso wurden die Teile für das Gehäuse kontrolliert und anschließend alles miteinander aufgebaut. Nachdem das Modell fertig war wurde an der Ausarbeitung der Software gearbeitet.
YouTube Video
In dem folgenden youtube-Video YouTube-Video wird eine Demonstration des Projekts Gesichtverfolgungskamera gezeigt. Die Aufnahme fand in der Hochschule Hamm-Lippstadt mit Genehmigung statt.
Weblinks
Literatur
→ zurück zur Übersicht: Kategorie:ProjekteET MTR BSE WS2022