Merge branch 'master' into t-watch-fixes

src/modules/AdminModule.cpp

@@ -368,6 +368,11 @@ void AdminModule::handleSetModuleConfig(const meshtastic_ModuleConfig &c)
         moduleConfig.has_remote_hardware = true;
         moduleConfig.remote_hardware = c.payload_variant.remote_hardware;
         break;
+    case meshtastic_ModuleConfig_neighbor_info_tag:
+        LOG_INFO("Setting module config: Neighbor Info\n");
+        moduleConfig.has_neighbor_info = true;
+        moduleConfig.neighbor_info = c.payload_variant.neighbor_info;
+        break;
     }
 
     saveChanges(SEGMENT_MODULECONFIG);
@@ -503,6 +508,11 @@ void AdminModule::handleGetModuleConfig(const meshtastic_MeshPacket &req, const
             res.get_module_config_response.which_payload_variant = meshtastic_ModuleConfig_remote_hardware_tag;
             res.get_module_config_response.payload_variant.remote_hardware = moduleConfig.remote_hardware;
             break;
+        case meshtastic_AdminMessage_ModuleConfigType_NEIGHBORINFO_CONFIG:
+            LOG_INFO("Getting module config: Neighbor Info\n");
+            res.get_module_config_response.which_payload_variant = meshtastic_ModuleConfig_neighbor_info_tag;
+            res.get_module_config_response.payload_variant.neighbor_info = moduleConfig.neighbor_info;
+            break;
         }
 
         // NOTE: The phone app needs to know the ls_secsvalue so it can properly expect sleep behavior.
@@ -663,4 +673,4 @@ AdminModule::AdminModule() : ProtobufModule("Admin", meshtastic_PortNum_ADMIN_AP
 {
     // restrict to the admin channel for rx
     boundChannel = Channels::adminChannel;
-}
+}

src/modules/CannedMessageModule.cpp

@@ -10,6 +10,10 @@
 
 #include "main.h" // for cardkb_found
 
+#ifndef INPUTBROKER_MATRIX_TYPE
+#define INPUTBROKER_MATRIX_TYPE 0
+#endif
+
 #ifdef OLED_RU
 #include "graphics/fonts/OLEDDisplayFontsRU.h"
 #endif
