2021-ING2-RaspiDashCam

Réalisation d'une camera Dashcam utilisant une carte Raspberry, une camera PiCamera ainsi qu'une centrale inertielle.

Slides & Videos

Members

NameContribution
Yannis PargoireProjet réalisé seul

State of the Art

Business Aspect

A Raspberry Pi two camera dashcam with overlaid GPS data

Dans cette vidéo, l’utilisation du Raspberry Pi Zero qui est nettement moins chère que la Raspberry Pi 4 est très intéressant d’un point de vue économique.

Nous pouvons cependant noter l’avantage de la gestion de la sécurité des fichiers en fonction de l’accélération subie.

Making A DashCam Using The Raspberry Pi Zero (pt.1) : Recording Video, Storage Check & FTP

Dans cette video nous pouvons voir l’utilisation du GPS qui est un atout supplémentaire par rapport à notre caméra.

Nous pouvons cependant noter l’avantage de la gestion de la sécurité des fichiers en fonction de l’accélération subie.

Technical Aspect

A Raspberry Pi two camera dashcam with overlaid GPS data

Dans cette vidéo l’utilisation des coordonnées GPS est un point relativement important dont nous ne bénéficions pas dans le projet que nous avons réalisé. L’utilisation du Raspberry Pi Zero induit une puissance moins importante et un codage plus complexe que sur la Raspberry Pi 4 que nous avons utilisé par ailleurs, il n’existe pas de port USB sur la Pi Zero nous empêchant d’installer une deuxième caméra via un port USB.

Nous pouvons cependant noter l’avantage de la gestion de la sécurité des fichiers en fonction de l’accélération subie.

Project Description

Problem Definition
Nous intéressons ici à une Dashcam dont le but est de filmer la route lorsque nous conduisons cependant, nous pouvons être confronté à un accident de la route auquel cas conserver la video peut être très utile et ce notamment pour l'assurance.
Ainsi nous voulons que cette caméra verrouille la video enregistrée lorsque nous avons un accident en définissant un accident comme correspondant à une variation importante d'accélération.
Challenges & Motivation
La première idée derrière ce projet est de réalisée une Dashcam, ces dernières peuvent être relativement coûteuses ainsi, nous tenterons ici de réduire les coûts.
Réaliser cette caméra avec les outils présentés précédemment qui nous sont peu familiers de plus, nous pensons l'utiliser pour notre propre voiture, tout cela rend ce projet intéressant.
De plus, nous aurons comme défis d'apprendre à gérer une carte Raspberry, son interaction avec un capteur et la gestion de fichiers qui s'en suit.
Real and Complete Usecases

La carte Raspberry aura pour rôle de contrôler la centrale inertielle et la caméra.

Le but de notre dispositif est de filmer le trajet que nous effectuons en voiture.

Ces videos sont enregistrées dans des fichiers et pour éviter d’utiliser un stockage trop important, nous écrasons les enregistrements précédents pour faire place aux nouveaux.

Cependant, nous verrouillons les videos et empêchons qu’elles soient écrasées lorsque nous avons un accident ou effectuons un freinage d’urgence.

De plus, les fichiers vidéos comprennent la date et l’heure affichés en temps réel.

Technical Description

Ce code se constitue d’un programme python répété 4 fois quasiment à l’identique ainsi qu’un programme shell permettant de gérer les programmes python et les fichiers en résultat.

