Bildverarbeitung mit Raspberry Pi und Webcam: Unterschied zwischen den Versionen

Aktuelle Version vom 12. Februar 2019, 16:00 Uhr

Einleitung und Ziel

Die Aufgabe Bildverarbeitung mit Raspberry Pi und Webcam, Weitergabe der Kamera-Objektliste über CAN, Modellbasierte Entwicklung über Matlab/Simulink gliedert sich in die folgenden Teilaufgaben:

Bildverarbeitung in Matlab/Simulink,
CAN-Schnittstelle,
Test,
Planung und
Dokumentation.

Das Ziel der Aufgabe ist die Aufzeichnung der Fahrbahn mit der Webcam. Die aufgenommen Bilder werden auf dem Raspberry Pi weiterverarbeitet und die Spurinformationen werden aus der aufgenommenen Fahrbahn extrahiert. Die Spurinformationen werden anschließend über den CAN-Bus ausgegeben.

Verwendete Hardware

Zur Umsetzung der Aufgabe wurde ein Raspberry Pi Modell B, eine Logitech HD Webcam C310, ein Micro-USB Netzteil und ein Netzwerkkabel verwendet. Die folgende Abbildung zeigt den Aufbau und wie die einzelnen Komponenten miteinander verbunden sein müssen.

Die eingesetzte Hardware wird in den folgenden Kapiteln beschrieben.

Raspberry Pi

Der Raspberry Pi ist ein Ein-Platinen PC in der Größe einer Kreditkarte. Es wird ein ARMv6-Prozessor mit 700MHz, 512MB Arbeitsspeicher und eine Broadcom VideoCore IV GPU eingesetzt. Zur Verbindung mit Peripheriegeräten verfüht der Raspberry Pi Modell B über zwei USB 2.0 Anschlüsse, einer RJ45 Büchse zur Verbindung mit 10/100MBit Ethernet, einer 3,5mm Klinkenbuchse als Audioausgang, einem Composite Video-Ausgang, einem HDMI-Ausgang, 21 GPIO-Pins und einem SD-/MMC-Karten Slot. Die Abbildung Raspberry Pi Model B zeigt den Raspberry Pi mit einer Beschriftung der Schnittstellen.

Die Stromversorgung des Raspberry Pi wird über eine Micro-USB Buchse hergestellt. Zum Betrieb sind mindestens 700mA notwendig, weshalb eine USB 2.0 Schnittstelle nicht ausreicht, da diese nur 500mA zur Verfügung stellt. Daher ist ein externes Netzteil erforderlich. Das Betriebssystem des Raspberry Pi wird mit einem PC auf eine SD-Karte geladen. Es stehen verschiedene Linux-Distributionen als Betriebssystem zur Verfügung, die frei heruntergeladen werden können. Zur Verwendung des Raspberry Pi mit Matlab/Simulink wird bei der Konfiguration von Matlab ein Betriebssystem auf eine SD-Karte geladen. Die Einrichtung des Raspberry Pi und die Matlab Konfiguration werden unter Punkt Einrichtung von Matlab/Simulink und des Raspberry Pi beschrieben.

Webcam

Als Webcam wird die Logitech HD Webcam C310 eingesetzt. Diese hat eine Auflösung von 1280x720 Pixel für Videos und kann Bilder mit einer Auflösung von bis zu 5 Megapixeln aufnehmen. Zusätzlich verügt die Kamera über ein integriertes Mikrofon. Über eine USB 2.0 Schnittstelle wird die Webcam mit dem Computer verbunden.

Netzteil

Die Spannungsversorgung des Raspberry Pi wird mit einem Steckernetzteil realisiert. Das Steckernetzteil hat einen micro-USB Anschluss an dem 5V bei einem Strom von 1,4A zur Verfügung stehen.

Einrichtung von Matlab/Simulink und des Raspberry Pi

Zur Verwendung des Raspberry Pi mit Matlab/Simulink muss Matlab 2013a oder neuer installiert sein. Das Simulink Support Package for Raspberry Pi Hardware enthält die Simulink-Blöcke zur Programmierung des Raspberry Pi. Einen guten ersten Einstieg in die Verwendung des Raspberry Pi mit Matlab/Simulink bietet das Mathworks Webinar Raspberry Pi Programming using Simulink unter Raspberry Pi Support from Simulink. Die Installation des Support Packages und die Einrichtung sowie die Verbindung des Raspberry Pi mit dem PC werden in den Folgen Schritten beschrieben.

