DEV Community: Rob

Using DutyCalls for IoT applications

Rob — Tue, 26 Apr 2022 10:26:52 +0000

Keeping track of the measurements of all your IoT devices is very useful and sometimes even necessary. This makes it possible to intervene before problems arise. In this blog we show how you can use DutyCalls, to provide insight into the measurements of all your devices.

Although we use the Python programming language in this post to explain the technical aspects, it is also interesting for non-programmers. DutyCalls can be used in a lot of other contexts. So also in non-technical environments. For information about the DutyCalls platform, please visit: https://dutycalls.me.

Getting started with DutyCalls

Before we can start monitoring our devices, we must first create a DutyCalls account. Then we need to create a workspace and set it up. Creating the account as well as the workspace is completely free.

For more information about setting up a workspace, consult the official DutyCalls documentation.

Collecting data from a device

Now that the DutyCalls environment has been set up, it is important to collect the data that you want to send to DutyCalls. For this tutorial, we'll be using the weather station we created for a previous blog post. This weather station consists of a Raspberry PI, a Sense HAT, a Python script for collecting measurements such as temperature/air pressure/humidity and a SiriDB database for storing the measurements. Check out our previous blog for more information about this.

Now take the following Python variable as an example of the script's output:

# This is the current relative humidity, expressed in
# percentage and rounded to 2 decimal places.
humidity = 44.35

Posting the data to DutyCalls

How can this information be made easily visible and how can you be informed if something is wrong? For example, when the humidity in your home is too high or too low. We can do this by simply creating a Ticket in DutyCalls. A Ticket is an object in DutyCalls that represents an event. We need to assign a number of characteristics to this Ticket, so that DutyCalls knows what to do with it.

For example, we could compose a Python Dictionary with the following characteristics on the basis of the measurement just mentioned:

ticket = {
    “title”: “Humidity is fine.”,
    “body”: f“Current humidity is: {humidity} percent.”,
    “severity”: “low”
}

Note: The above dictionary is based on a default service. You might have to change it according to your own service mapping.

Now to post this ‘ticket’ to DutyCalls we use the dutycalls-sdk. A Python library with which we can easily communicate with the DutyCalls API.

The use of this API does require credentials. To be specific, credentials from a DutyCalls Service. For information on how to retrieve these credentials, see the DutyCalls documentation.

This is how we authenticate with DutyCalls when using the Python library:

from dutycalls import Client

client = Client(login='abcdef123456', password='abcdef123456')

Note: You should replace these fake credentials with your own.

Now all we have to do is post the dictionary named ‘ticket’ that we composed earlier!

That can be done this way:

# Create a new Ticket in DutyCalls.
await client.new_ticket(ticket=ticket, ‘Example-Channel’)

Note: You should replace ‘Example-Channel’ with the name of your own Channel.

To confirm that everything went well, we check whether the newly created ticket is actually in our DutyCalls inbox. And as you can see below that is the case:

But what if the humidity is above a certain self-determined limit? You probably want to be notified immediately, as this can cause problems for both your health and your home. To achieve this, we're tweaking the DutyCalls related code of the script a bit:

from dutycalls import Client

humidity = 44.35

severity = “high” if humidity > 70 else “low”
title = “Humidity is too high!” if humidity > 70 else “Humidity is fine.”

ticket = {
    “title”: title,
    “body”: f“Current humidity is: {humidity} percent.”,
    “severity”: severity
}

client = Client(login='abcdef123456', password='abcdef123456')

await client.new_ticket(ticket=ticket, ‘Example-Channel’)

Now if the humidity is above 70% percent, we will receive an equivalent Ticket to the one below in DutyCalls:

We can see that the severity of the ticket is higher than the previous one and that an Alert has also been raised. When an Alert is raised in DutyCalls, the relevant user(s) will be notified about this. How the user is notified depends on the configuration in DutyCalls, but some of the methods are: push notifications (in browsers and in the mobile app), email, SMS and voice calls.

Tips & tricks

Below are a number of cool features of DutyCalls, which are definitely worth trying out when monitoring devices.

Integrations

All kinds of applications are or can be integrated with DutyCalls. This way you can monitor your devices and use the great features of DutyCalls from within your current applications. Checkout the documentation, to see how you can integrate your favorite application(s) with DutyCalls.

