Electricity Monitoring App – Send Push Notifications using Firebase Cloud Functions

This week Firebase launched a new and VERY exciting feature called Firebase Cloud Functions. It makes Firebase even more powerful than before, by allowing you to trigger functions when certain events happen. Events can be any of the following things:

  • Data changes on Firebase Realtime database nodes.
  • Authentication Changes
  • Analytics Changes
  • Cloud Storage Changes
  • and a few more…

Cloud Functions is a hosted, private, and scalable Node.js environment where you can run JavaScript code.

This is exactly what we needed in order to make the Electricity Monitoring App even more useful. By using Firebase Cloud Functions, we can send push notifications when the electricity is off and when it comes back on. Now we don’t need to keep checking the app for changes to our electricity state at home.

Sending a Push Notification Using Firebase Cloud Functions

The following is a diagram that indicates how this solution will work.Firebase cloud function with push notifications

The Raspberry Pi (or any other Android Things device) will write to the /online node in our Realtime Database when the state of electricity changes. Once that has happened the Cloud Function will be triggered, as it is listening for any changes on that node. If the data has changed, for instance the value of /online is now true instead of false, we can trigger a push notification to be sent to all devices that are registered for the "Power_Notifications"  topic using the Firebase Admin SDK.

Setup and Deployment of the Firebase Cloud Function

You will need to ensure you have NodeJS installed as well as NPM. Make sure you have followed my previous blog post in order to get the Raspberry Pi app and the companion app running. This post only covers the cloud function changes.

  1. Install Firebase CLI tools:
  2. Initialize the required dependencies by navigating into the cloud-functions  folder:
  3. Log in with Firebase (this will prompt you to log in using a browser):
  4. Run the following command to deploy the Firebase functions:
  5. You will be able to see the functions appear in the Firebase Console as seen below:
  6. Now run the app on the Pi and the companion app on your phone (make sure to update this to the latest version as there have been changes). When you disconnect your device from its power source, you will get a notification like below indicating your power is on or off! 

In the next section we will discuss how the Firebase Cloud Function was implemented. If you want to see how this is done, read on – otherwise Happy Electricity Monitoring!

Developing Firebase Cloud Function Triggers

So how did we send a push notification? The full code for the firebase cloud function can be found in this repository but we can cover the basics here:

  1. We require the firebase-functions npm package in order to create a Firebase function. The firebase-admin npm package is required for us to send notifications. The admin SDK needs to be initialized with the functions configuration.
  2. Export a function by the name of sendPowerNotification. This name will be visible on the Cloud Functions tab in the Firebase console, so call it something useful. Obtain a reference to the database node /online. We want to watch for changes on this node. Use the function onWrite which will trigger when a write event happens.
  3. When the onWrite event is triggered, an  event object is passed with the updated information. This object can indicate if anything has changed by calling the method data.changed(). If nothing has changed, we abort the function.

Sending a Push Notification using Firebase Messaging

  1. Check the value of the data object. If it is true or false we adjust the title of the notification that we are going to send accordingly.
  2. Create a payload object that has the required information for a Firebase Notification (title, message, sound etc). Then create an options object that contains the time to live for the notification and the priority.
  3. Finally, call the Firebase Admin Messaging SDK by using the sendToTopic() method with the above information. This will send a push notification to all devices that are registered to the "Power_Notifications" topic.

    The full source for this function can be found here.

Android Companion App Code Changes

The following changes were made to the Android Companion app:

  1. Adding the Firebase Messaging SDK to app/build.gradle:
  2. Register the "Power_Notifications" topic in the ElectricityApplication class.
  3. Change the push notification icon in the AndroidManifest.xml to the power icon found here:

    After these changes are all made, you will be able to receive notification updates about your electricity at home!

Conclusion

Firebase Cloud Functions are extremely powerful pieces of code that can do a lot of heavy lifting for you.  Firebase manages the hosting and scaling of the functions.

As you can see from the above example, it wasn’t too much work to send push notifications from Firebase Cloud Functions.

If you enjoyed this blog post, please consider buying me a cupcake. Follow me on twitter @riggaroo and let me know what you think there.

Subscribe to Blog via Email

Enter your email address to subscribe to this blog and receive notifications of new posts by email.

References

Firebase Cloud Functions Documentation

Android Things – Electricity Monitoring App – Github

Previous Blog Post describing Android Things setup

Firebase Cloud Functions Examples

Android Things – Electricity Monitoring App

