mv plugins/ to modules/

src/modules/esp32/RangeTestPlugin.cpp

@@ -0,0 +1,295 @@
+#include "RangeTestPlugin.h"
+#include "MeshService.h"
+#include "NodeDB.h"
+#include "PowerFSM.h"
+#include "RTC.h"
+#include "Router.h"
+#include "airtime.h"
+#include "configuration.h"
+#include "gps/GeoCoord.h"
+#include <Arduino.h>
+#include <FSCommon.h>
+//#include <assert.h>
+
+/*
+    As a sender, I can send packets every n-seonds. These packets include an incramented PacketID.
+    As a receiver, I can receive packets from multiple senders. These packets can be saved to the Filesystem.
+*/
+
+RangeTestPlugin *rangeTestPlugin;
+RangeTestPluginRadio *rangeTestPluginRadio;
+
+RangeTestPlugin::RangeTestPlugin() : concurrency::OSThread("RangeTestPlugin") {}
+
+uint32_t packetSequence = 0;
+
+#define SEC_PER_DAY 86400
+#define SEC_PER_HOUR 3600
+#define SEC_PER_MIN 60
+
+int32_t RangeTestPlugin::runOnce()
+{
+#ifndef NO_ESP32
+
+    /*
+        Uncomment the preferences below if you want to use the plugin
+        without having to configure it from the PythonAPI or WebUI.
+    */
+
+    // radioConfig.preferences.range_test_plugin_enabled = 1;
+    // radioConfig.preferences.range_test_plugin_sender = 45;
+    // radioConfig.preferences.range_test_plugin_save = 1;
+
+    // Fixed position is useful when testing indoors.
+    // radioConfig.preferences.fixed_position = 1;
+
+    uint32_t senderHeartbeat = radioConfig.preferences.range_test_plugin_sender * 1000;
+
+    if (radioConfig.preferences.range_test_plugin_enabled) {
+
+        if (firstTime) {
+            rangeTestPluginRadio = new RangeTestPluginRadio();
+
+            firstTime = 0;
+
+            if (radioConfig.preferences.range_test_plugin_sender) {
+                DEBUG_MSG("Initializing Range Test Plugin -- Sender\n");
+                return (5000); // Sending first message 5 seconds after initilization.
+            } else {
+                DEBUG_MSG("Initializing Range Test Plugin -- Receiver\n");
+                return (500);
+            }
+
+        } else {
+
+            if (radioConfig.preferences.range_test_plugin_sender) {
+                // If sender
+                DEBUG_MSG("Range Test Plugin - Sending heartbeat every %d ms\n", (senderHeartbeat));
+
+                DEBUG_MSG("gpsStatus->getLatitude()     %d\n", gpsStatus->getLatitude());
+                DEBUG_MSG("gpsStatus->getLongitude()    %d\n", gpsStatus->getLongitude());
+                DEBUG_MSG("gpsStatus->getHasLock()      %d\n", gpsStatus->getHasLock());
+                DEBUG_MSG("gpsStatus->getDOP()          %d\n", gpsStatus->getDOP());
+                DEBUG_MSG("gpsStatus->getHasLock()      %d\n", gpsStatus->getHasLock());
+                DEBUG_MSG("pref.fixed_position()        %d\n", radioConfig.preferences.fixed_position);
+
+                // Only send packets if the channel is less than 25% utilized.
+                if (airTime->channelUtilizationPercent() < 25) {
+                    rangeTestPluginRadio->sendPayload();
+                } else {
+                    DEBUG_MSG("rangeTest - Channel utilization is >25 percent. Skipping this opportunity to send.\n");
+                }
+
+                return (senderHeartbeat);
+            } else {
+                // Otherwise, we're a receiver.
+
+                return (500);
+            }
+            // TBD
+        }
+
+    } else {
+        DEBUG_MSG("Range Test Plugin - Disabled\n");
+    }
+
+#endif
+    return (INT32_MAX);
+}
+
+MeshPacket *RangeTestPluginRadio::allocReply()
+{
+
+    auto reply = allocDataPacket(); // Allocate a packet for sending
+
+    return reply;
+}
+
+void RangeTestPluginRadio::sendPayload(NodeNum dest, bool wantReplies)
+{
+    MeshPacket *p = allocReply();
+    p->to = dest;
+    p->decoded.want_response = wantReplies;
+
+    p->want_ack = true;
+
+    packetSequence++;
+
+    static char heartbeatString[20];
+    snprintf(heartbeatString, sizeof(heartbeatString), "seq %u", packetSequence);
+
+    p->decoded.payload.size = strlen(heartbeatString); // You must specify how many bytes are in the reply
+    memcpy(p->decoded.payload.bytes, heartbeatString, p->decoded.payload.size);
+
+    service.sendToMesh(p);
+
+    // TODO: Handle this better. We want to keep the phone awake otherwise it stops sending.
+    powerFSM.trigger(EVENT_CONTACT_FROM_PHONE);
+}
+
+ProcessMessage RangeTestPluginRadio::handleReceived(const MeshPacket &mp)
+{
+#ifndef NO_ESP32
+
+    if (radioConfig.preferences.range_test_plugin_enabled) {
+
+        /*
+            auto &p = mp.decoded;
+            DEBUG_MSG("Received text msg self=0x%0x, from=0x%0x, to=0x%0x, id=%d, msg=%.*s\n",
+                  nodeDB.getNodeNum(), mp.from, mp.to, mp.id, p.payload.size, p.payload.bytes);
+        */
+
+        if (getFrom(&mp) != nodeDB.getNodeNum()) {
+
+            if (radioConfig.preferences.range_test_plugin_save) {
+                appendFile(mp);
+            }
+
+            /*
+            NodeInfo *n = nodeDB.getNode(getFrom(&mp));
+
+            DEBUG_MSG("-----------------------------------------\n");
+            DEBUG_MSG("p.payload.bytes  \"%s\"\n", p.payload.bytes);
+            DEBUG_MSG("p.payload.size   %d\n", p.payload.size);
+            DEBUG_MSG("---- Received Packet:\n");
+            DEBUG_MSG("mp.from          %d\n", mp.from);
+            DEBUG_MSG("mp.rx_snr        %f\n", mp.rx_snr);
+            DEBUG_MSG("mp.hop_limit     %d\n", mp.hop_limit);
+            DEBUG_MSG("mp.decoded.position.latitude_i     %d\n", mp.decoded.position.latitude_i); // Depricated
+            DEBUG_MSG("mp.decoded.position.longitude_i    %d\n", mp.decoded.position.longitude_i); // Depricated
+            DEBUG_MSG("---- Node Information of Received Packet (mp.from):\n");
+            DEBUG_MSG("n->user.long_name         %s\n", n->user.long_name);
+            DEBUG_MSG("n->user.short_name        %s\n", n->user.short_name);
+            DEBUG_MSG("n->user.macaddr           %X\n", n->user.macaddr);
+            DEBUG_MSG("n->has_position           %d\n", n->has_position);
+            DEBUG_MSG("n->position.latitude_i    %d\n", n->position.latitude_i);
+            DEBUG_MSG("n->position.longitude_i   %d\n", n->position.longitude_i);
+            DEBUG_MSG("n->position.battery_level %d\n", n->position.battery_level);
+            DEBUG_MSG("---- Current device location information:\n");
+            DEBUG_MSG("gpsStatus->getLatitude()     %d\n", gpsStatus->getLatitude());
+            DEBUG_MSG("gpsStatus->getLongitude()    %d\n", gpsStatus->getLongitude());
+            DEBUG_MSG("gpsStatus->getHasLock()      %d\n", gpsStatus->getHasLock());
+            DEBUG_MSG("gpsStatus->getDOP()          %d\n", gpsStatus->getDOP());
+            DEBUG_MSG("-----------------------------------------\n");
+            */
+        }
+
+    } else {
+        DEBUG_MSG("Range Test Plugin Disabled\n");
+    }
+
+#endif
+
+    return ProcessMessage::CONTINUE; // Let others look at this message also if they want
+}
+
+bool RangeTestPluginRadio::appendFile(const MeshPacket &mp)
+{
+    auto &p = mp.decoded;
+
+    NodeInfo *n = nodeDB.getNode(getFrom(&mp));
+    /*
+        DEBUG_MSG("-----------------------------------------\n");
+        DEBUG_MSG("p.payload.bytes  \"%s\"\n", p.payload.bytes);
+        DEBUG_MSG("p.payload.size   %d\n", p.payload.size);
+        DEBUG_MSG("---- Received Packet:\n");
+        DEBUG_MSG("mp.from          %d\n", mp.from);
+        DEBUG_MSG("mp.rx_snr        %f\n", mp.rx_snr);
+        DEBUG_MSG("mp.hop_limit     %d\n", mp.hop_limit);
+        // DEBUG_MSG("mp.decoded.position.latitude_i     %d\n", mp.decoded.position.latitude_i);  // Depricated
+        // DEBUG_MSG("mp.decoded.position.longitude_i    %d\n", mp.decoded.position.longitude_i); // Depricated
+        DEBUG_MSG("---- Node Information of Received Packet (mp.from):\n");
+        DEBUG_MSG("n->user.long_name         %s\n", n->user.long_name);
+        DEBUG_MSG("n->user.short_name        %s\n", n->user.short_name);
+        DEBUG_MSG("n->user.macaddr           %X\n", n->user.macaddr);
+        DEBUG_MSG("n->has_position           %d\n", n->has_position);
+        DEBUG_MSG("n->position.latitude_i    %d\n", n->position.latitude_i);
+        DEBUG_MSG("n->position.longitude_i   %d\n", n->position.longitude_i);
+        DEBUG_MSG("n->position.battery_level %d\n", n->position.battery_level);
+        DEBUG_MSG("---- Current device location information:\n");
+        DEBUG_MSG("gpsStatus->getLatitude()     %d\n", gpsStatus->getLatitude());
+        DEBUG_MSG("gpsStatus->getLongitude()    %d\n", gpsStatus->getLongitude());
+        DEBUG_MSG("gpsStatus->getHasLock()      %d\n", gpsStatus->getHasLock());
+        DEBUG_MSG("gpsStatus->getDOP()          %d\n", gpsStatus->getDOP());
+        DEBUG_MSG("-----------------------------------------\n");
+    */
+    if (!FSBegin()) {
+        DEBUG_MSG("An Error has occurred while mounting the filesystem\n");
+        return 0;
+    }
+
+    if (FSCom.totalBytes() - FSCom.usedBytes() < 51200) {
+        DEBUG_MSG("Filesystem doesn't have enough free space. Aborting write.\n");
+        return 0;
+    }
+
+    // If the file doesn't exist, write the header.
+    if (!FSCom.exists("/static/rangetest.csv")) {
+        //--------- Write to file
+        File fileToWrite = FSCom.open("/static/rangetest.csv", FILE_WRITE);
+
+        if (!fileToWrite) {
+            DEBUG_MSG("There was an error opening the file for writing\n");
+            return 0;
+        }
+
+        // Print the CSV header
+        if (fileToWrite.println(
+                "time,from,sender name,sender lat,sender long,rx lat,rx long,rx elevation,rx snr,distance,hop limit,payload")) {
+            DEBUG_MSG("File was written\n");
+        } else {
+            DEBUG_MSG("File write failed\n");
+        }
+
+        fileToWrite.close();
+    }
+
+    //--------- Append content to file
+    File fileToAppend = FSCom.open("/static/rangetest.csv", FILE_APPEND);
+
+    if (!fileToAppend) {
+        DEBUG_MSG("There was an error opening the file for appending\n");
+        return 0;
+    }
+
+    struct timeval tv;
+    if (!gettimeofday(&tv, NULL)) {
+        long hms = tv.tv_sec % SEC_PER_DAY;
+        hms = (hms + SEC_PER_DAY) % SEC_PER_DAY;
+
+        // Tear apart hms into h:m:s
+        int hour = hms / SEC_PER_HOUR;
+        int min = (hms % SEC_PER_HOUR) / SEC_PER_MIN;
+        int sec = (hms % SEC_PER_HOUR) % SEC_PER_MIN; // or hms % SEC_PER_MIN
+
+        fileToAppend.printf("%02d:%02d:%02d,", hour, min, sec); // Time
+    } else {
+        fileToAppend.printf("??:??:??,"); // Time
+    }
+
+    fileToAppend.printf("%d,", getFrom(&mp));                     // From
+    fileToAppend.printf("%s,", n->user.long_name);                // Long Name
+    fileToAppend.printf("%f,", n->position.latitude_i * 1e-7);    // Sender Lat
+    fileToAppend.printf("%f,", n->position.longitude_i * 1e-7);   // Sender Long
+    fileToAppend.printf("%f,", gpsStatus->getLatitude() * 1e-7);  // RX Lat
+    fileToAppend.printf("%f,", gpsStatus->getLongitude() * 1e-7); // RX Long
+    fileToAppend.printf("%d,", gpsStatus->getAltitude());         // RX Altitude
+
+    fileToAppend.printf("%f,", mp.rx_snr); // RX SNR
+
+    if (n->position.latitude_i && n->position.longitude_i && gpsStatus->getLatitude() && gpsStatus->getLongitude()) {
+        float distance = GeoCoord::latLongToMeter(n->position.latitude_i * 1e-7, n->position.longitude_i * 1e-7,
+                                                  gpsStatus->getLatitude() * 1e-7, gpsStatus->getLongitude() * 1e-7);
+        fileToAppend.printf("%f,", distance); // Distance in meters
+    } else {
+        fileToAppend.printf("0,");
+    }
+
+    fileToAppend.printf("%d,", mp.hop_limit); // Packet Hop Limit
+
+    // TODO: If quotes are found in the payload, it has to be escaped.
+    fileToAppend.printf("\"%s\"\n", p.payload.bytes);
+    fileToAppend.close();
+
+    return 1;
+}

