Bewegingsdetector

Infraroodsensoren zijn sensoren die gebruik maken van infrarood licht. Ze worden voor verschillende doeleinden gebruikt, zoals het detecteren van beweging, ontvangers voor IrDA-systemen, contactloze temperatuursensoren en het maken van afstandschattingen. Beeldvormende infraroodsensoren worden bovendien ingezet als nachtzichtapparatuur.

Veelgebruikt wordt de passieve infraroodsensor (PIR) voor bewegingsdetectie. Je hebt ze wellicht al gezien, ze worden gebruikt in alarmsystemen (de sensoren in de hoeken van kamers zijn meestal PIR sensors). Alle voorwerpen die een temperatuur heeft van meer dan het absolute nulpunt zendt infrarood licht uit. Infrarood licht is niet zichtbaar voor het menselijk oog, maar kan wel door elektronica gedetecteerd worden.

Een sensor is passief als deze geen licht uitstraalt om beweging te detecteren. Het past zich aan de infrarood straling van een kamer aan en reageert op veranderingen daarin. Elk bewegend voorwerp zal deze infrarood straling beïnvloeden en dus door de PIR opgemerkt worden.

We houden ons niet bezig met de interne werking van een PIR sensor, wel zijn we geïnteresseerd in hoe we een PIR sensor op de Raspberry Pi kunnen aansluiten.

PIR sensor aansluiten

Voor je de Raspberry Pi opstart, verbind je de PIR sensor met de Pi. Let daarbij goed op de aansluitingen, niet op elke PIR staan de aansluitingen op dezelfde plaats en/of volgorde.

Met behulp van drie female-to-female draadverbindingen verbind je de PIR sensor met de Raspberry Pi:

Verbindt de VCC pen van de PIR sensor met de 5V pen van de Raspberry Pi.
Verbindt de GND pen van de PIR sensor met de massa van de Raspberry Pi. De PIR sensor kan nu via de Raspberry Pi van stroom worden voorzien.
Verbindt de OUT pen (oranje kabel op de afbeelding) van de PIR sensor met pen 4 van de GPIO van de Raspberry Pi. De spanning op deze pen verandert wanneer de PIR sensor beweging detecteert en geeft dit zo door aan de Raspberry Pi.

De PIR bewegingssensor testen

Zorg dat Raspberry Pi OS bijgewerkt is.

We gaan een script gebruiken om wat code te schrijven waarbij we tekst laten verschijnen bij het detecteren van beweging.

Het programma is relatief simpel. We schrijven eerst functies om het script te laten wachten op beweging of juist geen beweging. De PIR sensor meldt beweging op GPIO pen 4. De status van GPIO pen vier kan je met de volgende opdracht opvragen:

pi@raspberrypi:~ $ raspi-gpio get 4
GPIO 4: level=0 fsel=0 func=INPUT pull=UP

Dit was zonder dat de PIR beweging detecteerde, met beweging krijgen we:

pi@raspberrypi:~ $ raspi-gpio get 4
GPIO 4: level=1 fsel=0 func=INPUT pull=UP

M.a.w. de level waarde krijgt bij beweging de waarde 1, zonder beweging de waarde 0.

Dit moet constant gebeuren en gebruiken daarvoor een while lus. In de lus controleren we GPIO pen 4 op beweging (level=1). Als dit zo is ($? gelijk aan 0) wordt de lus verlaten (break). Als dit niet zo is, wordt 1 seconde gewacht (sleep 1) en wordt de lus opnieuw uitgevoerd. M.a.w. de functie is pas klaar als er beweging (eerste functie) of juist geen beweging (tweede functie) werd waargenomen.

De sleep opdracht zorgt dat ons script 1 seconden niets doet, waardoor andere programma's en het besturingssysteem andere taken kunnen uitvoeren. Zonder de sleep opdracht zou alle processorkracht naar ons script gaan en de Raspberry Pi vastlopen.

Ook ons programma bestaat uit een eindeloze lus. Daarin wachten we met behulp van onze functies respectievelijk op beweging en geen beweging waarbij we dit telkens melden (echo). De programmalus onderbreken we manueel met Ctrl+c en het script wordt beëindigd.

