Okay, folks, gather around for a story — it’s adventure time!

You know how our little bundles of joy, our babies, are the superheroes of sleep? They have the superpower to sleep through anything, and yet another superpower to wake up to the quietest sound! So, this adventure is all about how I created a ‘Silence Guardian’ for my baby’s room using some cool tech.

Once Upon a Tech Time…
Our quest begins with the mighty Raspberry Pi Pico W, a microcontroller with WiFi superpowers, and a friendly sidekick — a low-cost LM393 sound detection module. This dynamic duo teamed up to listen for any sounds that might disturb our sleeping superhero.

To the Cloud!
But what’s a superhero story without some magic? That’s where Initial State comes in. It’s a magical realm (data streaming service) where the Pico sends signals (sound detection events) if it hears a loud noise. Initial State keeps an eye (or ear!) on these signals and sends a message in a flash (text notification) if it detects a loud event.

Casting Spells with MicroPython
Every magic trick needs a spell, right? Our spell is written in MicroPython, a wizard-friendly version of Python 3 that’s perfect for casting spells (coding) on microcontrollers.

The Adventure Unfolds
We embarked on our quest with great enthusiasm, but every good adventure has its challenges. We first tried using a magic tool called Direct Memory Access (DMA), but it proved to be a tricky beast. So, we took a different path, treating our LM393 sidekick as a simple ‘yes/no’ sensor (high/low signal) and monitoring small ‘rolling’ windows of time to detect noises.

The Art of Listening
We spent some time fine-tuning our noise detection. It was like teaching our Pico to understand the difference between a whisper and a shout. I used a magical device called an oscilloscope that lets me see the sounds the Pico was hearing, making it easier to adjust our noise detection. But even without an oscilloscope, you can teach your Pico to listen — just use print statements in your spell (code) to understand what it’s hearing.

And They Lived Quietly Ever After
Our DIY adventure turned out to be a great success! We’ve become the guardians of silence for our little superhero’s dreams. And the best part? If we’re too loud, our phones get a text, reminding us to use our inside voices.

So, fellow adventurers, are you ready to embark on your own quest for quiet? Grab your gear, cast your spells, and let’s give our little superheroes the peaceful dreams they deserve!

Pictures
We decided to attach our sensor right next to the baby monitor camera, with the mic sensor facing the door. Also, we highly recommend befriending someone with a 3-d printer to create a nice little case for your project. And of-course, good wire management for the project will teach your baby good organization skills 😜

Things you’ll need

1. Pico W with MicroPython image
2. Microphone Sensor (link)
3. Micro USB cable with wall adapter to power up your project. (link)
4. Soldering Station is a nice to have

Wire everything together as below

Optional: Being able to see electrical signals on a scope is extremely helpful in understanding what your sensor is hearing and what your microcontroller is seeing. The pink signal is what my pico received when I made some noises. The blue signal is the 3V out of the pico.

Code
Here is my code if you want to try this out. I’ve over-saturated with comments to help newbies like me get started easily.

# Import necessary libraries  
import machine  
import utime  
import network  
import urequests as requests  
import ujson  
import secret as s  
import gc  
  
# Define the pin connected to the microphone sensor's output  
# IDK why and makese no sense but PULL_UP works better than PULL_DOWN. Magic!
mic_sensor_pin = machine.Pin(0, machine.Pin.IN, machine.Pin.PULL_UP)  

  
# Set the duration of the rolling window in seconds  
rolling_window_duration = 1  
  
# Set the number of samples to collect per second.
# The Pico struggles with higher sample rate 
samples_per_second = 500    
  
# Set the number of consecutive windows to consider for a loud event  
consecutive_windows_threshold = 3  
  
# Initialize an empty list to store the rolling window data  
rolling_window_buffer = []  
  
# Initialize a variable to keep track of the number of sent messages  
sent_count = 0  
  
# Function to connect to WiFi  
def connect_wifi(ssid, password):  
    # Initialize the WiFi interface  
    wlan = network.WLAN(network.STA_IF)  
    wlan.active(True)  
    try:  
        # Check if the device is already connected to WiFi  
        if not wlan.isconnected():  
            print('Connecting to WiFi...')  
            wlan.connect(ssid, password)  
            # Wait until the device is connected to WiFi  
            while not wlan.isconnected():  
                pass  
        print('Connected to WiFi with IP address', wlan.ifconfig()[0])  
    except:  
        print('Failed to connect to WiFi!')  
  
# Function to send data to the API  
def send_data(label, value):      
    # Perform garbage collection to free up memory 
    # As Pico was running out of resources here. 
    gc.collect()    
    # Prepare the data to be sent  
    values = {"events": [{"key": label, "value": value}]}      
    try:    
        # Send a POST request to the API  
        response = requests.post(s.url, headers=s.headers, json=values)      
        # Close the connection after the request is completed  
        response.close()   
    except Exception as e:    
        print("Failed to send data:", e)  
  
# Connect to WiFi  
connect_wifi(s.ssid, s.password)  
utime.sleep(2)  
  