Alerts

Would you like to determine yourself when users are notified of events? Make use of alerts. These can be configured globally per workspace or specifically per channel depending on the type of the alert. This way you can decide for yourself when alerts are raised. For more information about the types of alerts and how to configure them, visit the DutyCalls documentation.

Ignore rules

Do you want tickets received by DutyCalls to be ignored when they meet certain conditions? Make use of “ignore rules”. These rules can be configured per channel. For more information about these rules, please visit the documentation.

Expectations

Would you like to be notified when a certain ticket has not been received by DutyCalls? Make use of expectation rules. Expectation rules ensure that when a certain ticket is not received that is expected, an alert will be raised. These rules can be configured per channel. For more information about these rules, please visit the documentation.

Actions

Do you want DutyCalls to take immediate action after receiving a Ticket? Make use of actions. These can be configured per channel per tag. For more information about actions and tags, please visit the documentation.

Conclusion

In this post, you have seen that it is very easy to use DutyCalls for monitoring devices. All we had to do for this was collect relevant data from a device (humidity this case), compose a ticket based on this data and post the ticket to DutyCalls using the Python Dutycalls SDK. In DutyCalls we could then see the collected data very clearly and we were notified when something was wrong.

However, we have only shown a small part of the functionalities and benefits of DutyCalls in this post and we are much more curious about how you implement DutyCalls in your projects/work!

Using SiriDB for IoT applications

Rob — Wed, 30 Mar 2022 10:45:28 +0000

The Internet of Things has long been one of the most popular technology trends and for good reason. It offers many possibilities and advantages. This includes monitoring data, such as the temperature or air quality in a home. But this data must be stored somewhere for later use. Preferably by using a very efficient solution, because IoT devices often do not have a lot of computing power. An extremely suitable solution that can be used for this is SiriDB. A super fast and very robust time series database.

In this post, we'll show you how to easily build a weather station that uses SiriDB as the database for all its measurements. For this weather station we use a Raspberry Pi (3 Model B) in combination with a Sense HAT.

Prerequisites

Hardware

Raspberry Pi
Sense HAT

Software

You will need the latest version of Raspberry Pi OS, which already includes the following software packages:

Python 3
Sense HAT for Python 3

If for any reason you need to install the Sense HAT package manually, execute the following command on your Raspberry Pi:

$ sudo apt-get install sense-hat

Set up

Now that our Raspberry Pi is ready to go, we need to follow a few steps to install SiriDB.

First, install the required SiriDB dependencies:

$ sudo apt install libcleri-dev libpcre2-dev libuv1-dev libyajl-dev uuid-dev

Download the source code of SiriDB:

$ wget https://github.com/SiriDB/siridb-server/archive/refs/tags/2.0.46.zip

Note: Change the version in the URL to get the latest version of SiriDB.

Now unzip the downloaded ZIP file:

$ unzip 2.0.46.zip

After that, compile the source code:

$ cd siridb-server-2.0.46/Release/
$ make clean
$ make

Then install SiriDB:

$ sudo make install

Finally, install the SiriDB Connector for Python with pip (recommended), which will be used in a later step:

$ pip install siridb-connector

Configuration

Great! SiriDB is now installed. But in order for SiriDB to start automatically on startup, the file below named siridb-server.service needs to be added to the /etc/systemd/system folder:

[Unit]
Description=SiriDB Server
After=network.target

[Service]
Environment="SIRIDB_HTTP_API_PORT=9020"
ExecStart=/usr/bin/siridb-server
StandardOutput=journal
LimitNOFILE=65535
TimeoutStartSec=10
TimeoutStopSec=300

[Install]
WantedBy=multi-user.target

Note: The environment variable SIRIDB_HTTP_API_PORT must be added because if the HTTP API port is not set (or 0), the API service of SiriDB will not start. Checkout the documentation for more information about using environment variables with SiriDB.

Now we need to reload the daemon, to make the system aware of the newly added service:

$ sudo systemctl daemon-reload

Let’s enable our service so that it doesn’t get disabled when the Raspberry Pi restarts:

$ sudo systemctl enable siridb-server.service

And now let's start our service:

$ sudo systemctl start siridb-server.service

The SiriDB server is now running in the background.

