Hi,
my recent project has been an air quality measurement system at home based on Raspberry Pi Zero W with a set of suitable sensors and software accessing the sensor data. The results are planned to be stored on a NoSQL database on a server and visualized in a Web app built on AngularJS and Express JS.
The work on this project actually started weeks ago when I got the idea to use my Raspberry Pi Zero W as air quality monitoring gadget. At the beginning I sought after suitable sensors which was really easy thanks to existing projects, such as the project Airpi where a list of suggestions for hardware is provided. In order to minimize the costs I ordered everything at Aliexpress, and the outcome is that after a few weeks I still am waiting for some parts, but fortunately this is not a great hurdle, as due to the modular construction I can build the air quality measurement station gradually, by adding sensors and additional components as required. In the first step I only have connected the air temperature and humidity sensor AM2302 to provide the first metrics. This will be built further when the remaining parts (such as a sensor for detecting harmful gases) arrive.
Client implementation for reading the sensor values and sending those to a server
The first component of the system is the Raspberry Pi with the required sensors with which I read the measures and take care of storing those for a further use.
The figure below illustrates the first assembly with the sensor with a protecting resistor and power and ground cords connected between the breadboard and RaspBi. For a beginning hobbyist this was a nice exercise and thanks to wide software support there was existing libraries and code available that could be used with minor changes to provide the desired metrics.
I used the Adafruit Python DHT Sensor Library that can be used to read metrics from humidity and temperature sensors, such as DHT22 or AM2302.
In the Python code I read the sensor values once per minute and send the values in a HTTP/POST request in a JSON structure to the server taking care of storing the measures to a NoSQL DB and on the other hand providing access to the stored data. There still are various improvements to be made, such as the user authentication.
#!/usr/bin/python
# DHT Sensor Data-logging Example
# Copyright (c) 2014 Adafruit Industries
# Authors: Tony DiCola, Feetu Nyrhinen (modifications)
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import json
import sys
import time
import datetime
import requests
import Adafruit_DHT
# Type of sensor, can be Adafruit_DHT.DHT11, Adafruit_DHT.DHT22, or Adafruit_DHT.AM2302.
DHT_TYPE = Adafruit_DHT.AM2302
# Example of sensor connected to Raspberry Pi pin 23
DHT_PIN = 17
# How long to wait (in seconds) between measurements.
FREQUENCY_SECONDS = 60
while True:
# Attempt to get sensor reading.
humidity, temp = Adafruit_DHT.read(DHT_TYPE, DHT_PIN)
# Skip to the next reading if a valid measurement couldn't be taken.
# This might happen if the CPU is under a lot of load and the sensor
# can't be reliably read (timing is critical to read the sensor).
if humidity is None or temp is None:
time.sleep(2)
continue
d = datetime.datetime.now()
t = float("{0:.2f}".format(temp))
h = float("{0:.2f}".format(humidity))
print('date: ' +str(datetime.datetime.now()) + ', temperature: ' +str(t) +', humidity: ' +str(h))
try:
# Append the data in the spreadsheet, including a timestamp
parameters = {'date':d, 'temperature':t, 'humidity':h}
url = 'http://server.example.net/api/measurements'
head = {'Content-Type': 'application/json'}
ret = requests.post(url, data=parameters)
print ret.status_code
except:
print('Error in saving the measurement')
time.sleep(FREQUENCY_SECONDS)
continue
# Wait 30 seconds before continuing
print('Wrote a row to db')
time.sleep(FREQUENCY_SECONDS)
Server implementation for providing an interface for storing the measurement values and providing access to the existing data
As already mentioned before a server counterpart is required for serving and storing the data for future use cases, i.e. a planned Web app visualizing the measurement values.
The code listing below is the model class for our current data item for measurements. At the moment only a timestamp and the measures for temperature and humidity are included, but this class will be extended in the future as required. Like code reveals, we are going to use Mongoose API to simplify the access and use of the data in the MongoDB database.
// app/models/measurement.js
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var MeasurementSchema = new Schema({
date: Date,
temperature: Number,
humidity: Number
});
module.exports = mongoose.model('Measurement', MeasurementSchema);
The following listing realizes the actual REST endpoint for serving the request of saving and accessing measurements. The software is built on NodeJS, ExpressJS and Mongoose, and the data is transferred in the JSON format. Please note the listing is not complete, but only contains the relevant parts for the core functionality.
First we declare a set of variables required for the implementation, e.g. create a DB connection with Mongoose, specify a body parser to be used so that we can directly apply JSON in the transfers.
Basically we specify the routes, an of importance here are the route for storing a new measurement item and on the other hand a route for accessing all the existing measurements. Further routes can and will be specified as required. The post request contains the required data in the request body, i.e. the timestamp, the values of temperature and humidity. Based on the data a new Measurement object is create, initialized , and finally saved to the DB.
The method for accessing all the measurements is really straightforward thanks to Mongoose API; we basically call the find method on all the instances of the Measurement class and return the result as JSON.
var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost:27017/airquality');
var Measurement = require('./app/models/measurement');
var express = require('express');
var app = express();
app.disable('x-powered-by');
var bodyParser = require('body-parser');
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());
var port = process.env.PORT || 8080;
// ROUTES FOR OUR API
var router = express.Router(); // get an instance of the express Router
// middleware to use for all requests
router.use(function(req, res, next) {
console.log('Request incoming...');
next();
});
// test route to make sure everything is working (available at GET http://localhost:8080/api)
router.get('/', function(req, res) {
res.json({ message: 'Measurements API' });
});
// Routes for storing and accessing the measurements
router.route('/measurements')
.post(function(req, res) {
console.log('Saving a new measurement, ');
console.log('date: ' +req.body.date);
console.log('temp: ' +req.body.temperature);
console.log('humidity: ' +req.body.humidity);
console.log('----------------------------------------');
var measurement = new Measurement();
measurement.date = req.body.date;
measurement.temperature = req.body.temperature;
measurement.humidity = req.body.humidity;
// Save the measurement and check for errors
measurement.save(function(err) {
if (err) {
res.send(err);
}
res.json({ message: 'Measurement created!'});
});
})
.get(function(req, res) {
Measurement.find(function(err, measurements) {
if (err) {
res.send(err);
}
res.json(measurements);
});
});
// Register the routes
app.use('/api', router);
// START THE SERVER
app.listen(port);
console.log('Serving at port ' +port);
No rocket science, but still a useful exercise with many learning opportunities. I’m pretty certain I’ll return to the project later as it proceeds and also the client Web app becomes more polished. Until then: happy hacking!
Update April 25th, 2017
In the first implementation iteration the development had some severe drawbacks, like e.g. the lack of proper authentication. In this case I decided to take the easy path and apply HTTP Basic Authentication, as the server app is only used by a handful of users: the client taking care of storing the measurement data and on the other hand the Web client visualizing the results. The whole procedure was implemented as described on https://davidbeath.com/posts/expressjs-40-basicauth.html. Many thanks to the author for the fine tutorial. Without any great struggle I got the basic authentication running in no time at all.