src/modules/esp32/RangeTestPlugin.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include "SinglePortPlugin.h"
+#include "concurrency/OSThread.h"
+#include "configuration.h"
+#include <Arduino.h>
+#include <functional>
+
+class RangeTestPlugin : private concurrency::OSThread
+{
+    bool firstTime = 1;
+
+  public:
+    RangeTestPlugin();
+
+  protected:
+    virtual int32_t runOnce() override;
+};
+
+extern RangeTestPlugin *rangeTestPlugin;
+
+/*
+ * Radio interface for RangeTestPlugin
+ *
+ */
+class RangeTestPluginRadio : public SinglePortPlugin
+{
+    uint32_t lastRxID = 0;
+
+  public:
+    RangeTestPluginRadio() : SinglePortPlugin("RangeTestPluginRadio", PortNum_TEXT_MESSAGE_APP) {}
+
+    /**
+     * Send our payload into the mesh
+     */
+    void sendPayload(NodeNum dest = NODENUM_BROADCAST, bool wantReplies = false);
+
+    /**
+     * Append range test data to the file on the Filesystem
+     */
+    bool appendFile(const MeshPacket &mp);
+
+    /**
+     * Kevin's magical calculation of two points to meters.
+     */
+    float latLongToMeter(double lat_a, double lng_a, double lat_b, double lng_b);
+
+  protected:
+    virtual MeshPacket *allocReply() override;
+
+    /** Called to handle a particular incoming message
+
+    @return ProcessMessage::STOP if you've guaranteed you've handled this message and no other handlers should be considered for it
+    */
+    virtual ProcessMessage handleReceived(const MeshPacket &mp) override;
+};
+
+extern RangeTestPluginRadio *rangeTestPluginRadio;