For those who may not know, I live in beautiful sunny South Africa (see my tweets for lots of awesome pictures). A few years ago we battled with a lack of electricity. While “load-shedding” is not so common these days, we have numerous unplanned outages. We even have a few of apps that give out schedules when the electricity is scheduled to go off in your area (see here and here).

While these apps serve a purpose, they are not so good when we have unplanned outages.

Which often leaves me asking myself the following questions:

  • Do I have electricity at home right now?
  • If not, how long has the electricity been out for?
  • Is it okay to eat the contents of my freezer?

Introducing “Electricity Monitor”…

I decided to use a Raspberry Pi 3 running Android Things and Firebase Realtime Database to monitor the electricity in my house.

Mainly because Firebase has a VERY powerful tool for monitoring if a client is connected to your Realtime database or not. By leveraging the onDisconnect()  method on the Firebase Realtime database, the server can automatically change some data (or log a time) when a client disconnects from it.

Setup Requirements

In order to get the app running yourself, you need to:

  1. Checkout the repository here.
  2. Create a new Firebase Project here.
  3. Download the google-service.json file from the Firebase Console to both the app folder and the companion-app folder.
  4. Set the Realtime database rules to be read and write for everyone (Firebase Console -> Database -> Rules). (WARNING: This means there is NO security on our database – you should not have these rules in production)
  5. Deploy the “app” module to the Raspberry Pi or equivalent Android Things device (you need to make sure you have setup your Pi with the Android Things OS).
  6. Deploy the “companion-app” module to your phone.
  7. If you have electricity, you will see a house with lights on and the accumulated time you have had power for. If you don’t have electricity, the Raspberry Pi will lose its power source and trigger the onDisconnect()  callback on the Firebase server. This will then show up in our “companion-app” , it will display how long the electricity has been off for.

There you have it, a way to monitor your power at home using Android Things and Firebase!

Yes I know…

  • There are easier ways to monitor your power at home.
  • This is basically monitoring my Pi’s connection to the internet and not power, which in most cases will be accurate enough for me as I am hardly without internet. (I guess this could be rebranded as – “Do I have Internet at home?”)
  • Yes there is no security on the database right now. Luckily it is not controlling my power and its just a sample (Pull requests are welcome 🙂).
  • You might not understand the need for this app, which is okay, it is useful for me and hopefully fellow South Africans 😃

References

If you enjoy my blog posts, please consider buying me a cupcake!

Subscribe to Blog via Email

Enter your email address to subscribe to this blog and receive notifications of new posts by email.

 

Android Things – Building a Distributed Piano with Nearby Connections API

In the previous post, we had a short introduction to some hardware basics for the Software Engineer. We learnt about some different components and how to create a blinking LED with Android Things. In this blog post, we will learn to build a distributed piano with Android Things, a Piezo Speaker and Google’s Nearby API.

Hardware setup for an Android Things Distributed Piano:

You will need:

In order to create the speaker component, set up your breadboard with the piezo by following the diagram below:

Distributed Piano Piezo Speaker Setup
Distributed piano piezo speaker setup

Attach the speakers to a PWM pin (red line in this diagram) and to a GND pin to complete the circuit.

If you remember from the previous blog post, we used the GPIO pin to send an on/off signal to the LED. Because the speaker requires us to send different notes to it, a simple on/off wouldn’t work in this case, which is why we use a PWM pin.

PWM (Pulse Width Modulation) is a technique used to encode a message into a pulsing signal. Its main use is to control the power supplied to electrical devices. PWM is used for things such as controlling servo motors or controlling a piezo.

Software Component

Once the hardware is set up, we can move onto creating the piano apps. The descriptions below will highlight the important parts, the full source code can be found here.

We will create two apps, one that will run on the Android Things compatible board and the other that will act as the companion piano app.

Android Things App

  1. Once we have created a project, make sure to include the dependencies for Android Things, Google Play Services and the speaker driver in your build.gradle. In your AndroidManifest.xml, include the permission to ACCESS_NETWORK_STATE  as we will need this whilst using the Nearby API. Define the SERVICE_ID and make sure your PianoActivity  is set to be the IOT_LAUNCHER.

  2.  In the PianoActivity, we will broadcast that we are allowing “nearby connections” on this device. This code is based off the sample provided here for nearby connections.

  3. On receiving a message from the nearby API, translate the message into a frequency that the speaker will play. This example is using the PWM speaker driver from here.


    That is all that we require for the Android Things component.