# Start the main loop
# The logic is simple: monitor a window of time, count high signals (noises),
# If its more than the threshold, send event to Initial State
while True:  
    # Calculate the rolling window size in number of samples  
    rolling_window_size = int(rolling_window_duration * samples_per_second)  
      
    # Collect the current state of the microphone sensor  
    rolling_window = [mic_sensor_pin.value() for _ in range(rolling_window_size)]  
      
    # Count the number of loud sound events in the rolling window  
    loud_sound_count = sum(1 for state in rolling_window if state == 1)  
      
    # Check if the number of loud sounds is above the threshold  
    if loud_sound_count > (rolling_window_size * 0.1):  
        # Add a loud sound event to the rolling window buffer  
        rolling_window_buffer.append(1)  
          
        # Check if the number of consecutive loud sound events is above the threshold  
        if len(rolling_window_buffer) >= consecutive_windows_threshold:  
            # Increase the sent count  
            sent_count += 1  
            # Clear the rolling window buffer  
            rolling_window_buffer.clear()  
              
            # Send data to the API indicating a loud sound event  
            # Had to include sleep since pico wasn't fast enough. 
            send_data("Loud Noise", 1)  
            utime.sleep(3)  
            send_data("Loud Noise", 0) # to make my dashboard look nice 
            utime.sleep(3)  
    else:  
        # Clear the rolling window buffer if no loud sound was detected  
        rolling_window_buffer.clear()  
  
    # Sleep for a while to adjust the sample rate  
    utime.sleep_ms(10000 // samples_per_second)

Here is the secrets.py file with all the API and wifi stuff:

#initial State stuff
url = 'https://groker.init.st/api/events'
headers = {
  'Content-Type': 'application/json',
  'X-IS-AccessKey': 'Your API Key',
  'X-IS-BucketKey': 'Your Bucket ID',
  'Accept-Version': '~0'}


#Wifi Stuff
ssid = "Your WIFI Name"
password = "Your Wifi password"

Bonus use case, Use at your own risk
If your spouse’s work-from-home early morning ‘loud’ meetings wake you up, place one of these sensors on their desk! Works as a great sleep guardian for you too 😜

Shhh! The Baby’s Sleeping: Our Fun DIY Adventure in Noise Monitoring was originally published in Initial State on Medium, where people are continuing the conversation by highlighting and responding to this story.

Pre-reqs

1. Pico W
2. Free Initial State account

Parts List

1. Wires / Soldering station: to make all the connections.
2. Raspberry Pi PICO W:
3. Follow this guide to install the latest micro python on your Pico w
4. DHT sensor: This is a popular humidity and temperature sensor with one limitation: it records 1 sample per second. This isn’t really an issue for my project. These have a 3-pin design for +, —, and data. If you need help, here is a great tutorial.

I was recently in the market for a small fridge to store breast milk and baby formula. I did not want to pay a premium for the ‘baby’ marketed products. So, I ended up buying an ‘affordable’ mini fridge without a temperature or a humidity sensor. From what I could find online, the baby food needs to stay < 4° C (39.2° F) and < 65% relative humidity. So wanted to build something that’s :

1. cheap,
2. easy to put together,
3. measures temperature and humidity to test if the fridge is even good enough. I didn’t want to blindly trust the marketing claims.
4. send me notifications if temp/humidity falls outside my defined specs like the times when we forget to close the fridge door.

Pico W is my favorite DYI home automation board these days. It runs off a USB power bank, is really tiny, has excellent support for sensors, plenty of GPIOs, and has an excellent community with code examples. It is a 3.3v board so take care when trying to run 5v sensors.

Initial State is a great dashboarding service: Just send/stream any kind of data to it and you have great visualizations of your data. You can start with a 14-day trial or use the student-free tier, or the individual tier at $9.99/month, which has text notifications integrated and great pre-build visualization options for different data types.

There are plenty of Initial State examples for streaming data for the regular raspberry pi models. Since you don’t have to worry about computing and storage so much, you can just download the ISStreamer package into your Python project and get going. Pico W is built differently: slightly limited compute and storage. So, we must make use of the micro python alternate libraries to the popular libraries we use more often. Here is a quick summary:

1. Ujson: Lightweight and fast JSON data formator for uPython.
2. Urequests: This is a uPython alternative to the popular Requests package. This provides user-friendly HTTP clients with clean objects. This is what sends the data to your Initial State Dashboard

Quick Guide

Start by connecting long wires from your Pico W to the DHT sensor. While the sensor will stay inside your fridge, your Pico W needs to stay outside the fridge. So, consider where you will place your Pico W and how far from a wall outlet if you are not using a power bank.

For connecting the DHT sensor, I picked nearby pins for convenience. See the diagram below:

Writing Code

I use Thonny for Raspberry PI(s). Here is a great getting-started guide.

We will create two files: One to hold our secret information and another for the actual program. The neat thing about Pico W is that if you create a main.py file, it automatically runs that on bootup.

Secret.py

This is where we will store our wifi name/password, the Initial State API keys, and bucket information. This is what my file looks like

Code for secret.py :

#initial State stuff
url = 'https://groker.init.st/api/events'
headers = {
  'Content-Type': 'application/json',
  'X-IS-AccessKey': 'ist_YourAccessKey',
  'X-IS-BucketKey': 'YOURBUCKETKEY',
  'Accept-Version': '~0'}


#Wifi Stuff
ssid = "yourWifinetworkName"
password = "yourWiFipassword"

To generate your Initial State API keys and bucket information, login to your account, and create a new bucket as below. Note down the API/endpoint (URL in secret.py), the access key, and bucket key to update your secret.py

Code for my main.py file

import network
import urequests as requests
import ujson
import secret as s
import machine
import time
from machine import Pin
import dht

#button = machine.Pin(18, machine.Pin.IN, machine.Pin.PULL_UP)


def connect_wifi(ssid, password):
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    try:
        if not wlan.isconnected():
            print('Connecting to WiFi...')
            wlan.connect(ssid, password)
            while not wlan.isconnected():
                pass
        print('Connected to WiFi with IP address', wlan.ifconfig()[0])
    except:
        print('Failed to connect to WiFi!')

connect_wifi(s.ssid, s.password)
time.sleep(5)

while True:
    sensor = dht.DHT11(Pin(28))
    try:
        sensor.measure()
        sensorTemp = sensor.temperature()
        sensorHumidity = sensor.humidity()
        print(f"Temperature : {sensorTemp:.1f}")
        print(f"Humidity    : {sensor.humidity():.1f}")
        values = [
            {
                "key": "Temperature",
                "value": sensorTemp
                
            },
            {
                "key": "Humidity",
                "value": sensorHumidity
                
            }
            
            ]
        response = requests.post(s.url, headers=s.headers, json=values)
        print(response.text)
        time.sleep(10)


    except Exception as e:
        print('Error occurred while executing new code!')
        print('Error details:', e)

This is what my Initial State Dashboard looks like

Streaming Data from Pico W to InitialState Dashboards was originally published in Initial State on Medium, where people are continuing the conversation by highlighting and responding to this story.

Bucket Watchdog is one of the codeless integrations offered in the Initial State Integration Marketplace. It has the ability to monitor the number of events your bucket has received during a designated time period. You can then set a trigger on the event counts reported and know immediately if a device has stopped sending data.

It may not seem as flashy as Weatherstack Weather or as cool as Cryptocurrency, but it has the potential to be the most powerful integration if used correctly. I am going to walk you through how to install the Bucket Watchdog Integration, how to configure it to monitor your bucket, and how to set trigger alerts so you know when data stops streaming.

Initial State is a data visualization software that can be used for real-time data monitoring and historical data evaluation. It offers a free tier for students with an active edu email address, an individual tier for hobbyists and prototypers for $9.99/month, and an enterprise tier for businesses starting at $20/month. Every account is given a 14-day free trial to test out all features and functions on the platform.

How to Navigate to the Bucket Watchdog Integration

The Bucket Watchdog integration can be found in the Integration Marketplace. When you are logged into the app you will see a section for the Integration Marketplace on your homepage. Click on the Bucket Watchdog integration to go directly to the integration. Or click view all integrations to navigate to the marketplace. There you can go to the Bucket Watchdog integration by clicking details on the Watchdog integration. Both these ways will take you to the Bucket Watchdog integration page.

How to Configure the Bucket Watchdog Integration

To start the process click Begin Setup. This will open the Integration Setup window on the right side of your screen. This is where you will configure your integration.

Let’s go through all the integration setup details and explain in detail what each option entails.

Give This Integration A Name — This is exactly what it sounds like. Choose any name for this integration. This is how you will identify it in your list of active integrations. For example, if this was going to be used for my home temperature bucket I would name it Bucket Watchdog Home Temperature.

Watched Bucket — Here you can choose which bucket you want the integration to monitor. The dropdown will contain a list of all your data buckets that are on your bucket shelf. You can only select one bucket.

Monitoring Period — This is how long you want the integration to look into the past to check for events. This field requires a little critical thinking on your part. You want to select a period based on how often your device sends data to your bucket.

Let’s say you have a bucket that gets temperature and humidity every 5 minutes. That means 2 events are received every 5 minutes. So if you set the Monitoring Period for 1 minute, it’s not long enough to see the events. If you set the Monitoring Period for 5 minutes, it should see 2 events. If you set the Monitoring Period for 10 minutes, it should see 4 events.

Another example is if you set your Monitoring Period for 15 minutes but your device only sends events once an hour. Three times out of four your integration would show that you have zero events in the last 15 minutes. That is not helpful in trying to determine if a device has stopped sending data.

Select a time frame that makes sense for your bucket based on how you are sending in events.

Choose a Bucket — You can send this Watchdog signal into any existing bucket, including the one you are monitoring, or you can create a new bucket solely for this integration.

There are pros and cons to both options. If you choose to send it to a new bucket, you can have your Watchdog integration by itself and that makes calculating your trigger easier. If you send it into an existing bucket, let’s say the one you are monitoring, then the event from the integration is included in the watchdog count. I’ll explain this further in the trigger section.

How Often Do You Want New Data? — You can choose to have this integration update every 15 minutes, every 30 minutes, every hour, or every day. The more frequent the update the more credits it requires.

This is a choice that should be based on how often you need the data, how many credits you have available, and how long your Monitoring Period is. If you need to know ASAP if a signal stops sending, 15 minutes is the best option. If you just need to know if a signal goes down, regardless of how soon it happens then go with 1 hour.

The integration will have an initial run when it is first started and then will run the frequency chosen at the top of the next hour. If you choose every 15 minutes and start the integration at 4:53 it will immediately run and then start running every 15 minutes beginning at 5:00.

Once you have made your selections, click Start Integration to complete the setup. You will receive a message letting you know the installation was successful and it will give you a link to direct you to the bucket where your integration is now streaming.

How to Set a Bucket Watchdog Integration Trigger

Your selections are made and your integration is now streaming into a bucket. To make full use out of this integration you need to set a trigger to alert you if you receive fewer events in your bucket than anticipated.

There are two sets of logic for this, which depend upon whether you sent the integration into an existing bucket or a new bucket. If you send the Bucket Watchdog to a new bucket, it will show you the number of events during your Monitoring period in the bucket you selected. If you send the Bucket Watchdog to an existing bucket, you will see the number of events during your monitoring period in the bucket plus the bucket watchdog signal itself, which counts as one event. TLDR, if you send to an existing bucket you need to account for the Bucket Watchdog signal adding one event to the count.

You should see the watchdog signal in your data bucket with an initial value. This value is how many events were counted during the Monitoring Period you set. This is the value you should expect to consistently see in your bucket. Typically, anything below this threshold means a device has stopped sending data. That is what we want to be alerted to.

In the bucket where your integration resides, go to the bucket settings. Click on the Triggers tab to create a Trigger. Click Create New Trigger to open the Trigger editor. Enter watchdog_event_count_[integration name] as the stream key, it should come up as an option when you click on the box. Choose your operator as less than. Enter the value as any number below your actual watchdog count. In Notices, you can enter any email or phone number where you want to receive the alert at.

Once you enter all this information the message template box will become visible. The box will be populated with “{{bucketKey}}: {{streamKey}} -> {{triggeredValue}}.” You can change this to anything you want. Put in a message to yourself that you will understand or that gives context to the alert you will receive. There is a dropdown at the top right of the message template box that says insert. These are variables you can add to your message that will update based on your bucket’s information. For example, if you insert [[bucket key]] in the message it will be replaced with your actual bucket key when the alert is sent.

When you are finished editing your Triggers settings click Create on the editor and click Done at the bottom. This will finalize your Trigger and you will receive alerts any time your threshold is met.

Troubleshooting

There are a few ways you could set this integration up that would cause some false alarms, which is the last thing you want when it’s an important signal you are monitoring.

Frequency and Monitoring Period Aren’t Aligned

Ensure your Monitoring Period makes sense with the frequency of events streamed to your bucket. If you set a Monitoring Period of 5 minutes, but your bucket only receives events once every hour then your integration will tell you that it sees 0 events most of the time except for the one time per hour when events are streamed. See the issue here? You’d constantly get an alert that no events happened.

Watchdog Signal Events Are Not Accounted For

If you send your Watchdog events to the same bucket you are monitoring, the watchdog events will also be counted in the number of events the bucket has received. You should adjust the threshold for your trigger to account for this.

Bucket Watchdog monitors your data streams for you so you never have to worry if things are still streaming smoothly.

This Initial State IoT Integration Lets You Know When Your Data Stops Streaming was originally published in Initial State on Medium, where people are continuing the conversation by highlighting and responding to this story.

Introduction

I wanted to create a simple, compact display driven by a Raspberry Pi Zero that plugs into a power outlet to display some useful information in my kitchen. No visible wires hanging out or anything that looks funky. I assumed someone already makes a Pi Zero case + power supply combo that I could just buy and plug in. Alas, I found no such convenient product on the interwebs (why?!?!?). Unwilling to accept defeat, I came up with a solution using off-the-shelf parts. This ended up being a fun little project from the hardware to the software. I am hoping I can save someone from the same frustrations I had by documenting this build.

In this project, we will:

• Build a compact Raspberry Pi Zero display that plugs into a power outlet using cheap, off-the-shelf components.
• Set up a Pi Zero to run a simple Python script on boot that retrieves information from a web API and cycles through that info on the display.

Parts and Materials

Here are the parts I used for my final build:

• Raspberry Pi Zero WH ($14, link).
• Adafruit 2.23" 128x32 OLED Bonnet ($22.50, link).
• 16 GB micro SD card ($6, link).
• Dodoli 12W USB wall charger ($10 for two, link).
• UCEC USB-A male to USB micro male adapter ($9 for two, link).
• Pi Zero case (optional).

The plan is to run the Pi Zero headless. I keep and reuse one wireless keyboard/mouse (link) and an HDMI cable with an HDMI mini adapter (link) attached to a TV to set up any Pi Zeros for the first time.

Assembly is simple. The OLED display plugs into the 40-pin GPIO header of the Pi Zero. The USB micro male adapter plugs into the USB power port of the Pi Zero and the USB charger provides the actual power. You will need to format the SD card and install the Raspberry Pi OS (a great tutorial on getting your Pi set up for the first time can be found here).

Don’t Do This!!

My first attempt at finding the parts to use for this project looked like the image above. I bought the wrong USB charger because I failed to take into account that USB-A plugs in only one way. That USB wall charger orients the display toward the wall. No bueno. Make sure the USB-A plug is oriented like the one in the previous section (link)!!

Alternative Setup

The Nekmit USB charger I bought first has both a USB-A port that is oriented in the wrong direction (useless!) and a USB-C port that can plug in either direction (useful!). Unfortunately, I could not find a USB-C male to USB micro male adapter. But, I did find a couple of adapters to connect together to make it work. This build is a bit more expensive but gets the job done:

• Raspberry Pi Zero WH ($14, link).
• Adafruit 2.23" 128x32 OLED Bonnet ($22.50, link).
• 16 GB micro SD card ($6, link).
• Nekmit 30W USB-C charger ($20, link).
• USB-C female to USB micro male adapter ($7 for five, link).
• USB-C male to USB-C male adapter ($10, link).

Display Something Useful — Detailed Example

With the hardware in place, it is time to set up the Pi Zero to display something useful. I recently installed a Pi Zero in my crawl space to monitor temperature and humidity (and wrote up the details of this project here). I am sending the sensor data from my crawl space to Initial State. Instead of viewing this data on the web dashboard, I want it to be displayed on my Pi Zero display in my kitchen along with sensor data from my attic and outside weather information. Since my Pi Zero is headless, I also want to display the IP address in case I need to SSH into it again.

Once Raspberry Pi OS is installed (instructions) and you have set up WiFi (instructions), you will need to enable both SSH (for remote access) and i2c (for the OLED display). At the Pi terminal type:

sudo raspi-config

Select 5 Interfacing Options, P5 I2C, and select <YES> to enable i2c.

Select 5 Interfacing Options, P2 SSH, and select <YES> to enable SSH. Select <Finish> to save and exit.

Next, install the Python library to allow interfacing the Adafruit OLED Bonnet:

sudo pip3 install adafruit-circuitpython-ssd1305

Since I am going to read data from my Initial State account in this example, I want to install the Initial State Read API Python module to make writing my Python script easier:

sudo pip install ISReader

The following Python script rotates through displaying four screens of data — my crawl space temperature/humidity, my attic temperature/humidity, outside temperature/humidity, and the Pi Zero IP address. To use this script as it is, modify the User Settings section with your Initial State access key (more info), bucket key (more info), and stream names to be read.

The Python code above is easy-to-follow and can serve as a template to displaying whatever information you need. For example, you can use it to display information from other web APIs or just other data from Initial State (e.g. stock data, detailed weather data, Chuck Norris jokes).

Remotely Accessing Your Pi

• If you want to test out remotely configuring your Pi, at the Pi terminal type:

hostname -I

This will return the IP address of your Pi. At your laptop terminal, type:

ssh pi@<insert Pi ip address>

For example:

Once you can successfully SSH into your Pi, you may want to make it boot directly to the console instead of loading the desktop UI. You can do this as follows:sudo raspi-config -> 3 Boot Options-> B1 Desktop / CLI-> B2 Console Autologin-> <ok>-> exit.

Running on Boot

The final piece of the puzzle is to have the Pi Zero run this script on boot. This will allow you to plug your Pi Zero into a power outlet and it start displaying data without any other manual steps. At the Pi terminal:

crontab -e

At the bottom of the text file, add the following line of text (modify the path and script name to your specific path/script name), save, and exit:

@reboot python3 /home/pi/runoled.py &

Notice the 30 second delay on line 46 of the example script. This allows the Pi to establish a WiFi connection before it attempts to hit a web API.

Conclusion

Being able to plug a Pi Zero with an OLED display into a wall outlet and it actually look good is oddly satisfying. I really like the fact that I can reuse this project to display whatever information I want in the future. This project can be particularly useful in a media closet, server room, or in a lab setting.

How to Build a Plug-In Pi Zero Display and Show Something Useful was originally published in Initial State on Medium, where people are continuing the conversation by highlighting and responding to this story.

Every good plant mom (or dad) knows there are two important things to keep your indoor plants alive: light and water. The balance of getting the right amount of these two things is like walking a tight rope. As the type of millennial who accidentally kills succulents on the regular, I needed to find a way to keep my plants alive.

I like to add technology to all aspects of my life, so I thought how can I monitor my plants so I stop killing them? I’ve written tutorials about monitoring temperature before so why not try light and moisture. After a quick Adafruit search, the sensors I needed were in the mail. The next thing I had to do was get more information about how to take care of the plants I own.

Each plant requires different amounts of light and water. You can easily find information about how much light is required for your specific plant online. Indoor plants can range from low light to bright light. My house only gets low to medium light at best. It’s important to know what lighting your home has and to pick plants that will fit your lighting situation.

You now should know your plant and know how much sun it needs. How can you determine whether it is getting enough light? If your plant’s leaves are dark, have bleached patches, or are dried out, your plant may be getting too much sun. You need to move it to a shadier location. If your plant has small pale leaves or weak stems, it may be getting too little sun. You’ll need to move it to a sunnier location. Seems simple enough.

Now on to water. If your plant’s leaves are yellow and softening, you may be watering it too much. In this case, you should water it less. If your plant has brown, crispy leaves or the leaves falling off, your plant is too dry. The good rule of thumb I’ve been told is to check the soil with your finger. If the soil is wet or damp, you don’t need to water it. If the soil is dry it needs to be watered. The amount of water you need varies for each plant. The soil type shouldn’t matter that much.

This all seems very simple, yet somehow my plants keep dying. This project has fixed that! I found a way to measure soil moisture and ambient light. I’ll detail how I put this project together, how I remotely monitor my plants, and how this simple solution gave me a green thumb.

What You’ll Need

This is a list of what I used for this project:

• (2) Raspberry Pi Zero WH ($14 each) with power chargers ($7.50 each)
• (2) SD Card with NOOBS ($14.95 each)
• Adafruit STEMMA Soil Sensor — I2C Capacitive Moisture Sensor ($7.50)
• Adafruit BH1750 Ambient Light SensorLight sensor, soil moisture sensor ($4.50)
• STEMMA QT / Qwiic JST SH 4-pin Cable with Female Sockets ($0.95)
• JST PH 4-Pin to Female Socket Cable — I2C STEMMA Cable ($1.50)
• Initial State — or any data visualization platform ($9.99/mo)

For this design, I am using Raspberry Pi Zero WH, because they are inexpensive and the header is pre-soldered. A Raspberry Pi 3 or 4 could be used, it would just be overkill. The only issue with the Raspberry Pi Zero WH is it can sometimes be hard to find and there is usually a purchasing limit of 1 per order due to manufacturing limitations.

This design doesn’t make sense to replicate for all my indoor plants. That would be too costly and repetitive. The plan would be to monitor a single plant for 1–2 months until I got the right balance of sun and light and then move the setup to the next plant.

You’ll want a keyboard and monitor to be able to easily get your Pi’s up and running. I have some that I use to get every Pi I buy started. Some of my Pi’s are actually connected to monitors always and others I just connect to set them up and reuse the keyboard and monitors when needed.

I used a Raspberry Pi 3 as one of the Pi’s because I have one constantly connected to a monitor. This lets me put my dashboard on the monitor for a constant view of my data. This setup is a little over the top for what we are doing, but I really love the dashboard view on the Pi monitor.

Hardware

You’ll need to connect your Raspberry Pi’s to their respective sensors. This is easily done if you purchased the two cables in the material list or using female to female jumper wires.

To connect your Pi to the soil sensor, you’ll need to connect the following pins:

• Pi GND to sensor GND (black wire)
• Pi 3V3 to sensor VIN (red wire)
• Pi SDA to sensor SDA (white wire)
• Pi SCL to sensor SCL (green wire)

To connect your Pi to the light sensor, you need to connect the following:

• Pi GND to sensor GND (black wire)
• Pi 3V to sensor VCC (red wire)
• Pi SDA to sensor SDA (blue wire)
• Pi SCL to sensor SCL (yellow wire)

The connections will be slightly different for the BH1750 if you are using jumper wires and a soldered header versus the female socket cable pictured above. If you are using this alternative setup, your connection is as follows:

• Pi 3V to sensor VCC (red wire)
• Pi GND to sensor GND (black wire)
• Pi SCL to sensor SCL (yellow wire)
• Pi SDA to sensor SDA (blue wire)

My preference is to always use cables vs having to solder a header. Soldering the header onto these small devices can be hard if you aren’t well-practiced with soldering. They say practice makes perfect so maybe give it a try.

Test Your Sensors

For this project, I am using Python 3. You’ll need to have that downloaded and set as your default Python version on your Raspberry Pi. I followed these instructions to install Python 3 on my Pi’s and it went really well (just took a while to download it all).

Both sensors require I2C to be enabled on your Pi’s. You can do this one of two ways. One way is to go to your Raspberry Pi Configuration on your monitor, enable I2C, and reboot your Pi.

The other way is to type this into the command prompt:

sudo raspi-config

Select 5 Interfacing Options, P5 I2C, and select <YES> to enable i2c. Select <Finish> to save and exit. You can test out the connection to the sensor. On your Pi type the following in the command prompt:

sudo i2cdetect -y 1

You should see something like the following:

The sensor is detected on a Pi at address 0x76. This should show your sensor at address 0x76 (possibly address 0x77). If you don’t see either, check your wiring, make sure i2c is enabled in raspi-config, and reboot.

*You may need to install pip if your Python version does not have it preinstalled.

sudo apt install python-pip

Next, you’ll need to add three Adafruit libraries & the Initial State Streamer Module to get the sensors working and stream our data. The first is the Blinka library. This provides CircuitPython support in Python.

$ pip3 install adafruit-blinka

The second is the library for the soil sensor

$ sudo pip3 install adafruit-circuitpython-seesaw

The third is the library for the light sensor

$ sudo pip3 install adafruit-circuitpython-bh1750

The last one is the Initial State Streamer Module

$ sudo pip3 install ISStreamer

Once those are installed we can test each sensor accordingly.

To test the soil sensor, created a python script called soil_simpletest.py. Copy and paste the code below (from Adafruit’s tutorial) into the script, save, and exit the text editor.

To run the script type:

$ python3 soil_simpletest.py

You will see soil moisture (amount of water in the soil) values and temperature values if it is connected properly.

On your other Pi, you can test the BH1750 sensor. Create a script called bh1750_simpletest.py. Copy and paste the code below (from Adafruit’s BH1750 tutorial) into the script, save, and exit the text editor.

To run the test script type:

$ python3 bh1750_simpletest.py

You will see lux values if the sensor is connected properly.

Initial State

We have data but now we want to monitor that data. I think Initial State is a great solution for that, but you can choose to use any data visualization platform. This tutorial will show you how to use Initial State but you can modify the code to send data to any platform of your choosing.

Initial State is a data visualization software that can be used for real-time data monitoring and historical data evaluation. It offers a free tier for students with an active Edu email address, an individual tier for hobbyists and prototypers for $9.99/month, and an enterprise tier for businesses starting at $20/month. Every account is given a 14-day free trial to test out all features and functions on the platform.

Once you register for an account, you can go to your settings and view your access keys. An access key allows you to send data into your account. You’ll use your access key in the Python script later in the article.

Stream Data with Python

You’ve connected your hardware, tested your sensors, and chosen your data platform. Now we can stream data from your Pi’s and sensors to Initial State and create dashboards from that data.

For your Pi connected to the soil sensor, you will use the code below. Create a python script called is_soil.py and copy and paste the code below. You’ll need to make a few changes that I have detailed below before it is ready to be run.

For the Pi connected to the light sensor, you will use the code below. Create a python script called is_ambientlight.py and copy and paste the code below. You’ll need to make a few changes that I have detailed below before it is ready to be run.

In both code scripts, you can modify the lines in the User Settings area.

• SENSOR_LOCATION_NAME — This helps you identify which sensor you are streaming data from.
• BUCKET_NAME — This names your bucket and should be the same for both scripts.
• BUCKET_KEY — This is an identifier telling Initial State what data bucket you want to send data to. This should be the same for both scripts.
• ACCESS_KEY — You can find your Initial State access key by going to the settings page on your account. This should be the same for both scripts.
• MINUTES_BETWEEN_READS — This is how long you want to script to wait until it reads from the sensor again.

By making your access key and bucket key the same for each script, you will be streaming both sensors’ data in the same bucket.

To run the soil sensor code type:

$ python3 is_soil.py

To run the ambient light sensor code type:

$ python3 is_ambientlight.py

IP Address

I will always recommend sending the IP address of your Pi to your dashboard. This makes life easier so that if something goes awry, you can easily SSH into your Pi and get it resolved. No additional hardware is required, just another Python script to run in the background. You can stream the IP address to the same bucket as your plant data.

Auto-Run on Reboot

This is an important step in the process. If you set your Pi sensor code to run on reboot then if you lose power and it comes back, your code will start to automatically run when the Pi restarts. This can save you some time and heartache. Trust me.

In the Pi terminal type:

crontab -e

If this is the first time you have run crontab, it may ask you which text editor you want to use (I selected nano). Add the following line to the bottom of the crontab text file then save and exit:

@reboot nohup python3 /home/pi/plantmonitor/is_soil.py &

or:

@reboot nohup python3 /home/pi/plantmonitor/is_ambient.py &

You will need to specify the exact path of your script. Mine is kept in a folder called “plantmonitor.”

The nohup command is important. This stands for “no hangup” and allows you to create a process that runs in the background without stopping, even if your terminal window is closed. If you run your script from an SSH prompt without the nohup command, the script will exit as soon as your SSH connection is broken.

Plant Dashboard

You’ve got everything connected and your code is running, now it’s time to play with the data!

Soil Moisture Values

The soil sensor uses a capacitive touch measurement system to determine soil moisture. The soil moisture level can range from 200 (very dry) to 2000 (very wet). You can set the min and max on your gauge tile to these values.

Temperature Values

The soil sensor also has an internal temperature sensor that gives you ambient temperature readings. It is not highly accurate but can give you readings with +/- 2 degrees accuracy. It is a nice addition to be able to add this data to your dashboard.

Ambient Light (Lux) Values

The ambient light sensor measurements are in units of Lux (the SI unit of measurement for light. The sensor can measure from 0.0001 lux (moonless, overcast night) to 65,000 lux (direct sunlight). Plants that need low light can survive on the lower level of this range and plants that need direct light need the upper level.

Tiles

You have three data streams in your dashboard: temperature, ambient light, and moisture. I made three rows for each of the signals and made a pattern: summary tile, gauge tile, and line graph. For temperature I use the thermometer gauge tile, for moisture I use the liquid level gauge tile, and for ambient light, I use the arc gauge tile.

I specifically designed this dashboard to fit well on my Raspberry Pi monitor. I created duplicated views for my desktop and mobile with a different arrangement of tiles and additional tiles included.

Background Image

Initial State allows you to choose a background image from Unsplash, specify a background color, or upload a custom background image. This gives you limitless possibilities for dashboard creation. I searched for an indoor plant and choose an Unsplash image for mine.

Mobile

Another good view to create for your dashboards is a mobile view. It’s easy to duplicate your dashboard and create a specific design that looks good on your phone and shows you all the necessary information in one small window.

All you need to do is stack your three signals in tiles in a column and set the tiles to the gauge types you want. This will make it so when you open your phone to view the dashboard you will have a compact view like the one you see here.

Weatherstack Weather

Not only can you have light, temperature, and plant moisture data in your dashboard, you can also stream in local weather data through the Weatherstack Integration in the Initial State Integration Marketplace. All you have to do is set up the integration with your zip code or coordinates and you can stream temperature, cloud cover, and current forecast. All these things will affect how much ambient light your plant is getting.

Bucket Watchdog

If you have your Pi processes set up to run on reboot, you are good to go if your Pi restarts. But what happens if your Pi has an issue and shuts off completely? You’ll want to know if your dashboard stops receiving data so you can get it fixed quickly. The Bucket Watchdog Integration in the Initial State Integration Marketplace can monitor the signals sent to your bucket and alert you if it receives fewer signals than anticipated.

This project is slowly helping me with my plant mom skills. My goal is to kill slightly fewer plants this year now that I can monitor how much light and water they are getting. I encourage you to give this project a try and let me know how it goes!

How to Use a Soil Moisture Sensor to Keep Your Plants Alive was originally published in Initial State on Medium, where people are continuing the conversation by highlighting and responding to this story.

Breast Milk — or liquid gold as many moms attest — can be extremely difficult to generate and keep in order to create a consistent supply for your little one.

One afternoon, my wife called me in tears. She noticed that the chest freezer in our pantry suddenly quit working. Months worth of breast milk was ruined. She was understandably depressed. So much so, that I never mentioned that I lost a few important things too — three racks of ribs, a pork butt, and a whole box of mozzarella sticks.

Losing breast milk really sucks, but there are lots of stories about refrigerators and freezers malfunctioning with devastating consequences. In March of 2018, two fertility clinics lost frozen embryos within days of each other — first in Ohio, and then in San Francisco.

This tutorial will tell you exactly how to build a smart freezer thermometer that SMS/Texts and emails if it has a problem. You can make this fully-monitored reliable solution for temperature and humidity in a freezer or refrigerator at a cost of around 30 dollars. The system also monitors the temperature sensor acquisition device in case it malfunctions. With this double-redundancy, you can be confident that if temperatures start to deviate or the device stops working, you will be notified in plenty of time to make arrangements.

Can’t I just throw a wireless SmartThings sensor in the freezer? Unfortunately, No — alkaline batteries and lithium batteries do not work when frozen.

Refrigerators and Freezers

The only real difference between a working refrigerator and a freezer is temperature range. However, when they malfunction or a power outage occurs the timeframes for keeping food at a safe temperature varies widely, and it depends on what’s inside. Food is one thing, but what about certain medicines, vaccines, embryos, criminal DNA evidence, or even those cryogenic head-freezing services.

Did you know? A full freezer runs more efficiently and last longer in a power outage, because there’s less space for warm air to intrude when the door opens. Also, there is more frozen material to keep the space cooler longer.

• Refrigerator |Operating Temperature: 36°F to 40°F | Spoilage: 4 Hours
• Freezer | Temperature: -2°F to 0°F | Spoilage: up to 48 hours

note: Spoilage times vary widely if you open the door. Keep it closed if you can help it.

Materials Needed

• Raspberry Pi Zero W — $10 Raspberry Pi, great for headless applications, because it’s small, cheap, and has integrated Wifi.
• MicroSD card — 16GB is enough for the operating system and code.
• BME280 — Integrated temperature and humidity sensor. You can find these for very cheap, but you’ll want it already integrated onto a breakout board, and it needs to expose the I2C lines for this tutorial code to work.
• Hammond Miniature ABS Enclosure — Model: 1551QGY — used to enclose and mount the sensor inside the freezer.
• Flat Flex Cable — TE Connectivity Part: A9AAT-0808F — This is crucial, we need an extremely flat cable to bridge the seal of the freezer without causing an air leak. In addition, the linked cable already has solder tabs at the proper spacing for standard through-holes on the Pi and the BME280 protoboard.

Hardware Setup

We are just going to wire the sensor directly to the Raspberry Pi — No extra components required.

1. Modify the cable — The protoboard for the BME280 has 7 solder points, but the cable has 8 connectors. I used a utility knife to carefully strip off one conductor.
2. Solder to the sensor board — this is where choosing the right flat flex cable comes in handy. The solder tabs already line up with the holes.
3. Modify enclosure — I needed to Dremel away the lip of the mounting ridge for the cable to friction fit and exit the enclosure.
4. Mark your signals — before closing the clamshell enclosure, it is a good idea to mark the signals on other end of the cable with a sharpie. We’ll need to locate the two wires for I²C : Clock — SCL and Data — SDA. Also locate your power pins and ground.

1. Cut Flat Flex into “flying leads” — Slice each of the flat flex conductors you need into individual wires so they are flexible enough to go through the proper connection points.
2. Solder — I soldered the leads right to the board, but there are lots of way to interface between the Raspberry Pi I/O and your flat flex leads.
3. Install — The flat flex goes between the freezer seal and the edge of the freezer. Sensor on the inside — Pi on the out side. Use double sided Velcro or suction cups so that you can easily take the sensor in and out.

troubleshooting notes: (1) If you use the BME280 from Adafruit, you should solder in a jumper from CS to VIN to increase I²C reliability. (2) I connected VIN to the 5V pin on the Pi. This is not always the case because some BME280 breakout boards use the 3.3V.

Software: Raspberry Pi Setup

Our goal is to bring up the Raspberry Pi Zero W with a fresh operating system, and enable I2C.

1. Get Raspbian Lite onto your MicroSD card using and SD card reader for your computer. Once you can access the SD card from a computer, use the imagers available from raspberry Pi to get a fresh image installed.

2. Enable SSH — After the imager finishes you should see a root directly on the SD card named boot . Simply create an empty file called ssh to enable ssh. Yeah that’s it for that.

3. Setup Wifi — create a simple text file and call it wpa_supplicant.conf. Edit the file with your own wifi credentials like this:

country=us
update_config=1
ctrl_interface=/var/run/wpa_supplicant

network={
 scan_ssid=1
 ssid="MyNetworkSSID"
 psk="MyPa55w0rd"
}

4. Move your SD card from your PC to the socket on your raspberry pi and apply power. You need to wait about 30 seconds or so until your device connects to wifi.

Software: Get an SSH Terminal

In order to log in to your device, you’ll need to SSH in. First though, you need to find your Raspberry Pi IP address on your local network. There are a couple of ways of doing that from your computer:

1. A fresh raspberryPi image will have a hostname of raspberrypi . Try searching for that in your router device list.
2. Open the terminal on your computer and try pinging it. ping raspberrypi.local
3. If those don’t work take a deeper dive at the IP Address page on raspberrypi.org

Once you get your IP Address use SSH in the terminal to log in to your device. pi is a default username and the default password is raspberrypi

ssh pi@192.168.86.30

Software: I²C Setup

I²C is not on by default and the fresh install of Raspbian Lite does not have all the drivers.

1. Enable I²C in the OS by opening the configuration menu:

sudo raspi-config

Select 5 Interfacing Options, P5 I2C, and select <YES> to enable i2c. Select <Finish> to save and exit.

2. Install smbus and i2c-tools

sudo apt-get install -y python-smbus i2c-tools

3. Verify installation using this command. If you see something like the output below, you are good.

lsmod | grep i2c_

4. This is the moment of truth! Test your connection to the I²C bus of the BME280 sensor. You should see an address at 0x76 or 0x77 like below. Take note of the address, we’ll need it later.

sudo i2cdetect -y 1

Software: Install Python Libraries

1. First let’s get pip to make everything easier. pip comes pre-installed on Raspbian full but not Raspbian lite.

sudo apt install python3-pip

2. Install the BME280 pre-made raspberry pi driver, which gives us quick access to the sensor readings in our code.

sudo pip3 install RPi.bme280

3. Install the Initial State streamer library which creates a simple data stream connection to Initial State for monitoring, alarming, and the dashboard.

sudo pip3 install ISStreamer

Software: Python Code

Now we are finally ready to drop some code. To start a new program on the Pi, use nano and copy/paste the code below:

nano freezer_monitor.py

• The User Settings area is for you to fill in your desired names and sampling. It is a good idea to use 10 minutes as a preset minimum for this use-case.
• You will need an access Key from Initial State. Register for a free trial, with no credit card required. The account access key has to be specified on line 10. Copy/paste this key from your Initial State account settings. (more info).
• You’ll also need to fill in the I²C Address we found after setting up and testing the bus. Edit line 16. Mine was 0x77, yours may be something else. I’ve seen 0x76 on other BME280 sensor setups.
• WHILE TESTING: Uncomment lines 36–37 and Comment line 40. I added some code in the bottom to test your implementation more efficiently. It reduces the sleep time so you see faster sensor reads and prints them to console.

• FINAL PRODUCT: Comment lines 36–37 and uncomment line 40.

python3 freezer_monitor.py

Build a Web Dashboard

Go to your Initial State account (https://iot.app.initialstate.com), click on the “❄ Pantry Freezer” bucket name on your bucket shelf, and view the data coming into your dashboard. It’s live now, so go nuts… customize your dashboard by adding and sizing line graphs, gauges, statistics, images etc. (more info). Use expressions to round decimals and convert to degrees Fahrenheit if you like. Make it easy to read

Wanna see a public dashboard of my actual fridge? https://go.init.st/clht3qr

Brass Tacks: Alert me when temperature goes wrong

Monitoring on a dashboard is one thing, but the real value comes when we turn this into a smart thermometer alarm. We need to set an alert when the temperature drifts too high. SMS/Text and email coupled with a smart phone essentially deliver audible and visual alarms. This is done via triggers in Initial State. With a hosted IoT platform, the system can watch temperatures 24/7 and send you an email and a text when things go wrong.

Make it Reliable: Run on Startup and/or Reboot

To make our setup more robust, we need to kick off our Python script every time our Pi boots. This way the temperature monitor will restart without any intervention when we have a power outage.

Adding a process that runs on boot is really easy. At the Pi terminal:

crontab -e

It might ask which text editor you want to use (e.g. nano). Add one line to the bottom of the crontab file save and exit:

@reboot nohup python3 /home/pi/freezer_monitor/freezer_monitor.py &

You will need to specify the exact path of your script. In the example above, I created a directory called freezer_monitor and the script is called freezer_monitor.py.

Now your code will run headless any time your Pi reboots.

Make it Reliable: The Watchdog

Anything can happen, so you need a foolproof way of “monitoring the monitor.” We could do more process monitoring on the Pi itself, but the broadest way to make sure everything is running is to make sure the “heartbeat” of data is continuing to come at regular intervals from the device. If the device breaks, looses power, looses internet, or stops working, the Initial State Watchdog trigger can alert you in a timely fashion. Access the Watchdog Trigger in the Initial State Integration Marketplace.

The bucket watchdog counts incoming data points in the specified time interval. In the image above, I set the watchdog to watch my “Pantry Freezer” Bucket and return the count every 15 minutes. Since the code sends something every 10 minutes, we expect the number in the last 15 minutes to always be > 1. This logic becomes the trigger you make in your dashboard that ultimately sends you a text and/or email.

Note: The reason you set it to 1 and not 0 is because the watchdog itself sends one data point. If the devices stops sending, then that count will go down to one.

Conclusion

Monitoring refrigerators and freezers should be more common than it is. Shouldn’t my freezer just do this out of the box? Shouldn’t commercial units? Well until that day, use this tutorial to create a cheap redundant system for critical assets in just a few hours.

Ahhh… Although our family is through the breastfeeding phase, I can finally sleep at night knowing my two prime briskets from my last Costco run are safe and sound (and frozen)! My freezer alarm’s got me covered.

How to Build a Raspberry Pi Refrigerator/Freezer Monitor was originally published in Initial State on Medium, where people are continuing the conversation by highlighting and responding to this story.

With the rise of the Internet of Things (IoT) came the rise of affordable sensors — the most popular being remote temperature sensors. Temperature has a wide range of uses, from energy savings and comfort to safety and refrigeration.

You put temperature sensors in every building you’re in charge of, you’ve got an app to see the current temperature, but what about temperature trends over a long period of time? What if one of your wireless sensors goes offline without you knowing? That’s where Initial State’s new Bucket Watchdog service comes in.

Background Info: Initial State

Initial State is an Internet of Things platform for data visualizations. You can stream real-time data into your Initial State account and build dashboards and custom trigger alerts from your data. The user friendly platform also allows you to view historical data.

Background Info: Bucket Watchdog Integration

The Initial State Bucket Watchdog Integration remotely monitors your data bucket to ensure it’s continuously receiving data. Setting it up is as easy as a few button clicks, and you can set trigger alerts to let you know when a sensor has stopped streaming.

Case Study: Warehouse Sensors

Imagine you have a set of warehouses in multiple locations that you’ve outfitted with the latest wireless sensors to monitor temperature. Not only is it important that each warehouse stays within a certain temperature range, but you need to know if any sensors go offline. Disconnected sensors could mean anything from a poor internet connection to a power outage, which could be disastrous for your warehouse contents.

Step 1: Connect your sensors to Initial State

If you haven’t set up your sensor network yet, there are a variety of ways for you to get started. We have a large library of tutorials that detail how to create a sensor network with ESP32, Raspberry Pi, SmartThings, IFTTT, an Initial State SDK and our API. Once you have an Initial State account, it’s easy. You can see from the video below just how simple it is to create remote temperature monitoring systems with Initial State.

Below, you can see my dashboard of readings from my temperature monitoring system in four different warehouses.

Step 2: Add the Watchdog integration to your dashboard

Once you’ve got your Initial State dashboard up and running, you can add the Bucket Watchdog integration to make sure your sensors are still streaming. To do this, click the link on your Initial State home page to go to the Integration Marketplace.

Click “Details” under the “Bucket Watchdog” integration. You’ll have to authorize Initial State to access your data, then click “Begin Setup” to go to the setup window.

In the setup window enter the name of the integration. I named mine “Warehouse Bucket Watchdog”. Choose the bucket to monitor from the dropdown — my bucket is “Warehouse Monitor”. The monitoring period is how many minutes you’re expecting events. My sensors are reporting every 15 minutes, so I chose the 15 minute interval. If you don’t need to check that frequently, you can choose every 30 minutes, every hour, or daily.

Once you make all your selections, click “Start Integration”. You should see your new bucket appear on the bucket shelf.

This is what my Bucket Watchdog bucket looks like:

I have four different sensors, each sending only one temperature value every 15 minutes. The Watchdog sees that four new values have been added to my dashboard in the past 15 minutes. If I had a longer check interval (like an hour), the Watchdog would see more than four events. For an hourly check, there should be sixteen events.

The Watchdog integration is very useful for noticing a problem quickly. With lots of data in your dashboard, especially a lot of temperature readings at or around the same value, it can be difficult to spot a dead sensor. In the image below, Warehouse 2’s sensor has been dead for 30 minutes, but you can hardly tell.

The Watchdog dashboard makes it extremely obvious:

And the best part? You don’t even need to look at the dashboard for it to tell you something has wrong when you add Triggers.

Step 3: Add Triggers to your Watchdog stream

Triggers are Initial State’s built-in email or text alert system. They give you the ability to set an action that will occur on a specified condition for your data stream.

To set a trigger, simply click on “Settings” underneath your Watchdog bucket and select the “Triggers” tab. Click “Create New Trigger” to set up your trigger conditions and add a verified phone number or email address.

In my warehouse example, I want to know if my stream events ever drop below four in a fifteen minute period, so I set up the trigger on the right.

Now I get a text message any time my streams fall below four!

Conclusion

Remote temperature sensors are only useful if you can keep an eye on them remotely. From temperature to humidity readings, from warehouses to smart homes, wireless sensors are becoming more important to everyday business.

There are an infinite number of ways to maximize your data using Initial State and the Bucket Watchdog, from adding weather station data to your dashboard, to adding an icon to your iOS home screen for a mobile app like experience, and so much more. Keep an eye on your investments with real-time alerts and historical records of outages and time to get back online.

There is never a better time than now to get started with Initial State!

Logging and Supervising Your Remote Temperature Monitor was originally published in Initial State on Medium, where people are continuing the conversation by highlighting and responding to this story.

It’s summer time and for some of us that means sunshine, outdoors, and water. If you are lucky enough to live near an ocean or lake and you are a boat owner, that can also mean that it’s boat time.

During the summer months it is much easier to monitor your boat because you are always on it. What happens when summer ends and you need a way to make sure things are sitting smoothly while you are away? Some boat monitoring systems can run you thousands of dollars and be a pain to install. What if there was a way to spend less and still be able to monitor your boat in real-time and get alerts when things go awry?

This is a DIY solution using a Raspberry Pi, some electronics, and Initial State to monitor your boat, so you can have all the data when you are on it and when it’s in the slip. You can monitor temperature, battery voltages, shore power, and bilge pump cycles. This remote monitoring solution allows you to monitor your boat from anywhere in the world. It will give you a peace of mind knowing your boat is safe and secure.

There are a lot of reasons why you would want to know what is going on with your boat in the slip. For example, let’s examine bilge pump cycles. As the name suggests, bilge pumps pump water. They push water out of the bilge (lowest point on the inside of the boat) so that your boat doesn’t sink. Water can get into your bilge a multitude of ways: spray while driving the boat, rain and storms, missing plug. Today most bilge pumps are automatic but what happens if one fails? Being able to monitor how often your bilge pump is cycling can give you assurance yours is still in working condition and is pushing the bilge water out.

Let’s next look at shore power. Shore power is what you use for power when you have your boat docked and not running. This not only charges your battery but also lets you run AC powered devices on your boat. Constant shore power during the winter months is necessary to keep your batteries charged and Pi running. And if the power is out, who knows what else might be wrong. You can’t monitor your boat if you Pi is dead.

Lastly, battery voltages and temperature are a no brainer. Is the temperature too hot or too cold? Is that going to affect your boat and the devices on it? Are your batteries dead and need to be replaced? This kind of general information is important to have a clear picture of the health of your boat.

This project was implemented by the very smart and very creative John Poindexter. John was gracious enough to let me share this project with the world so please enjoy.

Basics of What You’ll Need

First things first, you’ll need a boat. The boat used in this project was a 1990 Hunter Passage 42 sailboat. While this project is tailored to this boat, you can modify what is documented to fit your boat.

Raspberry Pi 3 & SD Card to collect and send data.

Initial State to log data, view real-time conditions, and send alerts.

RadioShack General Purpose Prototyping Board.

KiCad for interface board layout or PCB design.

Netgear AirCard 815S mobile hotspot for internet connectivity.

A few miscellaneous electronic accessories for your interface between the boat inputs and the Raspberry Pi.

*Note: This project is not for the faint of heart. This is one for those who like a challenge and enjoy building their own systems. When it’s all said and done, you’ll feel good knowing you built it yourself.

The Details

Raspberry Pi

I recommend using a Raspberry Pi 3 or Raspberry Pi 4. It can connect to WiFi and send your data to a real-time monitoring solution. If your Pi isn’t already set up, you can follow the instructions on Raspberry Pi’s blog to get started.

Raspberry Pi keyboard & monitor

While not absolutely necessary to this project, a Raspberry Pi keyboard and monitor make it a lot easier to work with your Pi and get things done. The Sunfounder monitor and Logitech Wireless Touch Keyboard K400 were both used in the making of this project.

For the keyboard to be compatible with the latest version of Raspbian, you’ll need to install Solaar. Solaar is a Python version of the Logitech Unifying software.

Run the following in the terminal window of your Raspberry Pi:

sudo apt-get install solaar

After installation, you can find the Solaar app under the Accessories of the Pi as well as on the top menu bar. In addition to providing a pairing function it also shows the state of the battery.

There are lots of options for Raspberry Pi monitors and keyboards. Any one you choose will be good and make working with your Pi easier.

Mobile Hotspot

This mobile hotspot is used since marina WiFi can be unreliable for continuous connectivity. Really any mobile hotspot will do, you just need something that allows you to be continuously connected to WiFi. Follow the directions for the device you buy to set it up.

You’ll want to connect your Pi to the WiFi (whether marina or hotspot). Your hotspot will have 3 passwords: WiFi password, guest password, and admin login password. You can use the WiFi password to connect your Pi.

Your hotspot does have a battery but to keep it continuously running you’ll want to leave it plugged in. This is also why shore power is so important. Without power your Pi and hotspot both die, which will require an in person visit to resolve.

Initial State

Initial State is a data visualization software that can be used for real-time data monitoring and historical data evaluation. While this is the data visualization platform that is used for this project, you can use any platform that allows you to send in data via an API.

Initial State offers a free tier for students with an active edu email address, an individual tier for hobbyists and prototypers for $9.99/month, and an enterprise tier for businesses starting at $20/month. Every account is given a 14-day free trial to test out all features and functions on the platform.

Once you register for an account, you can go to your settings and view your access keys. An access key allows you to send data into your account. You’ll use your access key in the Python script later in the article.

SSH’ing & IP Address

One of the issues that occurred while doing this project was that the Raspberry Pi IP address wasn’t static and changed frequently. This makes it difficult to remotely SSH into your Pi when you don’t know the IP address. There is an easy solution for this.

The Pi Process tutorial shows you how to monitor your Pi’s processes and it’s IP address. You can send the IP address of your Pi to your Initial State dashboard. Knowing your Pi’s IP address makes it easy for you to remotely SHH into your Pi to access it.

Interface Board

You‘ll need to find a copy of your boat’s schematics. You can generally find this in your user manual or online. This will help you to understand the boat’s inputs. The interface board will be a connection between the boat’s inputs and the Raspberry Pi. You can use KiCad to design the layout for the connections.

Project Layout

This diagram shows the entire project layout including the Raspberry Pi, boat inputs, and interface board.

This is a list of the boat inputs and what was needed for connection to the Raspberry Pi.

Bilge Pump Cycles — PTV12010WAH 12V to 5V Power, R40–11D2–12 Counter Relay

Shower Power — 3.3V Bus, Ground Bus, BTA6–2C-J-CW-120 120VAC Relay

Battery1 & Battery 2 V — Voltage Divider, MCP3008 8 Channel ADC

Temperature — 12 VDC Fan, DS18B20 Temperature Sensor

Raspberry Pi — Ribbon Cable

General Purpose Board or PCB

Now that you have your design, you’ll need to layout your interface board. You have two options for this: you can use a general purpose board with wired connections (RadioShack Universal Board) or design a printed circuit board (KiCad). A general purpose board might be easier to start with as you can easily change things around, but a PCB tends to be neater when it comes to wiring and layout.

Rather than soldering the devices directly to the board, you can use sockets and headers to make replacing devices in the future easier.

Finished Hardware

You can connect your Raspberry Pi and your boat inputs to the interface board. You should check and recheck your wiring because it would be very easy to blow your Raspberry Pi with an incorrect connection. Thankfully, Raspberry Pi’s aren’t too expensive but it’s definitely a mistake you don’t want to make so be careful.

Python Code

You can view the entire python code below and at this link. What this code does is read the inputs from your boat and send that data to Initial State.

There is a single change that needs to be made within the code for you to be able to send data to your own dashboard. Line 122— Update with your access key from Initial State. You can change the bucket name and bucket key if you so choose.

Monitoring Your Data

Once everything is connected and your Pi is running the Python script, you should start receiving daily data updates on Initial State. When the data first arrives it will be automatically laid out for you but I recommend you take advantage of the customization options within Initial State to create a dashboard that is not only functional but one that looks good too.

You can add a custom background image of your boat or layout of your electronics. You can change the temperature tile to a thermometer and set color ranges so you know if it is high or low immediately by the visual color representation. You can set any of your signals to a line graph to view historical trends of the data. You can add a map tile and enter the GPS coordinates for your boat’s location.

You can see a real-time summary of your data in your Tiles dashboard. The Waves app gives you a separate but important way to view the data. Waves is great for viewing historical trends and identifying anomalies in your data.

In addition to the data you can pull from your boat, you can add weather information to your dashboard. The Weatherstack Integration in Initial State requires no code and is easily set up with just a few clicks. You just add your coordinates or zip code and you can get weather forecast data every 15 minutes or hourly. You can send this data into your boat dashboard to monitor weather conditions and storms.

You’ll want to set triggers on your dashboard so you can be alerted immediately if data falls outside of the normal thresholds. You can receive an alert via email or SMS. To do this, go to your triggers tab in your bucket settings. Here you can select which signal you want to monitor, the operator (equal to, less than, greater than, etc.), and the threshold value. Choose the contact you want to be notified by (email or phone number). Click done and your trigger is set. You can add up to 20 of these alerts per dashboard.

You can create a desktop view and a mobile view of your dashboard. This allows you to have a perfectly laid out dashboard for both viewing options. Your desktop view could be more in depth and your mobile could be a snapshot view to allow you to see updates quickly.

With so many tools now available, DIY has become more accessible than ever. So get out there and build your own boat monitoring system.

How to Monitor Your Boat During the Winter Months was originally published in Initial State on Medium, where people are continuing the conversation by highlighting and responding to this story.

Introduction

There isn’t a more important and less pleasant part of your home than the crawl space. Unless you enjoy dark, dirty, claustrophobic places, there is a good chance you rarely visit your crawl space. The health of your home is highly dependent on the health of your crawl space. Nothing wreaks havoc on your crawl space like excess moisture problems. Mold growth, wood rot, and insects thrive in dark, wet spaces. If you want to keep an eye on the health of your crawl space, you need to monitor its humidity levels.

This tutorial will show you how to remotely monitor your crawl space humidity from your mobile device and/or laptop. This will allow you to not only see the current humidity level but also see the historical data over time without having to frequently go down there. This tutorial will also show you how to set up trigger alarms to text/email you whenever your humidity exceeds a certain threshold.

Background

Crawl Space Types

Like most new houses in Tennessee, my house has a vented crawl space. Several crawl space vents around the house let outside air circulate under the floor, which, in theory, helps dry out any condensation that may form. There is a crawl space vapor barrier installed which covers the entire floor. This barrier keeps the moisture in the soil from being absorbed by everything in the crawl space including the floor joists. If everything works like it should, my crawl space should stay dry and mold free.

Other types include encapsulated and conditioned crawl spaces. These types are sealed from the outside and may include mechanical dehumidifiers to pull moisture out of the air.

Relative Humidity

When we measure humidity, we are measuring relative humidity. Relative humidity is the amount of water vapor in the air relative to how much water vapor the air can hold. Relative humidity is expressed in %. This is different than absolute humidity, which is the actual amount of water vapor contained in the air. Absolute humidity is expressed as grams of moisture per cubic meter of air (g/m3).

Warm air can hold more water vapor than cold air. If warm air moves from the outside into a cooler crawl space, the relative humidity will increase ~2.2% for every 1 °F decrease in temperature. For example, if the temperature is 90 °F and 60% humidity outside and that air moves into a vented crawl space that is 70 °F, the relative humidity inside the crawl space (assuming no other influences) would be (90–70)*2.2 + 60% = 104%. If our crawl space reaches 100% humidity, condensation forms (what we don’t want).

Any analysis of humidity in my vented crawl space requires monitoring the temperature of my crawl space as well as the humidity and temperature outside. Otherwise, I will have no idea if there are any other influencers affecting humidity.

The Hardware You Need

• Power outlet or extension cord in your crawl space (I had an electrician put an outlet in for $100).
• WiFi in your house.
• Raspberry Pi (3 or 4) or Raspberry Pi Zero W(H). $35 or $10 respectively.
• Micro SD card ($4).
• Raspberry Pi power supply ($8).
• BME280 temperature/humidity sensor ($4.50/ea).
• Female to female jumper wires ($5).

I bought a Raspberry Pi Zero W kit for $29 which also includes a case, a mini HDMI adapter, and a micro USB adapter. The Zero W requires you to solder the pin headers onto the board. If you can find a Pi Zero WH, the headers are pre-soldered. The Raspberry Pi 3 and 4 have pre-soldered pin headers. The BME280 linked above also requires you to solder a four-pin header. There are some versions of this sensor available that have the headers pre-soldered.

I have a wireless keyboard/mouse that I keep around for setting up each of my Raspberry Pis the first time. Once that Pi is set up, the keyboard/mouse is no longer needed. I use something like this.

*note: I experimented with multiple BME280 sensors as well as multiple DHT22 sensors. The BME280 sensors were, by far, the most consistent and accurate humidity sensors. The DHT22 humidity readings were all over the place from sensor to sensor.

The Software You Need

• The free Raspbian operating system for your Raspberry Pi.
• A Python script (included in this tutorial).
• An Initial State account for data streaming and visualizations ($9.99/mo).

This tutorial will utilize a paid web service, Initial State, for creating the dashboards, storing historical data, retrieving local weather data, and sending SMS/email alerts. All of these functions are fully hosted and available in a web app (hence the $9.99/mo). You can replace this part of the tutorial with another web service or build your own if the $9.99/mo is a no-go for you.

Assembly

The BME280 sensor will have four pins you need to connect to your Raspberry Pi (same pinout for either a Pi Zero or Pi 3/4).

• BME280 VIN pin connects to Pi pin 1 (3.3V).
• BME280 GND pin connects to Pi pin 6 (GND).
• BME280 SCL pin connects to Pi pin 5 (SCL).
• BME280 SDA pin connects to Pi pin 3 (SDA).

Software Setup

You will need a monitor and keyboard to set up your Raspberry Pi the first time. Once it is set up, you won’t need either a monitor or a keyboard to run when deployed in your crawl space.

Raspberry Pi Setup

• You need to install the Raspbian operating system on your Pi. Follow the instructions at https://projects.raspberrypi.org/en/projects/raspberry-pi-setting-up.
• Connect your Pi to your WiFi network https://projects.raspberrypi.org/en/projects/raspberry-pi-setting-up/6.
• The BME280 sensor requires you to enable i2c on your Pi. At the Pi terminal type:

sudo raspi-config

Select 5 Interfacing Options, P5 I2C, and select <YES> to enable i2c. Select <Finish> to save and exit.

• Let’s test out the connection to the sensor. On your Pi,

sudo i2cdetect -y 1

You should see something like the following:

This should show your sensor at address 0x76 (possibly address 0x77). If you don’t see either, check your wiring, make sure i2c is enabled in raspi-config, and reboot.

• (optional) If you want to remotely configure your Pi (which you do because you don’t want to have to go down to your crawl space unnecessarily), enable SSH on your Pi:
  sudo raspi-config, Select 5 Interfacing Options, P2 SSH, and <YES> to enable SSH. <Finish> to save and exit.
• (optional) If you want to test out remotely configuring your Pi, at the Pi terminal type:

hostname -I

This will return the IP address of your Pi. At your laptop terminal, type:

ssh pi@<insert Pi ip address>

For example:

Once you can successfully SSH into your Pi, you may want to make it boot directly to the console instead of loading the desktop UI. You can do this as follows:sudo raspi-config -> 3 Boot Options-> B1 Desktop / CLI-> B2 Console Autologin-> <ok>-> exit.

Python Setup

• There are two Python modules you need to install, one to communicate with the BME280 sensor and one to send data to your Initial State account. On your Pi, run the commands:

sudo pip install RPi.bme280

sudo pip install ISStreamer

Initial State

• Register for an account at https://api.init.st/auth/#/register .
• This will start a 14-day free trial (no credit card required for the trial).

Python Script

• The following script will read temperature and humidity from your BME280 and send the results to your Initial State account every ten minutes.

• Place this script onto your Pi.
• Your Initial State account access key has to be specified on line 10. Copy+paste this key from your Initial State account (more info).
• If you want to change to metric units or change the number of minutes between sensor reads, modify lines 11 and 12.
• If the i2c address was different than 0x76 in the Raspberry Pi setup section, change the value accordingly on line 17.
• Kick off the script on your Pi to start streaming sensor data to your Initial State account:

python crawlspace.py

Building a Web Dashboard

Go to your Initial State account (https://iot.app.initialstate.com), click on the “💦 Crawl Space” bucket name on your bucket shelf, and view the data coming into your dashboard. You can customize your dashboard by adding and sizing line graphs, gauges, statistics, etc. (more info).

Bringing in Local Weather

There is no way to do proper analysis of humidity in a vented crawl space without also logging the outside temperature/humidity. Luckily, Initial State has a nice integration with Weatherstack which lets you bring local weather data into your dashboard. You can add your local weather data to your existing data bucket by following the steps outlined in this support article. A more detailed tutorial can be found in this Medium article.

Instead of bringing in every available weather signal from Weatherstack, I recommend selecting only the most relevant data such as curr_weather_desc, curr_temp, and curr_humidity. Too many unncessary data streams make it hard to create an effective dashboard.

Dashboard Templates

If you want a good starting point for a dashboard layout, you can import one of the two dashboards designed for this tutorial by following the instructions in this support article. All you need are the share URLs for the dashboards above (https://go.init.st/fcpp6ll for the desktop version and https://go.init.st/ol4pfy0 for the mobile version).

You can create a second view of the same data by following this support article. This will allow you to have both a desktop and a mobile version of your data.

Pi IP Address

If you would like to add the IP address of your Pi to your dashboard (always handy in case you need to SSH into it and don’t remember the IP address or DHCP changes it), use the following modified Python script (make the same modifications to ACCESS_KEY, METRIC_UNITS, etc. as before).

You will need to install the psutil Python module before using this script:

sudo pip install psutil

Lines 34–36 stream the current IP address to your dashboard with every read.

Adding a SMS/Email Alert

If your humidity ever gets above a certain threshold (e.g. 80%), you probably want to get a notification so you can investigate why. Follow the instructions at this support article to set up a custom SMS and/or email trigger alert.

Deploying Your Crawl Space Humidity Monitor

Auto-Run on Boot

Once everything looks like it is working, you are almost ready to take your Pi + sensor down to your crawl space and fire it up. To make our setup a bit more robust, we need to kick off our Python script every time our Pi boots. This way our humidity monitor will restart without any intervention when we get a restored power outage.

Adding a process that runs on boot is really easy. At the Pi terminal:

crontab -e

If this is the first time you have run crontab, it may ask you which text editor you want to use (e.g. nano). Add the following line to the bottom of the crontab text file then save and exit:

@reboot python /home/pi/bme280/crawlspace.py &

You will need to specify the exact path of your script. In the example above, I created a directory called bme280 and put my Python script there.

Hardware Deployment

Turn off your Pi and take it down to your crawl space (no monitor, keyboard, or mouse is necessary). It is wise to hang your Pi from the floor joists instead of letting it touch the ground (to avoid any water that may get on the floor). I put a nail in one of the floor joists and draped the power cord over the nail. Turn it on and make sure data starts flowing into your dashboard.

Conclusion (Analysis of My Crawl Space)

I’ve had my crawl space humidity monitor running for about four weeks at the time of writing this tutorial. I installed this monitor in mid-June, right when the humidity went way up in Tennessee. My averages so far are as follows:

Crawl space temperature/humidity average: 68.6 °F / 83.2%.
Outside temperature/humidity average: 79.0 °F / 69.1%.

My crawl space averages 10.4° cooler in temperature and 14.1% higher in humidity. I would expect my vented crawl space to average ~92% humidity based on the outside temperature/humidity (using the relative humidity conversion of +2.2% humidity for every 1 °F decrease). This means that I do not have anything happening in my crawl space that is adding humidity. However, I am still uncomfortable with humidity readings that high as mold can grow whenever humidity reaches levels greater than 70% for prolong periods of time.

My plan is to collect more humidity data over the next few months before deciding if I should convert my vented crawl space into an encapsulated or conditioned crawl space.

How to Build a Crawl Space Humidity Monitor with a Raspberry Pi was originally published in Initial State on Medium, where people are continuing the conversation by highlighting and responding to this story.

The first question I ask in the morning is, “What’s the weather today?” Siri quickly responds with a human-esque retort and gives me the weather forecast data. My iPhone comes with a weather app that I can’t even erase, and being a Tornado survivor, I now have multiple ways to not only check the weather but also to get alerts.

For years, we’ve used weather data API’s with Initial State to monitor weather in real-time and create weather alerts. There seems to be a trend with these weather API’s of giving access to free weather data, and then closing down the free plan over time. We used to use Wunderground (no longer free) and then we used the Dark Sky API (acquired by Apple and no longer free). Now, we use Weatherstack! Along with changing where we get our weather information, we’ve made it much easier to access it using our new Data Integration Marketplace.

In this tutorial, I’ll show you just how easy it is to set up a real-time weather dashboard with the Weatherstack integration on Initial State.

Step 1: Log in or Create an Account

Creating an account at Initial State is easy and free. The individual tier gives you free and full access to the platform for 14-days. After that, it’s only $9.99/mo. If you’re an active student with a .edu or similar email address then it’s completely free, minus a few features such as triggers, shorter data retention and less API calls.

Simply go to initialstate.com, click the orange Get Started button and register/sign in from there.

Step 2: Using the Data Integration Marketplace

Once you’ve logged into your Initial State account, you’ll see a screen like the one below. Before we dive right into setting up the integration, click the “view all integrations” click pointed out in this screenshot. I want to show off all the other integrations we have right now because once you learn how easy it is to set the Weatherstack dashboard up, you’ll be able to do it with all of these. You can create new dashboards for these integrations or add them into other relevant dashboards to make them more robust.

At the time of writing this tutorial, we have 6 integrations on the marketplace:

1. Initial State’s Bucket Watchdog is an integration that checks in on your dashboards to make sure they’re still sending data. Nothing worse than setting up your Arduino or Raspberry Pi to collect data only to find the connection was interrupted. This integration will make sure you know as soon as that happens!
2. CoinCap let’s you stream cryptocurrency market price and volume data to an Initial State dashboard.
3. FMP streams real-time stock prices.
4. The Tesla Integration sends location, charge state and other Tesla data to Initial State.
5. The Twitch integration streams information from twitch channels
6. And finally, Weatherstack. Weatherstack streams, well, the weather.

You’ll notice little Initial State tokens that look like this.

Each Initial State account is given 10 tokens to use in the marketplace to use any way you please. Each integration costs a different amount of tokens to use based on how much data is streamed and how often the integration calls the API. Right now, users only have access to the 10 tokens they’re given, but eventually you will be able to purchase more.

Step 3: Weatherstack

Click the details button on the Weatherstack box on the integrations page.

This page will tell you all of the basic information about the integration and what’s required to use it. In this case, you’ll just need a zip code (or latitude & longitude) of a location that you’ll want to monitor the weather for, and you’ll have to know what units you’ll want to see that data in (metric, scientific or US imperial).

Click the Begin Setup button and you’ll see a modal pop up from the right side of your screen. There are just a few easy steps to take before we can start watching that weather data roll in:

1. Give your new dashboard a name. I named mine Nashville Weather.

Pro tip: I like to use emoji’s in my dashboards names to give them a little more oomph. A quick way to pull up emojis on a Mac is Ctrl+Command+Space bar. For Windows hold the Windows button and either the period (.) or semicolon (;).

2. Type in your location. I use the Zip Code of the area I want to track, but you can also put Latitude and Longitude to be more specific. It’s easy to find the latitude and longitude of your area just by going to google maps, searching for a place and then copying the latitude & longitude out of the browser and pasting it into the form. Only US, UK and Canada locations can be used at this time.

3. Choose your units. I chose US/Imperial because I lived in the United States.

4. Choose to create a new bucket or send your Weatherstack data to an existing bucket. For this tutorial, I’m going to create a new bucket/dashboard. However, let’s say you were already monitoring the temperature of the inside of your home, and wanted to add the weather to that dashboard then you could easily do so by clicking “Send data to an existing bucket” and then choosing the dashboard you want to send data to from the drop down.

Create a new bucket

Send to existing bucket

5. Choose whether you want all the data that Weatherstack will send or if you want just specific weather data to send to your dashboard. I’m going to send it all because I want to be able to see all of the data trend over time, but if you’re sending to an existing bucket you may not want every piece of weather data crowding your existing data. Please note, if you choose to send all the data then it will load in a pre-made template that our team created for you. Otherwise, the tiles will not be organized in any specific order. Regardless, you can customize them to your needs and visual preference.

All available data

I want to select specific data

If you check this option, then simply just go and check the box next to each piece of weather data that you want to stream to your dashboard like below.

7. Choose how often you want your dashboard to update with weather conditions. You can choose between every 15 minutes or hour by hour. Keep in mind that sending data every 15 minutes costs an extra token compared to sending it every hour. So, if you’re wanting to use other integrations in the marketplace at the same time then you may want to just poll every hour. You can always stop sending data from the integration and start it again, or change the frequency at which you send data later. However, if you do stop it and start again then there will be gaps in your data. I chose every hour because I want to use this dashboard to send weather alerts, and measure data over time. So, I don’t need data to update every 15 minutes.

8. Click Start Integration. Now you’re streaming data from Weatherstack! Click the “View in the IoT App” button to see the first data points roll in.

9. Customize your dashboard. If you’re streaming to a new bucket, we’ve set you up with a template to get you started. However, you should make it your own! Press the down arrow in the top center of your dashboard to bring down the timeline, click Edit Tiles, move some tiles around, resize them and change the background. Make the dashboard the way you want it so that it’s easy for you to ingest the data you want to collect.

You can also use other Weatherstack templates that we’ve created for you here.

To add a little more context to your dashboard, you can also add a map that shows the location of where you’re monitoring the weather.

Your dashboard might look a little bare at first, but give it some time and it will fill up with beautiful historical weather data.

Step 4: Setting Weather Alerts

As I mentioned in the introduction of this post, my wife and I recently survived a Tornado that tore through Nashville on March 3rd. Since then, I’ve learned that it’s important to set multiple alerts from different sources for severe weather. I follow a local meteorology group on Twitter, I pay for the StormWatch+ app, I have a NOAA certified weather radio and I’m also setting some alerts on my weather dashboard on Initial State. It might sound like overkill, but in my experience, having just one option to get alerts is not enough. When the Tornado hit our house, the iPhone alert didn’t wake us up and we were awakened by the sound of the storm hitting our home. We didn’t have much time to react. Now I have multiple ways to get alerts for different weather scenarios just in case I don’t hear one, or if one comes through a little late.

If you have a student account with Initial State, you won’t be able to do this step as triggers is only available on the Individual tier and above.

Here’s how you set up a weather alert on Initial State:

1. Click “settings” under the dashboard that you want to set alerts on.
2. Click Triggers in the top middle of the settings panel.
3. Click “+ Create a new trigger.”
4. Enter the signal key that you want to monitor. You can get the stream key by going to the edit tile menu on your dashboard, clicking the tile you want to monitor and copying the text in the signal key box. For this trigger, I’ll monitor the forecasted weather. (Get signal key from edit tile screen)

5. Change the operator from “=” to “match.” This is telling the app to look for the partial match of a string. So, it doesn’t have to be an exact match of exactly what the forecasted weather is.

6. Type whatever value you want to track in the forecast. I typed “rain” in value. Now the match operator will look for the word rain in the forecasted weather tile. So, if it says “moderate rain at times”, heavy rain, or “Rainn Wilson is listening to Purple Rain” it will set the trigger off. It just has to have the word rain in it. You can set it for any phrase that you’d like to track. I’m still monitoring the words Weatherstack uses for different forecasts so I can set up better and more frequent alerts over time. Fair warning here, I found that rain is in the forecast a lot. So, I get quite a few texts on this key value. You may want to watch the data over time and find a key value that is more specific to what you’re looking out for.

7. Enter your phone number. If you haven’t done this already it will need to send you a verification code to verify that you’re sending triggers to your phone and not someone else’s.

8. Type in what you want your message to say. I erased what was in there and put “Looks like it might rain. Go ahead and check the weather… Unless you want to get wet. Message from Weatherstack: {{triggeredValue}}” This way when I get a text, I’ll be able to go to the easiest and most trusted weather source I have near me at the time.

You can set multiple triggers on your data at the same time. You could also set a trigger for when the chance of thunder or snow is above a certain percentage, for current weather, or whatever else you think might be helpful. Keep in mind, you should always have multiple ways to get weather alerts. Just one way of receiving alerts is not enough.

Now, you’ve created a weather dashboard and set weather alerts that you can add into your weather alert mix! We’d love to see how you’ve customized your dashboards or how you used the integration marketplace. If you’ve made something that you want to show off then send a screenshot, or if you’re comfortable sharing your live dashboard, public share URL to us on Twitter using @initialstate. We’d love to see it!

Build a Weather Dashboard that sends alerts using a Weather Data API was originally published in Initial State on Medium, where people are continuing the conversation by highlighting and responding to this story.