src/modules/esp32/SerialPlugin.cpp

@@ -0,0 +1,211 @@
+#include "configuration.h"
+#include "SerialPlugin.h"
+#include "MeshService.h"
+#include "NodeDB.h"
+#include "RTC.h"
+#include "Router.h"
+#include <Arduino.h>
+
+#include <assert.h>
+
+/*
+    SerialPlugin
+        A simple interface to send messages over the mesh network by sending strings
+        over a serial port.
+
+        Default is to use RX GPIO 16 and TX GPIO 17.
+
+    Need help with this plugin? Post your question on the Meshtastic Discourse:
+       https://meshtastic.discourse.group
+
+    Basic Usage:
+
+        1) Enable the plugin by setting serialplugin_enabled to 1.
+        2) Set the pins (serialplugin_rxd / serialplugin_rxd) for your preferred RX and TX GPIO pins.
+           On tbeam, recommend to use:
+                RXD 35
+                TXD 15
+        3) Set serialplugin_timeout to the amount of time to wait before we consider
+           your packet as "done".
+        4) (Optional) In SerialPlugin.h set the port to PortNum_TEXT_MESSAGE_APP if you want to
+           send messages to/from the general text message channel.
+        5) Connect to your device over the serial interface at 38400 8N1.
+        6) Send a packet up to 240 bytes in length. This will get relayed over the mesh network.
+        7) (Optional) Set serialplugin_echo to 1 and any message you send out will be echoed back
+           to your device.
+
+    TODO (in this order):
+        * Define a verbose RX mode to report on mesh and packet infomration.
+            - This won't happen any time soon.
+
+    KNOWN PROBLEMS
+        * Until the plugin is initilized by the startup sequence, the TX pin is in a floating
+          state. Device connected to that pin may see this as "noise".
+        * Will not work on NRF and the Linux device targets.
+
+
+*/
+
+#define RXD2 16
+#define TXD2 17
+#define SERIALPLUGIN_RX_BUFFER 128
+#define SERIALPLUGIN_STRING_MAX Constants_DATA_PAYLOAD_LEN
+#define SERIALPLUGIN_TIMEOUT 250
+#define SERIALPLUGIN_BAUD 38400
+#define SERIALPLUGIN_ACK 1
+
+SerialPlugin *serialPlugin;
+SerialPluginRadio *serialPluginRadio;
+
+SerialPlugin::SerialPlugin() : concurrency::OSThread("SerialPlugin") {}
+
+char serialStringChar[Constants_DATA_PAYLOAD_LEN];
+
+SerialPluginRadio::SerialPluginRadio() : SinglePortPlugin("SerialPluginRadio", PortNum_SERIAL_APP)
+{
+    // restrict to the admin channel for rx
+    boundChannel = Channels::serialChannel;
+}
+
+int32_t SerialPlugin::runOnce()
+{
+#ifndef NO_ESP32
+
+    /*
+        Uncomment the preferences below if you want to use the plugin
+        without having to configure it from the PythonAPI or WebUI.
+    */
+
+    // radioConfig.preferences.serialplugin_enabled = 1;
+    // radioConfig.preferences.serialplugin_rxd = 35;
+    // radioConfig.preferences.serialplugin_txd = 15;
+    // radioConfig.preferences.serialplugin_timeout = 1000;
+    // radioConfig.preferences.serialplugin_echo = 1;
+
+    if (radioConfig.preferences.serialplugin_enabled) {
+
+        if (firstTime) {
+
+            // Interface with the serial peripheral from in here.
+            DEBUG_MSG("Initializing serial peripheral interface\n");
+
+            if (radioConfig.preferences.serialplugin_rxd && radioConfig.preferences.serialplugin_txd) {
+                Serial2.begin(SERIALPLUGIN_BAUD, SERIAL_8N1, radioConfig.preferences.serialplugin_rxd,
+                              radioConfig.preferences.serialplugin_txd);
+
+            } else {
+                Serial2.begin(SERIALPLUGIN_BAUD, SERIAL_8N1, RXD2, TXD2);
+            }
+
+            if (radioConfig.preferences.serialplugin_timeout) {
+                Serial2.setTimeout(
+                    radioConfig.preferences.serialplugin_timeout); // Number of MS to wait to set the timeout for the string.
+
+            } else {
+                Serial2.setTimeout(SERIALPLUGIN_TIMEOUT); // Number of MS to wait to set the timeout for the string.
+            }
+
+            Serial2.setRxBufferSize(SERIALPLUGIN_RX_BUFFER);
+
+            serialPluginRadio = new SerialPluginRadio();
+
+            firstTime = 0;
+
+        } else {
+            String serialString;
+
+            while (Serial2.available()) {
+                serialString = Serial2.readString();
+                serialString.toCharArray(serialStringChar, Constants_DATA_PAYLOAD_LEN);
+
+                serialPluginRadio->sendPayload();
+
+                DEBUG_MSG("Received: %s\n", serialStringChar);
+            }
+        }
+
+        return (10);
+    } else {
+        DEBUG_MSG("Serial Plugin Disabled\n");
+
+        return (INT32_MAX);
+    }
+#else
+    return INT32_MAX;
+#endif
+}
+
+MeshPacket *SerialPluginRadio::allocReply()
+{
+
+    auto reply = allocDataPacket(); // Allocate a packet for sending
+
+    return reply;
+}
+
+void SerialPluginRadio::sendPayload(NodeNum dest, bool wantReplies)
+{
+    MeshPacket *p = allocReply();
+    p->to = dest;
+    p->decoded.want_response = wantReplies;
+
+    p->want_ack = SERIALPLUGIN_ACK;
+
+    p->decoded.payload.size = strlen(serialStringChar); // You must specify how many bytes are in the reply
+    memcpy(p->decoded.payload.bytes, serialStringChar, p->decoded.payload.size);
+
+    service.sendToMesh(p);
+}
+
+ProcessMessage SerialPluginRadio::handleReceived(const MeshPacket &mp)
+{
+#ifndef NO_ESP32
+
+    if (radioConfig.preferences.serialplugin_enabled) {
+
+        auto &p = mp.decoded;
+        // DEBUG_MSG("Received text msg self=0x%0x, from=0x%0x, to=0x%0x, id=%d, msg=%.*s\n",
+        //          nodeDB.getNodeNum(), mp.from, mp.to, mp.id, p.payload.size, p.payload.bytes);
+
+        if (getFrom(&mp) == nodeDB.getNodeNum()) {
+
+            /*
+             * If radioConfig.preferences.serialplugin_echo is true, then echo the packets that are sent out back to the TX
+             * of the serial interface.
+             */
+            if (radioConfig.preferences.serialplugin_echo) {
+
+                // For some reason, we get the packet back twice when we send out of the radio.
+                //   TODO: need to find out why.
+                if (lastRxID != mp.id) {
+                    lastRxID = mp.id;
+                    // DEBUG_MSG("* * Message came this device\n");
+                    // Serial2.println("* * Message came this device");
+                    Serial2.printf("%s", p.payload.bytes);
+                }
+            }
+
+        } else {
+
+            if (radioConfig.preferences.serialplugin_mode == 0 || radioConfig.preferences.serialplugin_mode == 1) {
+                // DEBUG_MSG("* * Message came from the mesh\n");
+                // Serial2.println("* * Message came from the mesh");
+                Serial2.printf("%s", p.payload.bytes);
+
+            } else if (radioConfig.preferences.serialplugin_mode == 10) {
+                /*
+                 @jobionekabnoi
+                    Add code here to handle what gets sent out to the serial interface.
+                    Format it the way you want.
+                 */
+            }
+        }
+
+    } else {
+        DEBUG_MSG("Serial Plugin Disabled\n");
+    }
+
+#endif
+
+    return ProcessMessage::CONTINUE; // Let others look at this message also if they want
+}

