Alarm Button

This is a simple project which is either a door-bell, or an alarm-button depending on your viewpoint!

In short it is a button connected to an ESP8266 device. When the button is pressed a message is posted to a queue. A watcher can consume this event and do anything you like! The sample watcher included in the repository, and what I use it for, merely triggers the playback of an mp3 file.

We've previously discussed using a message-queue on a WeMos Mini-D1.

Hardware

The project involves the following components:

• 1 x WeMos Mini D1
  • Approximately €2.50.
• 1 x Push-Button
  • Approximately €0.05.
• 1 x 3D Printed Case - Approximately €5.00.
  • I had this design printed locally.

Wiring the project is very simple, and merely consists of connecting the button to the Mini D1, which is powered by a simple USB-PSU. I wired the button between D0 & D8.

The final result looks something like this:

Software

The software for this project is very simple, and logically divided into two parts:

• Handling connections to the local WiFi network.
  • This is required to send the message to the MQ bus.
• Reacting to the button-press.
  • By publishing a "click" event.

I've also added support for over-the-air-updates, which means that new code can be flashed on the deployed harware without touching the cabling, directly from the Arduino IDE.

Operation

If you've previously configured WiFi details the device will connect automatically, and begin working. If you've never configured the device it will instead notice that, and configure itself as an access-point. This means you can use your mobile phone, or other WiFi-connected device, to connect to this access-point and select the local WiFi network it should become part of.

Once running the system will quietly wait for button presses, when one is received it will publish a message via the MQ-broker, which will look like this:

{"click":"short","mac":"a0:20:a6:16:45:d2"}

Or:

{"click":"short","mac":"a0:20:a6:16:45:d2"}

i.e. The payload will be a JSON object with a click field. This event will be pushed to the "alarm" queue.

If you have multiple buttons you'll be able to differentiate them via the mac" field.

The Code

The main code looks like this:

//
// A button wired between D0 & D8 to publish an alarm notification via MQ.
//


//
// The name of this project.
//
// Used for the Access-Point name, and for over the air updates.
//
#define PROJECT_NAME "D1-MQ-ALARM"



//
// Should we enable debugging (via serial-console output) ?
//
// Use either `#undef DEBUG`, or `#define DEBUG`.
//
#define DEBUG


//
// If we did then DEBUG_LOG will log a string, otherwise
// it will be ignored as a comment.
//
#ifdef DEBUG
#  define DEBUG_LOG(x) Serial.print(x)
#else
#  define DEBUG_LOG(x)
#endif


//
// Damn this is a nice library!
//
//   https://github.com/tzapu/WiFiManager
//
#include "WiFiManager.h"

//
// WiFi & over the air updates
//
#include <ESP8266WiFi.h>
#include <ArduinoOTA.h>


//
// The button handler
//
#include "OneButton.h"


//
// Include the MQQ library, and define our server.
//
#include "PubSubClient.h"
#include "info.h"
const char* mqtt_server = "192.168.10.64";
WiFiClient espClient;
PubSubClient client(espClient);
info board_info;



//
// Setup a new OneButton on pin D8.
//
OneButton button(D8, false);


//
// Are there pending clicks to process?
//
volatile bool short_click = false;
volatile bool long_click = false;


//
// This function is called when the device is powered-on.
//
void setup()
{
    //
    // Enable our serial port.
    //
    Serial.begin(115200);

    //
    // Handle WiFi setup.
    //
    WiFiManager wifiManager;
    wifiManager.setAPCallback(access_point_callback);
    wifiManager.autoConnect(PROJECT_NAME);

    //
    // Now we're connected show the local IP address.
    //
    DEBUG_LOG("WiFi Connected : ");
    DEBUG_LOG(WiFi.localIP().toString().c_str());
    DEBUG_LOG("\n");

    //
    // The final step is to allow over the air updates
    //
    // This is documented here:
    //     https://randomnerdtutorials.com/esp8266-ota-updates-with-arduino-ide-over-the-air/
    //
    // Hostname defaults to esp8266-[ChipID]
    //
    ArduinoOTA.setHostname(PROJECT_NAME);

    ArduinoOTA.onStart([]()
    {
        DEBUG_LOG("OTA Start");
    });
    ArduinoOTA.onEnd([]()
    {
        DEBUG_LOG("OTA Ended");
    });
    ArduinoOTA.onProgress([](unsigned int progress, unsigned int total)
    {
        char buf[32];
        memset(buf, '\0', sizeof(buf));
        snprintf(buf, sizeof(buf) - 1, "Upgrade - %02u%%", (progress / (total / 100)));
        DEBUG_LOG(buf);
        DEBUG_LOG("\n");

    });
    ArduinoOTA.onError([](ota_error_t error)
    {
        if (error == OTA_AUTH_ERROR)
            DEBUG_LOG("Auth Failed");
        else if (error == OTA_BEGIN_ERROR)
            DEBUG_LOG("Begin Failed");
        else if (error == OTA_CONNECT_ERROR)
            DEBUG_LOG("Connect Failed");
        else if (error == OTA_RECEIVE_ERROR)
            DEBUG_LOG("Receive Failed");
        else if (error == OTA_END_ERROR)
            DEBUG_LOG("End Failed");
    });

    //
    // Ensure the OTA process is running & listening.
    //
    ArduinoOTA.begin();

    //
    // We have a switch between D8 & D0.
    //
    // If this is missing no harm will be done, it will just
    // never receive any clicks :)
    //
    pinMode(D8, INPUT_PULLUP);
    pinMode(D0, OUTPUT);
    digitalWrite(D0, HIGH);

    //
    // Configure the button-action(s).
    //
    button.attachClick(on_short_click);
    button.attachLongPressStop(on_long_click);

    //
    // Setup our pub-sub connection.
    //
    client.setServer(mqtt_server, 1883);
    client.setCallback(callback);
}