Aan dit hoofdstuk wordt nog hard gewerkt.

Oud cursisten kunnen nog op de oude pagina terecht.

Start Geany (Menu > Programmeren > Geany), maak een nieuw Python programma (Bestand > Opslaan als met de bestandsnaam beweging.py) en typ de volgende code:

#!/bin/bash
# Eerst definiëren we enkele functies
# Functie waarmee je wacht op beweging:
wait_for_motion () {
  while :
  do
    raspi-gpio get 4 | grep -q "level=1"
    if [ $? -eq 0 ]; then
      break
    fi
    sleep 1
  done
}
# Functie waarmee je wacht tot er geen beweging meer is
wait_for_no_motion () {
  while :
  do
    raspi-gpio get 4 | grep -q "level=0"
    if [ $? -eq 0 ]; then
      break
    fi
    sleep 1
  done
}
# Hier begint ons programma
# Oneindig lang worden bewegingen gemeld
# Breek het programma af met Ctrl+c
while :
do
  wait_for_motion
  echo "Beweging waargenomen"
  wait_for_no_motion
  echo "Geen beweging"
done

Sla het bestand op en druk F5 om het programma te starten.

Telkens wanneer de PIR sensor beweging detecteert verschijnt de tekst Beweging waargenomen! in het terminal venster. Indien er geen beweging meer wordt opgemerkt, verschijnt de tekst Geen beweging!. Druk Ctrl+c om het programma af te sluiten.

PIR potentiometers Op de PIR sensor staan twee oranje componenten die je met een Philips schroevendraaier kunt aanpassen. Dit zijn potentiometers en ze laten toe de gevoeligheid en de detectievertraging van de sensor in te stellen. Je begint meestal met een maximale gevoeligheid en de kortste detectievertraging. De gevoeligheid regelt de afstand waarop de sensor nog reageert (van 3 tot 7 meter, in wijzerzin draaien om te vergroten). De detectie vertraging regel je tussen de 0,3 en 600 seconden (in wijzerzin draaien om te vergroten)

Praktijk opdracht

Schakel de Raspberry Pi uit en verbindt de Pi Camera met de Raspberry Pi.
Start de Raspberry Pi en zorg dat de Pi Camera werkt. M.a.w. installeer de rpicam opdrachten en neem een foto.
Nu kunnen we de Pi Camera inzetten om bij het detecteren van beweging een opname te maken. We beginnen met het weergeven van een voorvertoning bij een bewegingsdetectie. Om de Pi Camera vanuit een Python programma te gebruiken, importeer je eerst het onderdeel PiCamera uit de bibliotheek picamera. Daarna creëren we het camera object camera, waarmee we toegang krijgen tot alle functies van de Pi Camera. Binnen de while lus starten we een voorvertoning bij elke bewegingsdetectie:
```
from gpiozero import MotionSensor
from picamera import PiCamera

camera = PiCamera()
camera.resolution = (1280, 720)
pir = MotionSensor(4)
while True:
    pir.wait_for_motion()
    camera.start_preview(fullscreen=False, window=(0, 50, 640, 360))
    pir.wait_for_no_motion()
    camera.stop_preview()
```
Met wat meer code kunnen we een opname maken om later te bekijken. Zo wil je bij meerdere indringers in de kamer, ze allemaal vastleggen en niet alleen de laatste. Om dit te realiseren, moeten we voor elke opname een andere bestandsnaam hebben. De eenvoudigste en veiligste is een naam te maken die bestaat uit de datum en tijd van de opname.

Een voorbeeld: de bestandsnaam 2021-12-07_14.01.51.h264 wordt gebruikt voor een opname gemaakt op 7 december 2021 om 14u01m51s. Dit gebruikt het formaat YEAR-MONTH-DAY_HOUR.MINUTE.SECOND.h264 dat ook door YouTube wordt gebruikt.