src/modules/esp32/SerialPlugin.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include "SinglePortPlugin.h"
+#include "concurrency/OSThread.h"
+#include "configuration.h"
+#include <Arduino.h>
+#include <functional>
+
+class SerialPlugin : private concurrency::OSThread
+{
+    bool firstTime = 1;
+
+  public:
+    SerialPlugin();
+
+  protected:
+    virtual int32_t runOnce() override;
+};
+
+extern SerialPlugin *serialPlugin;
+
+/*
+ * Radio interface for SerialPlugin
+ *
+ */
+class SerialPluginRadio : public SinglePortPlugin
+{
+    uint32_t lastRxID = 0;
+
+  public:
+    /*
+        TODO: Switch this to PortNum_SERIAL_APP once the change is able to be merged back here
+              from the main code.
+    */
+
+    SerialPluginRadio();
+
+    /**
+     * Send our payload into the mesh
+     */
+    void sendPayload(NodeNum dest = NODENUM_BROADCAST, bool wantReplies = false);
+
+  protected:
+    virtual MeshPacket *allocReply() override;
+
+    /** Called to handle a particular incoming message
+
+    @return ProcessMessage::STOP if you've guaranteed you've handled this message and no other handlers should be considered for it
+    */
+    virtual ProcessMessage handleReceived(const MeshPacket &mp) override;
+};
+
+extern SerialPluginRadio *serialPluginRadio;

