Mark Smith

I've been a big fan of the Raspberry Pi since the first version was
released in 2012. The newer generations are wonderful home-automation
and IoT prototyping computers, with built in WiFi, and the most recent
versions (the Pi 3 and Pi 4) are 64-bit. This means they can run the
MongoDB server, mongod, locally! MongoDB even provides a pre-compiled
version for the Raspberry Pi processor, so it's relatively
straightforward to get it installed.

I'm currently building a home-automation service on a Raspberry Pi 4.
Its job is to run background tasks, such as periodically requesting data
from the internet, and then provide the data to a bunch of small devices
around my house, such as some smart displays, and (ahem) my coffee
grinder.

The service doesn't have super-complex data storage requirements, and I
could have used an embedded database, such as SQLite. But I've become
resistant to modelling tables and joins in a relational database and
working with flat rows. The ability to store rich data structures in a
single MongoDB database is a killer feature for me.

## Prerequisites

You will need:

-   A Raspberry Pi 3 or 4
-   A suitably sized Micro SD card (I used a 16 Gb card)
-   A computer and SD card reader to write the SD card image. (This
    *can* be another Raspberry Pi, but I'm using my desktop PC)
-   A text editor on the host computer. (I recommend [VS
    Code](https://code.visualstudio.com/download))

## What This Tutorial Will Do

This tutorial will show you how to:

-   Install the 64-bit version of Ubuntu Server on your Raspberry Pi.
-   Configure it to connect to your WiFi.
-   *Correctly* install MongoDB onto your Pi.
-   Add a user account, so you can *safely* expose MongoDB on your home
    network.

When you're done, you'll have a secured MongoDB instance available on
your home network.

>
>
>Before we get too far into this, please bear in mind that you don't want
>to run a production, web-scale database on a Raspberry Pi. Despite the
>processor improvements on the Pi 4, it's still a relatively low-powered
>machine, with a relatively low amount of RAM for a database server.
>Still! For a local, offline MongoDB instance, with the ease of
>development that MongoDB offers, a Raspberry Pi is a great low-cost
>solution. If you *do* wish to serve your data to the Internet, you
>should definitely check out
>[Atlas](https://www.mongodb.com/cloud/atlas), MongoDB's cloud hosting
>solution. MongoDB will host your database for you, and the service has a
>generous (and permanent) free tier!
>
>

## Things Not To Do

*Do not* run `apt install mongodb` on your Raspberry Pi, or indeed any
Linux computer! The versions of MongoDB shipped with Linux distributions
are *very* out of date. They won't run as well, and some of them are so
old they're no longer supported.

MongoDB provide versions of the database, pre-packaged for many
different operating systems, and Ubuntu Server on Raspberry Pi is one of
them.

## Installing Ubuntu

Download and install the [Raspberry Pi
Imager](https://www.raspberrypi.org/downloads/) for your host computer.

![Download Raspberry Pi Imager](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/how-to/raspberry_pi/download_imager.png)

Run the Raspberry Pi Imager, and select Ubuntu Server 20.04, 64-bit for
Raspberry Pi 3/4.

![Select the correct Ubuntu image](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/how-to/raspberry_pi/ubuntu_os_selection.png)

Make sure you *don't* accidentally select Ubuntu Core, or a 32-bit
version.

Insert your Micro SD Card into your computer and select it in the
Raspberry Pi Imager window.

![Select your SD Card](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/how-to/raspberry_pi/select_sd_card.png)

Click **Write** and wait for the image to be written to the SD Card.
This may take some time! When it's finished, close the Raspberry Pi
Imager. Then remove the Micro SD Card from your computer, and re-insert
it.

The Ubuntu image for Raspberry Pi uses
[cloud-init](https://cloudinit.readthedocs.io/) to configure the system
at boot time. This means that in your SD card `system-boot` volume,
there should be a YAML file, called `network-config`. Open this file in
VS Code (or your favourite text editor).

Edit it so that it looks like the following. The indentation is
important, and it's the 'wifis' section that you're editing to match
your wifi configuration. Replace 'YOUR-WIFI-SSD' with your WiFi's name,
and 'YOUR-WIFI-PASSWORD' with your WiFi password.

``` yaml
version: 2
ethernets:
   eth0:
      dhcp4: true
      optional: true
wifis:
   wlan0:
      dhcp4: true
      optional: true
      access-points:
         "YOUR-WIFI-SSID":
            password: "YOUR-WIFI-PASSWORD"
```

Now eject the SD card (safely!) from your computer, insert it into the
Pi, and power it up! It may take a few minutes to start up, at least the
first time. You'll need to monitor your network to wait for the Pi to
connect. When it does, ssh into the Pi with
`ssh ubuntu@<raspberry-pi-ip-address>`. The password is also `ubuntu`.

You'll be prompted to change your password to something secret.

Once you've set your password update the operating system by running the
following commands:

``` bash
sudo apt update
sudo apt upgrade
```

## Install MongoDB

Now let's install MongoDB. This is done as follows:

``` bash
# Install the MongoDB 4.4 GPG key:
wget -qO - https://www.mongodb.org/static/pgp/server-4.4.asc | sudo apt-key add -

# Add the source location for the MongoDB packages:
echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu focal/mongodb-org/4.4 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-4.4.list

# Download the package details for the MongoDB packages:
sudo apt-get update

# Install MongoDB:
sudo apt-get install -y mongodb-org
```

The instructions above have mostly been taken from [Install MongoDB
Community Edition on
Ubuntu](https://docs.mongodb.com/manual/tutorial/install-mongodb-on-ubuntu/)

## Run MongoDB

Ubuntu 20.04 uses Systemd to run background services, so to set up
mongod to run in the background, you need to enable and start the
service:

``` bash
# Ensure mongod config is picked up:
sudo systemctl daemon-reload

# Tell systemd to run mongod on reboot:
sudo systemctl enable mongod

# Start up mongod!
sudo systemctl start mongod
```

Now, you can check to see if the service is running correctly by
executing the following command. You should see something like the
output below it:

``` bash
$ sudo systemctl status mongod

● mongod.service - MongoDB Database Server
   Loaded: loaded (/lib/systemd/system/mongod.service; enabled; vendor preset: enabled)
   Active: active (running) since Tue 2020-08-09 08:09:07 UTC; 4s ago
   Docs: https://docs.mongodb.org/manual
Main PID: 2366 (mongod)
   CGroup: /system.slice/mongod.service
         └─2366 /usr/bin/mongod --config /etc/mongod.conf
```

If your service is running correctly, you can run the MongoDB client,
`mongo`, from the command-line to connect:

``` bash
# Connect to the local mongod, on the default port:
$ mongo
MongoDB shell version v4.4.0
connecting to: mongodb://127.0.0.1:27017/?compressors=disabled&gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("576ec12b-6c1a-4382-8fae-8b6140e76d51") }
MongoDB server version: 4.4.0
---
The server generated these startup warnings when booting:
      2020-08-09T08:09:08.697+00:00: Using the XFS filesystem is strongly recommended with the WiredTiger storage engine. See http://dochub.mongodb.org/core/prodnotes-filesystem
      2020-08-09T08:09:10.712+00:00: Access control is not enabled for the database. Read and write access to data and configuration is unrestricted
---
---
      Enable MongoDB's free cloud-based monitoring service, which will then receive and display
      metrics about your deployment (disk utilization, CPU, operation statistics, etc).

      The monitoring data will be available on a MongoDB website with a unique URL accessible to you
      and anyone you share the URL with. MongoDB may use this information to make product
      improvements and to suggest MongoDB products and deployment options to you.

      To enable free monitoring, run the following command: db.enableFreeMonitoring()
      To permanently disable this reminder, run the following command: db.disableFreeMonitoring()
---
```

First, check the warnings. You can ignore the recommendation to run the
XFS filesystem, as this is just a small, local install. The warning
about access control not being enabled for the database is important
though! You'll fix that in the next section. At this point, if you feel
like it, you can enable the [free
monitoring](https://docs.mongodb.com/manual/administration/free-monitoring/)
that MongoDB provides, by running `db.enableFreeMonitoring()` inside the
mongo shell.

## Securing MongoDB

Here's the next, essential steps, that other tutorials miss out, for
some reason. Recent versions of mongod won't connect to the network
unless user authentication has been configured. Because of this, at the
moment your database is only accessible from the Raspberry Pi itself.
This may actually be fine, if like me, the services you're running with
MongoDB are running on the same device. It's still a good idea to set a
username and password on the database.

Here's how you do that, inside `mongo` (replace SUPERSECRETPASSWORD with
an *actual* secret password!):

``` javascript
use admin
db.createUser( { user: "admin",
            pwd: "SUPERSECRETPASSWORD",
            roles: [ "userAdminAnyDatabase",
                     "dbAdminAnyDatabase",
                     "readWriteAnyDatabase"] } )
exit
```

The three roles listed give the `admin` user the ability to administer
all user accounts and data in MongoDB. Make sure your password is
secure. You can use a [random password
generator](https://www.avast.com/random-password-generator) to be safe.

Now you need to reconfigure mongod to run with authentication enabled,
by adding a couple of lines to `/etc/mongod.conf`. If you're comfortable
with a terminal text editor, such as vi or emacs, use one of those. I
used nano, because it's a little simpler, with
`sudo nano /etc/mongod.conf`. Add the following two lines somewhere in
the file. Like the `network-config` file you edited earlier, it's a YAML
file, so the indentation is important!

``` yaml
# These two lines must be uncommented and in the file together:
security:
   authorization: enabled
```

And finally, restart mongod:

``` bash
sudo systemctl restart mongod
```

Ensure that authentication is enforced by connecting `mongo` without
authentication:

``` bash
$ mongo
MongoDB shell version v4.4.0
connecting to: mongodb://127.0.0.1:27017/?compressors=disabled&gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("4002052b-1a39-4158-8a99-234cfd818e30") }
MongoDB server version: 4.4.0
> db.adminCommand({listDatabases: 1})
{
      "ok" : 0,
      "errmsg" : "command listDatabases requires authentication",
      "code" : 13,
      "codeName" : "Unauthorized"
}
> exit
```

Ensure you've exited `mongo` and now test that you can connect and
authenticate with the user details you created:

``` bash
$ mongo -u "admin" -p "SUPERSECRETPASSWORD"
MongoDB shell version v4.4.0
connecting to: mongodb://127.0.0.1:27017/?compressors=disabled&gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("3dee8ec3-6e7f-4203-a6ad-976b55ea3020") }
MongoDB server version: 4.4.0
> db.adminCommand({listDatabases: 1})
{
      "databases" : [
               {
                        "name" : "admin",
                        "sizeOnDisk" : 151552,
                        "empty" : false
               },
               {
                        "name" : "config",
                        "sizeOnDisk" : 36864,
                        "empty" : false
               },
               {
                        "name" : "local",
                        "sizeOnDisk" : 73728,
                        "empty" : false
               },
               {
                        "name" : "test",
                        "sizeOnDisk" : 8192,
                        "empty" : false
               }
      ],
      "totalSize" : 270336,
      "ok" : 1
}
> exit
```

## Make MongoDB Available to your Network

**This step is optional!** Now that you've configured authentication on
your server, if you want your database to be available to other
computers on your network, you need to:

-   Bind MongoDb to the Raspberry Pi's public IP address
-   Open up port `27017` on the Raspberry Pi's firewall.

>
>
>If you *don't* want to access your data from your network, *don't*
>follow these steps! It's always better to leave things more secure, if
>possible.
>
>

First, edit `/etc/mongod.conf` again, the same way as before. This time,
change the IP address to 0.0.0.0:

``` yaml
# Change the bindIp to '0.0.0.0':
net:
   port: 27017
   bindIp: 0.0.0.0
```

And restart `mongod` again:

``` bash
sudo systemctl restart mongod
```

Open up port 27017 on your Raspberry Pi's firewall:

``` bash
sudo ufw allow 27017/tcp
```

Now, on *another computer on your network*, with the MongoDB client
installed, run the following to ensure that `mongod` is available on
your network:

``` bash
# Replace YOUR-RPI-IP-ADDRESS with your Raspberry Pi's actual IP address:
mongo --host 'YOUR-RPI-IP-ADDRESS'
```

If it connects, then you've successfully installed and configured
MongoDB on your Raspberry Pi!

### Security Caveats

*This short section is extremely important. Don't skip it.*

-   *Never* open up an instance of `mongod` to the internet without
    authentication enabled.
-   Configure your firewall to limit the IP addresses which can connect
    to your MongoDB port. (Your Raspberry Pi has just been configured to
    allow connections from *anywhere*, with the assumption that your
    home network has a firewall blocking access from outside.)
-   Ensure the database user password you created is secure!
-   Set up different database users for each app that connects to your
    database server, with *only* the permissions required by each app.

MongoDB comes with sensible security defaults. It uses TLS, SCRAM-based
password authentication, and won't bind to your network port without
authentication being set up. It's still up to you to understand how to
secure your Raspberry Pi and any data you store within it. Go and read
the [MongoDB Security
Checklist](https://docs.mongodb.com/manual/administration/security-checklist/)
for further information on keeping your data secure.

## Wrapping Up

As you can see, there are a few steps to properly installing and
configuring MongoDB yourself. I hadn't done it for a while, and I'd
forgotten how complicated it can be! For this reason, you should
definitely consider using [MongoDB Atlas](https://cloud.mongodb.com/)
where a lot of this is taken care of for you. Not only is the
free-forever tier quite generous for small use-cases, there are also a
bunch of extra services thrown in, such as serverless functions,
charting, free-text search, and more!

You're done! Go write some code in your favourite programming language,
and if you're proud of it (or even if you're just having some trouble
and would like some help) [let us
know!](https://community.mongodb.com/). Check out all the cool blog
posts on the [MongoDB Developer Hub](https://developer.mongodb.com/),
and make sure to bookmark [MongoDB
Documentation](https://docs.mongodb.com/)


Install and correctly configure MongoDB on Raspberry Pi

Install & Configure MongoDB on the Raspberry Pi

Joe Karlsson



<div class="introduction">

My favorite things in life are cats, computers, and crappy ideas, so I decided to combine all three and explore what was possible with JavaScript by creating a brand new Internet of Things (IoT) device for my feline friend at home. If you're reading this, you have probably heard about how hot internet-connected devices are, and you are probably interested in learning how to get into IoT development as a JavaScript developer. In this post, we will explore why you should consider JavaScript for your next IoT project, talk about IoT data best practices, and we will explore my latest creation, the IoT Kitty Litter Box.

![Stop Motion gif of the completed IoT Kitty Litter
Box](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/how-to/internet-of-toilets/final_assembly_process.gif
"Stop Motion gif of the completed IoT Kitty Litter Box")

## IoT And JS(?!?!)

Okay, so why on earth should you use JavaScript on an IoT project? You might have thought JavaScript was just for webpages. Well, it turns out that JavaScript is famously eating the world and it is now, in fact, running on lots of new and exciting devices, including most internet-enabled IoT chips! Did you know that [58% of developers that identified as IoT developers use Node.js?](https://nodejs.org/en/blog/announcements/nodejs-foundation-survey/)

### The Internet *Already* Speaks JavaScript

That's a lot of IoT developers already using Node.js. Many of these developers use Node because the internet *already* speaks JavaScript. It's natural to continue building internet-connected devices using the de facto standard of the internet. Why reinvent the wheel?

### Easy to Update

Another reason IoT developers use Node is it's ease in updating your code base. With other programming languages commonly used for IoT projects (C or C++), if you want to update the code, you need to physically connect to the device, and reflash the device with the most up-to-date code. However, with an IoT device running Node, all you have to do is remotely run `git pull` and `npm install`. Now that's much easier.

### Node is Event-Based

One of the major innovations of Node is the event loop. The event loop enables servers running Node to handle events from the outside world (i.e. requests from clients) very quickly. Node is able to handle these events extremely efficiently and at scale.

Now, consider how an IoT device in the wild is built to run. In this thought experiment, let's imagine that we are designing an IoT device for a farm that will be collecting moisture sensor data from a cornfield. Our device will be equipped with a moisture sensor that will send a signal once the moisture level in the soil has dropped below a certain level. This means that our IoT device will be responding to a moisture *event* (sounds a lot like an *event loop* ;P). Nearly all IoT use cases are built around events like this. The fact that Node's event-based architecture nearly identically matches the event-based nature of IoT devices is a perfect fit. Having an event-based IoT architecture means that your device can save precious power when it does not need to respond to an event from the outside world.

### Mature IoT Community

Lastly, it's important to note that there is a mature community of IoT developers actively working on IoT libraries for Node.js. My favorites are [Johnny-Five](http://johnny-five.io/) and [CylonJS](https://cylonjs.com/). Let's take a look at the "Hello World" on IoT devices: making an LED bulb blink. Here's what it looks like when I first got my IoT "Hello World" code working.

![IoT Hello
World](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/how-to/internet-of-toilets/hello_world_demo.gif
"IoT Hello World")

Just be careful that your cat doesn't try to eat your project while you are getting your Hello World app up and running.

![My cat eating the IoT Hello World
project](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/how-to/internet-of-toilets/cat_eating_project.gif
"My cat eating the IoT Hello World project")

## IoT (AKA: Internet of Toilets) Kitty Litter Box

This leads me to my personal IoT project, the IoT Kitty Litter Box. For this project, I opted to use [Johnny-Five](http://johnny-five.io/). So, what the heck is this IoT Kitty Litter Box, and why would anyone want to build such a thing? Well, the goal of building an internet-connected litter box was to:

-   Help track my feline friend's health by passively measuring my cat's weight every time he sets foot in the litter tray.
-   Monitor my cat's bathroom patterns over time. It will make it easy to track any changes in bathroom behavior.
-   Explore IoT projects and have some fun!

Also, personally, I like the thought of building something that teeters right on the border of being completely ridiculous and kinda genius. Frankly, I'm shocked that no one has really made a consumer product like this! Here it is in all of its completed glory.

![Stop Motion gif of the completed IoT Kitty Litter
Box](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/how-to/internet-of-toilets/stop_motion_intro.gif
"Stop Motion gif of the completed IoT Kitty Litter Box")

### Materials and Tools

-   1 x Raspberry Pi - I used a Raspberry Pi 3 Model B for this demo, but any model will do.
-   1 x Breadboard
-   2 x Female to male wires
-   1 x 3D printer \[Optional\] - The 3D printer was used for printing the case where the electronics are enclosed.
-   1 x PLA filament \[Optional\] - Any color will work.
-   1 x Solder iron and solder wire
-   8 x M2x6 mm bolts
-   1 x HX711 module - This module is required as a load cell amplifier and it converts the analog load cell signal to a digital signal so the Raspberry Pi can read the incoming data.
-   4 x 50 kg load cell (x4) - They are used to measure the weight. In this project, four load cells are used and can measure a maximum weight of 200kg.
-   1 x Magnetic door sensor - Used to detect that the litter box is opened.
-   1 x Micro USB cable
-   1 x Cat litter box

### How Does the IoT Kitty Litter Box Work?

So how does this IoT Kitty Litter Box work? Let's take a look at the events that I needed to handle:

-   When the lid of the box is removed, the box enters "maintenance mode." When in maintenance mode, I can remove waste or refresh the litter.
-   When the lid of the box is put back on, it leaves maintenance mode, waits one minute for the litter to settle, then it recalibrates a new base weight after being cleaned.
-   The box then waits for a cat-sized object to be added to the weight of the box. When this event occurs, we wait 15 seconds for the cat to settle and the box records the weight of the cat and records it in a MongoDB database.
-   When the cat leaves the box, we reset the base weight of the box, and the box waits for another bathroom or maintenance event to occur.

You can also check out this handy animation that walks through the various events that we must handle.

![Animation of how the box
works](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/how-to/internet-of-toilets/how_the_box_works.gif
"Animation of how the box works")

### How to Write Code That Interacts With the Outside World

For this project, I opted to work with a Raspberry Pi 3 Model B+ since it runs a full Linux distro and it's easy to get Node running on it. The Raspberry Pi is larger than other internet-enabled chips on the market, but its ease of use makes it ideal for first-timers looking to dip into IoT projects. The other reason I picked the Raspberry Pi is the large array of GPIO pins. These pins allow you to do three things.

1.  Power an external sensor or chip.
2.  Read input from a sensor (i.e. read data from a light or moisture sensor).
3.  Send data from the Raspberry Pi to the outside world (i.e. turning a light on and off).

![Animation of how the box
works](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/how-to/internet-of-toilets/gpio_setup.png
"Animation of how the box works")

I wired up the IoT Kitty Litter Box using the schema below. I want to note that I am not an electrical engineer and creating this involved lots of Googling, failing, and at least two blown circuit boards. It's okay to make mistakes, especially when you are first starting out.

### Schematics

![IoT Kitty Litter Box Schema
Design](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/how-to/internet-of-toilets/schema_design.png
"IoT Kitty Litter Box Schema Design")

We will be using these GPIO pins in order to communicate with our sensors out in the "real world."

## Let's Dig Into the Code

I want to start with the most simple component on the box, the magnetic switch that is triggered when the lid is removed, so we know when the box goes into "maintenance mode." If you want to follow along, [you can check out the complete source code here](https://github.com/JoeKarlsson/iot-kitty-litter-box).

### Magnetic Switch

``` javascript
const { RaspiIO } = require('raspi-io');
const five = require('johnny-five');

// Initialize a new Raspberry Pi Board
const board = new five.Board({
   io: new RaspiIO(),
});

// Wait for the board to initialize then start reading in input from sensors
board.on('ready', () => {
   // Initialize a new switch on the 16th GPIO Input pin
   const spdt = new five.Switch('GPIO16');

   // Wait for the open event to get triggered by the sensor
   spdt.on('open', () => {
      enterMaintenceMode();
   });

   // Recalibrate the box once the sensor has closed
   // Once the box has been cleaned, the box prepares for a new event
   spdt.on('close', () => {
      console.log('close');
      // When the box has been closed again
      // wait 1 min for the box to settle
      // and recalibrate a new base weight
      setTimeout(() => {
            scale.calibrate();
      }, 60000);
   });
});

board.on('fail', error => {
   handleError(error);
});
```

You can see the event and asynchronous nature of IoT plays really nicely with Node's callback structure. Here's a demo of the magnetic switch component in action.

![Switch Demo](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/how-to/internet-of-toilets/switch_demo.gif "Switch Demo")

### Load Cells

Okay, now let's talk about my favorite component, the load cells. The load cells work basically like any bathroom scale you may have at home. The load cells are responsible for converting the pressure placed on them into a digital weight measurement I can read on the Raspberry Pi. I start by taking the base weight of the litter box. Then, I wait for the weight of something that is approximately cat-sized to be added to the base weight of the box and take the cat's weight. Once the cat leaves the box, I then recalibrate the base weight of the box. I also recalibrate the base weight after every time the lid is taken off in order to account for events like the box being cleaned or having more litter added to the box.

In regards to the code for reading data from the load cells, things were kind of tricky. This is because the load cells are not directly compatible with [Johnny-Five](http://johnny-five.io/). I was, however, able to find a [Python library that can interact with the HX711 load cells](https://github.com/tatobari/hx711py).

``` python
#! /usr/bin/python2

import time
import sys
import RPi.GPIO as GPIO
from hx711 import HX711
# Infintely run a loop that checks the weight every 1/10 of a second
while True:
   try:
      # Prints the weight - and send it to the parent Node process
      val = hx.get_weight()
      print(val)

      # Read the weight every 1/10 of a second
      time.sleep(0.1)

   except (KeyboardInterrupt, SystemExit):
      cleanAndExit()
```

In order to use this code, I had to make use of Node's Spawn Child Process API. The child process API is responsible for spinning up the Python process on a separate thread. Here's what that looks like.

``` javascript
const spawn = require('child_process').spawn;

class Scale {
   constructor(client) {
      // Spin up the child process when the Scale is initialized
      this.process = spawn('python', ['./hx711py/scale.py'], {
            detached: true,
      });
   }

   getWeight() {
      // Takes stdout data from Python child script which executed
      // with arguments and send this data to res object
      this.process.stdout.on('data', data => {
            // The data is returned from the Python process as a string
            // We need to parse it to a float
            this.currWeight = parseFloat(data);

            // If a cat is present - do something
            if (this.isCatPresent() {
               this.handleCatInBoxEvent();
            }
      });

      this.process.stderr.on('data', err => {
            handleError(String(err));
      });

      this.process.on('close', (code, signal) => {
            console.log(
               `child process exited with code ${code} and signal ${signal}`
            );
      });
   }
   [...]
}

module.exports = Scale;
```

This was the first time I have played around with the Spawn Child Process API from Node. Personally, I was really impressed by how easy it was to use and troubleshoot. It's not the most elegant solution, but it totally works for my project and it uses some cool features of Node. Let's take a look at what the load cells look like in action. In the video below, you can see how pressure placed on the load cells is registered as a weight measurement from the Raspberry Pi.

![Load Cell
Demo](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/how-to/internet-of-toilets/load_cell_demo.gif
"Load Cell Demo")

## How to Handle IoT Data

Okay, so as a software engineer at MongoDB, I would be remiss if I didn't talk about what to do with all of the data from this IoT device. For my IoT Litter Box, I am saving all of the data in a fully managed database service on [MongoDB Atlas](https://www.mongodb.com/cloud/atlas). Here's how I connected the litter box to the MongoDB Atlas database.

``` javascript
const MongoClient = require('mongodb').MongoClient;
const uri = 'YOUR MONGODB URI HERE'
const client = new MongoClient(uri, { useNewUrlParser: true });
client.connect(err => {
   const collection = client.db('IoT').collection('toilets');
   // perform actions on the collection object
   client.close();
});
```

### IoT Data Best Practices

There are a lot of places to store your IoT data these days, so I want to talk about what you should look for when you are evaluating data platforms.

#### High Database Throughput

First thing when selecting a database for your IoT project, you need to ensure that you database is able to handle a massive amount of concurrent writes. Most IoT architectures are write-heavy, meaning that you are writing more data to your database then reading from it. Let's say that I decide to start mass manufacturing and selling my IoT Kitty Litter Boxes. Once I deploy a couple of thousand boxes in the wild, my database could potentially have a massive amount of concurrent writes if all of the cats go to the bathroom at the same time! That's going to be a lot of incoming data my database will need to handle!

#### Flexible Data Schema

You should also consider a database that is able to handle a flexible schema. This is because it is common to either add or upgrade sensors on an IoT device. For example, on my litter box, I was able to easily update my schema to add the switch data when I decided to start tracking how often the box gets cleaned.

#### Your Database Should Easily Time Series Data

Lastly, you will want to select a database that natively handles time series data. Consider how your data will be used. For most IoT projects, the data will be collected, analyzed, and visualized on a graph or chart over time. For my IoT Litter Box, my database schema looks like the following.

``` json
{
   "_id": { "$oid": "dskfjlk2j92121293901233" },
   "timestamp_day": { "$date": { "$numberLong": "1573854434214" } },
   "type": "cat_in_box",
   "cat": { "name": "BMO", "weight": "200" },
   "owner": "Joe Karlsson",
   "events": [
         {
            "timestamp_event": { "$date": { "$numberLong": "1573854435016" } },
            "weight": { "$numberDouble": "15.593333333" }
      },
      {
            "timestamp_event": { "$date": { "$numberLong": "1573854435824" } },
            "weight": { "$numberDouble": "15.132222222" }
      },
      {
            "timestamp_event": { "$date": { "$numberLong": "1573854436632"} },
            "type": "maintenance"
      }
   ]
}
```

## Summary

Alright, let's wrap this party up. In this post, we talked about why you should consider using Node for your next IoT project: It's easy to update over a network, the internet already speaks JavaScript, there are tons of existing libraries/plugins/APIs (including [CylonJS](https://cylonjs.com/) and [Johnny-Five](http://johnny-five.io/)), and JavaScript is great at handling event-driven apps. We looked at a real-life Node-based IoT project, my IoT Kitty Litter Box. Then, we dug into the code base for the IoT Kitty Litter Box. We also discussed what to look for when selecting a database for IoT projects: It should be able to concurrently write data quickly, have a flexible schema, and be able to handle time series data.

![Final IoT Kitty Litter Box Assembly
process](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/how-to/internet-of-toilets/final_assembly_process.gif
"Final IoT Kitty Litter Box Assembly process")

What's next? Well, if I have inspired you to get started on your own IoT project, I say, "Go for it!" Pick out a project, even if it's "crappy," and build it. Google as you go, and make mistakes. I think it's the best way to learn. I hereby give you permission to make stupid stuff just for you, something to help you learn and grow as a human being and a software engineer.

>When you're ready to build your own IoT device, check out [MongoDB Atlas](https://www.mongodb.com/cloud/atlas), MongoDB's fully managed database-as-a-service. Atlas is the easiest way to get started with MongoDB and has a generous, forever-free tier.

## Related Links

Check out the following resources for more information:

-   [Bringing JavaScript to the IoT Edge - Joe Karlsson \| Node + JS Interactive 2019](https://www.youtube.com/watch?v=711Sb55fzdg/).
-   [IoT Kitty Litter Box Source Code](https://github.com/JoeKarlsson/iot-kitty-litter-box/).
-   [Want to learn more about MongoDB? Be sure to take a class on the MongoDB University](https://university.mongodb.com/).
-   [Have a question, feedback on this post, or stuck on something be sure to check out and/or open a new post on the MongoDB Community Forums](https://developer.mongodb.com/community/forums/).
-   [Quick Start: Node.js](https://www.mongodb.com/blog/post/quick-start-nodejs-mongodb--how-to-get-connected-to-your-database).
-   [Want to check out more cool articles about MongoDB? Be sure to check out more posts like this on the MongoDB Developer Hub](https://developer.mongodb.com).

Learn all about developing IoT projects using JS and MongoDB by building an smart toilet for your cat! Click here for more!

RaspberryPi

All RaspberryPi Content

Install & Configure MongoDB on the Raspberry Pi

An Introduction to IoT (Internet of Toilets)

Related Topics