Daarvoor importeren we de datetime Python module en schrijven we code om een bestandsnaam met een datum en tijd te genereren. Daarna kan je de opname starten met de aangemaakte bestandsnaam en terug stoppen. Juist zoals dat ging met het starten en stoppen van de voorvertoning:
```
from gpiozero import MotionSensor
from picamera import PiCamera
from datetime import datetime

camera = PiCamera()
camera.resolution = (1280, 720)
pir = MotionSensor(4)
while True:
    pir.wait_for_motion()
    bestandsnaam = datetime.now().strftime("%Y-%m-%d_%H.%M.%S.h264")
    camera.start_recording(bestandsnaam)
    pir.wait_for_no_motion()
    camera.stop_recording()
```
Test het programma en laat een paar opnames maken.

Test de opnames in de terminal met de opdracht ffplay <bestandsnaam>, een voorbeeld:

pi@RPIDanPin:~ $ ffplay 2021-12-07_14.01.51.h264          
ffplay version 4.3.3-0+rpt2+deb11u1 Copyright (c) 2003-2021 the FFmpeg developers
  built with gcc 10 (Raspbian 10.2.1-6+rpi1)
  ...
  libavutil      56. 51.100 / 56. 51.100
  libavcodec     58. 91.100 / 58. 91.100
  libavformat    58. 45.100 / 58. 45.100
  libavdevice    58. 10.100 / 58. 10.100
  libavfilter     7. 85.100 /  7. 85.100
  libavresample   4.  0.  0 /  4.  0.  0
  libswscale      5.  7.100 /  5.  7.100
  libswresample   3.  7.100 /  3.  7.100
  libpostproc    55.  7.100 / 55.  7.100
Input #0, h264, from '2021-12-07_14.01.51.h264':B sq=    0B f=0/0   
  Duration: N/A, bitrate: N/A
    Stream #0:0: Video: h264 (High), yuv420p(progressive), 1280x720, 25 fps, 25 tbr, 1200k tbn, 50 tbc
    nan M-V:    nan fd=   0 aq=    0KB vq=    0KB sq=    0B f=0/0

Onopvallend verloopt de opname niet. Bij elke opname wordt een rode led op de Pi Camera actief, dit valt enorm op. Deze led kan je uitschakelen in het configuratiebestand /boot/config.txt van de Raspberry Pi. Open als systeembeheerder dit configuratiebestand en voeg de volgende regel toe:
```
disable_camera_led=1
```
Sla de aanpassing op en herstart de Pi om de nieuwe instelling te activeren. Test of alles nog werkt.
Voor een bepaalde toepassing bestaan soms meerdere oplossingen. Je moet dus voor je aan iets begint, nadenken over hoe je het gaat aanpakken. Hou rekening met uw eigen vaardigheden, zo zal een handige Harry eerder voor een hardware oplossing kiezen, een programmeur (sterk in logisch denken) kiest eerder voor een software oplossing. Ga ook op zoek naar reeds bestaande oplossingen, de meeste bestaande oplossingen, zeker als die open source zijn, kan je verder uitbouwen om te voldoen aan uw eigen noden. We gaan het project om beweging te detecteren helemaal omgooien. We gebruiken minder hardware en vervangen die door software. Schakel de Raspberry Pi daarvoor eerst uit en koppel de PIR sensor los.
Start de Raspberry Pi opnieuw op.

We gaan software gebruiken die de beelden van de Pi Camera analyseert en zo beweging kan detecteren. De software die we hier gebruiken staat op GitHub en is open source.

RPi-Cam-Web-Interface download je als volgt:

pi@RPIDanPin:~ $ wget https://github.com/silvanmelchior/RPi_Cam_Web_Interface/archive/refs/heads/master.zip
--2021-12-07 16:00:43--  https://github.com/silvanmelchior/RPi_Cam_Web_Interface/archive/refs/heads/master.zip
Herleiden van github.com (github.com)... 140.82.121.3
Verbinding maken met github.com (github.com)|140.82.121.3|:443... verbonden.
HTTP-verzoek is verzonden; wachten op antwoord... 302 Found
Locatie: https://codeload.github.com/silvanmelchior/RPi_Cam_Web_Interface/zip/refs/heads/master [volgen...]
--2021-12-07 16:00:43--  https://codeload.github.com/silvanmelchior/RPi_Cam_Web_Interface/zip/refs/heads/master
Herleiden van codeload.github.com (codeload.github.com)... 140.82.121.9
Verbinding maken met codeload.github.com (codeload.github.com)|140.82.121.9|:443... verbonden.
HTTP-verzoek is verzonden; wachten op antwoord... 200 OK
Lengte: niet-opgegeven [application/zip]
Wordt opgeslagen als: ‘master.zip’

