PELS is a handheld system that can be carried by citizen scientists to gather environmental data.
The repository can be found here: https://github.com/heidtn/PELS
Here are the software design decisions:
- The software will be written in python 2.x using pep8 conventions
- Documentation will follow the numpydocs format
- The UI will be written using the Kivy library for python
- Numerical data will be stored in a sqlite database locally
- The program will use the sqlite3 library for interfacing with the database
- Image/Video data will be stored in a separate folder for images.
- There will still be database entries for the data, however they will only link to the path and the images themselves will not be stored in the database.
Here are the hardware design decisions:
- The system will use a raspberry pi as the computer
- There will be a TFT touchscreen LCD (size TBD)
- There will be an on board battery that can supply power for >4 hours
- The device shall be weatherproof (can't be submerged, but can get splashed and be OK)
- There will be a camera on the back (I will be developing with NOIR, but this could be anything in theory).
- There will be a microscope attachment
In order to modularize the system, I've decided to format everything in a customizable way. The software will be sectioned into modules that are essentially actions users can take using the PELS device. Primarily, modules will be interfaces for collecting data using the different on board sensors.
The directory format will probably look like the following:
-> PELS Project
->Primary App (primary execution point for the system)
->Interface Handler (can be usd by modules to pull from multiple data locations)
->module 1, module 2, etc...
->i2c interface, usb interface, UART interface
->Database (a sqlite database to locally hold data)
->Images (directory for collected images using cameras)
This allows users to create their own modules for sensors as well as to create interfaces for existing sensors without too much overhead work.
I've selected the basic components for the first prototypes. They include the basic necessary parts for running everything as well as a few sensors that I believe are useful in ecological analysis. Here are the parts and their purposes:
Raspberry pi 3 - The computer that runs everything on this system. I'd like to test with a pi zero, which should be compatible with evertything here as well.
2.8" touchscreen TFT - This is an RPi compatible screen available on adafruit that seems perfect for this application.
GP-20U7 (56 Channel) GPS - This is for geologging collected data.
Pi NoIR camera module - Infrared cameras can be used to view plant health and a wealth of other information about the environment.
SparkFun Soil Moisture Sensor - Sparkfun's soil moisture sensor data could yield some interesting data about water retention.
Si7021 Humidity and Temperature Sensor - Humidity and temperature data can help calibrate sensors and give further insights into the environment.
Methane CNG Gas Sensor MQ-4 - Methane
I'll test with these components to see what makes sense for this application. In the meantime I'm going to mock up an interface to make it easier to test. I'm thinking about using python's Kivy framework which I have heard good things about.
So here are the general elements of the project:
1. Sensors - This includes selecting sensors as well as the drivers for managing and communicating with the sensors.
2. Software - The software management will be put together in a simple and modular way to interact with the sensors and to identify general shortcomings.
3. CAD - This is an ongoing process for the physical parts of different elements of the system.
4. Database (future) - If people are into this project, there will be an opportunity to set up a database for collecting and displaying user acquired data.
1. General design - I need to decide what sensors I want to include in the first iteration. This is a pen and paper approach. I'll select basic components and sketch general outlines.
2. Order parts - I'll order the basic parts needed to prototype and test after design.
3. Software - Create software interface for the different elements for testing and development.
3. First prototype - Cram everything into an off the shelf case and see how it feels to use
4. CAD - Start refining the 3D models of the system for 3D printing/purchasing/assembly.
5. Order/assemble parts - Finalize and order parts then test fits and functionality
6. Refine! - Improve issues, add new features, etc. etc.