webwinkelkeur logo

4.7 gem.

5142+ beoordelingen
webwinkelkeur logoBekijk alles

5142+ beoordelingen

5142+ beoordelingen

Bestel voor 16:00 voor dezelfde dag verzending

14 dagen retour

GB

NL

Particulier

Zakelijk

logologo

Klantenservice

0

Raspberry Pi Camera time-lapse

Beginner
1 uur
136,98

In dit project zul je leren hoe je je eigen time-lapse camera kan maken met je Raspberry Pi 4 of Raspberry Pi 5. In dit project word alles uitgelegd zodat het makkelijk zelf te doen is en ook makkelijk zelf aan te passen is naar wat nodig is. We zullen het o.a hebben over hoe je de time-lapse volledig zelf kan configureren en ook is word er uitgelegd hoe de functies in de code werken. Laten we dan maar meteen beginnen!

Overzicht stappen van het project

  1. Voorbereiding hardware en software
  2. Terminal openen
  3. Projectmap aanmaken
  4. config.yaml maken en uitleg
  5. Installatiescript (dep.bash) maken en uitvoeren
  6. Python‑script (timelapse.py) aanmaken en code uitleg
  7. Directorystructuur controleren
  8. Timelapse draaien
  9. Video bekijken
  10. Veelvoorkomende problemen & tips

1. Voorbereiding hardware en software
 

Camera aansluiten

  • Zet de Raspberry Pi uit (sudo poweroff of knopje).
  • Sluit de PiCamera ribbon-kabel aan op de CSI-poort van de Pi (zwart lipje omhoog, kabel met koperen pootjes naar de HDMI-poorten).
  • Sluit de Pi aan en zet ‘m aan.

Camera-interface inschakelen

  • Open in de terminal:
sudo raspi-config
  • Ga naar Interface Options → Camera → kies Enable → Finish → herstart de Pi als daarom gevraagd wordt.
sudo apt-get update -y
sudo apt-get upgrade -y

Updates ophalen

  • Na herstart, open terminal en voer uit:
  • Dit haalt de nieuwste pakketlijsten op en installeert updates.

2. Terminal openen

  • Grafisch: klik op het zwart‑wit icoon van de terminal (linksbovenin de menubalk).
  • Sneltoets: druk op Ctrl+Alt+T.
  • De terminal is je “commandoregel” waar je alle volgende commando’s invoert.

3. Projectmap aanmaken

In de terminal typ je:

mkdir ~/timelapse_project
  • mkdir maakt een nieuwe map.
  • ~ staat voor je home‑directory (bijv. /home/pi).

Ga naar die map:

cd ~/timelapse_project
  • cd = change directory, je “gaat naar” de map.

Controleer dat je in de juiste map zit:

pwd
  • pwd toont je huidige locatie in het bestandssysteem.
  • Je zou iets als /home/pi/timelapse_project moeten zien.

4. config.yaml maken en uitleg

Open de editor:

nano config.yaml
  • nano is een eenvoudige teksteditor in de terminal.

Plak deze inhoud:
camera:
  preview: true                    # Laat tijdens opnemen een klein voorvertoningsvenster zien
  pixel_ratio:
    - 1920                         # Breedte van de foto’s
    - 1080                         # Hoogte van de foto’s
  preview_pixel_ratio:
    - 640                          # Breedte van de preview
    - 480                          # Hoogte van de preview
logging: true                      # Zet op true om statusberichten in de terminal te zien
picture_folder: "pictures"         # Map waar foto’s komen
time_lapse_folder: "time_lapse_videos"  # Map waar de video komt
maxtime:
  duration: 60                     # Totale opname‑tijd in seconden
frame_interval: 0.5                # Tussen elke foto (in seconden)
frame_rate_video: 30               # Frames per seconde in de video

Opslaan: druk op Ctrl+O, Enter.

Afsluiten: Ctrl+X

Wat doet dit?
Config.yaml is ook wel het configuratie bestand van alle python code die je zult uitvoerenJe vertelt het script hoe de camera moet werken, waar de bestanden komen te staan, hoe lang het loopt, en hoe snel de uiteindelijke video is.

5. Installatiescript (dep.bash) maken en uitvoeren

Maak het bestand:

nano dep.bash

Plak dit erin:

#!/usr/bin/env bash
sudo apt-get update -y                 # Haalt de nieuwste pakketlijsten op
sudo apt-get upgrade -y                # Installeert alle beschikbare updates
sudo apt-get autoremove -y             # Verwijdert oude, overbodige pakketten
# Installeer Python-modules & camera-drivers
sudo apt-get install python3-picamera2 -y
sudo apt-get install python3-libcamera -y
sudo apt-get install python3-yaml -y
sudo apt-get install python3-shutil -y
sudo apt-get install python3-opencv -y   # ‘cv2’
sudo apt-get install python3-numpy -y
sudo apt-get install python3-pathlib -y

Maak uitvoerbaar:

chmod +x dep.bash

Voer uit:

./dep.bash

 

Wat gebeurt er?

  • update en upgrade zorgen dat je systeem up‑to‑date is.
  • autoremove ruimt op.
  • install haalt specifieke Python‑packages en camera‑libraries binnen.

6. Python‑script (timelapse.py) aanmaken en code uitleg

Open een nieuw bestand:

nano timelapse.py

Plak de volledige code (van from picamera2 import Picamera2 t/m cleanup()).

from picamera2 import Picamera2
from libcamera import Transform, controls
import libcamera
 
import yaml
import shutil
import cv2
import numpy as np
from pathlib import Path
import os
import time
 
# Open het configuratie bestand en lees hem
with open('config.yaml', 'r') as file:
    config = yaml.safe_load(file)
 
# Maak een camera object
camera = Picamera2()
 
# Zet maximale stappen
iterations = int(config["maxtime"]["duration"] / config["frame_interval"]) # maximale tijd / interval 
picdir = config["picture_folder"]
log = config["logging"]
 
 
 
 
 
def images_to_video(image_folder=f"{config['picture_folder']}", output_path=f"{config['time_lapse_folder']}/output.mp4", fps=30, pixel_radius=3):
    
    if log:
        print("Foto's naar video aan het converteren...")
 
 
    folder_path = Path(image_folder)
    
    # Get list of numbered images
    image_files = sorted([f for f in folder_path.glob('*.jpg') 
                     if f.stem.isdigit()],
                    key=lambda x: int(x.stem))
 
    if not image_files:
        raise ValueError("Geen fotos gevonden")
        
    # Read first image to get dimensions
    first_frame = cv2.imread(str(image_files[0]))
    
    # Create VideoWriter object with H.264 codec
    height, width = first_frame.shape[:2]
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')  # H.264 codec
    out = cv2.VideoWriter(
        str(output_path),
        fourcc,
        fps,
        (width, height)
    )
    
    # Process each image
    for img_path in image_files:
        frame = cv2.imread(str(img_path))
        
        # Apply Gaussian blur based on pixel radius
        if pixel_radius > 0:
            frame = cv2.GaussianBlur(frame, 
                                   (pixel_radius*2 + 1, pixel_radius*2 + 1), 
                                   0)
            
        out.write(frame)
    
    # Release VideoWriter
    out.release()
    cv2.destroyAllWindows()
    
 
def create_directorys(folders: list):
    for folder in folders:
        if not os.path.exists(f"{os.getcwd()}/{folder}"):
            try:
                os.mkdir(f"{os.getcwd()}/{folder}")
                print(f"Map aangemaakt : {folder}")
            except Exception as e:
                if e.errno != errno.EEXIST: 
                    print(f"Error bij het aanmaken van een map: {e}")
    return
 
 
 
def cleanup():
    shutil.rmtree(f"{os.getcwd()}/{config['picture_folder']}") # verwijdert alle foto bestanden
    exit()
 
 
 
def maak_foto_en_sla_op(i):
    try:
        # Maak de foto
        camera.capture_file(f"{os.getcwd()}/{picdir}/{i}.jpg")
        if log:
            print(f"foto {i} opgeslagen")
    except Exception as e:
        raise e
    
    
def error(e):
    images_to_video()
    cleanup()
    print(f"Er is een error voorgekomen ({e}). De fotos die zijn gemaakt zijn opgeslagen en worden omgezet in een time-lapse")
    exit(1)
    
 
 
 
# configureer de code
camera_config = camera.create_still_configuration(
    main={"size": (config["camera"]["pixel_ratio"][0], config["camera"]["pixel_ratio"][1])},
    lores={"size": (config["camera"]["preview_pixel_ratio"][0], config["camera"]["preview_pixel_ratio"][1])}
)
 
camera_config = camera.create_preview_configuration(
    main={"size": (config["camera"]["pixel_ratio"][0], config["camera"]["pixel_ratio"][1])},
    lores={"size": (config["camera"]["preview_pixel_ratio"][0], config["camera"]["preview_pixel_ratio"][1])}
)
 