master.zip                            [ <=>                                                       ] 415,91K  --.-KB/s    in 0,1s    

2021-12-07 16:00:44 (3,33 MB/s) - '‘master.zip’' opgeslagen [425894]

En pak je uit met de opdracht:

pi@RPIDanPin:~ $ unzip master.zip 
Archive:  master.zip
677dddecce9130cd3880df3ca404545fea22feb3
   creating: RPi_Cam_Web_Interface-master/
  inflating: RPi_Cam_Web_Interface-master/.gitignore  
  inflating: RPi_Cam_Web_Interface-master/DoNot UseRPi_Cam_Web_Interface_Installer.sh  
  inflating: RPi_Cam_Web_Interface-master/LICENSE.txt  
...
 extracting: RPi_Cam_Web_Interface-master/www/userLevelExample  
  inflating: RPi_Cam_Web_Interface-master/www/userbuttonsD  
  inflating: RPi_Cam_Web_Interface-master/www/video.png

Open de map met de uitgepakte RPi-Cam-Web-Interface software met de opdracht:
```
pi@RPIDanPin:~ $ cd RPi_Cam_Web_Interface-master/
```
Installeer de RPi-Cam-Web-Interface software met:
```
pi@RPIDanPin:~ $ ./install.sh
```
Na een tijdje verschijnt het volgende terminal dialoogvenster:

Bevestig de standaard instellingen met de OK knop.
Na het voltooien van de installatie verschijnt het volgende dialoogvenster:

Bevestig het opstarten van de RPi-Cam-Web-Interface software.

Om de RPi-Cam-Web-Interface te bedienen, gebruik je een webbrowser. M.a.w. surf naar jouw Raspberry Pi:
1. De webpagina toont live videobeelden, enkele knoppen en enkele uitklapbare onderdelen.
  1. We beginnen met een eenvoudige test. Klik op de knop record image.
  2. Om de gemaakte foto te bekijken, klik je op de knop Download Videos and Images.
  3. Klik op de miniatuur van de foto om deze groter weer te geven. Om alle details weer te geven, klik je op de vergrote foto om deze in de originele resolutie te bekijken.
  4. Sluit het tabblad met de originele foto.
  5. Klik op de knop Delete om de foto te verwijderen.
  6. Klik in de balk bovenaan op de koppeling Back - RPi Cam Control v6.6.19: mycam@RPIDanPin om terug naar de startpagina te surfen.
2. Tweede test: start een video-opname.
  1. De video-opname blijft lopen, tot je op de knop klikt om deze te stoppen.
  2. Bekijk op dezelfde manier als bij een foto de opgenomen video.
  3. Verwijder de video-opname.
3. Derde test: start een timelapse en zorg voor een leuke stop motion film.
  1. Bekijk de foto's van de timelapse. Enkel de eerste foto is zichtbaar. Om van de timelapse foto's een film te maken, klik je op de knop Start Convert. Onmiddellijk verschijnt een tweede tegel, waarin duidelijk vermeld staat dat er een video wordt aangemaakt (Busy).
  2. Terwijl de timelapse video wordt aangemaakt, ga je terug naar de startpagina.
