jrcichra / smartcar Goto Github PK

View Code? Open in Web Editor NEW

11.0 1.0 3.0 13.39 MB

Transfer dashcam footage when you get home

License: MIT License

Dockerfile 4.80% Python 86.26% Shell 4.55% Makefile 4.39%

car dashcam docker-containers smartcar framework microservices python3 hacktoberfest

smartcar's Introduction

SmartCar

A collection of karmen containers to build a distributed car container network

Smartcar footage:

Current Functionality

Starts and stops recording with ignition
Transfers footage to NAS when you come home
Collects obdii sensor data locally on an interval

Current containers

Karmen
- Controller for managing all other containers
Dashcam
- Interfaces with the Raspberry Pi Camera
GPIO
- Interfaces with the GPIO pins (for ignition)
Transfer
- Transfers footage to NAS when you get home
OBDII
- Collect car sensor data (Speed, RPM, Throttle)
- Uses standard libarary: https://python-obd.readthedocs.io/en/latest/

More containers on the way (OBDII) - make new containers and make a pull request!

Getting started

You need some hardware and handywork to get this started in your car.

Look at your car's wiring diagram. Find out where you can tap into 12V (w/ a buck converter and a fuse)
Also see what wire corelates to your ignition
(I used wires going to my car radio (12V & ignition on/off))
You'll need a latch relay that is triggered with ignition on. This powers the Pi
Once the Pi is on, smartcar will emit "key_on" by default, starting the recording process
You'll need another relay system to determine when the ignition went off, but on a different pin, that does not turn off the Pi (remember, your Pi is on because of the former latch relay)

NOTE: as of writing the pin numbers are hardcoded in gpio.py

Configuration

config.yml

See my example RPi config. TLDR; karmen takes a declarative mapping of container events to container actions

docker-compose.yml

See my example RPi compose.

smartcar's People

Contributors

Stargazers

Watchers

Forkers

arvind-india tymiles003 concurs-program

smartcar's Issues

Write Go Client Library

Make it easier to write Go containers.

Build on top of Crankshaft

Can we have Android Auto going alongside the Dashcam logic?

https://github.com/opencardev/crankshaft

Tie in camera with OpenPilot?

Could we do something like lane assist tracking and crash warnings?

Mid-transfer interrupt should start a new recording

Client library is not handing off action requests.

Getting an action response does not unblock the serial queue

a reminder for next time

Check filesizes match before deleting local copy

This is a feature I had in the original PoC. Somehow, it didn't make it to the smartcar project. This will prevent issues where the file was not transferred properly.

If filesizes don't match, don't delete the local file!

Move isCI() into a common library and make it check the CI environment variables

Print transfer progress for files

Improve INFO logging

Not informative enough on what's happening (DEBUG is too verbose)

Rewrite controller in Go

Current spagetti code is too confusing to maintain and scale. Now that I got v1 of the controller built - it's time to use go to make the concurrency better.

Write an efficient makefile

Revert unbuffer change

b6fb1b5

causes video files to reach the destination as 0 bytes, and apparently returns a successful code.

Write Electron GUI

Try to use mapbox for navigation, flexible enough for new features and panes for a touchscreen

Poll KEY_ON/KEY_OFF

Instead of interrupts, poll the KEY_ON/KEY_OFF every few seconds and emit when there's a state change

Try azure pipelines for faster builds

Do this after the makefile, see if the makefile can reduce duplicate container builds

Loki / ElasticSearch

Be able to grab logs from the car when we download data from it

Add thread to update time in annotation

Forgot to include this - the timestamp in the car never updates, only the frame counter does.

Simplify Python Client Library

The current method requires knowledge of the internal JSON. This shouldn't be the case.

Try using python async await.

Consider branching out controller into its own project

Centralized Pub/Sub not limited to a car situation. It's a microservices design pattern.

Would be based on simplicity of actual code + simple libraries.

Update to use Karmen

Make this repo use https://github.com/jrcichra/karmen instead of the controller go code inside (deprecated for karmen)

Better logging visibility

./something to get docker-compose logs in order