Companion Piano Player App

  1. Create a module inside your current project for the companion app. This app will need to include the Nearby Connections API dependency too.
  2. In the layout xml file, we will include a keyboard view and a scrolling bar to scroll the keyboard.  I have extracted the KeyboardView  from the repository that can be found here.
  3. In the activity, create a GoogleApiClient and start listening for any connections that are advertising themselves. For simplicity, we will just connect to the first endpoint that is discovered.


  4. Obtain a reference to the KeyboardView and attach a listener which will trigger when the notes are pressed on and off.
  5. When a note is pressed send a message via Nearby API with the corresponding note frequency to the connected Raspberry Pi. Send a “stop” signal, when the KeyboardView listener detects that the note has stopped playing.

That is how you can make a distributed piano using Android Things. For the full source code check the github repository here.

Conclusion

By using Android Things and the Google Nearby API we could quite easily create a distributed piano. This post demonstrated how easily you can build your own Android Things Piano.

If you manage to play something awesome with this example, please share it with me on twitter @riggaroo. Check this Sia cover by Gautier Mechling:


If you want to get updates from this blog, be sure to subscribe below:

Subscribe to Blog via Email

Enter your email address to subscribe to this blog and receive notifications of new posts by email.

Android Things – Hardware Basics for the Software Engineer

Android Things is the new kid on the block. It is Google’s embedded platform designed specifically for use with low-powered, IoT (Internet of Things) devices. The Android Things dev preview is available for a few different IoT boards, such as the Raspberry Pi 3, the Intel® Edison and the NXP Pico i.MX6UL.

As someone who has never worked with circuits, I had a bit of a steeper learning curve than others when tinkering with Android Things.  I have studied all the theory around circuits and how they work but we never actually had hands on experience creating circuits. Besides that, school was a long time ago, so I needed to brush up on my theory too.

I think it is important to understand the basics of circuits and hardware components before diving in head first into Android Things development. This post will explain the basics of circuits, hardware components and how we can use this knowledge to build a simple blinking LED with Android Things.

Hardware Components

There are different parts you would typically need to build something with Android Things (or any other IoT platform for that matter) depending on what you want to build.

Breadboard – This is your construction base for prototyping electronics. It allows you to connect different components and wires to create a circuit. When you are finished prototyping, you would typically solder your components together and not use a breadboard anymore. The columns on the edges of the breadboard are connected vertically by conductive metal strips, and the inner rows are connected horizontally. Read more about breadboards here.

Breadboard
Breadboard

Jumper WiresUsed to connect the components of a breadboard together and to connect an IoT board (Raspberry Pi, Arduino etc) to the breadboard.

Jumper Wires
Jumper Wires

Resistors – Components that are used to resist the flow of electrical energy. It converts some of the electrical energy into heat. Resistors can have different resistance. It is important to calculate and use the correct resistor when building circuits. The stripe markings on a resistor reflect the resistance measure. More info on how to calculate resistor values can be found here.

Resistors

LEDs – Components that convert electrical energy into light energy. LEDs (or Light Emitting Diodes) are polarized components, this means they only allow electricity to flow in one direction. The short leg of the LED is called a cathode(-) and will connect to ground. The long leg of the LED is an anode(+) and will connect to power.

LEDs
LEDs – Light Emitting Diodes

Push Switch – Component which allows electricity to flow between its two contacts. When the switch is pushed down, the circuit is closed. When the switch is up, the circuit is open. 

Push Switch
Push Switch
Push Switch
Push Switch

And many more components!

Power Calculations

When building a circuit, you need to do some calculations before plugging components into one another. For example, an LED can only handle certain a certain amperage (about 0.023A). If you provide more amps than it can handle, you can risk damaging your LED. This is where resistors come in. In order to build a basic circuit where we have a blinking LED, we need to do some calculations as to what resistor we should use.

This is where Ohm’s Law comes in handy.  Ohm’s Law states that the current through a conductor between two points is directly proportional to the voltage across the two points. This law will help us calculate the resistors we should use when creating our circuits.

Ohm's Law
Ohm’s Law

Ohms Law: V = I * R

This diagram translates into 3 different equations: V = I * R or I = V/R or R = V/I, where V is Voltage (volts), I is Current (amps) and R is Resistance (ohms).

GPIO Pins

With the Raspberry Pi 3 (and the other Android Things supported boards), there are a couple of GPIO (general purpose input output) pins that give us a physical interface between the Pi and our breadboard. The pins allow us to interact with different components and receive and send information to them. Each board is configured differently and the pins themselves provide different functionality. To understand how these GPIO pins work for each board, you should look at the manufacturer’s pinout diagram.