Auswahl des Compilers: In der Matlab-Konsole den Befehl mex -setup eingeben. Nun kann der zu verwendende Compiler ausgewählt werden. In diesem Projekt wurde das Microsoft Software Development Kit (SDK) verwendet.
Installation des Hardware Support Packages
1. In Matlab unter HOME das Dropdownmenü Add-Ons öffnen und Get Hardware Support Packages anklicken.
2. Install from Internet auswählen und mit Next> fortfahren.
3. In der linken SpalteRaspberry Pi auswählen und Rechts einen Haken vor Install setzen. Mit Next> gelangt man zum nächsten Schritt.
4. Anmeldung beim Mathworks Account mit den der HSHL E-Mail Adresse und dem zugehörigen Passwort.
5. Lizenzvereinbarung akzeptieren und die Installation mit dem Button Install starten.
6. Bei Set up support package Raspberry Pi auswählen und mit Next> bestätigen.
7. Die Firmware für den Raspberry Pi mit einem Klick auf Download herunterladen.
8. Zur Verbindungseinstellung unter Configure network Manually enter Network settings auswählen und mit Next> fortfahren. Wichtig: Die IP-Konfiguration und die LAN-Einstellungen des Host-PC müssen den hier eingegeben Adressen angepasst werden. Es können zum Beispiel die in Abbildung LAN-Einstellungen des Host-PC gezeigten Einstellungen verwendet werden.
  LAN-Einstellungen des Host-PC
9. SD-Karte in den PC einstecken und unter Select a drive das Laufwerk der SD-Karte auswählen, gegebenenfalls muss die Liste mit Refresh aktualisiert werden. Mit Next> zum nächsten Schritt gehen.
10. Ein Klick auf Write schreibt die Firmware auf die SD-Karte. (Sollte das Schreiben der Firmware fehlschlagen, ist ein löschen der SD-Karte oder die Formatierung mit Windows nicht ausreichend. Die SD-Karte muss mit dem Tool SD Formatter der SD Association in den Auslieferungszustand gebracht werden. Die aktuelle Version 4.0 (Stand 06.02.2014) steht unter SD Formatter 4.0 zum Download zur Verfügung.)
11. Raspberry Pi mit dem Host-PC verbinden.
  1. SD-Karte mit der Firmware in den Raspberry Pi einstecken.
  2. LAN-Kabel einstecken.
  3. Micro-USB Kabel des Netzteils mit dem Raspberry Pi verbinden.
  4. Mit Next> fortfahren.
12. Test der Verbindung über den Button Test Connection.
13. Die Einrichtung ist abgeschlossen und der Raspberry Pi kann mit Matlab/Simulink verwendet werden.
Anschluss der Webcam
1. Im ausgeschalteten Zustand des Raspberry Pi das LAN-Kabel und dann die Kamera anschließen.
2. Netzteil anschließen.
3. Die Verbindung zum Raspberry Pi kann mit dem Befehl !ping 169.254.0.31 überprüft werden.
  Ping erfolgreich
  Bei einer erfolgreichen Verbindung wird in der Konsole die rechts abgebildete Meldung angezeit.
4. Mit dem Matlab-Befehl raspberrypi.execute('ls -al /dev/video*') wird kontrolliert ob die Kamera am Raspberry Pi angeschlossen ist und verwendet werden kann. Wird crw-rw---T+ 1 root video 81, 0 Jan 1 1970 /dev/video0 ausgegeben ist die Kamera korrekt verbunden und wurde vom Raspberry Pi erkannt.

Für jede weitere Verwendung des Raspberry Pi mit der Webcam müssen nur die Schritte unter Punkt 3 Anschluss der Webcam durchgeführt werden.

Bildverarbeitung in Matlab/Simulink

Das Simulinkmodell zur Verarbeitung des Kamearbildes wird in Abbildung Simulinkmodell zur Verarbeitung der Kamerabilder dargestellt.

Es ist in dem Verzeichnis \trunk\Teams\RaspberryPi_Webcam\Simulink\Pi_Lane_Tracking abgelegt.

Die Kamerabilder werden mit dem V4L Video Capture-Block aus dem Simulink Support Package for Raspberry Pi eingelesen. Die Bilder haben die Größe 640x480 Pixel und das Format YCbCr 4:2:2. Das YCbCr Format teilt Bilder in die Grundhelligkeit Y und die Farbinformationen Blau-Gelb (Cb) und Rot-Grün (Cr) auf. Zur Weiterverarbeitung wird nur der Y-Kanal verwendet, wodurch eine Wandlung des Bildes in Graustufen entfällt. Die Grauwerte des Bildes werden in der Matlab-Function Lane_Detection weiterverarbeitet.