//
// Record that a short-click happened.
//
void on_short_click()
{
    short_click = true;
}

//
// Record that a long-click happened.
//
void on_long_click()
{
    long_click = true;
}


//
// If we're not configured with WiFi login details we run an access-point.
//
// Show that, explicitly.
//
void access_point_callback(WiFiManager* myWiFiManager)
{
    DEBUG_LOG("AccessPoint Mode");
    DEBUG_LOG(PROJECT_NAME);
    DEBUG_LOG("\n");
}



//
// This function is called continuously.
//
void loop()
{
    //
    // Handle any pending over the air updates.
    //
    ArduinoOTA.handle();

    //
    // Process the input-button
    //
    button.tick();

    //
    // Ensure we're connected to our queue.
    //
    if (!client.connected())
        reconnect();

    //
    // Handle queue messages.
    //
    client.loop();

    //
    // Handle any pending clicks here.
    //
    handlePendingButtons();

    //
    // Now have a little rest.
    //
    delay(20);
}


//
// We bind our button such that short-clicks, long-clicks,
// and double-clicks will invoke a call-back.
//
// The callbacks just record the pending state, and here we
// process any of them that were raised.
//
void handlePendingButtons()
{

    //
    // If we have a pending-short-click then handle it
    //
    if (short_click)
    {
        short_click = false;
        DEBUG_LOG("Short Click\n");

        // Send it away
        String payload = "{\"click\":\"short\",\"mac\":\"" + board_info.mac() + "\"}";
        client.publish("alarm", payload.c_str());

    }

    //
    // If we have a pending long-click then handle it.
    //
    if (long_click)
    {
        long_click = false;
        DEBUG_LOG("Long Click\n");

        // Send it away
        String payload = "{\"click\":\"long\",\"mac\":\"" + board_info.mac() + "\"}";
        client.publish("alarm", payload.c_str());
    }
}



//
// This is called when messages are received.
//
// We only subscribe to the `meta`-topic, and we don't do
// anything with the messages.  It's just a nice example
// showing how we could if we wanted to.
//
//
void callback(char* topic, byte* payload, unsigned int length)
{
    Serial.print("Message arrived [Topic:");
    Serial.print(topic);
    Serial.print("] ");

    for (int i = 0; i < length; i++)
    {
        Serial.print((char)payload[i]);
    }

    Serial.println();
}




//
// Reconnect to the pub-sub-server, if we're dropped.
//
void reconnect()
{
    // Loop until we're reconnected
    while (!client.connected())
    {
        DEBUG_LOG("Attempting MQTT connection...");

        String id = PROJECT_NAME;
        id += board_info.mac();

        // Attempt to connect
        if (client.connect(id.c_str()))
        {
            //
            // We've connected
            //
            DEBUG_LOG("connected\n");

            //
            // Dump all our local details to the meta-topic
            //
            client.publish("meta", board_info.to_JSON().c_str());

            //
            // Subscribe to the `meta`-topic.
            //
            client.subscribe("meta");
        }
        else
        {
            DEBUG_LOG("failed, rc=");
            DEBUG_LOG(client.state());
            DEBUG_LOG(" try again in 5 seconds\n");
            // Wait 5 seconds before retrying
            delay(5000);
        }
    }

}

Several libraries are used, and these are bundled together in a git repository, you can access all the source by cloning the repo involved, and then looking at the project:

• https://github.com/skx/esp8266/tree/master/d1-alarm

In the repository you'll also find a simpler queue-watcher, written in perl, that will trigger the alarm playback. This uses a script which is Linux-specific and assumes you're using the mpd audio-stuff.

Alternative Approaches

Building a single button like this was fine, but over time I wanted more.

Rather than building multiple alarm-buttons I decided it was better to make the buttons as dumb as possible, and put the "smarts" on my PC.

That lead to the use of simple radio-transmitters and a software-defined radio receiver:

• 433Mhz-based alarm buttons