4. Vierde test: start de bewegingsdetectie.
  1. Maak enkele hevige bewegingen en bekijk de aangemaakte foto's en/of video's.
  2. Blijkbaar werden geen extra foto's of video's aangemaakt. Tijd om de Camera Settings te bekijken.
  3. Zoals je merkt kan je hier van alles instellen. Welke instelling gebruik je om het beeld te draaien als het op zijn kop staat? ......
  4. Maar we wijken af, ons probleem is dat de bewegingsdetectie niet werkt. Zoek naar de instelling Motion detect mode:.
  5. Deze heeft de waarde External, m.a.w. de bewegingsdetectie wordt door een ander gespecialiseerd programma verzorgt. En dit programma is ofwel niet geïnstalleerd of niet actief. Verander dit naar Internal zodat de RPi-Cam-Web-Interface software de bewegingsdetectie zelf uitvoert.
  6. Test nogmaals de bewegingsdetectie. Bij beweging wordt er nu een video-opname gemaakt.
  7. Om de bewegingsdetectie zichtbaar te maken, waardoor je deze beter kunt afregelen, open je de Motion Settings.
  8. Zet de Motion Vector Preview aan.
  9. Je ziet nu niet meer wat de camera ziet, maar wat de bewegingsdetectie waarneemt. Zet de Motion Vector Preview terug af.
5. Ondertussen moet de timelapse video klaar zijn. Bekijk deze.
6. Ga terug naar de Camera Settings.
  1. Indien de omgeving donker of juist zeer helder is, kan dit compenseren met de Exposure instellingen. Dat kan manueel (Exposure Compensation) of met vooraf ingestelde profielen (Exposure Mode). Zet de Exposure Mode op Night en bekijk het resultaat.
  2. Vergelijk de Exposure Mode Night met Beach.
    Wat valt er op? .......
  3. Zet te Exposure Mode terug op de standaard waarde.
7. Op sommige momenten wil je bewegingsdetectie en opnames, op andere momenten niet. Denk aan een beveiligingscamera die enkel op bepaalde momenten moet werken.
  1. Activeer de Edit schedule settings.
  2. Standaard wordt een dagplanning (DayMode = All Day) gebruikt. In deze mode kan je de bewegingsdetectie enkel per dag in of uit schakelen (één vinkje per dag van de week). Het gaat echter verder dan puur in- of uit-schakelen. Activeer de Command reference en bepaal wat de opdracht ca betekent? ......
  3. Selecteer de DayMode Sun based.
  4. Nu wordt er enkel tijdens de dag cameraopnames gemaakt bij bewegingsdetectie. Zorg dat dit enkel tijdens de weekend nachten gebeurt.
  5. Aangezien je werkt met zonsopgang en zonsondergang, moet de locatie van de camera correct zijn. Zoek op het internet de locatie coördinaten van de school op en zet deze in de tekstvakken Latitude en Longitude.
  6. Ook de GMTOffset moet correct ingesteld worden (in de zomer +2, in de winter +1).
  7. Controleer na het aanpassen van de instellingen in de balk tussen de twee tabellen de berekende Sunrise en Sunset waarden.
  8. Met de laatste DayMode Fixed Times kan je op elk moment van elke weekdag bij bewegingsdetectie een opdracht laten uitvoeren.
  9. Veronderstel dat om de aanwezigheden te noteren bij elke bewegingsdetectie (gericht op een deur) een foto wordt genomen. Stel dit in zodat dit enkel tijdens de les gebeurt.
8. Daarstraks hadden we het over gespecialiseerde bewegingsdetectie software die extern kan gebruikt worden. RPi-Cam-Web-Interface gebruikt daarvoor het pakket motion. Na wat onderzoek blijkt dat het pakket wel degelijk geïnstalleerd is.
  1. Je kunt controleren of motion correct werkt met de volgende opdracht:
```
pi@RPIDanPin:~ $ sudo systemctl status motion.service 
● motion.service - Motion detection video capture daemon
     Loaded: loaded (/lib/systemd/system/motion.service; enabled; vendor preset: enabled)
     Active: inactive (dead) since Tue 2021-12-07 19:36:09 CET; 1 day 18h ago
       Docs: man:motion(1)
    Process: 382 ExecStart=/usr/bin/motion (code=exited, status=0/SUCCESS)
   Main PID: 382 (code=exited, status=0/SUCCESS)
        CPU: 521ms

dec 07 19:35:57 RPIDanPin systemd[1]: Started Motion detection video capture daemon.
dec 07 19:36:08 RPIDanPin motion[382]: [0:motion] [NTC] [ALL] conf_load: Processing thread 0 - config file /etc/motion/motion.conf
dec 07 19:36:08 RPIDanPin motion[382]: [0:motion] [NTC] [ALL] conf_load: Processing thread 0 - config file /etc/motion/motion.conf
dec 07 19:36:08 RPIDanPin motion[382]: [0:motion] [ERR] [ALL] create_path: Problem creating directory /var/log/motion: Permission de>
dec 07 19:36:08 RPIDanPin motion[382]: [0:motion] [ERR] [ALL] create_path: Problem creating directory /var/log/motion: Permission de>
dec 07 19:36:08 RPIDanPin motion[382]: [0:motion] [EMG] [ALL] motion_startup: Exit motion, cannot create log file /var/log/motion/mo>
dec 07 19:36:08 RPIDanPin motion[382]: [0:motion] [EMG] [ALL] motion_startup: Exit motion, cannot create log file /var/log/motion/mo>
dec 07 19:36:09 RPIDanPin systemd[1]: motion.service: Succeeded.
```
  2. De motion software werkt niet omdat deze problemen heeft om een map aan te maken, wegens onvoldoende rechten. Het opstartscript van motion kan je bekijken met de opdracht:
```
pi@RPIDanPin:~ $ cat /lib/systemd/system/motion.service
[Unit]
Description=Motion detection video capture daemon
Documentation=man:motion(1)

[Service]
Type=simple
User=motion
ExecStart=/usr/bin/motion

[Install]
WantedBy=multi-user.target
```
  3. Hieruit blijkt dat motion voor de veiligheid draait onder een eigen gebruiker (user) met de naam motion. Enkel de root gebruiker (administator) kan een map aanmaken in de map /var/log. M.a.w. laten we voor de motion software zelf deze map aanmaken en de motion software er toegang tot geven.
  4. Maak de map als root gebruiker aan met de opdracht:
```
pi@RPIDanPin:~ $ sudo mkdir /var/log/motion
```
  5. Maak de aangemaakte map toegankelijk voor de motion gebruiker met de opdracht:
```
pi@RPIDanPin:~ $ sudo chown -R motion:motion /var/log/motion
```
  6. Daarna kunnen we de motion software herstarten:
```
pi@RPIDanPin:~ $ sudo systemctl restart motion.service
```
  7. En opvragen of het nu wel gelukt is:
```
pi@RPIDanPin:~ $ sudo systemctl status motion.service 
● motion.service - Motion detection video capture daemon
     Loaded: loaded (/lib/systemd/system/motion.service; enabled; vendor preset: enabled)
     Active: deactivating (stop-sigterm) since Thu 2021-12-09 14:07:08 CET; 7s ago
       Docs: man:motion(1)
    Process: 3286 ExecStart=/usr/bin/motion (code=exited, status=0/SUCCESS)
   Main PID: 3286 (code=exited, status=0/SUCCESS)
      Tasks: 4 (limit: 3596)
        CPU: 1.112s
     CGroup: /system.slice/motion.service
             └─3287 /usr/bin/motion

dec 09 14:07:07 RPIDanPin systemd[1]: Started Motion detection video capture daemon.
dec 09 14:07:08 RPIDanPin motion[3286]: [0:motion] [NTC] [ALL] conf_load: Processing thread 0 - config file /etc/motion/motion.conf
dec 09 14:07:08 RPIDanPin motion[3286]: [0:motion] [NTC] [ALL] conf_load: Processing thread 0 - config file /etc/motion/motion.conf
dec 09 14:07:08 RPIDanPin motion[3286]: [0:motion] [NTC] [ALL] motion_startup: Logging to file (/var/log/motion/motion.log)
dec 09 14:07:08 RPIDanPin motion[3286]: [0:motion] [NTC] [ALL] motion_startup: Logging to file (/var/log/motion/motion.log)
```
  8. De externe motion software werkt nu, maar moet nog volledig geconfigureerd worden. Dit is echter voor deze cursus te hoog gegrepen. We blijven dus met de interne bewegingsdetectie werken. Wel kon je kennismaken met hoe je foutmeldingen kunt weergeven en daarop gepast op kunt reageren. Meer info over de motion software kan je vinden op de Motion GitHub pagina.
