View source for Modular ESP Firmware - Modularization - source code

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

#include <stdint.h>
#include <Arduino.h>

#include <ESP8266WiFi.h>

void setup_wifi();

#include <PubSubClient.h>

void setup_mqtt();

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

void DOtheBloodyMQTT();

void setup();
void loop();

bool getTimer(unsigned long &timer, unsigned long interval);
void blinkLED();                // Just a little function to blink the LED for the beacon function.
void DoLights(char *WhatToDo);  // Turn LED on/off
void DoAnswer(char *WhatToDo);  // Send back text
void DoControl(char *WhatToDo); // Send MQTT to another device/topic

#endif // FUNCTIONS_H

</syntaxhighlight>

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

// WiFi
// Store your WiFi credentials here.
// Update these with values suitable for your network.

#define WAP 0
//  Allow testing on the various networks at the lab...
#if WAP==0
const char* WiFi_ssid = "TinkerToys";
const char* WiFi_password = "password";
#elif WAP==1
const char* WiFi_ssid = "TinkerToysB";
const char* WiFi_password = "password";
#elif WAP==2
const char* WiFi_ssid = "vanneck";
const char* WiFi_password = "password";
#else
const char* WiFi_ssid = "VictoriaDrive2B";
const char* WiFi_password = "password";
#endif

const char* WiFi_ClientName = "GimmeAName";

// MQTT
// Store your MQTT credentials here.
// Update these with values suitable for your network.

// Set BrokerName OR BrokerIP, not both...
const char* MQTT_broker = "BROKER.DOMAIN.TLD";
// const int*  MQTT_BrokerIP = { 192, 168, 0, 12 };

const char* MQTT_user = "";
const char* MQTT_pass = "";

const char* MQTT_ClientName = "GimmeAName";

#endif // TOPSECRET_H

</syntaxhighlight>

=== BotSecret.h ===
<syntaxhighlight lang="cpp" line="1">
#ifndef BOTSECRET_H
#define BOTSECRET_H

////////////////////////////////////////////////////////////////
extern char* WiFi_ssid;
extern char* WiFi_password;
extern char* WiFi_ClientName;
////////////////////////////////////////////////////////////////

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

#endif // BOTSECRET_H

</syntaxhighlight>

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

#define MQTT_BUFFER_SIZE (50)       // This number is arbitrary

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];

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

#endif  // MQTT_H

</syntaxhighlight>

=== main.cpp ===
<syntaxhighlight lang="cpp" line="1">
#include "TopSecret.h"
#include "functions.h"

////////////////////////////////////////////////////////////////
//
//  This version roughly based on principles from:
//    https://community.platformio.org/t/tutorial-for-creating-multi-cpp-file-arduino-project/5830/43
//
//  Need to look further into "extern"
//    https://stackoverflow.com/questions/10422034/when-to-use-extern-in-c
//
////////////////////////////////////////////////////////////////

void setup()
{
  Serial.begin(115200);
  delay(50); // Delay to let the ESP get booted before sending out serial data
  Serial.printf("\n+---------------------------------------+\n");
  Serial.printf("|           ESP MQTT Testing            |\n");
  Serial.printf("+---------------------------------------+\n");

  setup_wifi();

  setup_mqtt();

  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, HIGH);

}

void loop()
{
  // put your main code here, to run repeatedly:
  DOtheBloodyMQTT();
}

</syntaxhighlight>

=== Wifi.cpp ===
<syntaxhighlight lang="cpp" line="1">
#include "functions.h"
#include "BotSecret.h"

////////////////////////////////////////////////////////////////
// WiFi Functions
////////////////////////////////////////////////////////////////

void setup_wifi()
{

  // We start by connecting to a WiFi network
  Serial.printf("|                                       |\n");
  Serial.printf("| Connecting to: %-22s |\n", WiFi_ssid);
  Serial.printf("| ");

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

  int dotcount = 0;
  while (WiFi.status() != WL_CONNECTED) // Give it a bit of time to establish the WiFi connection...
  {
    dotcount++;
    delay(500);
    Serial.printf(".");
  }

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

  Serial.printf("| WiFi connected on Channel %-2d          |\n", WiFi.channel());
  // Serial.printf("|Channel: %d\n", WiFi.channel());
  Serial.printf("| IP address: %-15s           |\n", WiFi.localIP().toString().c_str());
  Serial.printf("+---------------------------------------+\n");

#ifdef DEBUG0
  WiFi.printDiag(Serial);
#endif
}

</syntaxhighlight>

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

#include "MQTT.h"

WiFiClient espClient;
PubSubClient MQTT_client(espClient);

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

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

void setup_mqtt()
{
    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();
    Serial.printf("+---------------------------------------+\n");
}

