Stay up-to-date wrt master (cc @mc-hamster)

# Conflicts:
#	src/plugins/Plugins.cpp
#	src/plugins/RangeTestPlugin.cpp
#	src/plugins/StoreForwardPlugin.cpp

docs/software/plugins/RangeTestPlugin.md

@@ -0,0 +1,93 @@
+# About
+
+The RangeTest Plugin will help you perform range and coverage tests.
+
+# Configuration
+
+These are the settings that can be configured.
+
+    range_test_plugin_enabled
+        Is the plugin enabled?
+        
+        0 = Disabled (Default)
+        1 = Enabled
+
+    range_test_plugin_save
+        If enabled, we will save a log of all received messages to /static/rangetest.csv which you can access from the webserver. We will abort
+        writing if there is less than 50k of space on the filesystem to prevent filling up the storage.
+
+        0 = Disabled (Default)
+        1 = Enabled
+
+    range_test_plugin_sender
+        Number of seconds to wait between sending packets. Using the long_slow channel configuration, it's best not to go more frequent than once every 60 seconds. You can be more agressive with faster settings. 0 is default which disables sending messages.
+
+# Usage Notes
+
+For basic usage, you will need two devices both with a GPS. A device with a paired phone with GPS may work, I have not tried it. 
+
+The first thing to do is to turn on the plugin. With the plugin turned on, the other settings will be available:
+
+	range_test_plugin_enabled = 1
+
+If you want to send a message every 60 seconds:
+    
+	range_test_plugin_sender = 60
+
+To save a log of the messages:
+
+    range_test_plugin_save = 1
+
+Recommended settings for a sender at different radio settings:
+
+    Long Slow  ... range_test_plugin_sender = 60
+    Long Alt   ... range_test_plugin_sender = 30
+    Medium     ... range_test_plugin_sender = 15
+    Short Fast ... range_test_plugin_sender = 15
+
+## Other things to keep in mind
+
+Be sure to turn off either the plugin configured as a sender or the device where the plugin setup as sender when not in use. This will use a lot of time on air and will spam your channel.
+
+Also be mindful of your space usage on the file system. It has protections from filling up the space but it's best to delete old range test results.
+
+
+# Known Problems
+
+* If turned on, using mesh network will become unwieldly because messages are sent over the same channel as the other messages. See TODO below.
+
+# TODO
+
+* Right now range test messages go over the TEXT_MESSAGE_APP port. We need a toggle to switch to optionally send over RANGE_TEST_APP.
+
+# FAQ
+
+Q: Where is rangetest.csv saved?
+A: Turn on the WiFi on your device as either a WiFi client or a WiFi AP. Once you can connect to your device, go to /static and you will see rangetest.csv.
+
+Q: Do I need to have WiFi turned on for the file to be saved?
+A: Nope, it'll just work.
+
+Q: Do I need a phone for this plugin?
+A: There's no need for a phone.
+
+Q: Can I use this as a message logger?
+A: While it's not the intended purpose, sure, why not. Do it!
+
+Q: What will happen if I run out of space on my device?
+A: We have a protection in place to keep you from completly filling up your device. This will make sure that other device critical functions will continue to work. We will reserve at least 50k of free space.
+
+Q: What do I do with the rangetest.csv file when I'm done?
+A: Go to /static and delete the file.
+
+Q: Can I use this as a sender while on battery power?
+A: Yes, but your battery will run down quicker than normal. While sending, we tell the device not to go into low-power mode since it needs to keep to a fairly strict timer.
+
+Q: Why is this operating on incoming messages instead of the existing location discovery protocol?
+A: This plugin is still young and currently supports monitoring just one port at a time. I decided to use the existing message port because that is easy to test with. A future version will listen to multiple ports to be more promiscuous. 
+
+# Need more help?
+
+Go to the Meshtastic Discourse Group if you have any questions or to share how you have used this.
+
+https://meshtastic.discourse.group

docs/software/plugins/StoreForwardPlugin.md

@@ -1,14 +1,12 @@
 # About
 
-  This is a work in progress and is not yet available.
+This is a work in progress and is not yet available.
 
-The Store Request Plugin is an implementation of a Store and Forward system to enable resilient messaging in the event that a client device is disconnected from the main network.
+The Store Forward Plugin is an implementation of a Store and Forward system to enable resilient messaging in the event that a client device is disconnected from the main network.
 
-Because of the increased network traffic for this overhead, it's not adviced to use this if you are duty cycle limited for your airtime usage nor is it adviced to use this for SF12.
+Because of the increased network traffic for this overhead, it's not adviced to use this if you are duty cycle limited for your airtime usage nor is it adviced to use this for SF12 (Long range but Slow).
 
