View source for SugarBush - The Firmware

=platformio.ini=
Yes, this looks insanely complex...

The good news is that it's fairly straightforward once you wrap your head around what the various parts do.

* <span style="color: rgb(51, 153, 102);" data-mce-style="color: #339966;">'''[env]'''</span> is fairly obvious. It's the definition of the hardware...
* <span style="color: rgb(51, 153, 102);" data-mce-style="color: #339966;">'''[common]'''</span> is all the stuff that's '''common''' to all of the builds.
* <span style="color: rgb(51, 153, 102);" data-mce-style="color: #339966;">'''[env:WhatEver]'''</span> blocks are the magic part. They define the differences between all of the various builds.

Note things like <span style="color: rgb(255, 0, 0);" data-mce-style="color: #ff0000;">${common.lib_deps}</span> & <span style="color: rgb(255, 0, 0);" data-mce-style="color: #ff0000;">${common.build_flags}</span>, These simply pull in the stuff from <span><span style="color: #339966;" data-mce-style="color: #339966;">'''[common]'''</span> for each individual build.

<syntaxhighlight lang="ini" line="1">
[platformio]
; default_envs = SugarShack_Alert

[env]
platform = espressif8266
; For now, let's stick with the 8266 family MCUs
board = d1_mini

framework = arduino

monitor_speed = 115200
; I like my serial comms fast.  (Without this line you get the default of 9600)

[common]
lib_deps =
        PubSubClient
        SimpleTimer

build_flags =
        -D DEBUG        ; This is just plain handy.  Use it to turn debugging output on/off...
        ; -D DEBUG0       ; Show WiFi Debug info
        ; -D DEBUG1       ; Show extra WiFi Debug info
        ; -D DEBUG2       ; Show Sensor Debug info
        ; -D DEBUG3       ; Show extra Sensor Debug info
        ; -D DEBUG4       ; Show MQTT Debug info
        ; -D DEBUG5       ; Show Pixels Debug info
        -D WAP=2        ; Select the WiFi Access Point. (Might also select servers based on WAP choice)
                        ; WAP 0  = TinkerToys           (Test setup / Skeeter.tinkerNet.ca for MQTT)
                        ; WAP 1  = TinkerToysB          (Victoria Drive setup / SkyNet.tinkerNet.ca for MQTT)
                        ; WAP 2  = vanneck              (SugarBush setup / 192.168.0.222 for MQTT)
                        ; WAP 3  = paradise             (paradise / SkyNet.MillersParadise.ca for MQTT)
                        ; WAP 4+ = VictoriaDrive2B      ()

[env:SugarShack_Alert]
        ; Little noisy blinkenbox
        ;     4 Neopixels hung off GPIO 12
        ;     Speaker hung off GPIO 14
        ;       Pixel 1 GRN = 25%
        ;       Pixel 2 GRN = 50%
        ;       Pixel 3 GRN = 75%
        ;       All 4 RED = Tank Full!
        ;       Pixel 4 slowly blinking:
        ;         GRN = OK
        ;         ORA = No MQTT
        ;         RED = No WiFi
lib_deps =
        ${common.lib_deps}
        jfturcot/SimpleTimer
        Adafruit NeoPixel

build_flags =
        ${common.build_flags}
        -D SS_Alert
        -D d_Pixels
        -D d_Audio

[env:SugarShack_PHTank]
        ; Monitor depth probes in the PumpHouse Tank
        ;       ~25% Level: GPIO 4
        ;       ~50% Level: GPIO 5
        ;       ~75% Level: GPIO 12
        ;       100% Level: GPIO 13
        ; MIGHT need to do some sort of output for the relays on the lightbar
lib_deps =
        ${common.lib_deps}
        jfturcot/SimpleTimer

build_flags =
        ${common.build_flags}
        -D SS_PHTank
        -D s_Depth

[env:SugarShack_PHLightBar]
        ; Control the lightbar in the PupHouse camera view
lib_deps =
        ${common.lib_deps}

build_flags =
        ${common.build_flags}

[env:SugarShack_PHDumper]
        ; Monitor the dumper cycles
        ;       Switch on GPIO 4 (Maybe Hall-Effect...  Maybe Reed Switch...)
lib_deps =
        ${common.lib_deps}
        jfturcot/SimpleTimer

build_flags =
        ${common.build_flags}
        -D SS_Dumper

[env:SugarShack_RO]
        ; Monitor the R/O system
lib_deps =
        ${common.lib_deps}
build_flags =
        ${common.build_flags}

[env:SugarShack_Evaporator]
        ; Monitor the levels in the Evaporator
        ;       At least 2 depth probes
        ;       Some NeoPixels
        ;       Maybe a speaker
lib_deps =
        ${common.lib_deps}
build_flags =
        ${common.build_flags}

[env:SugarShack_BottlingTank]
        ; Monitor temperature in Bottling Tank
        ;       Maybe depth too...
lib_deps =
        ${common.lib_deps}
build_flags =
        ${common.build_flags}
[env:SugarShack_Climate]
        ; Monitor temperature, humidity & barometric pressure in the SugarShack
lib_deps =
        ${common.lib_deps}
build_flags =
        ${common.build_flags}

[env:SugarShack_HoldingTanks]
        ; Monitor depth probes in the Outside Holding Tanks
lib_deps =
        ${common.lib_deps}
build_flags =
        ${common.build_flags}
[env:SugarShack_FeedTank]
        ; Monitor depth probes in the Feed Tank for the Evaporator
        ;       (This unit will likely have more than 4 probes)
lib_deps =
        ${common.lib_deps}
build_flags =
        ${common.build_flags}

</syntaxhighlight>

=main.cpp=
<syntaxhighlight lang="cpp" line="1">
/*
 * Monitor tele/TankLevel
 * 
 * If Tank == PumpHouse && Level == 0
 *  Turn off all lights & Screamer
 * If Tank == PumpHouse && Level >= 25
 *  Turn on Light 1
 * If Tank == PumpHouse && Level >= 50
 *  Turn on Light 2
 * If Tank == PumpHouse && Level >= 75
 *  Turn on Light 3
 * If Tank == PumpHouse && Level >= 100
 *  Turn on Light Screamer
 */

/*
 * Maybe add a PAUSE button...
 *  (Disable the screamer for half an hour?)
 */

#include "libraries.h"
#include "functions.h"
#include "externs.h"
#include "TopSecret.h"

SimpleTimer timer;

#ifdef SS_Dumper
int ReedPin = 4;
int HallPin = 5;
// int  Dumptime = 0;
#endif // SS_Dumper

void setup()
{
  char debugTEXT[46];

  Serial.begin(115200);
  delay(500); // Delay to let the ESP get booted before sending out serial data
  debug_TitleScreen();

  // WiFi //////////////////////////////////////////////////////////////////////
  WiFi_init();
  debug_Separator();

  // MQTT //////////////////////////////////////////////////////////////////////
  MQTT_init();

// Pixels ////////////////////////////////////////////////////////////////////
#ifdef d_Pixels

  Pixels_init();

  for (int i = 0; i < PixelCount; i++)
  {
    SetAPixel(i, BLU);
  }

#endif // d_Pixels

// Depth Probes ////////////////////////////////////////////////////////////////
#ifdef s_Depth

  Depth_init();

#endif // d_Depth

// Audio ////////////////////////////////////////////////////////////////
#ifdef d_Audio

  Noise_init();

#endif // d_Audio

  // Hall-Effect ///////////////////////////////////////////////////////////////
#ifdef SS_Dumper
  debug_Separator();
  debug_SectionTitle("Hall Effect Sensor");
  pinMode(HallPin, INPUT);
  attachInterrupt(digitalPinToInterrupt(ReedPin), DumpDetect, CHANGE);
  sprintf(debugTEXT, "Reed Switch on pin %d", ReedPin);
  debug_LineOut(debugTEXT);
  attachInterrupt(digitalPinToInterrupt(HallPin), DumpDetect2, CHANGE);
  sprintf(debugTEXT, "Hall Effect Sensor on pin %d", HallPin);
  debug_LineOut(debugTEXT);
#endif // SS_Dumper

  // Interval Timers ///////////////////////////////////////////////////////////
  debug_Separator();
  debug_SectionTitle("Interval Timers");

  timer.setInterval(20, MQTT_handler);
  debug_LineOut("MQTT");

  timer.setInterval(2000, WiFi_Test);
  debug_LineOut("WiFiCheck");

#ifdef s_Depth
  timer.setInterval(5000, CheckProbes);
  debug_LineOut("Check Probes");
#endif // s_Depth

  // READY /////////////////////////////////////////////////////////////////////
  debug_ReadyScreen();
}

void loop()
{
  // Run the interval timers
  // Running processes here in loop() is a synchronous flow.
  // Running processes via the interval timers is assynchronous.
  // If your actions don't depend directly on each other,
  // synchronous flow makes no sense at all...
  timer.run();

#ifdef SS_Dumper
  //   This is just here to give me console output while developing...
  // Serial.print(".");
  // delay(1000);
#endif // SS_Dumper
}

</syntaxhighlight>

=Debugging.cpp=
<syntaxhighlight lang="cpp" line="1">
#include "libraries.h"
#include "functions.h"

void debug_TitleScreen()
{
    Serial.printf("\n\n#================================================#\n");
#ifdef SS_Alert
    Serial.printf("# SugarShack PumpHuose Alerter                   #\n");
    Serial.printf("# ESP With a Peizo & Pixels                      #\n");
    Serial.printf("+------------------------------------------------+\n");
#endif //SS_Alert
#ifdef SS_PHTank
    Serial.printf("# SugarShack PumpHuose Tank Monitor              #\n");
    Serial.printf("+------------------------------------------------+\n");
#endif // SS_PHTank
#ifdef SS_Dumper
    Serial.printf("# SugarShack PumpHuose Dumper Monitor            #\n");
    Serial.printf("+------------------------------------------------+\n");
#endif // SS_Dumper
    Serial.printf("# WiFi Enabled...                                #\n");
    Serial.printf("# Speaks fluent MQTT...                          #\n");
    Serial.printf("#================================================#\n");
}

void debug_ReadyScreen()
{
  Serial.printf("#================================================#\n");
  Serial.printf("#                 Ready To Run.                  #\n");
  Serial.printf("#================================================#\n");
}

void debug_Separator()
{
    Serial.printf("+------------------------------------------------+\n");
}

void debug_SectionTitle(const char *Title)
{
    Serial.printf("| %-46s |\n", Title);
}

void debug_LineOut(const char *Line)
{
    Serial.printf("|    %-43s |\n", Line);
}

void debug_Action(const char *Line)
{
    {
        const char* SPACE = "                              ";
        char BUFFER[100];
        char BUFFER2[100];

        int BuffSize = (23 - (strlen(Line) / 2));

        strcpy(BUFFER, SPACE);
        BUFFER[BuffSize] = '\0';

        sprintf(BUFFER2, "%s%s", BUFFER, Line);
        Serial.printf("| %-46s |\n", BUFFER2);
    }
}

void debug_Trouble(const char *Line)
{
    Serial.printf("* %-46s *\n", Line);
}

void debug_Success(const char *Line)
{
    Serial.printf("+ %-46s +\n", Line);
}

void debug_ProgressBar0()
{
        Serial.printf("| ");
}
void debug_ProgressBar1()
{
            Serial.printf(".");

}
void debug_ProgressBar2(int dotcount)
{
        for (int i = 0; i < (47 - dotcount); i++)
        {
            Serial.printf(" ");
        }
        Serial.printf("|\n");
}

</syntaxhighlight>

=WiFi.cpp=
<syntaxhighlight lang="cpp" line="1">
#include "libraries.h"
#include "functions.h"

////////////////////////////////////////////////////////////////
// These exist because the variables are declared elsewhere in
// the project.  (Specifically, in TopSecret.h)
extern char *WiFi_ssid;
extern char *WiFi_password;
extern char *WiFi_ClientName;
////////////////////////////////////////////////////////////////

// Initialize the WiFi
//
// If we don't get a connection, we just keep trying forever.
// Probably be an idea to eventually just give up, but most
// ESP8266 devices are kinda useless without the connection...
void WiFi_init()
{
    char debugTEXT[46];

    WiFi.mode(WIFI_STA); // Connecting as a STATION
    WiFi.begin(WiFi_ssid, WiFi_password);

    // We start by connecting to a WiFi network
    sprintf(debugTEXT, "Connecting to: %-22s", WiFi_ssid);
    debug_SectionTitle(debugTEXT);
    {
        debug_ProgressBar0();
        int dotcount = 0;
        while (WiFi.status() != WL_CONNECTED) // Give it a bit of time to establish the WiFi connection...
        {
            dotcount++;
            delay(500);
            debug_ProgressBar1();
            if (dotcount >= 46)
            {
                debug_ProgressBar2(dotcount);
                dotcount = 0;
                debug_ProgressBar0();
            }
            // SSD1306_Static("  no WiFi  ", 3);
        }
        debug_ProgressBar2(dotcount);
    }
    sprintf(debugTEXT, "WiFi connected on Channel %-2d", WiFi.channel());
    debug_LineOut(debugTEXT);
    sprintf(debugTEXT, "IP address: %-15s", WiFi.localIP().toString().c_str());
    debug_LineOut(debugTEXT);

    sprintf(debugTEXT, "My name is NOT %-22s", wifi_station_get_hostname());
    debug_LineOut(debugTEXT);
    sprintf(debugTEXT, "Really... It's %-22s", WiFi_ClientName);
    debug_LineOut(debugTEXT);

    // SSD1306_Static(" WiFi good ", 3);

    // Add "build_flags = -D DEBUG1" to your platformio.ini to get some extra WiFi stats
#ifdef DEBUG1
    WiFi.printDiag(Serial);
    sprintf(debugTEXT, "RSSI: %d dBm", WiFi.RSSI());
    debug_LineOut(debugTEXT);
    sprintf(debugTEXT, "HostName: %-13s !!!! BULLSHIT !!!!", WiFi.hostname().c_str());
    debug_LineOut(debugTEXT);
    // Apparently, the ESP8266WiFi library does not actually support DHCP completely
    // { https://www.reddit.com/r/arduino/comments/d6mvc7/getting_hostname_from_dhcp_with_esp8266/ }
    // { https://github.com/esp8266/Arduino/issues/5695 }
#endif
}

int WiFi_strength()
{
    return (WiFi.RSSI());
}

int blip[3] = {000, 255, 000};  // GRN

void WiFi_Test()  // Is Good...  Maybe
{
    if (WiFi.status() != WL_CONNECTED)
    {
        Serial.println("Oh Poop!");
        blip[0] = 128;
        blip[1] = 128;
    }
    else
    {
    if (blip[1] == 255)
        blip[1] = 0;
    else
        blip[1] = 255;
    }
#ifdef d_Pixels
    SetAPixel(3, blip);
#endif // d_Pixels
}

int blip2[3] = {255, 000, 000}; // RED

void WiFi_Test2() // Lost WiFi
{
    if (blip2[0] == 255)
        blip2[0] = 0;
    else
        blip2[0] = 255;
#ifdef d_Pixels
    SetAPixel(3, blip2);
#endif // d_Pixels
}

int blip3[3] = {255, 128, 000}; // ORA

void WiFi_Test3() // lost MQTT
{
    if (blip3[0] == 255)
    {
        blip3[0] = 0;
        blip3[1] = 0;
        blip3[2] = 0;
    }
    else
    {
        blip3[0] = 255;
        blip3[1] = 128;
        blip3[2] = 000;
    }
#ifdef d_Pixels
    SetAPixel(3, blip3);
#endif // d_Pixels
}</syntaxhighlight>

=MQTT.cpp=
<syntaxhighlight lang="cpp" line="1">
#include "libraries.h"
#include "functions.h"
#include "externs.h"

#include "MQTT.h"

WiFiClient espClient;
PubSubClient MQTT_client(espClient);

void MQTT_handler()
{
    if (!MQTT_client.connected())
    {
        MQTT_reconnect();
    }
    MQTT_client.loop();
    // MQTT_beacon();
}

////////////////////////////////////////////////////////////////
// MQTT Functions
////////////////////////////////////////////////////////////////

void MQTT_init()
{
    MQTT_client.setServer(MQTT_broker, 1883);
    MQTT_client.setCallback(MQTT_callback);

    //  Build the topic names
    strcpy(MQTT_inTopic, "cmnd/"); //  in - Commands
    strcat(MQTT_inTopic, MQTT_ClientName);
    strcat(MQTT_inTopic, "/#");
    strcpy(MQTT_teleTopic, "tele/"); // out - Telemetry
    strcat(MQTT_teleTopic, MQTT_ClientName);
    strcpy(MQTT_statTopic, "stat/"); // out - Status
    strcat(MQTT_statTopic, MQTT_ClientName);
    strcpy(MQTT_outTopic, "noti/"); // out - Notifications
    strcat(MQTT_outTopic, MQTT_ClientName);

    MQTT_reconnect();
}

void MQTT_callback(char *topic, byte payload[100], int length)
{
    char debugTEXT[46];

    char MQTT_msg_in[MQTT_BUFFER_SIZE];
    char *MQTT_command = strrchr(topic, '/');
    char CNasT[MQTT_BUFFER_SIZE];
    strcpy(CNasT, "/");
    strcat(CNasT, MQTT_ClientName); // "ClientName as Topic"

#ifdef DEBUG4
    debug_SectionTitle("Message arrived");
    sprintf(debugTEXT, "Topic: %30s", MQTT_command);
    debug_LineOut(debugTEXT);
#endif

    // if (length < MQTT_BUFFER_SIZE)
    // if (length < 63)
    // Messages 63 characters long or bigger make BOOM
    // with a "Soft WDT reset"
    // MQTT_BUFFER_SIZE is 100
    // I R cornfoozed...
    if (length < 59) // & now 59 is bad...  :|
    {

        MQTT_msg_in[0] = '\0'; // start with an empty string!
        for (int i = 0; i < length; i++)
        {
            MQTT_msg_in[i] = (char)payload[i];
            MQTT_msg_in[i + 1] = '\0';
        }

#ifdef DEBUG4
        sprintf(debugTEXT, "Message: %28s", MQTT_msg_in);
        debug_LineOut(debugTEXT);
        sprintf(debugTEXT, "Message Size: %d", length);
        debug_LineOut(debugTEXT);
#endif

        /////////////////////////////////////////////////////
        // Message handling goes here...
        /////////////////////////////////////////////////////

        if (strcmp(MQTT_command, CNasT) == 0) // MQTT_ClientName as Topic
        {
            // Missing topic
#ifdef DEBUG4
            debug_Trouble("Missing topic...");
#endif
        }
        else if (strcmp(MQTT_command, "/Level") == 0) // Tank Level
        {
            if (strcmp(MQTT_msg_in, "") == 0)
            {
#ifdef DEBUG4
                debug_Trouble("No actual message...");
#endif
                // Might be a good way to request status...
            }
            else
            {
                int level = atoi(MQTT_msg_in);
                sprintf(debugTEXT, "Tank Level is: %d", level);
                debug_Action(debugTEXT);

#ifdef d_Pixels

                if (level == 0)
                {
                    SetAPixel(0, BLK);
                    SetAPixel(1, BLK);
                    SetAPixel(2, BLK);
                    SetAPixel(3, BLK);
                    STFU();
                }
                if (level >= 25)
                {
                    SetAPixel(0, GRN);
                    SetAPixel(1, BLK);
                    SetAPixel(2, BLK);
                    SetAPixel(3, BLK);
                    STFU();
                }
                if (level >= 50)
                {

                    SetAPixel(1, GRN);
                    SetAPixel(2, BLK);
                    SetAPixel(3, BLK);
                    STFU();
                }
                if (level >= 75)
                {
                    SetAPixel(2, GRN);
                    SetAPixel(3, BLK);
                    STFU();
                }
                if (level >= 100)
                {
                    SetAPixel(0, RED);
                    SetAPixel(1, RED);
                    SetAPixel(2, RED);
                    SetAPixel(3, RED);
                    ScreamBloodyMurder();
                }
#endif // d_Pixels
            }
        }
        else if (strcmp(MQTT_command, "/Dump") == 0) // Dumper has dumped
        {
            Boop();
        }
        else if (strcmp(MQTT_command, "/Screen") == 0) // Screen control
        {
            if (strcmp(MQTT_msg_in, "") == 0)
            {
#ifdef DEBUG4
                debug_Trouble("No actual message...");
#endif
                // Might be a good way to request status...
            }
            // else if ((strcmp(MQTT_msg_in, "1") == 0) || (strcmp(MQTT_msg_in, "ON") == 0))
            // SSD1306_on();
            // else if ((strcmp(MQTT_msg_in, "0") == 0) || (strcmp(MQTT_msg_in, "OFF") == 0))
            // SSD1306_off();
            // else if ((strcmp(MQTT_msg_in, "+") == 0) || (strcmp(MQTT_msg_in, "UP") == 0))
            // SSD1306_Bright();
            // else if ((strcmp(MQTT_msg_in, "-") == 0) || (strcmp(MQTT_msg_in, "DOWN") == 0))
            // SSD1306_Dim();
            else
                debug_Trouble("Say What?");
        }
        else
        {
#ifdef DEBUG4
            debug_Trouble("Dunno Whatcha want...");
#endif
        }
    }
    else
    {
#ifdef DEBUG4
        debug_Trouble("But, it's TOO Bloody Big!");
#endif
    }
}

void MQTT_reconnect()
{
    char debugTEXT[46];

    // Loop until we're reconnected
    while (!MQTT_client.connected())
    {
        /////////////////////////////////////////////////////////////////////////////////////////////////
        sprintf(debugTEXT, "WiFi:%d dBm", WiFi_strength());
        debug_Action(debugTEXT);
        /////////////////////////////////////////////////////////////////////////////////////////////////
        debug_SectionTitle("Attempting MQTT connection...");

        // Create a random client ID
        String clientId = MQTT_ClientName;
        clientId += String(random(0xffff), HEX);

        // Attempt to connect
        if (MQTT_client.connect(clientId.c_str()))
        {
            /////////////////////////////////////////////////////////////////////////////////////////////////
            sprintf(debugTEXT, "WiFi:%d dBm", WiFi_strength());
            debug_Action(debugTEXT);
            /////////////////////////////////////////////////////////////////////////////////////////////////
            // SSD1306_Static(" MQTT good ", 3);
            // delay(500);
            // SSD1306_Static("           ", 3);
            sprintf(debugTEXT, "connected to %-24s", MQTT_broker);
            debug_LineOut(debugTEXT);
            sprintf(debugTEXT, "My Name:  %-27s", MQTT_ClientName);
            debug_LineOut(debugTEXT);
            // Once connected, publish an announcement...
            char MQTT_statTopic_Device[100];
            strcpy(MQTT_statTopic_Device, MQTT_statTopic);
            strcat(MQTT_statTopic_Device, "/HELLO");
            // MQTT_client.publish(MQTT_statTopic_Device, "world");
            MQTT_client.publish(MQTT_statTopic_Device, WiFi_ssid);
            // ... and resubscribe
            MQTT_client.subscribe(MQTT_inTopic);
        }
        else
        {
            /////////////////////////////////////////////////////////////////////////////////////////////////
            sprintf(debugTEXT, "WiFi:%d dBm", WiFi_strength());
            debug_Action(debugTEXT);
            /////////////////////////////////////////////////////////////////////////////////////////////////

            if (WiFi.status() != WL_CONNECTED)
            {
                WiFi_Test2();
                debug_Trouble("UH OH!!!  No WiFi!!!");
            }
            else
            {
                // SSD1306_Static("  no MQTT  ", 3);
                WiFi_Test3();
                debug_Trouble("UH OH!!!  No MQTT!!!");
            }

            sprintf(debugTEXT, "failed, rc=%d", MQTT_client.state());
            debug_Trouble(debugTEXT);
            debug_Trouble("trying again in 2 seconds");
            // Wait 5 seconds before retrying
            delay(2000);
        }
    }
}

void MQTT_beacon()
{
    /* Beacon signal published at set interval to indicate the device
   * is still powered up and actively connected to MQTT...
   * A keepalive of sorts
   * also updates state within MQTT so it can be captured for
   * indicator light elsewhere
   * &, as a bonus, it's sending the WiFi strength.
   */
    char MQTT_statTopic_Device[100];
    char WiFiSignal[10];
    strcpy(MQTT_statTopic_Device, MQTT_statTopic);
    strcat(MQTT_statTopic_Device, "/WiFi_strength");
    sprintf(WiFiSignal, "%d dBm", WiFi_strength());
#ifdef DEBUG0
    debug_SectionTitle("WiFi:");
    debug_LineOut(WiFiSignal);
#endif

    MQTT_client.publish(MQTT_statTopic_Device, WiFiSignal);
    blinkLED(5);

#ifdef DEBUG4
    debug_Action("Beacon sent");
#endif
}

void MQTT_Status(char const *Device, char const *Status) // Send status messages
{
    char MQTT_statTopic_Device[100];
    strcpy(MQTT_statTopic_Device, MQTT_statTopic);
    strcat(MQTT_statTopic_Device, "/");
    strcat(MQTT_statTopic_Device, Device);

#ifdef DEBUG4
    char debugTEXT[46];

    sprintf(debugTEXT, "}- %16s = %-16s -{", Device, Status);
    debug_Trouble(debugTEXT);
#endif
    MQTT_client.publish(MQTT_statTopic_Device, Status);
}

void MQTT_SendTELE(const char *Topic, char *Message)
{
    char MQTT_teleTopic_Device[100];
    strcpy(MQTT_teleTopic_Device, MQTT_teleTopic);
    strcat(MQTT_teleTopic_Device, "/");
    strcat(MQTT_teleTopic_Device, Topic);
    MQTT_client.publish(MQTT_teleTopic_Device, Message);
}

void MQTT_SendSTAT(const char *Topic, char *Message)
{
    char MQTT_statTopic_Device[100];
    strcpy(MQTT_statTopic_Device, MQTT_statTopic);
    strcat(MQTT_statTopic_Device, "/");
    strcat(MQTT_statTopic_Device, Topic);
    MQTT_client.publish(MQTT_statTopic_Device, Message);
}

void MQTT_SendCMND(const char *Topic, char *Message)
{
    char MQTT_statTopic_Device[100];
    strcpy(MQTT_statTopic_Device, Topic);
    // strcat(MQTT_statTopic_Device, "/");
    // strcat(MQTT_statTopic_Device, Topic);
    MQTT_client.publish(MQTT_statTopic_Device, Message);
}

void HandleMessages()
{
}
</syntaxhighlight>

=Sensing=
==Depth.cpp==
<syntaxhighlight lang="cpp" line="1">
#include "libraries.h"
#include "functions.h"

/*
 * Puplish to tele/TankLevel
 * 
 * If all probes are high
 *  publish {"Tank":"PumpHouse", "Level":0}
 * If bottom probe is low
 *  publish {"Tank":"PumpHouse", "Level":25}
 * If bottom probe is low
 *  publish {"Tank":"PumpHouse", "Level":50}
 * If bottom probe is low
 *  publish {"Tank":"PumpHouse", "Level":75}
 * If bottom probe is low
 *  publish {"Tank":"PumpHouse", "Level":100}
 */

int Probe1 = 4; // no pullup...
int Probe2 = 5;
int Probe3 = 12; // no pullup...
int Probe4 = 13;

void Depth_init()
{
    char debugTEXT[46];
    debug_Separator();
    debug_SectionTitle("Configuring Depth Probes...");
    // pinMode(Probe1, INPUT_PULLUP);
    // pinMode(Probe2, INPUT_PULLUP);
    // pinMode(Probe3, INPUT_PULLUP);
    // pinMode(Probe4, INPUT_PULLUP);
    pinMode(Probe1, INPUT);
    pinMode(Probe2, INPUT);
    pinMode(Probe3, INPUT);
    pinMode(Probe4, INPUT);
#ifdef DEBUG
    sprintf(debugTEXT, "Depth Probes on GPIOs %d %d %d & %d", Probe1, Probe2, Probe3, Probe4);
    debug_LineOut(debugTEXT);
#endif
}

void CheckProbes()
{
    Serial.print("Probes: ");
    Serial.print(digitalRead(Probe1));
    Serial.print(" ");
    Serial.print(digitalRead(Probe2));
    Serial.print(" ");
    Serial.print(digitalRead(Probe3));
    Serial.print(" ");
    Serial.print(digitalRead(Probe4));
    Serial.println(" ");
    if (!digitalRead(Probe4)) // 14   D5
    {
        MQTT_SendTELE("Level", "{\"Tank\":\"PumpHouse\", \"Level\":100}");
        // MQTT_SendCMND("cmnd/SugarShack_Alarm/Level", "{\"Tank\":\"PumpHouse\", \"Level\":100}");
        MQTT_SendCMND("cmnd/SugarShack_Alarm/Level", "100");
        // Serial.println("PROBE 4");
    }
    // return 100;
    else if (!digitalRead(Probe3)) // 13   D7
    {
        MQTT_SendTELE("Level", "{\"Tank\":\"PumpHouse\", \"Level\":75}");
        // MQTT_SendCMND("cmnd/SugarShack_Alarm/Level", "{\"Tank\":\"PumpHouse\", \"Level\":75}");
        MQTT_SendCMND("cmnd/SugarShack_Alarm/Level", "75");
        // Serial.println("PROBE 3");
    }
    // return 75;
    else if (!digitalRead(Probe2)) // 12   D6
    {
        MQTT_SendTELE("Level", "{\"Tank\":\"PumpHouse\", \"Level\":50}");
        // MQTT_SendCMND("cmnd/SugarShack_Alarm/Level", "{\"Tank\":\"PumpHouse\", \"Level\":50}");
        MQTT_SendCMND("cmnd/SugarShack_Alarm/Level", "50");
        // Serial.println("PROBE 2");
    }
    // return 50;
    else if (!digitalRead(Probe1)) // 5    D1
    {
        MQTT_SendTELE("Level", "{\"Tank\":\"PumpHouse\", \"Level\":25}");
        // MQTT_SendCMND("cmnd/SugarShack_Alarm/Level", "{\"Tank\":\"PumpHouse\", \"Level\":25}");
        MQTT_SendCMND("cmnd/SugarShack_Alarm/Level", "25");
        // Serial.println("PROBE 1");
    }
    // return 25;
    else
    {
        MQTT_SendTELE("Level", "{\"Tank\":\"PumpHouse\", \"Level\":0}");
        // MQTT_SendCMND("cmnd/SugarShack_Alarm/Level", "{\"Tank\":\"PumpHouse\", \"Level\":0}");
        MQTT_SendCMND("cmnd/SugarShack_Alarm/Level", "0");
        // Serial.println("NO PROBE");
    }
    // return 0;
}
</syntaxhighlight>

==HallEffect.cpp==
<syntaxhighlight lang="cpp" line="1">
#include "libraries.h"
#include "functions.h"
#include "externs.h"

extern int ReedPin;
extern int HallPin;

 unsigned long Dumptime;
 unsigned long TIK = 0;
 unsigned long TOK = 0;

volatile bool DiDiT;

void ICACHE_RAM_ATTR DumpDetect()
{
    char debugTEXT[46];

    TOK = millis();
    Dumptime = (TOK - TIK) / 1000;
    TIK = TOK;

    if ((digitalRead(ReedPin) == HIGH) && (!DiDiT))
    {
        DiDiT = true;
        sprintf(debugTEXT, "{\"Device\":\"Dumper\",\"Type\":\"Reed A\",\"Time\":%d}", Dumptime);
        MQTT_SendTELE("Cycle", debugTEXT);
    Serial.printf("\nWoo Hoo!  It Dumped! (Reed A)\t(%d Seconds)", Dumptime);
    }
    else if ((digitalRead(ReedPin) == LOW) && (DiDiT))
    {
        DiDiT = false;
        sprintf(debugTEXT, "{\"Device\":\"Dumper\",\"Type\":\"Reed B\",\"Time\":%d}", Dumptime);
        MQTT_SendTELE("Cycle", debugTEXT);
    Serial.printf("\nWoo Hoo!  It Dumped! (Reed B)\t(%d Seconds)", Dumptime);
    }
}

void ICACHE_RAM_ATTR DumpDetect2()
{
    char debugTEXT[46];

    TOK = millis();
    Dumptime = (TOK - TIK) / 1000;
    TIK = TOK;

    sprintf(debugTEXT, "{\"Device\":\"Dumper\",\"Type\":\"Hall\",\"Time\":%d}", Dumptime);
    MQTT_SendTELE("Cycle", debugTEXT);
    Serial.printf("\nWoo Hoo!  It Dumped! (Hall)\t(%d Seconds)", Dumptime);
}
</syntaxhighlight>

=Alerts=
==Noise.cpp==
<syntaxhighlight lang="cpp" line="1">
#include "libraries.h"
#include "functions.h"
#include "Noise.h"

void Noise_init()
{
  char debugTEXT[46];

  debug_Separator();
  debug_SectionTitle("Configuring Audio");
    sprintf(debugTEXT, "Configured speaker/piezo on pin %d", piezoPin);
  debug_LineOut(debugTEXT);
}

void ScreamBloodyMurder()
{
    for (int counter = 0; counter < 5; counter++)
    {
        tone(piezoPin, 666);
        delay(500);
        noTone(piezoPin);
        tone(piezoPin, 333);
        delay(500);
        noTone(piezoPin);
    }
    debug_Action("Holy POOP!  The Pumphouse is gonna flood!");
}

void STFU()
{
    noTone(piezoPin);
}

void Boop()
{
    tone(piezoPin, 111);
        debug_Action("BOOP!");
        delay(125);
        noTone(piezoPin);
}#include "libraries.h"
#include "functions.h"
#include "Noise.h"

void Noise_init()
{
  char debugTEXT[46];

  debug_Separator();
  debug_SectionTitle("Configuring Audio");
    sprintf(debugTEXT, "Configured speaker/piezo on pin %d", piezoPin);
  debug_LineOut(debugTEXT);
}

void ScreamBloodyMurder()
{
    for (int counter = 0; counter < 5; counter++)
    {
        tone(piezoPin, 666);
        delay(500);
        noTone(piezoPin);
        tone(piezoPin, 333);
        delay(500);
        noTone(piezoPin);
    }
    debug_Action("Holy POOP!  The Pumphouse is gonna flood!");
}

void STFU()
{
    noTone(piezoPin);
}

void Boop()
{
    tone(piezoPin, 111);
        debug_Action("BOOP!");
        delay(125);
        noTone(piezoPin);
}
</syntaxhighlight>

==Pixels.cpp==
<syntaxhighlight lang="cpp" line="1">
#ifdef d_Pixels

#include "libraries.h"
#include "functions.h"
#include "Pixels.h"

void Pixels_init()
{
  char debugTEXT[46];

  debug_Separator();
  debug_SectionTitle("Configuring Pixels");

  pixels.begin();
  for (int i = 0; i < PixelCount; i++)
  {
    SetAPixel(i, BLK);
  } // strip.clear(); would be better if it worked right!
  // for(int i = 0; i < 8; i++) { pixels1.setPixelColor(i, 0, 0, 0); }
  pixels.setBrightness(PixelBright);
  pixels.show();

  sprintf(debugTEXT, "Configured %d Pixels on pin %d", PixelCount, PixelPin);
  debug_LineOut(debugTEXT);
  sprintf(debugTEXT, "Brightness: %d", PixelBright);
  debug_LineOut(debugTEXT);
}

void SetAPixel(int PixelNumber, int Colour[])
{
  char debugTEXT[46];
  // Serial.printf(" -> %d, %d\n", PixelNumber, Colour);
  pixels.setPixelColor(PixelNumber, Colour[0], Colour[1], Colour[2]);
  pixels.show();
#ifdef DEBUG5
  sprintf(debugTEXT, "Pixel %d Pixel colour: %03d,%03d,%03d", PixelNumber, Colour[0], Colour[1], Colour[2]);
  debug_LineOut(debugTEXT);
#endif
}

#endif // d_Pixels
</syntaxhighlight>

=Controls=
==Triggers.cpp==
<syntaxhighlight lang="cpp" line="1">
/*
 * Simple GPIO pull downs to turn on relays...
 */

</syntaxhighlight>

=Header Files=

==TopSecret.h==
<syntaxhighlight lang="cpp" line="1">
#ifndef TOPSECRET_H
#define TOPSECRET_H

#ifdef SugarBush
const char* WiFi_ClientName = "SugarShack_Climate";
const char* MQTT_ClientName = "SugarShack_Climate";
const char* DISP_Title = "SugarBush";
#elif SugarBushDev
const char* WiFi_ClientName = "SugarShack_Climate_Dev";
const char* MQTT_ClientName = "SugarShack_Climate_Dev";
const char* DISP_Title = "SugarBush";
#elif SS_Alert
const char* WiFi_ClientName = "SugarShack_Alarm";
const char* MQTT_ClientName = "SugarShack_Alarm";
const char* DISP_Title = "SugarBush";
#elif SS_PHTank
const char* WiFi_ClientName = "SugarShack_TankLevel";
const char* MQTT_ClientName = "SugarShack_TankLevel";
const char* DISP_Title = "SugarBush";
#elif SS_Dumper
const char* WiFi_ClientName = "SugarShack_Dumper";
const char* MQTT_ClientName = "SugarShack_Dumper";
const char* DISP_Title = "SugarBush";
#else
const char* WiFi_ClientName = "Test";
const char* MQTT_ClientName = "Test";
const char* DISP_Title = "Dude!";
#endif

// WiFi

#if WAP==0
const char* WiFi_ssid = "TinkerToys";
const char* WiFi_password = "Password";
const char* MQTT_broker = "skeeter.tinkernet.ca";
const char* MQTT_user = "";
const char* MQTT_pass = "";

#elif WAP==1
const char* WiFi_ssid = "TinkerToysB";
const char* WiFi_password = "Password";
const char* MQTT_broker = "skynet.tinkernet.ca";
const char* MQTT_user = "";
const char* MQTT_pass = "";
#elif WAP==2
const char* WiFi_ssid = "vanneck";
const char* WiFi_password = "Password";
const char* MQTT_broker = "192.168.0.222";
const char* MQTT_user = "";
const char* MQTT_pass = "";
#elif WAP==3
const char* WiFi_ssid = "paradise";
const char* WiFi_password = "Password";
const char* MQTT_broker = "skynet.millersparadise.ca";
const char* MQTT_user = "";
const char* MQTT_pass = "";
#else
const char* WiFi_ssid = "VictoriaDrive2B";
const char* WiFi_password = "Password";
const char* MQTT_broker = "skynet.tinkernet.ca";
const char* MQTT_user = "";
const char* MQTT_pass = "";
#endif

#endif // TOPSECRET_H
</syntaxhighlight>

== MQTT.h ==
<syntaxhighlight lang="cpp" line="1">
#ifndef MQTT_H
#define MQTT_H

#define MQTT_BUFFER_SIZE (100)       // This number is arbitrary
                                    // Topic can be up to 65,536 bytes
                                    // Message can be up to 268,435,456 bytes

char MQTT_outTopic[MQTT_BUFFER_SIZE];
char MQTT_inTopic[MQTT_BUFFER_SIZE];
char MQTT_teleTopic[MQTT_BUFFER_SIZE];
char MQTT_statTopic[MQTT_BUFFER_SIZE];

char MQTT_msg_out[MQTT_BUFFER_SIZE *10];

unsigned long beacon_timer = 0;
#define BEACON_INTERVAL 30000 // Timer interval for the "keep-alive" status beacon

extern char *MQTT_broker;
extern char *MQTT_user;
extern char *MQTT_pass;
extern char *MQTT_ClientName;

extern char *WiFi_ssid;

#endif  // MQTT_H
</syntaxhighlight>

== functions.h ==
<syntaxhighlight lang="cpp" line="1">
#ifndef FUNCTIONS_H
#define FUNCTIONS_H

// WiFi ////////////////////////////////////////////////////////////////////////

void WiFi_init();       // Initialize the WiFi
int WiFi_strength();    // Check the signal strength
void WiFi_Test();
void WiFi_Test2();
void WiFi_Test3();

// MQTT ////////////////////////////////////////////////////////////////////////

void MQTT_init();

void MQTT_callback(char *topic, byte *payload, int length);
void MQTT_reconnect();
void MQTT_beacon();

void MQTT_handler();

void MQTT_SendTELE(const char *Topic, char *Message);
void MQTT_SendSTAT(const char *Topic, char *Message);
void MQTT_SendCMND(const char *Topic, char *Message);

void HandleMessages();

// Supplimental Stuff //////////////////////////////////////////////////////////

void blinkLED(int speed); // Just a little function to blink the LED

// Debug ///////////////////////////////////////////////////////////////////////
void debug_TitleScreen();                   // Title block for the project
void debug_ReadyScreen();                   // Indicate setup is finished
void debug_Separator();                     // Make a line
void debug_SectionTitle(const char* Title); // Text at the left
void debug_LineOut(const char* Line);       // Text 3 characters inset
void debug_Action(const char* Line);        // Text centred
void debug_Trouble(const char* Line);       // 
void debug_Success(const char* Line);       // 
void debug_ProgressBar0();
void debug_ProgressBar1();
void debug_ProgressBar2(int dotcount);

// Pixels //////////////////////////////////////////////////////////////////////
void Pixels_init();
void SetAPixel(int, int*);

// Noise ///////////////////////////////////////////////////////////////////////
void Noise_init();
void ScreamBloodyMurder();
void STFU();
void Boop();

// Depth Probes ////////////////////////////////////////////////////////////////
void Depth_init();
void CheckProbes();

// Hall Effect Trigger /////////////////////////////////////////////////////////
void DumpDetect();
void DumpDetect2();

#endif // FUNCTIONS_H
</syntaxhighlight>

== libraries.h ==
<syntaxhighlight lang="cpp" line="1">
#ifndef LIBRARIES_H
#define LIBRARIES_H

// WiFi ////////////////////////////////////////////////////////////////////////
#include <ESP8266WiFi.h>

// MQTT ////////////////////////////////////////////////////////////////////////
#include <PubSubClient.h>

// Supplimental Stuff //////////////////////////////////////////////////////////
#include <SimpleTimer.h>

#include <Wire.h>

// Pixels //////////////////////////////////////////////////////////////////////
#ifdef d_Pixels
#include <Adafruit_NeoPixel.h>
#endif

#endif // LIBRARIES_H
</syntaxhighlight>

== externs.h ==
<syntaxhighlight lang="cpp" line="1">
#ifndef EXTERNS_H
#define EXTERNS_H

#ifdef d_Pixels

extern int RED[];
extern int GRN[];
extern int BLU[];
extern int BLK[];
extern int YEL[];
extern int PixelCount;


#endif // d_Pixels

#endif // EXTERNS_H
</syntaxhighlight>

== Noise.h ==
<syntaxhighlight lang="cpp" line="1">
#ifndef NOISE_H
#define NOISE_H

int piezoPin = 14;

#endif // NOISE_H
</syntaxhighlight>

== Pixels.h ==
<syntaxhighlight lang="cpp" line="1">
#ifndef PIXELS_H
#define PIXELS_H

///////////////////////////////////////////////////
// Which pin is your neoPixel strip connected to
#define PixelPin 12    // GPIO13 / Tarduino D7
int PixelCount = 4;
#define OBL 2

Adafruit_NeoPixel pixels = Adafruit_NeoPixel(PixelCount, PixelPin, NEO_GRB + NEO_KHZ800);


// Setup some constants for use in SetAPixel()

//int Bright1 = 6;    // 0-255    //  No-Name strip
//int Bright2 = 1;    // 0-255    //  AdaFruit strip

int PixelBright = 5;    // 0-255    //  No-Name strip

// The colours:
int RED[] = {255, 000, 000};
int GRN[] = {000, 255, 000};
int BLU[] = {000, 000, 255};
int BLK[] = {000, 000, 000};
int YEL[] = {255, 255, 000};

#endif // PIXELS_H
</syntaxhighlight>