src/modules/esp32/StoreForwardPlugin.cpp

@@ -0,0 +1,444 @@
+#include "StoreForwardPlugin.h"
+#include "MeshService.h"
+#include "NodeDB.h"
+#include "RTC.h"
+#include "Router.h"
+#include "airtime.h"
+#include "configuration.h"
+#include "mesh-pb-constants.h"
+#include "mesh/generated/storeforward.pb.h"
+#include "modules/PluginDev.h"
+#include <Arduino.h>
+#include <iterator>
+#include <map>
+
+StoreForwardPlugin *storeForwardPlugin;
+
+int32_t StoreForwardPlugin::runOnce()
+{
+
+#ifndef NO_ESP32
+
+    if (radioConfig.preferences.store_forward_plugin_enabled) {
+
+        if (radioConfig.preferences.is_router) {
+
+            // Send out the message queue.
+            if (this->busy) {
+                
+
+                // Only send packets if the channel is less than 25% utilized.
+                if (airTime->channelUtilizationPercent() < 25) {
+
+                    // DEBUG_MSG("--- --- --- In busy loop 1 %d\n", this->packetHistoryTXQueue_index);
+                    storeForwardPlugin->sendPayload(this->busyTo, this->packetHistoryTXQueue_index);
+
+                    if (this->packetHistoryTXQueue_index == packetHistoryTXQueue_size) {
+                        strcpy(this->routerMessage, "** S&F - Done");
+                        storeForwardPlugin->sendMessage(this->busyTo, this->routerMessage);
+
+                        // DEBUG_MSG("--- --- --- In busy loop - Done \n");
+                        this->packetHistoryTXQueue_index = 0;
+                        this->busy = false;
+                    } else {
+                        this->packetHistoryTXQueue_index++;
+                    }
+                    
+                } else {
+                    DEBUG_MSG("Channel utilization is too high. Skipping this opportunity to send and will retry later.\n");
+                }
+            }
+            DEBUG_MSG("SF myNodeInfo.bitrate = %f bytes / sec\n", myNodeInfo.bitrate);
+
+            return (this->packetTimeMax);
+        } else {
+            DEBUG_MSG("Store & Forward Plugin - Disabled (is_router = false)\n");
+
+            return (INT32_MAX);
+        }
+
+    } else {
+        DEBUG_MSG("Store & Forward Plugin - Disabled\n");
+
+        return (INT32_MAX);
+    }
+
+#endif
+    return (INT32_MAX);
+}
+
+/*
+    Create our data structure in the PSRAM.
+*/
+void StoreForwardPlugin::populatePSRAM()
+{
+    /*
+    For PSRAM usage, see:
+        https://learn.upesy.com/en/programmation/psram.html#psram-tab
+    */
+
+    DEBUG_MSG("Before PSRAM initilization:\n");
+
+    DEBUG_MSG("  Total heap: %d\n", ESP.getHeapSize());
+    DEBUG_MSG("  Free heap: %d\n", ESP.getFreeHeap());
+    DEBUG_MSG("  Total PSRAM: %d\n", ESP.getPsramSize());
+    DEBUG_MSG("  Free PSRAM: %d\n", ESP.getFreePsram());
+
+    this->packetHistoryTXQueue =
+        static_cast<PacketHistoryStruct *>(ps_calloc(this->historyReturnMax, sizeof(PacketHistoryStruct)));
+
+    /* Use a maximum of 2/3 the available PSRAM unless otherwise specified.
+        Note: This needs to be done after every thing that would use PSRAM
+    */
+    uint32_t numberOfPackets = (this->records ? this->records : (((ESP.getFreePsram() / 3) * 2) / sizeof(PacketHistoryStruct)));
+
+    this->packetHistory = static_cast<PacketHistoryStruct *>(ps_calloc(numberOfPackets, sizeof(PacketHistoryStruct)));
+
+    DEBUG_MSG("After PSRAM initilization:\n");
+
+    DEBUG_MSG("  Total heap: %d\n", ESP.getHeapSize());
+    DEBUG_MSG("  Free heap: %d\n", ESP.getFreeHeap());
+    DEBUG_MSG("  Total PSRAM: %d\n", ESP.getPsramSize());
+    DEBUG_MSG("  Free PSRAM: %d\n", ESP.getFreePsram());
+    DEBUG_MSG("Store and Forward Stats:\n");
+    DEBUG_MSG("  numberOfPackets for packetHistory - %u\n", numberOfPackets);
+}
+
+void StoreForwardPlugin::historyReport()
+{
+    DEBUG_MSG("Iterating through the message history...\n");
+    DEBUG_MSG("Message history contains %u records\n", this->packetHistoryCurrent);
+}
+
+/*
+ *
+ */
+void StoreForwardPlugin::historySend(uint32_t msAgo, uint32_t to)
+{
+
+    // uint32_t packetsSent = 0;
+
+    uint32_t queueSize = storeForwardPlugin->historyQueueCreate(msAgo, to);
+
+    if (queueSize) {
+        snprintf(this->routerMessage, 80, "** S&F - Sending %u message(s)", queueSize);
+        storeForwardPlugin->sendMessage(to, this->routerMessage);
+
+        this->busy = true; // runOnce() will pickup the next steps once busy = true.
+        this->busyTo = to;
+
+    } else {
+        strcpy(this->routerMessage, "** S&F - No history to send");
+        storeForwardPlugin->sendMessage(to, this->routerMessage);
+    }
+}
+
+uint32_t StoreForwardPlugin::historyQueueCreate(uint32_t msAgo, uint32_t to)
+{
+
+    // uint32_t packetHistoryTXQueueIndex = 0;
+
+    this->packetHistoryTXQueue_size = 0;
+
+    for (int i = 0; i < this->packetHistoryCurrent; i++) {
+        /*
+            DEBUG_MSG("SF historyQueueCreate\n");
+            DEBUG_MSG("SF historyQueueCreate - time %d\n", this->packetHistory[i].time);
+            DEBUG_MSG("SF historyQueueCreate - millis %d\n", millis());
+            DEBUG_MSG("SF historyQueueCreate - math %d\n", (millis() - msAgo));
+        */
+        if (this->packetHistory[i].time && (this->packetHistory[i].time < (millis() - msAgo))) {
+            DEBUG_MSG("SF historyQueueCreate - Time matches - ok\n");
+            /*
+                Copy the messages that were received by the router in the last msAgo
+                to the packetHistoryTXQueue structure.
+
+                TODO: The condition (this->packetHistory[i].to & NODENUM_BROADCAST) == to) is not tested since
+                I don't have an easy way to target a specific user. Will need to do this soon.
+            */
+            if ((this->packetHistory[i].to & NODENUM_BROADCAST) == NODENUM_BROADCAST ||
+                ((this->packetHistory[i].to & NODENUM_BROADCAST) == to)) {
+                this->packetHistoryTXQueue[this->packetHistoryTXQueue_size].time = this->packetHistory[i].time;
+                this->packetHistoryTXQueue[this->packetHistoryTXQueue_size].time = this->packetHistory[i].time;
+                this->packetHistoryTXQueue[this->packetHistoryTXQueue_size].to = this->packetHistory[i].to;
+                this->packetHistoryTXQueue[this->packetHistoryTXQueue_size].from = this->packetHistory[i].from;
+                this->packetHistoryTXQueue[this->packetHistoryTXQueue_size].channel = this->packetHistory[i].channel;
+                this->packetHistoryTXQueue[this->packetHistoryTXQueue_size].payload_size = this->packetHistory[i].payload_size;
+                memcpy(this->packetHistoryTXQueue[this->packetHistoryTXQueue_size].payload, this->packetHistory[i].payload,
+                       Constants_DATA_PAYLOAD_LEN);
+                this->packetHistoryTXQueue_size++;
+
+                DEBUG_MSG("PacketHistoryStruct time=%d\n", this->packetHistory[i].time);
+                DEBUG_MSG("PacketHistoryStruct msg=%.*s\n", this->packetHistory[i].payload);
+                // DEBUG_MSG("PacketHistoryStruct msg=%.*s\n", this->packetHistoryTXQueue[packetHistoryTXQueueIndex].payload);
+            }
+        }
+    }
+    return this->packetHistoryTXQueue_size;
+}
+
+void StoreForwardPlugin::historyAdd(const MeshPacket &mp)
+{
+    const auto &p = mp.decoded;
+
+    this->packetHistory[this->packetHistoryCurrent].time = millis();
+    this->packetHistory[this->packetHistoryCurrent].to = mp.to;
+    this->packetHistory[this->packetHistoryCurrent].channel = mp.channel;
+    this->packetHistory[this->packetHistoryCurrent].from = mp.from;
+    this->packetHistory[this->packetHistoryCurrent].payload_size = p.payload.size;
+    memcpy(this->packetHistory[this->packetHistoryCurrent].payload, p.payload.bytes, Constants_DATA_PAYLOAD_LEN);
+
+    this->packetHistoryCurrent++;
+}
+
+MeshPacket *StoreForwardPlugin::allocReply()
+{
+    auto reply = allocDataPacket(); // Allocate a packet for sending
+    return reply;
+}
+
+void StoreForwardPlugin::sendPayload(NodeNum dest, uint32_t packetHistory_index)
+{
+    DEBUG_MSG("Sending S&F Payload\n");
+    MeshPacket *p = allocReply();
+
+    p->to = dest;
+    p->from = this->packetHistoryTXQueue[packetHistory_index].from;
+    p->channel = this->packetHistoryTXQueue[packetHistory_index].channel;
+
+    // Let's assume that if the router received the S&F request that the client is in range.
+    //   TODO: Make this configurable.
+    p->want_ack = false;
+
+    p->decoded.payload.size =
+        this->packetHistoryTXQueue[packetHistory_index].payload_size; // You must specify how many bytes are in the reply
+    memcpy(p->decoded.payload.bytes, this->packetHistoryTXQueue[packetHistory_index].payload,
+           this->packetHistoryTXQueue[packetHistory_index].payload_size);
+
+    service.sendToMesh(p);
+}
+
+void StoreForwardPlugin::sendMessage(NodeNum dest, char *str)
+{
+    MeshPacket *p = allocReply();
+
+    p->to = dest;
+
+    // FIXME - Determine if the delayed packet is broadcast or delayed. For now, assume
+    //  everything is broadcast.
+    p->delayed = MeshPacket_Delayed_DELAYED_BROADCAST;
+
+    // Let's assume that if the router received the S&F request that the client is in range.
+    //   TODO: Make this configurable.
+    p->want_ack = false;
+
+    p->decoded.payload.size = strlen(str); // You must specify how many bytes are in the reply
+    memcpy(p->decoded.payload.bytes, str, strlen(str));
+
+    service.sendToMesh(p);
+
+    // HardwareMessage_init_default
+}
+
+ProcessMessage StoreForwardPlugin::handleReceived(const MeshPacket &mp)
+{
+#ifndef NO_ESP32
+    if (radioConfig.preferences.store_forward_plugin_enabled) {
+
+        DEBUG_MSG("--- S&F Received something\n");
+
+        // The router node should not be sending messages as a client.
+        if (getFrom(&mp) != nodeDB.getNodeNum()) {
+
+            if (mp.decoded.portnum == PortNum_TEXT_MESSAGE_APP) {
+                DEBUG_MSG("Packet came from - PortNum_TEXT_MESSAGE_APP\n");
+
+                auto &p = mp.decoded;
+
+                if ((p.payload.bytes[0] == 'S') && (p.payload.bytes[1] == 'F') && (p.payload.bytes[2] == 0x00)) {
+                    DEBUG_MSG("--- --- --- Request to send\n");
+
+                    // Send the last 60 minutes of messages.
+                    if (this->busy) {
+                        strcpy(this->routerMessage, "** S&F - Busy. Try again shortly.");
+                        storeForwardPlugin->sendMessage(getFrom(&mp), this->routerMessage);
+                    } else {
+                        storeForwardPlugin->historySend(1000 * 60, getFrom(&mp));
+                    }
+                } else if ((p.payload.bytes[0] == 'S') && (p.payload.bytes[1] == 'F') && (p.payload.bytes[2] == 'm') &&
+                           (p.payload.bytes[3] == 0x00)) {
+                    strlcpy(this->routerMessage, "01234567890123456789012345678901234567890123456789012345678901234567890123456789"
+                                                 "01234567890123456789012345678901234567890123456789012345678901234567890123456789"
+                                                 "01234567890123456789012345678901234567890123456789012345678901234567890123456",
+                                                 sizeof(this->routerMessage));
+                    storeForwardPlugin->sendMessage(getFrom(&mp), this->routerMessage);
+
+                } else {
+                    storeForwardPlugin->historyAdd(mp);
+                }
+
+            } else if (mp.decoded.portnum == PortNum_STORE_FORWARD_APP) {
+
+            } else {
+                DEBUG_MSG("Packet came from an unknown port %u\n", mp.decoded.portnum);
+            }
+        }
+
+    } else {
+        DEBUG_MSG("Store & Forward Plugin - Disabled\n");
+    }
+
+#endif
+
+    return ProcessMessage::CONTINUE; // Let others look at this message also if they want
+}
+
+ProcessMessage StoreForwardPlugin::handleReceivedProtobuf(const MeshPacket &mp, StoreAndForward *p)
+{
+    if (!radioConfig.preferences.store_forward_plugin_enabled) {
+        // If this plugin is not enabled in any capacity, don't handle the packet, and allow other plugins to consume
+        return ProcessMessage::CONTINUE;
+    }
+
+    if (mp.decoded.portnum == PortNum_TEXT_MESSAGE_APP) {
+        DEBUG_MSG("Packet came from an PortNum_TEXT_MESSAGE_APP port %u\n", mp.decoded.portnum);
+        return ProcessMessage::CONTINUE;
+    } else if (mp.decoded.portnum == PortNum_STORE_FORWARD_APP) {
+        DEBUG_MSG("Packet came from an PortNum_STORE_FORWARD_APP port %u\n", mp.decoded.portnum);
+
+    } else {
+        DEBUG_MSG("Packet came from an UNKNOWN port %u\n", mp.decoded.portnum);
+        return ProcessMessage::CONTINUE;
+    }
+
+    switch (p->rr) {
+    case StoreAndForward_RequestResponse_CLIENT_ERROR:
+        // Do nothing
+        DEBUG_MSG("StoreAndForward_RequestResponse_CLIENT_ERROR\n");
+        break;
+
+    case StoreAndForward_RequestResponse_CLIENT_HISTORY:
+        DEBUG_MSG("StoreAndForward_RequestResponse_CLIENT_HISTORY\n");
+
+        // Send the last 60 minutes of messages.
+        if (this->busy) {
+            strcpy(this->routerMessage, "** S&F - Busy. Try again shortly.");
+            storeForwardPlugin->sendMessage(getFrom(&mp), this->routerMessage);
+        } else {
+            storeForwardPlugin->historySend(1000 * 60, getFrom(&mp));
+        }
+
+        break;
+
+    case StoreAndForward_RequestResponse_CLIENT_PING:
+        // Do nothing
+        DEBUG_MSG("StoreAndForward_RequestResponse_CLIENT_PING\n");
+        break;
+
+    case StoreAndForward_RequestResponse_CLIENT_PONG:
+        // Do nothing
+        DEBUG_MSG("StoreAndForward_RequestResponse_CLIENT_PONG\n");
+        break;
+
+    case StoreAndForward_RequestResponse_CLIENT_STATS:
+        // Do nothing
+        DEBUG_MSG("StoreAndForward_RequestResponse_CLIENT_STATS\n");
+        break;
+
+    case StoreAndForward_RequestResponse_ROUTER_BUSY:
+        // Do nothing
+        DEBUG_MSG("StoreAndForward_RequestResponse_ROUTER_BUSY\n");
+        break;
+
+    case StoreAndForward_RequestResponse_ROUTER_ERROR:
+        // Do nothing
+        DEBUG_MSG("StoreAndForward_RequestResponse_ROUTER_ERROR\n");
+        break;
+
+    case StoreAndForward_RequestResponse_ROUTER_HEARTBEAT:
+        // Do nothing
+        DEBUG_MSG("StoreAndForward_RequestResponse_ROUTER_HEARTBEAT\n");
+        break;
+
+    case StoreAndForward_RequestResponse_ROUTER_PING:
+        // Do nothing
+        DEBUG_MSG("StoreAndForward_RequestResponse_ROUTER_PING\n");
+        break;
+
+    case StoreAndForward_RequestResponse_ROUTER_PONG:
+        // Do nothing
+        DEBUG_MSG("StoreAndForward_RequestResponse_ROUTER_PONG\n");
+        break;
+
+    default:
+        assert(0); // unexpected state - FIXME, make an error code and reboot
+    }
+
+    return ProcessMessage::STOP; // There's no need for others to look at this message.
+}
+
+StoreForwardPlugin::StoreForwardPlugin()
+    : SinglePortPlugin("StoreForwardPlugin", PortNum_TEXT_MESSAGE_APP), concurrency::OSThread("StoreForwardPlugin")
+{
+
+#ifndef NO_ESP32
+
+    isPromiscuous = true; // Brown chicken brown cow
+
+    if (StoreForward_Dev) {
+        /*
+            Uncomment the preferences below if you want to use the plugin
+            without having to configure it from the PythonAPI or WebUI.
+        */
+
+        radioConfig.preferences.store_forward_plugin_enabled = 1;
+        radioConfig.preferences.is_router = 1;
+        radioConfig.preferences.is_always_powered = 1;
+    }
+
+    if (radioConfig.preferences.store_forward_plugin_enabled) {
+
+        // Router
+        if (radioConfig.preferences.is_router) {
+            DEBUG_MSG("Initializing Store & Forward Plugin - Enabled as Router\n");
+            if (ESP.getPsramSize()) {
+                if (ESP.getFreePsram() >= 1024 * 1024) {
+
+                    // Do the startup here
+
+                    // Maximum number of records to return.
+                    if (radioConfig.preferences.store_forward_plugin_history_return_max)
+                        this->historyReturnMax = radioConfig.preferences.store_forward_plugin_history_return_max;
+
+                    // Maximum time window for records to return (in minutes)
+                    if (radioConfig.preferences.store_forward_plugin_history_return_window)
+                        this->historyReturnWindow = radioConfig.preferences.store_forward_plugin_history_return_window;
+
+                    // Maximum number of records to store in memory
+                    if (radioConfig.preferences.store_forward_plugin_records)
+                        this->records = radioConfig.preferences.store_forward_plugin_records;
+
+                    // Maximum number of records to store in memory
+                    if (radioConfig.preferences.store_forward_plugin_heartbeat)
+                        this->heartbeat = radioConfig.preferences.store_forward_plugin_heartbeat;
+
+                    // Popupate PSRAM with our data structures.
+                    this->populatePSRAM();
+
+                } else {
+                    DEBUG_MSG("Device has less than 1M of PSRAM free. Aborting startup.\n");
+                    DEBUG_MSG("Store & Forward Plugin - Aborting Startup.\n");
+                }
+
+            } else {
+                DEBUG_MSG("Device doesn't have PSRAM.\n");
+                DEBUG_MSG("Store & Forward Plugin - Aborting Startup.\n");
+            }
+
+            // Client
+        } else {
+            DEBUG_MSG("Initializing Store & Forward Plugin - Enabled as Client\n");
+        }
+    }
+#endif
+}