camera.configure(camera_config)
 
 
camera.start(show_preview=config["camera"]["preview"])
 
camera.set_controls({"AfMode": controls.AfModeEnum.Continuous, "AfSpeed": controls.AfSpeedEnum.Fast})
 
 
create_directorys([config["picture_folder"], config["time_lapse_folder"]])
 
print("Let op : Het bestand output.mp4 word overgeschreven ook al staat hij er. Als je nog een oude video heb sla hem dan onder een andere naam op of op een andere plek om hem nog te behouden")
if log:
    print("Programma begint met opnemen over 3 seconden")
time.sleep(3)
if log:
    print("Programma maakt nu foto's")
 
 
try:
    for i in range(1, iterations+1):
        try:
            maak_foto_en_sla_op(i)
            time.sleep(config["frame_interval"]) 
        except Exception as e:
            error(e)
            cleanup()
except Exception as e:
    error(e)
    cleanup()
 
images_to_video()
print("Klaar!")
cleanup()

Opslaan en afsluiten: Ctrl+O, Enter & Ctrl+X.


 

Uitleg belangrijkste stukken code

Imports

from picamera2 import Picamera2
import yaml, shutil, cv2, numpy as np
from pathlib import Path
import os, time

Haalt alle modules binnen die we nodig hebben.

Config laden

with open('config.yaml','r') as f:
    config = yaml.safe_load(f)

Leest je instellingen uit config.yaml.

Iteraties berekenen

iterations = int(config["maxtime"]["duration"] / config["frame_interval"])

Berekent hoeveel foto’s er in totaal worden genomen.

Mappen aanmaken

def create_directorys(folders):
    # Maakt folders als ze nog niet bestaan

Zorgt dat pictures/ en time_lapse_videos/ bestaan.

Foto’s maken

def maak_foto_en_sla_op(i):
    camera.capture_file(f"{picdir}/{i}.jpg")

Neemt een enkele foto en slaat ‘m op als 1.jpg, 2.jpg, etc.

Foto’s naar video

def images_to_video(...):
    # Leest alle .jpg-bestanden, maakt er een mp4 van

Combineert de foto’s en voegt (optioneel) blur toe.

Error-afhandeling

def error(e):
    images_to_video()   # Zet op dat er een video wordt gemaakt
    cleanup()

Vangt fouten op, zorgt dat gemaakte foto’s niet verloren gaan.

Hoofdprogramma

camera.start(...)
for i in range(1, iterations+1):
    maak_foto_en_sla_op(i)
    time.sleep(config["frame_interval"])
images_to_video()
cleanup()
  1. Start de camera
  2. Loopt door alle iteraties
  3. Pakt foto, wacht interval
  4. Maakt video, ruimt op
     

7. Directorystructuur controleren

In je timelapse_project‑map zou je nu moeten zien:

ls -R

.
├── config.yaml
├── dep.bash
├── timelapse.py
├── pictures/               # (leegt aanvankelijk)
└── time_lapse_videos/      # (leegt aanvankelijk)

8. Timelapse draaien

  1. Zorg dat je in de projectmap bent (cd ~/timelapse_project).
  2. Typ:
python3 timelapse.py

Wat je ziet:

  • In de terminal statusberichten (“foto 1 opgeslagen”, …).
  • Na 3 seconden een countdown (als logging aanstaat).
  • De camera maakt foto’s volgens jouw interval.

Wacht tot Klaar! in de terminal verschijnt.

9. Video bekijken

Na afloop staat de timelapse in:

~/timelapse_project/time_lapse_videos/output.mp4

Op de Pi zelf:

omxplayer time_lapse_videos/output.mp4

Op je computer: haal het bestand via SCP/USB over en open in VLC of een andere speler.

10. Veelvoorkomende problemen & tips

ProbleemOplossing
Camera niet beschikbaarCheck sudo raspi-config → Interface Options → Camera
Permissie‑foutDraai script met python3 (niet als root), en check bestandsperms
Weinig schijfruimtePas maxtime of frame_interval aan, of breid SD‑kaart uit
Foto’s bewarenHaal of comment cleanup() weg aan het einde van het script
Video‑codec problemenGebruik omxplayer of pas fourcc in images_to_video() aan

Gerelateerde projecten

project banner

Gevorderd | Raspberry Pi

Raspberry Pi project: Pi-hole ad blocker

project banner

Expert | Raspberry Pi

Raspberry Pi Proxyserver opzetten

project banner

Gevorderd | Raspberry Pi

Raspberry Pi starten vanaf USB of Netwerk

Benodigde producten