The only thing left to do in terms of configuration is to create a database in SiriDB. For this we use the SiriDB HTTP API. SiriDB has a default service account with the username sa and password siri, which we will use. For our tutorial we only need a second precision database. We also select a shard duration of 6 hours for this database because our measurement interval will be only a few seconds. Sometimes you may want to store one value per measurement per hour or even per day. In that case, your database will perform better by using a larger shard duration.

Create the database on the SiriDB server running on port 9020 using cURL with basic authentication:

$ curl --location --request POST 'http://localhost:9020/new-database' \
--header 'Content-Type: application/json' \
--header 'Authorization: Basic c2E6c2lyaQ==' \
--header 'Content-Type: text/plain' \
--data-raw '{
    "dbname": "iot",
    "time_precision": "s",
    "buffer_size": 8192,
    "duration_num": "6h",
    "duration_log": "3d"
}'

Note: The value passed to the header parameter Authorization, is the word Basic word followed by a space and a base64-encoded string username:password. See the documentation for more information about authentication in SiriDB.

Collecting data

To collect the data we use Python 3 together with the Sense HAT package.

The Python script below called sense.py contains the minimal code necessary to collect some key measurements using the Raspberry Pi Sense HAT and then write them to SiriDB:

import asyncio
import time

from sense_hat import SenseHat
from siridb.connector import SiriDBClient


async def collect_data(siri):

    # Start connecting to SiriDB.
    await siri.connect()

    # Initialize the Raspberry Pi Sense HAT.
    sense = SenseHat()

    try:
        # Make sure the script runs indefinitely.
        while True:

            # Get the current temperature and round it to 2 decimal places.
            temp = round(sense.get_temperature(), 2)

            # Get the current humidity and round it to 2 decimal places.
            humi = round(sense.get_humidity(), 2)

            # Get the current pressure and round it to 2 decimal places.
            pres = round(sense.get_pressure(), 2)

            # Show the current temperature on the Sense HAT.
            sense.show_message('%s C' % temp)

            # Get the current time in seconds since the Epoch.
            ts = int(time.time())

            # Add the collected data to the SiriDB serie: "temperature".
            await siri.insert({'temperature': [[ts, temp]]})

            # Add the collected data to the SiriDB serie: "humidity".
            await siri.insert({'humidity': [[ts, humi]]})

            # Add the collected data to the SiriDB serie: "pressure".
            await siri.insert({'pressure': [[ts, pres]]})

            # Wait 10 seconds before retrieving new measurements.
            await asyncio.sleep(10)

    finally:
        # Close all SiriDB connections.
        siri.close()

# Initialize the SiriDB client.
siri = SiriDBClient(
    username='iris', # Default username
    password='siri', # Default password
    dbname='iot', # The name of the database we created earlier
    hostlist=[('localhost', 9000)],  # Multiple connections are supported
    keepalive=True 
)

loop = asyncio.get_event_loop()
loop.run_until_complete(collect_data(siri))

Add the script to your Raspberry Pi and start it with:

$ python sense.py

To verify that everything is working properly you should now see a message on your Sense Hat every 10 seconds:

Note: Our camera couldn't capture the message from the LED matrix well, but it does show the correct temperature. (Assuming you believe us of course 🙂)

Visualization

That was all! Some key measurements are now automatically collected every 10 seconds and written to SiriDB.

However, it would be even more valuable if some insights could also be obtained from this data. This can be done using a visualization application such as Grafana, for which SiriDB has made a ready-to-use plugin: grafana-siridb-http-datasource.

How Grafana can be used in combination with SiriDB is explained here. But below you can already see what the measured data would look like in this application:

Conclusion

In this blog post we have shown step by step how easy and effective it is to deploy SiriDB for IoT applications. Now you have enough information to get started with SiriDB yourself!

If you want to learn more about SiriDB, you can visit the official documentation page at https://docs.siridb.net.

aiowmi - A Python WMI library

Rob — Mon, 14 Mar 2022 08:05:38 +0000

In need of a solution for WMI queries from a non-Microsoft operating system? Make use of aiowmi! A Python library for WMI, which we have made freely available as an open source project.

Read the announcement below for more information or start using aiowmi in all your projects right away!

https://cesbit.com/aiowmi