@@ -62,7 +66,7 @@ CannedMessageModule::CannedMessageModule()
     if (moduleConfig.canned_message.enabled) {
         this->loadProtoForModule();
         if ((this->splitConfiguredMessages() <= 0) && (cardkb_found.address != CARDKB_ADDR) &&
-            (cardkb_found.address != TDECK_KB_ADDR)) {
+            (cardkb_found.address != TDECK_KB_ADDR) && !INPUTBROKER_MATRIX_TYPE) {
             LOG_INFO("CannedMessageModule: No messages are configured. Module is disabled\n");
             this->runState = CANNED_MESSAGE_RUN_STATE_DISABLED;
             disable();

src/modules/Modules.cpp

@@ -4,8 +4,10 @@
 #include "input/TrackballInterruptImpl1.h"
 #include "input/UpDownInterruptImpl1.h"
 #include "input/cardKbI2cImpl.h"
+#include "input/kbMatrixImpl.h"
 #include "modules/AdminModule.h"
 #include "modules/CannedMessageModule.h"
+#include "modules/NeighborInfoModule.h"
 #include "modules/NodeInfoModule.h"
 #include "modules/PositionModule.h"
 #include "modules/RemoteHardwareModule.h"
@@ -47,6 +49,7 @@ void setupModules()
         waypointModule = new WaypointModule();
         textMessageModule = new TextMessageModule();
         traceRouteModule = new TraceRouteModule();
+        neighborInfoModule = new NeighborInfoModule();
 
         // Note: if the rest of meshtastic doesn't need to explicitly use your module, you do not need to assign the instance
         // to a global variable.
@@ -60,7 +63,11 @@ void setupModules()
         upDownInterruptImpl1->init();
         cardKbI2cImpl = new CardKbI2cImpl();
         cardKbI2cImpl->init();
-#endif
+#ifdef INPUTBROKER_MATRIX_TYPE
+        kbMatrixImpl = new KbMatrixImpl();
+        kbMatrixImpl->init();
+#endif // INPUTBROKER_MATRIX_TYPE
+#endif // HAS_BUTTON
 #if HAS_TRACKBALL
         trackballInterruptImpl1 = new TrackballInterruptImpl1();
         trackballInterruptImpl1->init();

src/modules/NeighborInfoModule.cpp

@@ -0,0 +1,319 @@
+#include "NeighborInfoModule.h"
+#include "MeshService.h"
+#include "NodeDB.h"
+#include "RTC.h"
+
+#define MAX_NUM_NEIGHBORS 10 // also defined in NeighborInfo protobuf options
+NeighborInfoModule *neighborInfoModule;
+
+static const char *neighborInfoConfigFile = "/prefs/neighbors.proto";
+
+/*
+Prints a single neighbor info packet and associated neighbors
+Uses LOG_DEBUG, which equates to Console.log
+NOTE: For debugging only
+*/
+void NeighborInfoModule::printNeighborInfo(const char *header, const meshtastic_NeighborInfo *np)
+{
+    LOG_DEBUG("%s NEIGHBORINFO PACKET from Node %d to Node %d (last sent by %d)\n", header, np->node_id, nodeDB.getNodeNum(),
+              np->last_sent_by_id);
+    LOG_DEBUG("----------------\n");
+    LOG_DEBUG("Packet contains %d neighbors\n", np->neighbors_count);
+    for (int i = 0; i < np->neighbors_count; i++) {
+        LOG_DEBUG("Neighbor %d: node_id=%d, snr=%.2f\n", i, np->neighbors[i].node_id, np->neighbors[i].snr);
+    }
+    LOG_DEBUG("----------------\n");
+}
+/*
+Prints the nodeDB nodes so we can see whose nodeInfo we have
+NOTE: for debugging only
+*/
+void NeighborInfoModule::printNodeDBNodes(const char *header)
+{
+    int num_nodes = nodeDB.getNumMeshNodes();
+    LOG_DEBUG("%s NODEDB SELECTION from Node %d:\n", header, nodeDB.getNodeNum());
+    LOG_DEBUG("----------------\n");
+    LOG_DEBUG("DB contains %d nodes\n", num_nodes);
+    for (int i = 0; i < num_nodes; i++) {
+        meshtastic_NodeInfoLite *dbEntry = nodeDB.getMeshNodeByIndex(i);
+        LOG_DEBUG("     Node %d: node_id=%d, snr=%.2f\n", i, dbEntry->num, dbEntry->snr);
+    }
+    LOG_DEBUG("----------------\n");
+}
+
+/*
+Prints the nodeDB neighbors
+NOTE: for debugging only
+*/
+void NeighborInfoModule::printNodeDBNeighbors(const char *header)
+{
+    int num_neighbors = getNumNeighbors();
+    LOG_DEBUG("%s NODEDB SELECTION from Node %d:\n", header, nodeDB.getNodeNum());
+    LOG_DEBUG("----------------\n");
+    LOG_DEBUG("DB contains %d neighbors\n", num_neighbors);
+    for (int i = 0; i < num_neighbors; i++) {
+        meshtastic_Neighbor *dbEntry = getNeighborByIndex(i);
+        LOG_DEBUG("     Node %d: node_id=%d, snr=%.2f\n", i, dbEntry->node_id, dbEntry->snr);
+    }
+    LOG_DEBUG("----------------\n");
+}
+
+/*
+Prints the nodeDB with selectors for the neighbors we've chosen to send (inefficiently)
+Uses LOG_DEBUG, which equates to Console.log
+NOTE: For debugging only
+*/
+void NeighborInfoModule::printNodeDBSelection(const char *header, const meshtastic_NeighborInfo *np)
+{
+    int num_neighbors = getNumNeighbors();
+    LOG_DEBUG("%s NODEDB SELECTION from Node %d:\n", header, nodeDB.getNodeNum());
+    LOG_DEBUG("----------------\n");
+    LOG_DEBUG("Selected %d neighbors of %d DB neighbors\n", np->neighbors_count, num_neighbors);
+    for (int i = 0; i < num_neighbors; i++) {
+        meshtastic_Neighbor *dbEntry = getNeighborByIndex(i);
+        bool chosen = false;
+        for (int j = 0; j < np->neighbors_count; j++) {
+            if (np->neighbors[j].node_id == dbEntry->node_id) {
+                chosen = true;
+            }
+        }
+        if (!chosen) {
+            LOG_DEBUG("     Node %d: neighbor=%d, snr=%.2f\n", i, dbEntry->node_id, dbEntry->snr);
+        } else {
+            LOG_DEBUG("---> Node %d: neighbor=%d, snr=%.2f\n", i, dbEntry->node_id, dbEntry->snr);
+        }
+    }
+    LOG_DEBUG("----------------\n");
+}
+
+/* Send our initial owner announcement 35 seconds after we start (to give network time to setup) */
+NeighborInfoModule::NeighborInfoModule()
+    : neighbors(neighborState.neighbors), numNeighbors(&neighborState.neighbors_count),
+      ProtobufModule("neighborinfo", meshtastic_PortNum_NEIGHBORINFO_APP, &meshtastic_NeighborInfo_msg), concurrency::OSThread(
+                                                                                                             "NeighborInfoModule")
+{
+    ourPortNum = meshtastic_PortNum_NEIGHBORINFO_APP;
+
+    if (moduleConfig.neighbor_info.enabled) {
+        this->loadProtoForModule();
+        setIntervalFromNow(35 * 1000);
+    } else {
+        LOG_DEBUG("NeighborInfoModule is disabled\n");
+        disable();
+    }
+}
+
+/*
+Allocate a zeroed neighbor info packet
+*/
+meshtastic_NeighborInfo *NeighborInfoModule::allocateNeighborInfoPacket()
+{
+    meshtastic_NeighborInfo *neighborInfo = (meshtastic_NeighborInfo *)malloc(sizeof(meshtastic_NeighborInfo));
+    memset(neighborInfo, 0, sizeof(meshtastic_NeighborInfo));
+    return neighborInfo;
+}
+
+/*
+Collect neighbor info from the nodeDB's history, capping at a maximum number of entries and max time
+Assumes that the neighborInfo packet has been allocated
+@returns the number of entries collected
+*/
+uint32_t NeighborInfoModule::collectNeighborInfo(meshtastic_NeighborInfo *neighborInfo)
+{
+    int my_node_id = nodeDB.getNodeNum();
+    neighborInfo->node_id = my_node_id;
+    neighborInfo->last_sent_by_id = my_node_id;
+    neighborInfo->node_broadcast_interval_secs = moduleConfig.neighbor_info.update_interval;
+
+    int num_neighbors = cleanUpNeighbors();
+
+    for (int i = 0; i < num_neighbors; i++) {
+        meshtastic_Neighbor *dbEntry = getNeighborByIndex(i);
+        if ((neighborInfo->neighbors_count < MAX_NUM_NEIGHBORS) && (dbEntry->node_id != my_node_id)) {
+            neighborInfo->neighbors[neighborInfo->neighbors_count].node_id = dbEntry->node_id;
+            neighborInfo->neighbors[neighborInfo->neighbors_count].snr = dbEntry->snr;
+            // Note: we don't set the last_rx_time and node_broadcast_intervals_secs here, because we don't want to send this over
+            // the mesh
+            neighborInfo->neighbors_count++;
+        }
+    }
+    printNodeDBNodes("DBSTATE");
+    printNodeDBNeighbors("NEIGHBORS");
+    printNodeDBSelection("COLLECTED", neighborInfo);
+    return neighborInfo->neighbors_count;
+}
+
+/*
+Remove neighbors from the database that we haven't heard from in a while
+@returns new number of neighbors
+*/
+size_t NeighborInfoModule::cleanUpNeighbors()
+{
+    uint32_t now = getTime();
+    int num_neighbors = getNumNeighbors();
+    NodeNum my_node_id = nodeDB.getNodeNum();
+
+    // Find neighbors to remove
+    std::vector<int> indices_to_remove;
+    for (int i = 0; i < num_neighbors; i++) {
+        meshtastic_Neighbor *dbEntry = getNeighborByIndex(i);
+        // We will remove a neighbor if we haven't heard from them in twice the broadcast interval
+        if ((now - dbEntry->last_rx_time > dbEntry->node_broadcast_interval_secs * 2) && (dbEntry->node_id != my_node_id)) {
+            indices_to_remove.push_back(i);
+        }
+    }
+
+    // Update the neighbor list
+    for (int i = 0; i < indices_to_remove.size(); i++) {
+        int index = indices_to_remove[i];
+        LOG_DEBUG("Removing neighbor with node ID 0x%x\n", neighbors[index].node_id);
+        for (int j = index; j < num_neighbors - 1; j++) {
+            neighbors[j] = neighbors[j + 1];
+        }
+        (*numNeighbors)--;
+    }
+
+    // Save the neighbor list if we removed any neighbors
+    if (indices_to_remove.size() > 0) {
+        saveProtoForModule();
+    }
+
+    return *numNeighbors;
+}
+
+/* Send neighbor info to the mesh */
+void NeighborInfoModule::sendNeighborInfo(NodeNum dest, bool wantReplies)
+{
+    meshtastic_NeighborInfo *neighborInfo = allocateNeighborInfoPacket();
+    collectNeighborInfo(neighborInfo);
+    meshtastic_MeshPacket *p = allocDataProtobuf(*neighborInfo);
+    // send regardless of whether or not we have neighbors in our DB,
+    // because we want to get neighbors for the next cycle
+    p->to = dest;
+    p->decoded.want_response = wantReplies;
+    printNeighborInfo("SENDING", neighborInfo);
+    service.sendToMesh(p, RX_SRC_LOCAL, true);
+}
+
+/*
+Encompasses the full construction and sending packet to mesh
+Will be used for broadcast.
+*/
+int32_t NeighborInfoModule::runOnce()
+{
+    bool requestReplies = false;
+    sendNeighborInfo(NODENUM_BROADCAST, requestReplies);
+    return getConfiguredOrDefaultMs(moduleConfig.neighbor_info.update_interval, default_broadcast_interval_secs);
+}
+
+/*
+Collect a recieved neighbor info packet from another node
+Pass it to an upper client; do not persist this data on the mesh
+*/
+bool NeighborInfoModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_NeighborInfo *np)
+{
+    printNeighborInfo("RECEIVED", np);
+    updateNeighbors(mp, np);
+    // Allow others to handle this packet
+    return false;
+}
+
+/*
+Copy the content of a current NeighborInfo packet into a new one and update the last_sent_by_id to our NodeNum
+*/
+void NeighborInfoModule::updateLastSentById(meshtastic_MeshPacket *p)
+{
+    auto &incoming = p->decoded;
+    meshtastic_NeighborInfo scratch;
+    meshtastic_NeighborInfo *updated = NULL;
+    memset(&scratch, 0, sizeof(scratch));
+    pb_decode_from_bytes(incoming.payload.bytes, incoming.payload.size, &meshtastic_NeighborInfo_msg, &scratch);
+    updated = &scratch;
+
+    updated->last_sent_by_id = nodeDB.getNodeNum();
+
+    // Set updated last_sent_by_id to the payload of the to be flooded packet
+    p->decoded.payload.size =
+        pb_encode_to_bytes(p->decoded.payload.bytes, sizeof(p->decoded.payload.bytes), &meshtastic_NeighborInfo_msg, updated);
+}
+
+void NeighborInfoModule::resetNeighbors()
+{
+    *numNeighbors = 0;
+    neighborState.neighbors_count = 0;
+    memset(neighborState.neighbors, 0, sizeof(neighborState.neighbors));
+    saveProtoForModule();
+}
+
+void NeighborInfoModule::updateNeighbors(const meshtastic_MeshPacket &mp, meshtastic_NeighborInfo *np)
+{
+    // The last sent ID will be 0 if the packet is from the phone, which we don't count as
+    // an edge. So we assume that if it's zero, then this packet is from our node.
+    if (mp.which_payload_variant == meshtastic_MeshPacket_decoded_tag && mp.from) {
+        getOrCreateNeighbor(mp.from, np->last_sent_by_id, np->node_broadcast_interval_secs, mp.rx_snr);
+    }
+}
+
+meshtastic_Neighbor *NeighborInfoModule::getOrCreateNeighbor(NodeNum originalSender, NodeNum n,
+                                                             uint32_t node_broadcast_interval_secs, int snr)
+{
+    // our node and the phone are the same node (not neighbors)
+    if (n == 0) {
+        n = nodeDB.getNodeNum();
+    }
+    // look for one in the existing list
+    for (int i = 0; i < (*numNeighbors); i++) {
+        meshtastic_Neighbor *nbr = &neighbors[i];
+        if (nbr->node_id == n) {
+            // if found, update it
+            nbr->snr = snr;
+            nbr->last_rx_time = getTime();
+            // Only if this is the original sender, the broadcast interval corresponds to it
+            if (originalSender == n)
+                nbr->node_broadcast_interval_secs = node_broadcast_interval_secs;
+            saveProtoForModule(); // Save the updated neighbor
+            return nbr;
+        }
+    }
+    // otherwise, allocate one and assign data to it
+    // TODO: max memory for the database should take neighbors into account, but currently doesn't
+    if (*numNeighbors < MAX_NUM_NODES) {
+        (*numNeighbors)++;
+    }
+    meshtastic_Neighbor *new_nbr = &neighbors[((*numNeighbors) - 1)];
+    new_nbr->node_id = n;
+    new_nbr->snr = snr;
+    new_nbr->last_rx_time = getTime();
+    // Only if this is the original sender, the broadcast interval corresponds to it
+    if (originalSender == n)
+        new_nbr->node_broadcast_interval_secs = node_broadcast_interval_secs;
+    saveProtoForModule(); // Save the new neighbor
+    return new_nbr;
+}
+
+void NeighborInfoModule::loadProtoForModule()
+{
+    if (!nodeDB.loadProto(neighborInfoConfigFile, meshtastic_NeighborInfo_size, sizeof(meshtastic_NeighborInfo),
+                          &meshtastic_NeighborInfo_msg, &neighborState)) {
+        neighborState = meshtastic_NeighborInfo_init_zero;
+    }
+}
+
+/**
+ * @brief Save the module config to file.
+ *
+ * @return true On success.
+ * @return false On error.
+ */
+bool NeighborInfoModule::saveProtoForModule()
+{
+    bool okay = true;
+
+#ifdef FS
+    FS.mkdir("/prefs");
+#endif
+
+    okay &= nodeDB.saveProto(neighborInfoConfigFile, meshtastic_NeighborInfo_size, &meshtastic_NeighborInfo_msg, &neighborState);
+
+    return okay;
+}

src/modules/NeighborInfoModule.h

@@ -0,0 +1,84 @@
+#pragma once
+#include "ProtobufModule.h"
+
+/*
+ * Neighborinfo module for sending info on each node's 0-hop neighbors to the mesh
+ */
+class NeighborInfoModule : public ProtobufModule<meshtastic_NeighborInfo>, private concurrency::OSThread
+{
+    meshtastic_Neighbor *neighbors;
+    pb_size_t *numNeighbors;
+
+  public:
+    /*
+     * Expose the constructor
+     */
+    NeighborInfoModule();
+
+    /* Reset neighbor info after clearing nodeDB*/
+    void resetNeighbors();
+
+    bool saveProtoForModule();
+
+    // Let FloodingRouter call updateLastSentById upon rebroadcasting a NeighborInfo packet
+    friend class FloodingRouter;
+
+  protected:
+    // Note: this holds our local info.
+    meshtastic_NeighborInfo neighborState;
+
+    /*
+     * Called to handle a particular incoming message
+     * @return true if you've guaranteed you've handled this message and no other handlers should be considered for it
+     */
+    virtual bool handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_NeighborInfo *nb) override;
+
+    /*
+     * Collect neighbor info from the nodeDB's history, capping at a maximum number of entries and max time
+     * @return the number of entries collected
+     */
+    uint32_t collectNeighborInfo(meshtastic_NeighborInfo *neighborInfo);
+
+    /*
+    Remove neighbors from the database that we haven't heard from in a while
+    @returns new number of neighbors
+    */
+    size_t cleanUpNeighbors();
+
+    /* Allocate a new NeighborInfo packet */
+    meshtastic_NeighborInfo *allocateNeighborInfoPacket();
+
+    // Find a neighbor in our DB, create an empty neighbor if missing
+    meshtastic_Neighbor *getOrCreateNeighbor(NodeNum originalSender, NodeNum n, uint32_t node_broadcast_interval_secs, int snr);
+
+    /*
+     * Send info on our node's neighbors into the mesh
+     */
+    void sendNeighborInfo(NodeNum dest = NODENUM_BROADCAST, bool wantReplies = false);
+
+    size_t getNumNeighbors() { return *numNeighbors; }
+
+    meshtastic_Neighbor *getNeighborByIndex(size_t x)
+    {
+        assert(x < *numNeighbors);
+        return &neighbors[x];
+    }
+
+    /* update neighbors with subpacket sniffed from network */
+    void updateNeighbors(const meshtastic_MeshPacket &mp, meshtastic_NeighborInfo *np);
+
+    /* update a NeighborInfo packet with our NodeNum as last_sent_by_id */
+    void updateLastSentById(meshtastic_MeshPacket *p);
+
+    void loadProtoForModule();
+
+    /* Does our periodic broadcast */
+    int32_t runOnce() override;
+
+    /* These are for debugging only */
+    void printNeighborInfo(const char *header, const meshtastic_NeighborInfo *np);
+    void printNodeDBNodes(const char *header);
+    void printNodeDBNeighbors(const char *header);
+    void printNodeDBSelection(const char *header, const meshtastic_NeighborInfo *np);
+};
+extern NeighborInfoModule *neighborInfoModule;