For example the pinout diagram for the Raspberry Pi 3 can be seen below:

Raspberry Pi 3 Pinout
Raspberry Pi 3 Pinout – Source – https://developer.android.com/things/hardware/raspberrypi-io.html

There are 40 pins on the Raspberry Pi 3 and you can see they have different functions. Some pins provide power, some are ground and others will be used for receiving or sending values to our circuit’s components.

Basic circuit for a blinking LED with Android Things

To create the blinking LED example, we need to create a circuit. In this example, we will be using the Raspberry Pi 3. Using the Fritzing tool, I have created this example circuit that we want to build using our components.

Android Things - Raspberry Pi 3 and Blinking LED
Android Things – Raspberry Pi 3 and Blinking LED

In the diagram above, the pins correspond to the Raspberry Pi pinout diagram shown earlier. In this example, we have used a 220Ω resistor, an LED and some jumper wires to connect them all together. We are supplying the circuit with 5V of power from the Raspberry Pi 3.

When applying Ohm’s Law, we can see that the amps that will flow through the LED is I = 5V/220Ω which means I = 0.023A or 23 milliamps (23mA). This value is just about the max you can safely use with the LEDs, which is why we chose a 220Ω resistor. Some LEDs can handle different currents, it is worth checking out the specs for the LED you are using.

When setting up the above circuit with the Raspberry Pi 3, it is important to ensure the pins are used in the correct place as we mentioned before, since the pins have different uses. Make sure to connect the BCM6 pin (as indicated in the pinout diagram) to the 220Ω resistor.

It is also important to place the LED correctly into the breadboard, with the anode(+) (longer leg) connecting to power and the cathode(-) (shorter leg) to ground, otherwise you might not see a blinking LED.

The LED will not blink until we deploy an app to the Raspberry Pi. However, we can test that the circuit closes by connecting it to the 5V power directly instead of the BCM6 pin and the light should stay on at this point (but be sure to reconnect it to the BCM6 pin so that the example code will run).

The connected components on the breadboard can also be viewed as a simple circuit diagram which may be easier to understand:

Circuit Diagram - Android Things
Circuit Diagram – Android Things

Creating a blinking LED Android Things app

We have covered how to set up a basic circuit and discussed some hardware components. Now we need to start making the LED blink. In order to do this, we will create an Android app that sends signals via the Raspberry Pi to make the LED blink.

We need to first install Android Things on our Raspberry Pi 3. The official guide on the Android Things site is great at explaining how to do this, so I won’t go into that detail here. Once we have deployed the Android Things OS and connected to the device via ADB, we can create the project.

  1. Open Android Studio, click “Create New Project” and then create a project using a blank activity named BlinkingActivity
  2. Once our project is created,  add the Android Things dependency. In your app level build.gradle:
  3. Add the <uses-library>  tag into AndroidManifest.xml to indicate that this app requires the Android Things libraries on the device.
  4. Specify the BlinkingActivity to be the launcher activity in the AndroidManifest.xml. This indicates that the activity will run by default when the device is turned on.
  5. We will use the PeripheralManagerService  to control the behaviour of our LED. Open the connection to the pin in onCreate  and close the connection in onDestroy . Set the initial direction of the pin to be DIRECTION_OUT_INITIALLY_LOW which means we are using the pin as an output pin and initially it should be a low voltage supplied to it.
  6. To make the LED blink, we will create a  Handler which we post messages to every 500ms to change the state of the LED. We post to the handler in onCreate . Inside the handler, we invert the current value of the ledGpio  object by calling ledGpio.setValue() . This will blink the LED.
  7. Make sure your device is connected and deploy the app to the device. You should see a blinking LED!The code for this tutorial can be found here: https://github.com/riggaroo/AndroidThings-BlinkingLED

Conclusion

Android Things is an exciting IoT platform to start prototyping with. The ability to access Google APIs on this platform and use the Android development tools (such as Android Studio) is what differentiates this platform from the other IoT platforms. This blog post serves as a starting point for understanding different hardware components and how to start interacting with them with Android Things.

If you liked this blog post, please consider subscribing for more!

Subscribe to Blog via Email

Enter your email address to subscribe to this blog and receive notifications of new posts by email.

Thanks to  @joshliebe and @blundell_apps for reviewing this blog post.

Links