Chaque programme IOT_Project.py se distingue en différentes parties :

  1. Importation des librairies ;
  2. Mise en place des définitions de fonctions se basant sur la communication I2C avec le capteur ;
  3. Initialisation des registres du capteur comprenant son alimentation et la plage d’accélérations que peut mesurer le capteur, nous avons ici pris +/- 8g ce qui est bien au-dessus de l’accélération subie par un accident, mais dans le cas de très fortes accélérations subies, avoir l’information peut toujours être intéressante et ce notamment pour l’assurance, permettant ainsi d’estimer la vitesse des véhicules en jeu ;
  4. Initialisation de la camera (résolution, nombre d’images par seconde, taille du texte affiché sur la vidéo ;
  5. Début du code principal, activation de la preview (affichage de ce que voit la caméra et ce avant même de lire le fichier enregistré), démarrage de l’enregistrement, initialisation de la date et l’heure de début d’enregistrement, initialisation des variables
  6. Boucle while principale : Nous y restons tant que l’enregistrement ne dépasse pas 15 minutes, et que l’accélération moyenne sur 5 valeurs subie sur les autres axes que l’axe verticale dépasse les 1.2g (valeur différente de ce que nous avons trouvé dans la littérature mais résultat des mesures que nous avons nous-mêmes effectué) ;
  7. Lecture des informations des accéléromètres et des gyroscopes provenant du capteur et conversion des accélérations en “g”, calcul des valeurs moyennes sur 5 valeurs des accélérations ;
  8. Sortie de la boucle, arrêt de l’enregistrement et de la preview;
  9. Si nous sommes sortie de la boucle car l’accélération sur un des axes a dépassé l’accélération limite alors on renvoie les valeurs des accélérations qui seront par la suite copiées dans un fichier texte ainsi que la date et l’heure.

Programme IOT_Project.sh :

  1. Exécution en boucle infinie de 4 programmes python du même type que celui expliqué ci-dessus ;
  2. Le programme shell exécute un des programmes python, déprotège le fichier txt associé pour faciliter le lancement du programme et protège le fichier vidéo.

 

Le capteur est un capteur gy-521 mpu 6050

Nous utilisons la camera Raspberry PiCamera 2

Hardware

Materials
ImageNamePart NumberPriceCountLink
GY-521 MPU 6050 sensor15€1🛒
Arduino Male Female Cable10,10€4🛒
Boîtier Raspberry Pi 4110,61€1🛒
Raspberry Pi 4160€1🛒
Schematic

Software

Arduino Code

#!/usr/bin/python
import smbus
import math
from picamera import PiCamera
import datetime as dt
import time


# Register
power_mgmt_1 = 0x6b
power_mgmt_2 = 0x6c
#IL faut mettre AFS_SEL = 2 pour mesurer sur l amplitude +/- 8g
def read_byte(reg):
    return bus.read_byte_data(address, reg)

def read_word(reg):
    h = bus.read_byte_data(address, reg)
    l = bus.read_byte_data(address, reg+1)
    value = (h << 8) + l
    return value

def read_word_2c(reg):
    val = read_word(reg)
    if (val >= 0x8000):
        return -((65535 - val) + 1)
    else:
        return val

def dist(a,b):
    return math.sqrt((a*a)+(b*b))

def get_y_rotation(x,y,z):
    radians = math.atan2(x, dist(y,z))
    return -math.degrees(radians)

def get_x_rotation(x,y,z):
    radians = math.atan2(y, dist(x,z))
    return math.degrees(radians)



#*********Initialisation capteur et communication I2C*******#


bus = smbus.SMBus(1) # bus = smbus.SMBus(0)
address = 0x68       # via i2cdetect

bus.write_byte_data(address, power_mgmt_1, 0)
bus.write_byte_data(address, 0x1c, 0x10)        #Met AFS_SEL = 2 pour mesurer l amplitude a +/- 8g


#...................Reglage camera......................#


camera = PiCamera()
camera.rotation = 0

camera.resolution = (1920, 1080)

camera.framerate = 30

camera.annotate_text_size = 60

#...................Debut du code principal*********************#

camera.start_preview()  #Activation de l affichage de ce que voit actuellement la camera


camera.start_recording('dash_record.mjpeg') #Lacement de l enregistrement du fichier

start = dt.datetime.now()

gyroscope_xout = 0
gyroscope_yout = 0
gyroscope_zout = 0

acceleration_xout = 0
acceleration_yout = 0
acceleration_zout = 0

ax0=0
ax1=0
ax2=0
ax3=0
axAv=0

ay0=0
ay1=0
ay2=0
ay3=0
ayAv=0

az0=0
az1=0
az2=0
az3=0
azAv=0



while ((dt.datetime.now() - start).seconds <900) and (abs(axAv) <1.15) and (abs(ayAv) <1.15) and (abs(azAv) <1.15):   #Nous sortons de la boucle si le temps d enregistrement depasse 15min ou si la valeur absolue de acceleration moyenne $
        camera.annotate_text = dt.datetime.now().strftime('%d-%m-%Y    %H:%M:%S')       #Nous ecrivons la date et l heure sur le fichier video

        gyroscope_xout = read_word_2c(0x43)/131
        gyroscope_yout = read_word_2c(0x45)/131
        gyroscope_zout = read_word_2c(0x47)/131

        acceleration_xout = read_word_2c(0x3b)/4096.0   #Le 1/4096.0 est un coefficient correcteur a appliquer lorsque nous travaillons en +/-  8g
        acceleration_yout = read_word_2c(0x3d)/4096.0
        acceleration_zout = read_word_2c(0x3f)/4096.0

        axAv = (ax0+ax1+ax2+ax3+acceleration_xout)/5.0
        ayAv = (ay0+ay1+ay2+ay3+acceleration_yout)/5.0
        azAv = (az0+az1+az2+az3+acceleration_zout)/5.0

        ax0=ax1
        ax1=ax2
        ax2=ax3
        ax3=acceleration_xout

        ay0=ay1
        ay1=ay2
        ay2=ay3
        ay3=acceleration_yout


        az0=az1
        az1=az2
        az2=az3
        az3=acceleration_zout



camera.stop_recording()
camera.stop_preview()



if (abs(axAv) <5) or (abs(ayAv) <5) or (abs(azAv) <5):
        print "%s" %dt.datetime.now().strftime('%d-%m-%Y    %H:%M:%S')
        print "\n gyroscope_xout: ", ("%5d" % gyroscope_xout), " en_degrees_par_seconde: ", (gyroscope_xout)
        print "\n gyroscope_yout: ", ("%5d" % gyroscope_yout), " en_degrees_par_seconde: ", (gyroscope_yout)
        print "\n gyroscope_zout: ", ("%5d" % gyroscope_zout), " en_degrees_par_seconde: ", (gyroscope_zout)
        print "\n acceleration_xout: ", ("%6d" % acceleration_xout), " en_g: ", axAv
        print "\n acceleration_yout: ", ("%6d" % acceleration_yout), " en_g: ", ayAv
        print "\n acceleration_zout: ", ("%6d" % acceleration_zout), " en_g: ", azAv


#!/bin/bash
a=0
while ((a!=1))
do
        python IOT_Project.py > IOT_Project.txt
        sudo chmod 777 IOT_Project.txt
        sudo chmod 444 dash_record.mjpeg

        python IOT_Project1.py > IOT_Project1.txt
        sudo chmod 777 IOT_Project1.txt
        sudo chmod 444 dash_record1.mjpeg

        python IOT_Project2.py > IOT_Project2.txt
        sudo chmod 777 IOT_Project2.txt
        sudo chmod 444 dash_record2.mjpeg

        python IOT_Project3.py > IOT_Project3.txt
        sudo chmod 777 IOT_Project3.txt
        sudo chmod 444 dash_record3.mjpeg
done
exit 0