9. Aangezien we de motion software niet gebruiken, gaan we deze niet automatisch laten opstarten. We beginnen met het stoppen van de motion software:
```
pi@RPIDanPin:~ $ sudo systemctl stop motion.service
```
10. En daarna schakelen we de automatische start uit:
```
pi@RPIDanPin:~ $ sudo systemctl disable motion.service
Removed /etc/systemd/system/multi-user.target.wants/motion.service.
```
11. Om andere cemera bewegingsdetectie software te kunnen testen, moeten we ook de RPi-Cam-Web-Interface software uitschakelen. De autostart van RPi-Cam-Web-Interface wordt op een geheel andere manier geconfigureerd, namelijk in het opstartscript /etc/rc.local.
12. Open het opstartscript /etc/rc.local als root gebruiker met de teksteditor nano.
13. Verwijder of nog beter plaats de volgende regels in commentaar (kan dan later terug geactiveerd worden):
```
#START RASPIMJPEG SECTION
mkdir -p /dev/shm/mjpeg
chown www-data:www-data /dev/shm/mjpeg
chmod 777 /dev/shm/mjpeg
sleep 4;su -c 'raspimjpeg > /dev/null 2>&1 &' www-data
if [ -e /etc/debian_version ]; then
  sleep 4;su -c 'php /var/www/html/schedule.php > /dev/null 2>&1 &' www-data
else
  sleep 4;su -s '/bin/bash' -c 'php /var/www/html/schedule.php > /dev/null 2>&1 &' www-data
fi
#END RASPIMJPEG SECTION
```
14. Sla de aanpassingen op en verlaat de teksteditor nano.
15. Herstart de Raspberry Pi.
16. Als je nu met de opdracht raspistill -o foto.jpg een foto kunt maken, is de opdracht geslaagd.
Een alternatief vinden we bij Kerberos.io. Deze software werkt niet op het recente Raspberry Pi OS Bulsseye besturingssysteem en moeten we dus installeren via een door Kerberos.io aangemaakt besturingssysteem:
1. Download het Kerberos.io image (KIOS) van de Kerberos-io GitHub webpagina. Elk type Raspberry Pi heeft zijn eigen image. Zorg dat je het juiste download.
2. Pak het gedownloade image bestand uit met 7-Zip (desnoods moet je dit nog downloaden en installeren).
3. Plaats de Kerberos image voor jouw type Raspberry Pi op een SD kaart.
4. Start de Raspberry Pi met het Kerberos image.
5. Surf naar het IP adres dat op het scherm verschijnt.
6. Selecteer de taal Nederlands en klik op de pijlknop.
7. Op de pagina Welkom lees je de informatie en klik je daarna op Volgende
8. Stel je profiel in met een gebruikersnaam en wachtwoord (niets invullen = standaard: root, root). Klik daarna op de knop Volgende.
9. Op de webpagina Online opslag leer je de informatie en klik je daarna op de knop Finaliseer.
10. Meld je aan met de pas ingevoerde (of standaard) username en password. Klik daarna op Login.
11. Op het Dashboard zie je standaard een livebeeld met grafieken over de gedetecteerde bewegingen per uur en per weekdag.
12. Zorg dat de camera een beweging detecteert.
13. Selecteer de Weergave Laatste activiteit. Welk beeld zie je nu? ......
14. In het onderdeel Systeem kan je verschillende systeemeigenschappen en -prestaties raadplegen.
15. Belangrijk voor netwerktoegang is de Hostname, noteer deze hier: ......
16. Hier kan je ook beelden downloaden en verwijderen, bijvoorbeeld om plaats te maken voor andere opnames. Verwijder de tot nu toe aangemaakte beelden.
17. In het onderdeel Configuratie kan je Kerberos.io instellen.
18. Geef de Kerberos machine de naam Klaslokaal.
19. Controleer en corrigeer indien nodig de Tijdzone, noodzakelijk voor correcte dag-/nachtopnames.
20. Sluit een USB camera aan (bijvoorbeeld de in de monitor ingebouwde webcam).
21. Activeer in Kerberos.io de USB camera. Gebruik de veilige standaard instellingen. Desnoods kan je het beeld draaien. Vergeet niet te bevestigen en aan te passen.
22. Bij een test op het Dashboard lijkt dit niet te werken.
23. Om de USB camera op te merken, moet de Raspberry Pi herstarten. Dit kan enkel via een SSH verbinding naar root@hostnaam van de Kerberos Raspberry Pi. Je moet daarbij geen wachtwoord opgeven (veilig?).
24. Herstart de Kerberos Raspberry Pi met de opdracht reboot.
25. Nu verschijnen de USB camera beelden.
26. Nu stellen we in het onderdeel Configuratie met de knop Beweging de bewegingsdetectie in.
27. Dit bestaat uit drie stappen (bolletjes onderaan).
28. In de eerste stap stel je het gevoelige gebied in. Versleep de bollen op het beeld zodanig dat enkel de bovenste helft van het beeld gevoelig is voor beweging. Bijvoorbeeld om de bewegingsdetectie voor loslopende honden en/of katten te negeren.
29. In stap twee bepaal je de gevoeligheid. Beweeg de muis over de vraagtekens om uitleg over een instelling te krijgen.
30. In stap drie configureer je of je bij een bewegingsdetectie een foto of een video wordt gemaakt. Zorg dat er enkel een foto wordt gemaakt (neemt minder ruimte in op de SD kaart).
31. Zorg dat er op de foto een goed leesbare tijdsaanduiding staat.
32. Activeer de Privacy optie. Zo kan je openbare plaatsen zoals de openbare weg (rijweg en voetpad) uit het beeld verwijderen.
33. Met de Script uitvoer kan je zelf een opdracht bij een bewegingsdetectie laten uitvoeren. Je schrijft dan een script om bijvoorbeeld een mail te sturen, een foto op een website te plaatsen, enz.
34. Met de GPIO optie kan je de spanning op een GPIO pin omschakelen om zo bijvoorbeeld via een relais een lamp in te schakelen of een slagboom op te halen.
35. Met de MQTT optie kan je bij beweging communiceren met een domoticasysteem die dan bepaalde activiteiten kan starten.
36. Bevestig, pas aan en test de nieuwe configuratie. Pas indien nodig de configuratie aan.
37. Probeer verbinding te maken met de IP camera in de klas. Probeer daarvoor de video stream URL te achterhalen, bijvoorbeeld via de website van ISpyConnect.
38. Raadpleeg de online Kerberos.io handleiding om de Raspberry Pi met een WiFi Access Point te verbinden. Verbindt de Kerberos.io Raspberry Pi met het access point Triangel met het wachtwoord 050391323.
39. Controleer of de Kerberos.io Raspberry Pi verbonden is met het WiFi access point in het onderdeel Systeem.
40. Wie eveneens wil profiteren van de mogelijkheden van het Raspberry Pi OS besturingsysteem, installeert Kerberos.io beter met behulp van Docker. Een systeem dat voorgeïnstalleerde software verdeeld als blokken. Door deze blokken te stapelen, kan je op een eenvoudige manier snel software toevoegen, zonder deze te moeten configureren. Nadeel is echter dat je zoals bij kant en klare images, afhankelijk bent van degene die de docker (image) onderhoudt voor updates. Daarenboven moet je de voorgeconfigureerde docker software en images nemen zoals de maker ze heeft samengesteld, m.a.w. je kunt ze minder goed aan jouw situatie aanpassen.
41. Probeer jouw Kerberos.io besturingssysteem up te daten via een SSH verbinding. Gebruik daarvoor de zoekfunctie van de handleiding op het internet.
42. Test of alles nog werkt.
43. Bekijk hoe je Kerberos.io via Docker kunt installeren.
44. Installeer indien tijd over op een basisimage van Raspberry Pi OS (32-bit) de Kerberos.io via Docker.

Bewegingsdetector

PIR sensor aansluiten

De PIR bewegingssensor testen

Praktijk opdracht

Openbare reacties op deze pagina (kunnen door alle bezoekers gelezen worden)