Impact Recorder for Vehicles




Introduction: Impact Recorder for Vehicles

Impact Recorder is designed to record impact sustained to vehicle while driving or stationary. The impacts are stored in the database in the form of readings as well as video/picture.
Upon impact remote user can be verified in real time, and remote user can than watch the saved video or take remote access to pi camera and watch events accordingly.

Step 1: Parts & Accessories

(1) Raspberry Pi 3 or better : Computational power required

(2) Raspberry pi sense hat

(3) Raspberry pi camera / Usb camera

(4) Memory card with latest raspbian image ( Should support node red, almost every latest image does)

(5) Power supply at-least 2.1 A ( i have used battery bank for standalone operation in car)

Step 2: Parts Description : Sense Hat

The Sense HAT has an 8×8 RGB LED matrix, a five-button joystick and includes the following sensors:

  • Gyroscope
  • Accelerometer
  • Magnetometer
  • Temperature
  • Barometric
  • pressure
  • Humidity

More information on working with sense hat can be derived from following links: Sense_Hat

API for sense hat are hosted at : Sense_hat_API

Code for sense-hat programming is covered in later steps. Sense hat code can also be simulated on a simulator hosted at : Sense-hat simulator

Step 3: Assembling : Impact Recorder

  • Assembling is simpler as sense hat needs to be stacked over pi (designated mounting bolts are provided with sense hat) .
  • USB camera or pi camera can be connected. In the tutorial, pi camera is considered and accordingly coding is carried out for the same.
  • Insert the memory card and configure python code and node -red (configuration & code is covered in further steps)

Picture above shows pi-camera connected through flat ribbon cable to pi

Step 4: Assembling : Impact Recorder on Dash Board of Car

For mounting the recorder, i have used double sided tape , the advantage is recorder can be easily shifted in different position , whichever suits best your car.

Further camera is mounted vertically as shown, using same double side tape,

Next in line is to connect a power source (10,000 mAH power bank) along with a ready internet connection

Internet connection shall be required for MQTT application ( the details for MQTT are covered in further steps)

Step 5: Impact Recoder : Working & Applications

From the sense hat , acceleration and gyroscope are used to check whether the raw values are beyond set limit in code.

Accelerometer : The accelerometer tells the amount of gravitational force (G-force) acting on each of x,y & z axis, if any axis measures more than 1G force, than rapid motion can be detected. (please note the axis pointing downward would have 1g value and needs to be considered accordingly in python code).

Gyroscope ; The gyroscope is used to measure angular motion, i.e during sharp turn the sensor might get activated (depends upon the setting in the code) , so a person sharply whirling the vehicle would get caught!!

Any activation of set limit is also displayed on the sense hat LED matrix as "!" in red for acceleration & green for gyroscope activation

Step 6: Software Description : Node Red

Node-RED is a flow-based programming tool, originally developed by IBM’s Emerging Technology Servicesteam and now a part of the JS Foundation.

More information on node red can be obtained through following link :node-red

For our case we would be using node -red for following activities

(1) Interacting with the joysticks to start camera functions

(2) Monitoring the impacts on vehicle and relaying the information to end user by employing MQTT and further accepting the end user commands through MQTT and starting the requisite application on pi

(3) Performing some basic stuffs like shutdown of pi

The further steps gives the detailed information for the flow diagram implemented on node-red

Please note the node-red flow diagrams interact with the python code, hence the latter part covers the python code aspects.

Step 7: Node-red Basics

Certain Basic steps are highlighted to begin Node-red in a flash, but yes node-red is too simple to begin and work out applications.

  • Starting Node-red : http://localhost:1880.
  • Starting Node-red when pi is connected to internet http:// ip address>:1880

Step 8: Node-red : Flow _1a

The Flow _1a , monitors any changes in the CSV file and on the basis of the changes , i.e impact detected , camera video recording is set to on mode and further the user is informed over internet that an impact has occurred

Step 9: Node Red : Flow_1b

In the said flow , video recording can be started at any point by just pressing the joystick

Step 10: Node Red : Flow_2a

In the said flow , whenever any new picture or video is stored/uploaded to directory the information is relayed to the registered user over internet