Lane-Detection

Die Schritte zur Erkennung der Fahrspur werden im folgenden erläutert.

Bild einlesen

Das eingelesene Bild wird um 90° gegen den Uhrzeigersinn gedreht und vertikal gespiegelt. Diese Bearbeitung ist notwendig um das Bild des V4L Video Capture Block dem in Matlab verwendeten Koordinatensystem anzupassen.

img = fliplr(rot90(img_in,3));

Kantenerkennung

Die Kanten werden mit dem Sobel-Filter detektiert. Die Sobel-Matrix wird mit einer Faltung auf das bearbeitete Bild angewendet. Das Ergebnis dieser Faltung ist ein Bild in dem alle Gradienten der Kanten enthalten sind. Im folgenden werden alle Kanten deren Wert größer 40 ist mit 255 ersetzt und die anderen Gradienten auf Null gesetzt. Hierdurch bleiben nur die Starken Kanten zwischen der Fahrbahn und den Markierungen erhalten.

%% Sobelfilter zur Kantenerkennung
k = [1 2 1; 0 0 0; -1 -2 -1];       % Sobel-Matrix anlegen
V = conv2(double(img),k','same');   % Sobel anwenden
edgeImage = uint8((V > 40) * 255);  % Es werden alle Kanten deren Gradienten > 40 sind berücksichtigt

Das Ergebnis dieses Schritts ist in den folgenden Abbildung dargestellt.<br\>

Das Bild mit den Kanteninformationen wird auf die Region of Interest von 100x640Pixel reduziert. Der ROI-Bereich ist so ausgelegt, dass alle Kanten in diesem Bereich zu den Fahrbahnmakrierungen gehören. Somit muss nicht zwischen Kanten der Fahrbahn und anderen Kanten unterschieden werden.

% Kantenbild auf ROI 100x640 begrenzen
edgeImageRed = zeros(100,640);
for x=1:100
    for y=2:640        
        edgeImageRed(x,y) = edgeImage(x+379,y);           
    end    
end

Das folgende Bild zeigt das auf die ROI reduzierte Kantenbild.<br\>

Koordinaten der Fahrspuren erkennen

Die Bestimmung der Koordinaten ist in linke Fahrspur und rechte Fahrspur unterteilt. Zur Zuordnung der Kanteninformationen zur linken und rechten Fahrspur wird das Bilder horizontal in der Mitte geteilt. Alle Kanten im Bereich eins bis 320 gehören zur linken Spur und die Kanten von 320 bis 640 bilden die rechte Spur. Die Koordinaten der Fahrspuren werden ermittelt, indem geprüft wird ob ein Element des Kantenbildes ungleich Null ist und dieses Element noch nicht detektiert wurde. Die Koordinaten eines solchen Elementes werden in einer Matrix gespeichert und anschließend sortiert. Dieser Ablauf ist für die linke Fahrspur und die rechte Fahrspur identisch.

%% Koordinaten der Fahrspuren ermitteln
% Linke Fahrspur
kante_l_koord = zeros(320,2);
ctr = 1;
for y=1:320
    for x=1:100        
        if((edgeImageRed(x,y) ~= 0) && (edgeImageRed(x,y) ~= edgeImageRed(x,y+1)))  % Pixel mit Kanteninformation hat Wert 255
            kante_l_koord(ctr,1) = x;   % x und y Koordinaten werden gespeichert, wenn Pixel Kanteninformationen enthält und
            kante_l_koord(ctr,2) = y;   % noch nicht gespeichert wurde
            ctr = ctr+1;
        end
    end    
end
% Kantenkkordinaten neu ablegen in reihenfolge 1 - Anzahl Pixel mit Kanteninformation
koord_l = zeros(ctr-1,2);
for i=1:(ctr-1)
   koord_l(i,1) = kante_l_koord(i,1);
   koord_l(i,2) = kante_l_koord(i,2);
end
 

% Rechten Fahrspur
kante_r_koord = zeros(320,2);
ctr = 1;
for y=320:640
    for x=1:100        
        if((edgeImageRed(x,y) ~= 0) && (edgeImageRed(x,y) ~= edgeImageRed(x,y+1)))  % Pixel mit Kanteninformation hat Wert 255
            kante_r_koord(ctr,1) = x;   % x und y Koordinaten werden gespeichert, wenn Pixel Kanteninformationen enthält und
            kante_r_koord(ctr,2) = y;   % noch nicht gespeichert wurde
            ctr = ctr+1;
        end
    end    
end
% Kantenkkordinaten neu ablegen in reihenfolge 1 - Anzahl Pixel mit Kanteninformation
koord_r = zeros(ctr-1,2);
for i=1:(ctr-1)
   koord_r(i,1) = kante_r_koord(i,1);
   koord_r(i,2) = kante_r_koord(i,2);
end

Polynom bilden

Die Polynome der linken Fahrspur und der rechten Fahrspur wurden mit den Funktionen polyfit und polyval aus den Koordinaten der Kanten erstellt. polyfit findet die Koeffizienten des zu erstellenden Polynoms und polyval berechnet die Funktionswerte des erzeugten Polynoms.

%% Polynom bilden
X_val = 1:1:640;

P_l = polyfit(koord_l(:,1), koord_l(:,2),2);
Y_l = polyval(P_l, X_val);

P_r = polyfit(koord_r(:,1), koord_r(:,2),2);
Y_r = polyval(P_r, X_val);

Die Polynome der Fahrspur werden in der folgenden Abbildung dargestellt.<br\>

Bild mit Spurpolynomen

Die Spurpolynome werden in rot in ein Bild mit schwarzen Hintergrund eingezeichnet.

%% Bild mit Spurpolynom erzeugen
% In einem schwarzen Bild wird das Spurpolynom in Rot angelegt
Lane_Pic = uint8(zeros(100,640,3));%uint8(ImageRed);

for i=1:100
      % Linkes Spurpolynom einblenden
      if((Y_l(i)<=640) && (Y_l(i)>=1))
        Lane_Pic(i,uint16(Y_l(i)),1) = 255; 
        Lane_Pic(i,uint16(Y_l(i)),2) = 0;
        Lane_Pic(i,uint16(Y_l(i)),3) = 0;
      end
      % Rechtes Spurpolynom einblenden
      if((Y_r(i)<=640) && (Y_r(i)>=1))
        Lane_Pic(i,uint16(Y_r(i)),1) = 255; 
        Lane_Pic(i,uint16(Y_r(i)),2) = 0;
        Lane_Pic(i,uint16(Y_r(i)),3) = 0;
      end
end

Ausgabe

Die Matlab-Function gibt das eingelesene Originalbild am Ausgang out und das Bild mit dem Spurpolynomen am Ausgang Lane aus.

%% Ausgabe
% Originalbild ausgeben
out = img;

% Bild mit Spurpolynomen ausgeben
Lane = Lane_Pic(:,:,1);

Überlagerung und Ausgabe

Das Originalbild und die Spurpolynom-Bild werden mit dem Simulinkblock Compositing überlagert. Der Video-Viewer-Block gibt das Bild mit den Spurpolynomen in Graustufen aus. Deshalb werden die Spurpolynome in weiß dargestellt. Die Abbildung Ausgabe mit Spurpolynom zeigt die Ausgabe mit dem Video-Viewer-Block.

Ausblick

Es empfiehlt sich als nächstes ein Lane-Tracking zur Spurstabilisierung zu implementieren, weil die in das Originalbild eingeblendeten Spurpolynome bei einem stabilen Originalbild um wenige Pixel nach links und rechts schwanken.<br\> Zur Realisierung von Spurwechselmanövern ist die Unterscheidung der linken und rechten Spur dynamisch umzusetzen.<br\> Im Anschluss an diese Schritte kann eine CAN-Schnittstelle zur Übertragung der Spurparameter realisiert werden.

Stand zu Meilenstein 3

Der Stand zu Meilenstein 3 ist unter \Teams\RaspberryPi_Webcam\ abgelegt. Bis zu Meilenstein drei wurden die Schritte Spurerkennung, Polynombildung und Einblenmdung des Spurpolynoms in das Videobild fertig gestellt.

Quellen

Raspberry Pi Support from Simulink Zuletzt abgerufen am 27.12.2013
Simulink Target Hardware Raspberry Pi Zuletzt abgerufen am 27.12.2013
Raspberry Pi Programming using Simulink Zuletzt abgerufen am 27.12.2013
Raspberry Pi Beitrag auf de.wikipedia.orgZuletzt abgerufen am 27.12.2013
Matlab-Coder Edge Detection on ImagesZuletzt abgerufen am 27.12.2013

Autor: Nils Brunnert (Diskussion) 11:22, 6. Feb. 2014 (CET)

→ zurück zum Hauptartikel: Praktikum SDE