Die Einrichtung eines Flask-Servers auf dem Raspberry Pi Zero 2W zur Steuerung des PI Camera Modul 3 ist ein spannendes Projekt für alle, die sich für IoT und Programmierung interessieren. In diesem Artikel zeige ich dir Schritt für Schritt, wie du deinen Raspberry Pi so konfigurierst, dass er Bilder aufnimmt und diese per Flask an einen Client sendet.
Verwendete Elektronik
- Raspberry Pi Zero 2W Case
- Raspberry Pi Zero 2W
- Raspberry Pi 5 8Gb
- Raspberry Pi 5 4Gb
- Raspberry Camera Module 3
Schritt 1: Raspberry Pi OS Lite installieren
- Lade den Raspberry Pi Imager herunter und installiere ihn auf deinem Computer.
- Öffne den Raspberry Pi Imager und wähle Raspberry Pi OS (other) > Raspberry Pi OS Lite (64-bit).
- Wähle die microSD-Karte als Zielspeicher und schreibe das Image.
- Da das OS Lite keine Benutzeroberfläche enthält, muss das WLAN über die Advanced Settings vom Pi Imager bereits konfiguriert werden. Klicke auf das Zahnrad-Symbol, um die Einstellungen zu öffnen, und gib deine WLAN-SSID und das Passwort ein.
Schritt 2: Vorbereitungen auf der SD-Karte
- Erstelle im Boot-Verzeichnis der SD-Karte (dort, wo sich auch die
config.txtbefindet) eine leere Datei mit dem Namenssh. Dies ermöglicht SSH-Zugriff auf den Pi.
Schritt 3: Raspberry Pi starten und SSH einrichten
- Starte den Raspberry Pi Zero 2W und verbinde ihn mit deinem Netzwerk.
- Logge dich per SSH ein:
ssh pi@raspberrypi.local
Schritt 4: System aktualisieren und notwendige Pakete installieren
- Aktualisiere das System:
sudo apt update sudo apt upgrade - Installiere die erforderlichen Pakete:
sudo apt install -y python3-picamera2 --no-install-recommends
Schritt 5: Python-Umgebung einrichten und Flask installieren
- Erstelle eine virtuelle Python-Umgebung:
python -m venv .venv --system-site-packages--system-site-packagesist wichtig, da dieses Flag die zuvor installierte picamera2 Bibliothek zur Python Umgebung hinzufügt. - Aktiviere die virtuelle Umgebung:
source .venv/bin/activate - Installiere Flask:
pip install flask pillow
Schritt 6: Flask-Anwendung schreiben und starten
Erstelle eine Python-Datei main.py mit folgendem Inhalt:
from flask import Flask, send_file
from picamera2 import Picamera2
from PIL import Image
import io
import time
app = Flask(__name__)
picam2 = Picamera2()
# Setup your camera configuration here
def setup_camera():
"""
Setup the camera for still image capture.
This function creates a still configuration for the camera with the main image size set to (4608, 2592) and the low-resolution image size set to (640, 480). The display is set to "lores". It then configures the camera with the created configuration and starts the camera.
Parameters:
None
Returns:
None
"""
camera_config = picam2.create_still_configuration(
main={"size": (4608, 2592)}, lores={"size": (640, 480)}, display="lores"
)
picam2.configure(camera_config)
picam2.start()
@app.route("/benchmark")
def benchmark():
"""
This function is a Flask route that is triggered when a GET request is made to '/benchmark'. It performs a benchmark by calling the 'get_image' function for each combination of 'format' and 'quality' from the 'formats' and 'qualitys' lists respectively. The 'get_image' function captures an image from the camera and returns it as a file of the specified format. After all the images are captured, the function returns the string "Done" with a status code of 200.
Parameters:
None
Returns:
A tuple containing the string "Done" and the integer 200.
"""
formats = ["jpeg", "png", "webp"]
qualitys = [90, 80, 70, 60, 50, 40, 30, 20, 10]
for format in formats:
for quality in qualitys:
get_image(format=format, quality=quality)
return "Done", 200
@app.route("/get-image/<format>/<quality>")
def get_image(format, quality=90):
"""
Captures an image from the camera and returns it as a file of the specified format.
This function is a Flask route that is triggered when a GET request is made to '/get-image/'. The `` parameter specifies the output format (jpeg, png, or webp). It captures an image from the camera using the `picam2.capture_array()` method and converts it into a PIL Image object. The image is then saved as a file of the specified format in a BytesIO object. The function calculates the size of the image in kilobytes and prints it. Finally, the function returns the image as a Flask send_file response with the appropriate mimetype.
Parameters:
format (str): The output format (jpeg, png, or webp).
Returns:
A Flask send_file response containing the captured image as a file of the specified format.
"""
print("format=", format, " quality=", quality)
if format not in ["jpeg", "png", "webp"]:
return "Invalid format", 400
start = time.time()
array = picam2.capture_array("main")
print("Capture time:", time.time() - start)
start = time.time()
im = Image.fromarray(array)
img_io = io.BytesIO()
im.save(img_io, format, quality=quality)
img_size_kb = len(img_io.getvalue()) / 1024
img_io.seek(0)
print(f"Image size in kilobytes: {img_size_kb:.2f} KB")
print("Convert time:", time.time() - start)
return send_file(img_io, mimetype=f"image/{format}")
if __name__ == "__main__":
setup_camera()
app.run(host="0.0.0.0", port=5000)
Starte die Flask-Anwendung:
python main.pyDein Flask-Server ist jetzt bereit, Bilder vom PI Camera Modul 3 aufzunehmen und an den Client zu senden. Greife über deinen Browser oder ein HTTP-Client-Tool auf die URL http://raspberrypi.local:5000/get-image/jpeg/80 zu, um ein Bild zu erhalten. Statt jpeg können webp und png Dateien generiert werden. Der letzte Parameter legt die Qualität (Kompression) fest – 0 (niedrige Qualität) bis 100 (hohe Qualität/keine Kompression).
Mit diesen Schritten hast du erfolgreich einen Flask-Server auf deinem Raspberry Pi Zero 2W eingerichtet, der Bilder vom PI Camera Modul 3 aufnimmt und an Clients sendet. Viel Spaß bei deinem Projekt!
Benchmark
Hier ist der Chart, der die Konvertierungszeit (Convert Time) und die Bildgröße (Image Size) für die Bildformate JPEG, PNG und WebP in Abhängigkeit von der Qualitätsstufe darstellt, wobei jede Formatgruppe konsistent mit einer Farbe dargestellt wird.
Analyse der Konvertierungszeit und Bildgröße
- JPEG (blaue Linie):
- Konvertierungszeit: Bleibt konstant niedrig, unabhängig von der Qualitätsstufe.
- Bildgröße: Nimmt mit abnehmender Qualität stetig ab.
- PNG (grüne Linie):
- Konvertierungszeit: Ist konstant hoch, unabhängig von der Qualitätsstufe.
- Bildgröße: Bleibt weitgehend konstant und ist deutlich größer als bei JPEG und WebP.
- WebP (rote Linie):
- Konvertierungszeit: Variiert mehr, bleibt jedoch insgesamt niedriger als bei PNG und höher als bei JPEG.
- Bildgröße: Nimmt mit abnehmender Qualität stetig ab und bleibt in einem moderaten Bereich.
Dieser Chart verdeutlicht, dass JPEG hinsichtlich der Konvertierungszeit und Bildgröße am effizientesten ist. WebP bietet eine gute Balance zwischen Konvertierungszeit und Bildgröße, während PNG die längste Konvertierungszeit und die größte Dateigröße aufweist.
