Washing Machine Alarm

We have a new-born baby in the house, which means we do a lot of laundry. Also we have a new-born baby in the house which means we don't have enough sleep. Together these facts mean that we do a lot of laundry, and frequently forget to check on the machine.

This project is a simple one which will facilitate sending an alarm when the washing machine finishes.

Hardware

The hardware for this project is simple:

• 1 x WeMos Mini D1 - Approximately €2.50.
• 1 x Vibration sensor - Approximately €0.80.

Wiring the project is very simple, and merely consists of connecting the vibration alarm to the Mini D1 board, which is powered by a simple USB-PSU:

1. Vcc -> Vcc
2. Group -> Ground
3. DO ("Digital Out") -> WeMos D1 D1

 

Vibration Sensor:

Software

The software for this project is pretty simple it just involved a lot of patience to test. In short we sample the vibration sensor every 30 seconds, for five minutes. We read a "1" when there is a vibration, and a "0" when there is none.

We define a set of states:

• QUIET
  • No vibrations were heard in the previous five minutes. This is the starting state.
• NOISY
  • Vibrations were heard in the previous five minutes.
  • In my case I regard things as "noisy" if 3, or more, of the 10 samples were showing vibration.
• FINISHED
  • This is the magic state which means we're done.

So the code samples for five minutes, then decides what state it is in based on the previous state. If there were no vibrations over the previous five minutes - but the five minutes before that there were then we're finished, for example.

Hopefully my logic is readable and correct.

The software will also connect to the local WiFi network on startup, and will serve a HTTP-page showing the previous ten samples, and the current state.

Every time a state-transition occurs the device will make a HTTP-call to another server which will be responsible for actually alerting when we see "FINISHED" for the first time.

The Code

The complete code looks like this:

/*
   Washing Machine Alarm - https://steve.fi/Hardware/

   This script is designed to alert me/us to the finish of
   a washing-machine cycle.

    We're using a state-machine to keep track of where things
    are.  We're always in one of three states:

      QUIET

      RUNNING

      FINISHED

   To determine which state we're inside we read the vibration
   sensor every 30 seconds, for five minutes.  If we receive three
   motion-events we decide we've got movement, otherwse we do
   not.  This allows the state to be updated appropriately.

   If you use this you'll want to change the WiFi details (`SCOTLAND` +
   `highlander1`), as well as the reporting URL in the function
   `log_state()` - that triggers real notification.  Annoyingly the
   D1 doesn't really support HTTPS or I'd do that directly.

*/



#include <ESP8266WiFi.h>


// HTTP
#include <ESP8266HTTPClient.h>

#define VIB_PIN D1

//
// WiFi details.
//
const char* ssid = "SCOTLAND";
const char* password = "highlander1";


//
// We work out our state by sampling ten times, once every 30 seconds.
//
bool history_records [10];
int history_num = 0;


//
// We'll use an enum to keep track of states
//
enum state_t
{
    quiet,
    noisy,
    finished
};


//
// The current state.
//
state_t state = quiet;




//
// We'll be running a HTTP-server on port 80.
//
WiFiServer server(80);



//
// Called once to set things up.
//
void setup()
{
    // Setup serial-output
    Serial.begin(115200);
    delay(10);

    // Connect to WiFi network
    WiFi.mode(WIFI_STA);
    WiFi.hostname("washing-monitor");
    WiFi.begin(ssid, password);

    // Wait until we're connected.
    Serial.println(" WiFi connecting ..");

    while (WiFi.status() != WL_CONNECTED)
    {
        delay(500);
        Serial.print(".");
    }

    Serial.println("WiFi connected");

    // Start the (HTTP)-server
    server.begin();
    Serial.println("Server started");

    // Print the IP address
    Serial.print("Use this URL to connect: ");
    Serial.print("http://");
    Serial.print(WiFi.localIP());
    Serial.println("/");
}