void MQTT_callback(char *topic, byte *payload, int length)
{

    char MQTT_msg_in[MQTT_BUFFER_SIZE];
    char *MQTT_command = strrchr(topic, '/');

#ifdef DEBUG
    Serial.printf("|                                       |\n");
    Serial.printf("| Message arrived                       |\n");
    Serial.printf("| Command: %28s |\n", MQTT_command);
#endif

    if (length < MQTT_BUFFER_SIZE)
    {
        for (int i = 0; i < length; i++)
        {
            MQTT_msg_in[i] = (char)payload[i];
            MQTT_msg_in[i + 1] = '\0';
        }

#ifdef DEBUG
        Serial.printf("| Message: %28s |\n", MQTT_msg_in);
#endif
        /////////////////////////////////////////////////////
        // Message handling goes here...
        /////////////////////////////////////////////////////
        if (strcmp(MQTT_command, "/lights") == 0)
        {
            DoLights(MQTT_msg_in);
        }
        else if (strcmp(MQTT_command, "/respond") == 0)
        {
            DoAnswer(MQTT_msg_in);
        }
        else if (strcmp(MQTT_command, "/control") == 0)
        {
            DoControl(MQTT_msg_in);
        }
        else
        {
#ifdef DEBUG
            Serial.printf("| Dunno Whatcha want...                 |\n");
#endif
        }
    }
    else
    {
#ifdef DEBUG
        Serial.printf("| But, it's TOO Bloody Big!             |\n");
#endif
    }
}

void MQTT_reconnect()
{
    // Loop until we're reconnected
    while (!MQTT_client.connected())
    {
        Serial.printf("|                                       |\n");
        Serial.printf("| Attempting MQTT connection...         |\n");
        // Create a random client ID
        String clientId = MQTT_ClientName;
        clientId += String(random(0xffff), HEX);
        // Attempt to connect
        if (MQTT_client.connect(clientId.c_str()))
        {
            Serial.printf("| connected to %-24s |\n", MQTT_broker);
            Serial.printf("| My Name:  %-27s |\n", MQTT_ClientName);
            // Once connected, publish an announcement...
            MQTT_client.publish(MQTT_statTopic, "hello world");
            // ... and resubscribe
            MQTT_client.subscribe(MQTT_inTopic);
        }
        else
        {
            Serial.printf("|                                       |\n");
            Serial.printf("| failed, rc=%d                         |\n", MQTT_client.state());
            Serial.printf("| trying again in 5 seconds             |\n");
            // Wait 5 seconds before retrying
            delay(5000);
        }
    }
}

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
   */
    if (getTimer(beacon_timer, BEACON_INTERVAL))
    {
        MQTT_client.publish(MQTT_teleTopic, "boop");
        blinkLED();
    }
}

////////////////////////////////////////////////////////////////
// Random cmnd handlers for testing...
////////////////////////////////////////////////////////////////

void DoLights(char *WhatToDo) // Turn LED on/off
{
    Serial.printf("[- Lights - %3s                        -]\n", WhatToDo);
    if (strcmp(WhatToDo, "ON") == 0)
        digitalWrite(LED_BUILTIN, LOW);
    if (strcmp(WhatToDo, "OFF") == 0)
        digitalWrite(LED_BUILTIN, HIGH);
}

void DoAnswer(char *WhatToDo) // Send back text
{
    Serial.printf("[- Responding: %-23s -]\n", WhatToDo);
    MQTT_client.publish(MQTT_outTopic, WhatToDo);
}

void DoControl(char *WhatToDo) // Send MQTT to another device/topic
{
    /*
  Should be something along the lines of,

  MQTT_client.publish(TopicFromMessage, MessageFromMessage);

  Where
    TopicFromMessage
  is an MQTT topic for sending to another device
  and
    MessageFromMessage
  is the message to publish to that topic...
  */
}

</syntaxhighlight>

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

////////////////////////////////////////////////////////////////
// Supplimentary Functions
////////////////////////////////////////////////////////////////

bool getTimer(unsigned long &timer, unsigned long interval)
/* Global timer function, used a lot
 *
 * @param unsigned long time - The current timer
 * @param unsigned long interval - Length of time to run timer
 *
 * @return bool True when timer is complete
 * @return bool False when timer is counting
 */
{

  if (timer < 1)
  {
    timer = millis();
  }

  if (millis() - timer >= interval)
  {
    timer = 0;
    return true;
  }

  return false;
}

void blinkLED() // Just a little function to blink the on-board LED for the beacon function.
{
  digitalWrite(LED_BUILTIN, LOW);
  delay(10);
  digitalWrite(LED_BUILTIN, HIGH);
  delay(10);
  digitalWrite(LED_BUILTIN, LOW);
  delay(10);
  digitalWrite(LED_BUILTIN, HIGH);
}

</syntaxhighlight>

=== platformio.ini ===
<syntaxhighlight lang="ini" line="1">
[env:esp07]
platform = espressif8266
board = esp07
framework = arduino
monitor_speed = 115200
build_flags =
        -D DEBUG

lib_deps =
        PubSubClient
</syntaxhighlight>