Step 11: Node Red : Flow_2b

This flow is primarly designed for the remote user , so as to control the device in following manner

(a) shutdown device

(b) take pictures

(c) Record videos

(d) start main code (datalogger code is the main code which calculates the impact)

Step 12: Node Red ; Flow_3

The flow is designed for local access , so as to start the main code or shutdown device

Step 13: MQTT

MQTT (Message Queuing Telemetry Transport) is an TCP/IP protocol , wherein publisher and subscriber interact.

In Our case Pi is publisher, whereas the application installed in our moblile/PC shall be the subscriber.

In this way on generation of any impact, information is relayed remotely to the user ( a working internet connection is must)

More information about MQTT can be accessed from following link : MQTT

To start using MQTT , we need to register first , for the tutorial i have used cloudmqtt ( , there is a free plan under "cute cat" , thats all.

After registering create a instance say "pi" after which you would be getting following details

  • Server name
  • port
  • username
  • password

The above are required while subscribing through mobile/pc

For my application , i have used MQTT application from google play store (Android version)

Step 14: MQTT : Subscriber

The MQTT application running on mobile (Android version)

The impact detected on pi are relayed back

Step 15: MQTT : Editing Properties in Node-red

In node-red after selecting MQTT node , "Server name" and "topic" to be mentioned .This should be same on subscriber end

Step 16: The Python Code :

The code functionality is as per attached flowchart

Step 17: The Final Code

The python code is attached

In order to make our python script run from terminal, we need to make them executable as chmod +x , than further the top of the code should contain the following "shebang" line #! /usr/bin/python3 (this is required so as to execute functions from node-red)

#!/usr/bin/python3 // shebang line
from sense_hat import SenseHat from datetime import datetime from csv import writer import RPi.GPIO as GPIO from time import sleep

sense = SenseHat() import csv

timestamp = delay = 5 // delay is defined to store data in data.csv file red = (255,0,0) green = (0,255,0) yellow = (255,255,0)

#GPIO.setmode(GPIO.BCM) #GPIO.setup(17,GPIO.OUT)

def get_sense_impact(): sense_impact = [] acc = sense.get_accelerometer_raw() sense_impact.append(acc["x"]) sense_impact.append(acc["y"]) sense_impact.append(acc["z"])

gyro = sense.get_gyroscope_raw() sense_impact.append(gyro["x"]) sense_impact.append(gyro["y"]) sense_impact.append(gyro["z"])

return sense_impact

def impact(): // function to detect impact #GPIO.setmode(GPIO.BCM) #GPIO.setup(4,GPIO.OUT) acceleration = sense.get_accelerometer_raw() x = acceleration['x'] y = acceleration['y'] z = acceleration['z'] x=abs(x) y=abs(y) z=abs(z)

gyro = sense.get_gyroscope_raw() gyrox = gyro["x"] gyroy = gyro["y"] gyroz = gyro["z"]

gyrox = round(gyrox,2) gyroy = round(gyroy,2) gyroz = round(gyroz,2)

impact = get_sense_impact()

if x > 1.5 or y > 1.5 or z > 1.5: // the values are set after iteration on actual road can be changed accordingly for different types and driving skills with open('impact.csv', 'w', newline='') as f: data_writer = writer(f) data_writer.writerow(['acc x','acc y','acc z','gyro x','gyro y','gyro z']) #GPIO.output(4,GPIO.HIGH) sense.clear() sense.show_letter("!" , red) data_writer.writerow(impact)

elif gyrox > 1.5 or gyroy > 1.5 or gyroz > 1.5: // the values are set looking into the speed at which turns are initiated with open('impact.csv', 'w', newline='') as f: data_writer = writer(f) data_writer.writerow(['acc x','acc y','acc z','gyro x','gyro y','gyro z']) #GPIO.output(4,GPIO.HIGH) sense.clear() sense.show_letter("!" , green) data_writer.writerow(impact)

else: # GPIO.output(4,GPIO.LOW) sense.clear()

def get_sense_data(): // function to record and store values from sensor sense_data = []

sense_data.append(sense.get_temperature()) sense_data.append(sense.get_pressure()) sense_data.append(sense.get_humidity())

orientation = sense.get_orientation() sense_data.append(orientation["yaw"]) sense_data.append(orientation["pitch"]) sense_data.append(orientation["roll"])

acc = sense.get_accelerometer_raw() sense_data.append(acc["x"]) sense_data.append(acc["y"]) sense_data.append(acc["z"]) mag = sense.get_compass_raw() sense_data.append(mag["x"]) sense_data.append(mag["y"]) sense_data.append(mag["z"])

gyro = sense.get_gyroscope_raw() sense_data.append(gyro["x"]) sense_data.append(gyro["y"]) sense_data.append(gyro["z"])


return sense_data

with open('data.csv', 'w', newline='') as f: data_writer = writer(f)

data_writer.writerow(['temp','pres','hum','yaw','pitch','roll','acc x','acc y','acc z','mag x','mag y','mag z','gyro x','gyro y','gyro z','datetime'])

while True: print(get_sense_data()) for event in sense.stick.get_events(): # Check if the joystick was pressed if event.action == "pressed": # Check which direction if event.direction == "up": # sense.show_letter("U") # Up arrow acceleration = sense.get_accelerometer_raw() x = acceleration['x'] y = acceleration['y'] z = acceleration['z'] x=round(x, 0) y=round(y, 0) z=round(z, 0)

# Update the rotation of the display depending on which way up the if x == -1: sense.set_rotation(90) elif y == 1: sense.set_rotation(270) elif y == -1: sense.set_rotation(180) else: sense.set_rotation(0) sense.clear() t = sense.get_temperature() t = round(t,1) message = "T: " + str(t) sense.show_message(message,text_colour = red,scroll_speed=0.09) elif event.direction == "down": acceleration = sense.get_accelerometer_raw() x = acceleration['x'] y = acceleration['y'] z = acceleration['z'] x=round(x, 0) y=round(y, 0) z=round(z, 0)

# Update the rotation of the display depending on which way up the if x == -1: sense.set_rotation(90) elif y == 1: sense.set_rotation(270) elif y == -1: sense.set_rotation(180) else: sense.set_rotation(0) # sense.show_letter("D") # Down arrow sense.clear() h = sense.get_humidity() h = round(h,1) message = "H: " + str(h) sense.show_message(message,text_colour = green,scroll_speed=0.09) p = sense.get_pressure() p = round(p,1) message = "P: " + str(p) sense.show_message(message,text_colour = yellow,scroll_speed=0.09)

# elif event.direction == "left": # acceleration = sense.get_accelerometer_raw() # x = acceleration['x'] #y = acceleration['y'] #z = acceleration['z'] #x=round(x, 0) #y=round(y, 0) #z=round(z, 0)

# Update the rotation of the display depending on which way up the // Not used and controlled by node-red #if x == -1: sense.set_rotation(90) #elif y == 1: sense.set_rotation(270) #elif y == -1: sense.set_rotation(180) #else: sense.set_rotation(0) #sense.show_letter("L") # Left arrow # elif event.direction == "right": # sense.show_letter("K") # Right arrow # elif event.direction == "middle": # sense.clear()

impact() data = get_sense_data()

dt = data[-1] - timestamp if dt.seconds > delay: data_writer.writerow(data) timestamp =

Step 18: Monitoring Live Video

Impact Recorder can also be used to monitor live video, as video can be started anytime anywhere through MQTT

we would use VLC player to stream videos, by default in latest raspbian the VLC is pre-installed, else install vlc as under

More information about viewing network stream can be accessed through VLC Network stream

Thank you for reading!!

There is much more the impact recorder can do..

Watch out next space for magnetic field analysis in carrying out obstacle mapping

Sensors Contest

Participated in the
Sensors Contest

Be the First to Share


    • Potato Speed Challenge

      Potato Speed Challenge
    • Bikes Challenge

      Bikes Challenge
    • Remix Contest

      Remix Contest

    2 Discussions


    Question 1 year ago on Step 17

    Do you think this setup could be modified for recording track telemetry for a race car?


    Answer 1 year ago

    Yes that's a good idea, in fact recorder can be made to record statistics on predefined interval , which can be later viewed for bettering the track time against various odds