-# Running notes
-
-This will only work on nodes that are designated as a Router.
+# Requirements
 
 Initial Requirements:
 
@@ -17,5 +15,91 @@ Initial Requirements:
 * * Router nodes are intended to be always online. If this plugin misses any messages, the reliability of the stored messages will be reduced
 * Esp32 Processor based device with external PSRAM. (tbeam v1.0 and tbeamv1.1, maybe others)
 
-Initial Features
-* 
+# Implementation timeline
+
+Not necessarily in this order:
+
+UC 1) MVP - automagically forward packets to a client that may have missed packets.
+
+UC 2) Client Interface (Web, Android, Python or iOS when that happens) to optionally request packets be resent. This is to support the case where Router has not detected that the client was away. This is because the router will only know you're away if you've been gone for a period of time but will have no way of knowing if you were offline for a short number of minutes. This will cover the case where you have ducked into a cave or you're swapping out your battery.
+
+UC 3) router sends a periodic “heartbeat” to let the clients know they’re part of the main mesh
+
+UC 4) support for a mesh to have multiple routers that have the store & forward functionality (for redundancy)
+
+UC 5) Support for "long term" delayed messages and "short term" delayed messages. Handle the cases slightly different to improve user expierence. A short term delayed message would be a message that was resent becaue a node was not heard from for <5 minutes. A long term delayed message is a message that has not been delivered in >5 minutes.
+
+UC 6) Eventually we could add a "want_store_and_forward" bit to MeshPacket and that could be nicer than whitelists in this plugin. Initially we'd only set that bit in text messages (and any other plugin messages that can cope with this). This change would be backward wire compatible so can add easily later.
+
+UC 7) Currently the way we allocate messages in the device code is super inefficient. It always allocates the worst case message size. Really we should dynamically allocate just the # of bytes we need. This would allow many more MeshPackets to be kept in RAM.
+
+UC 8) We'll want a "delayed" bit in MeshPacket. This will indicate that the message was not received in real time.
+
+# Things to consider
+
+Not all these cases will be initially implemented. It's just a running stream of thoughts to be considered.
+
+## Main Mesh Network with Router
+
+The store and forward plugin is intended to be enabled on a router that designates your "main" mesh network.
+
+## Store and Forward on Multiple Routers
+
+If multiple routers with the plugin are enabled, they should be able to share their stored database amongst each other. This enable resilliancy from one router going offline.
+
+## Fragmented networks - No router
+
+In this case, the mesh network has been fragmented by two client devices leaving the main network.
+
+If two Meshtastic devices walk away from the main mesh, they will be able to message each other but not message the main network. When they return to the main network, they will receive the messages they have missed from the main mesh network.
+
+## Fragmented network - With routers
+
+In this case, we have two routers separate by a great distance, each serving multiple devices. One of the routers have gone offline. This has now created two physically seaprated mesh networks using the same channel configuration.
+
+Q: How do we rejoin both fragmented networks? Do we care about messages that were unrouted between fagments?
+
+## Identifing Delayed Messages
+
+When a message is replayed for a node, identify the packet as "Delayed". This will indicate that the message was not received in real time.
+
+# Router Data Structures
+
+Structure of received messages:
+
+    receivedMessages
+      Port_No
+      packetID
+      to
+      from
+      rxTimeMsec
+      data
+
+Structure of nodes and last time we heard from them. This is a record of any packet type.
+
+    receivedRecord
+      From
+      rxTimeMillis
+
+# General Operation for UC1 - automagically forward packets to a client that may have missed packets
+
+On every handled packet
+* Record the sender from and the time we heard from that sender into senderRecord.
+
+On every handled packet
+
+* If the packet is a message, save the messsage into receivedMessages
+
+On every handled packet, if we have not heard from that sender in a period of time greater than timeAway, let's assume that they have been away from the network.
+
+* In this case, we will resend them all the messages they have missed since they were gone
+
+## Expected problems this implementation
+
+* If the client has been away for less than 5 minutes and has received the previously sent message, the client will gracefully ignore it. This is thanks to PacketHistory::wasSeenRecently in PacketHistory.cpp.
+* * If the client has been away for more than 5 minutes and we resend packets that they have already received, it's possible they will see duplicate messages. This should be unlikely but is still possible. 
+
+
+# Designed limitations
+
+The Store and Forward plugin will subscribe to specific packet types and channels and only save those. This will both reduce the amount of data we will need to store and reduce the overhead on the network. Eg: There's no need to replay ACK packets nor is there's no need to replay old location packets.