//
// Called constantly to respond to things.
//
void loop()
{
    // Last time we checked the vibration-state.
    static long last_update = 0;

    // The last time we finished a laundry cycle.
    static long  finished_time = 0;

    // Check if a web-client has connected
    WiFiClient client = server.available();

    // If they have then we're good.
    if (client)
    {
        // Wait until the client sends some data
        while (client.connected() && !client.available())
            delay(1);

        //
        // Read the first line of the request
        //
        // We just log this, but useful to see.
        String request = client.readStringUntil('\r');
        Serial.println(request);
        client.flush();


        // Return the response: header.
        client.println("HTTP/1.1 200 OK");
        client.println("Content-Type: text/html");
        client.println("");

        // Return the response: body.
        client.println("<!DOCTYPE HTML>");
        client.println("<html><head><title>Washing Machine</title><meta http-equiv=\"refresh\" content=\"5\"/></head><body>");

        if (state == quiet)
            client.println("<h1>Washing Machine</h1><blockquote><p>Current state is QUIET.</p></blockquote>");

        if (state == noisy)
            client.println("<h1>Washing Machine</h1><blockquote><p>Current state is RUNNING.</p></blockquote>");

        if (state == finished)
            client.println("<h1>Washing Machine</h1><blockquote><p>Current state is FINISHED.</p></blockquote>");


        //
        // Show the state of the samples.
        //
        client.println("<h2>History</h2><blockquote>");
        client.println("<table cellspacing=\"5\" cellpadding=\"5\" border=\"1\">");
        client.println("<tr><th>Sample</th><th>Vibration?</th></tr>");

        for (int i = 0; i < 11; i++)
        {
            client.print("<tr><td>");
            client.print(i);

            // Current reading?
            if (history_num == i)
                client.print(" * ");

            client.print("</td>");
            client.print("<td>");

            if (i < history_num)
            {
                if (history_records[i])
                    client.print("true");
                else
                    client.print("false");
            }
            else
            {
                client.print("?");
            }

            client.println("</td></tr>");
        }

        client.println("</table></blockquote>");


        client.print("<p>Next sample in ");
        long next = 30 - ((millis() - last_update) / 1000);
        client.print(next);
        client.println(" seconds.</p>");


        client.println("</body></html>");
        delay(1);
        Serial.println("Client disconnected");
    }


    //
    // Should we update our sensor state?
    //
    // We do so if a) we've never updated (i.e. just booted), or
    // b) it was more than 30 seconds since our last update.
    //
    long now = millis();

    if ((last_update == 0) || (abs(now - last_update) > 1000 * 30))
    {
        // Read the sensor
        history_records[ history_num ] = digitalRead(VIB_PIN) ;

        // Show on the serial console
        Serial.print("Sampling for reading: ");
        Serial.print(history_num);
        Serial.print(" read: ");
        Serial.println(history_records[ history_num ]);

        // Bump our count
        history_num ++;

        // Record when we read this value
        last_update = now;

        //
        // If we've now read 10 entries we've finished our
        // testing-phase, so we want to see if our state has
        // changed.
        //
        if (history_num > 10)
        {
            //
            // Work out what state-transition to make, if any.
            //
            // The state depends on the *CURRENT* state, as well
            // as the last five minutes of updates.
            //
            switch (state)
            {
            case  quiet:
            {
                if (is_quiet())
                {
                    // still quiet - no change
                    Serial.println("Old state: Quiet - New State: Quiet");
                }
                else
                {
                    // went from quiet to noisy?
                    state = noisy;
                    Serial.println("Old state: Quiet - New State: Noisy");
                }

                break;
            }

            case noisy:
            {
                // if we're noisy that means the machine is running
                if (is_quiet())
                {
                    state = finished;
                    Serial.println("Old state: Noisy - New State: Finished");
                    finished_time = now;
                }
                else
                {
                    state = noisy ;  // no change
                    Serial.println("Old state: Noisy - New State: Noisy");
                }

                break;
            }

            case finished:
            {
                Serial.println("Old state: Finished - New State: Finished");

                //
                // If we finished a long time ago then we can reset
                //
                // Here we say that after 30 minutes of finishing we
                // go back to the quiet time, awaiting a new load of
                // laundry.
                //
                if ((now - finished_time) > (1000 * 60 * 30))
                {
                    state = quiet;
                }

                break;
            }



                // Now log the state - after the end of the five minute sampling
                // period.
            log_state(state);
            }

            // And now we reset our monitoring state.
            history_num = 0;
        }
    }
}


//
// Is the vibration-sensor 100% quiet?
//
bool is_quiet()
{
    int sum = 0;

    for (int i = 0; i < 10; i++)
        sum += history_records[i];

    return (sum == 0);
}

//
// Is motion detected?  We use a threshold of 3/10 periods.
//
bool is_motion()
{
    int sum = 0;

    for (int i = 0; i < 10; i++)
        sum += history_records[i];

    return (sum >= 3);
}

//
// Log the state to a remote HTTP-server
//
void log_state(state_t s)
{
    char url[128];


    HTTPClient client;

    if (s == quiet)
        sprintf(url, "http://192.168.10.64/cgi-bin/washing.cgi?state=quiet");
    else if (s == noisy)
        sprintf(url, "http://192.168.10.64/cgi-bin/washing.cgi?state=noisy");
    else if (s == finished)
        sprintf(url, "http://192.168.10.64/cgi-bin/washing.cgi?state=finished");
    else
        sprintf(url, "http://192.168.10.64/cgi-bin/washing.cgi?state=UNKNOWN");

    client.begin(url);

    // httpCode will be negative on error
    int httpCode = client.GET();
    Serial.printf("[HTTP] GET resulted in code: %d\n", httpCode);

    if (httpCode > 0)
    {
        // file found at server
        if (httpCode == HTTP_CODE_OK)
        {

            // Get the body of the response.
            // This uses some hellish String object.
            String payload = client.getString();

            Serial.println(payload);
        }
    }
    else
    {
        Serial.printf("[HTTP] GET... failed, error: %s\n", client.errorToString(httpCode).c_str());

    }

    client.end();
}

Download the code.

Onboard HTTP Server

As mentioned the code will also launch a HTTP-server, which will output the current state, as well as the vibration-records which have been stored. The result is a very simple page looking like this:

The asterisk denotes the current reading - so the readings above that are current, and below are from the previous 5minute interval.

Future Challenges?

It might be nice to make the alerting more local - for example a buzzer could make an annoying noise, or we could play an MP3.

Recent Changes

The state transition handled the obvious case, right from the start:

• Quiet (not running) -> Noisy (running) -> Quiet (finished)

But there was no transition back, so I've added a record of the cycle finishing - that way 30 minutes after we hit the "finished" state we revert back to the "quiet" phase. This means you no longer need to reset the device to track another cycle.