src/modules/esp32/StoreForwardPlugin.h

@@ -0,0 +1,85 @@
+#pragma once
+
+#include "SinglePortPlugin.h"
+#include "concurrency/OSThread.h"
+#include "mesh/generated/storeforward.pb.h"
+
+#include "configuration.h"
+#include <Arduino.h>
+#include <functional>
+
+struct PacketHistoryStruct {
+    uint32_t time;
+    uint32_t to;
+    uint32_t from;
+    uint8_t channel;
+    bool ack;
+    uint8_t payload[Constants_DATA_PAYLOAD_LEN];
+    pb_size_t payload_size;
+};
+
+class StoreForwardPlugin : public SinglePortPlugin, private concurrency::OSThread
+{
+    // bool firstTime = 1;
+    bool busy = 0;
+    uint32_t busyTo = 0;
+    char routerMessage[Constants_DATA_PAYLOAD_LEN] = {0};
+
+    uint32_t receivedRecord[50][2] = {{0}};
+
+    PacketHistoryStruct *packetHistory = 0;
+    uint32_t packetHistoryCurrent = 0;
+
+    PacketHistoryStruct *packetHistoryTXQueue = 0;
+    uint32_t packetHistoryTXQueue_size = 0;
+    uint32_t packetHistoryTXQueue_index = 0;
+
+    uint32_t packetTimeMax = 2000;
+
+  public:
+    StoreForwardPlugin();
+
+    /**
+     Update our local reference of when we last saw that node.
+     @return 0 if we have never seen that node before otherwise return the last time we saw the node.
+     */
+    void historyAdd(const MeshPacket &mp);
+    void historyReport();
+    void historySend(uint32_t msAgo, uint32_t to);
+
+    uint32_t historyQueueCreate(uint32_t msAgo, uint32_t to);
+
+    /**
+     * Send our payload into the mesh
+     */
+    void sendPayload(NodeNum dest = NODENUM_BROADCAST, uint32_t packetHistory_index = 0);
+    void sendMessage(NodeNum dest, char *str);
+    virtual MeshPacket *allocReply() override;
+    /*
+      Override the wantPortnum method.
+      */
+    virtual bool wantPortnum(PortNum p) { return true; };
+
+  private:
+    void populatePSRAM();
+
+    // S&F Defaults
+    uint32_t historyReturnMax = 250; // 250 records
+    uint32_t historyReturnWindow = 240; // 4 hours
+    uint32_t records = 0; // Calculated
+    bool heartbeat = false; // No heartbeat.
+
+  protected:
+    virtual int32_t runOnce() override;
+
+    /** Called to handle a particular incoming message
+
+    @return ProcessMessage::STOP if you've guaranteed you've handled this message and no other handlers should be considered for
+    it
+    */
+    virtual ProcessMessage handleReceived(const MeshPacket &mp) override;
+    virtual ProcessMessage handleReceivedProtobuf(const MeshPacket &mp, StoreAndForward *p);
+
+};
+
+extern StoreForwardPlugin *storeForwardPlugin;