Meshtastic vs MeshCore

FloodingRouter Implementation

void FloodingRouter::perhapsRebroadcast(const meshtastic_MeshPacket *p)
{
    // Never rebroadcast from the phone
    if (!iface) {
        LOG_DEBUG("No interface - dropping rebroadcast\n");
        return;
    }

    // Note: if the packet originates from the local node, do not rebroadcast as the Routing layer has already 
    // done that if it needs to. (previously this was causing duplicate rebroadcasts and interference)
    if (shouldFilterReceived(p) || p->from == getNodeNum()) {
        LOG_DEBUG("Dropping rebroadcast of received, from=0x%x, to=0x%x\n", p->from, p->to);
        return;
    }

    if (iface->findInTxQueue(p->from, p->id)) {
        LOG_DEBUG("This same packet is still in the TX queue - we will relayer anyway\n");
    }

    // Is this message destined for or from us? Then don't rebroadcast
    NodeNum ourNode = getNodeNum();
    if (p->to == ourNode || p->from == ourNode) {
        LOG_DEBUG("Dropping rebroadcast of our message, from=0x%x, to=0x%x\n", p->from, p->to);
        return;
    }

    // If the message is a broadcast or destined for our node, rebroadcast
    // broadcasts and messages directed to the phone always have max_hop_limit
    if (loopbackBroadcastsToPhone(config.lora.loopback_broadcasts_to_phone) ? isBroadcast(p->to) : p->to == NODENUM_BROADCAST) {
        // Treat messages that arrive without a hop_limit included as having a default of 3
        auto hopLimit = Default::getHopLimit(p);
        if (hopLimit > 0) {
            // rebroadcasting a broadcast packet
            LOG_DEBUG("Rebroadcasting broadcast message, from=0x%x, id=0x%x, hopLimit=%d\n", p->from, p->id, hopLimit);
            auto newP = packetPool.allocCopy(*p);
            newP->hop_limit = hopLimit - 1; // bump down the hop count
            iface->sendTo(newP);
        } else {
            LOG_DEBUG("Not rebroadcasting broadcast message, from=0x%x, id=0x%x, hopLimit=0\n", p->from, p->id);
        }
    }
}

NextHopRouter Constants

// The number of retransmissions intermediate nodes will do (actually 1 less than this)
constexpr static uint8_t NUM_INTERMEDIATE_RETX = 2;
// The number of retransmissions the original sender will do
constexpr static uint8_t NUM_RELIABLE_RETX = 3;

Congestion Scaling

uint32_t Default::getConfiguredOrDefaultMsScaled(uint32_t configured, uint32_t defaultValue, uint32_t numOnlineNodes)
{
    // If we are a router, we don't scale the value. It's already significantly higher.
    if (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER)
        return getConfiguredOrDefaultMs(configured, defaultValue);

    // Additionally if we're a tracker or sensor, we want priority to send position and telemetry
    if (IS_ONE_OF(config.device.role, meshtastic_Config_DeviceConfig_Role_SENSOR, meshtastic_Config_DeviceConfig_Role_TRACKER))
        return getConfiguredOrDefaultMs(configured, defaultValue);

    return getConfiguredOrDefaultMs(configured, defaultValue) * congestionScalingCoefficient(numOnlineNodes);
}

Packet Routing Logic

DispatcherAction Mesh::onRecvPacket(Packet* pkt) {
  if (pkt->isRouteDirect() && pkt->path_len >= PATH_HASH_SIZE) {
    if (self_id.isHashMatch(pkt->path) && allowPacketForward(pkt)) {
      if (_tables->hasSeen(pkt)) return ACTION_RELEASE;  // don't retransmit!

      // remove our hash from 'path', then re-broadcast
      pkt->path_len -= PATH_HASH_SIZE;
      memcpy(pkt->path, &pkt->path[PATH_HASH_SIZE], pkt->path_len);

      uint32_t d = getDirectRetransmitDelay(pkt);
      return ACTION_RETRANSMIT_DELAYED(0, d);  // Routed traffic is HIGHEST priority 
    }
    return ACTION_RELEASE;   // this node is NOT the next hop (OR this packet has already been forwarded), so discard.
  }
  // Additional routing logic...
}

Flood Routing with Priority

void Mesh::sendFlood(Packet* packet, uint32_t delay_millis) {
  packet->header &= ~PH_ROUTE_MASK;
  packet->header |= ROUTE_TYPE_FLOOD;
  packet->path_len = 0;

  _tables->hasSeen(packet); // mark this packet as already sent in case it is rebroadcast back to us

  uint8_t pri;
  if (packet->getPayloadType() == PAYLOAD_TYPE_PATH) {
    pri = 2;
  } else if (packet->getPayloadType() == PAYLOAD_TYPE_ADVERT) {
    pri = 3;   // de-prioritie these
  } else {
    pri = 1;
  }
  sendPacket(packet, pri, delay_millis);
}

Airtime Budget

float Dispatcher::getAirtimeBudgetFactor() const {
  return 2.0;   // default, 33.3%  (1/3rd)
}

Randomized Delay Implementation

// Multiple nodes around sender could all try to rebroadcast at once, so apply a random delay
uint32_t rand_delay = _rng->nextInt(ANNOUNCE_DELAY_MIN, ANNOUNCE_DELAY_MAX);