在UnetStack中实现水下路由协议：通过信标交换控制信息的问询

Awesome question—building a custom underwater routing protocol on UnetStack is a fun challenge, and using beacons to exchange control info is a core part of it. Let’s break down how to make this work effectively:

UnetStack nodes already transmit periodic beacons by default (handled by the BeaconAgent). These beacons carry basic node info like address, location, and link quality. To exchange routing-specific control info, you’ll extend this default behavior rather than building from scratch.

There are two primary ways to add your routing control info to beacons:

2.1 Use Custom Beacon Parameters #

You can attach key-value pairs directly to the beacon’s param map. This is great for simple, discrete values like routing metrics, next-hop addresses, or node state flags.

Example configuration (run in the UnetShell or a Groovy agent script):

// Set custom routing parameters in the beacon
beacon.param['routingMetric'] = node.currentLinkQuality
beacon.param['preferredNextHop'] = node.bestNeighborAddress
beacon.param['isSink'] = node.isSinkNode()

2.2 Add Custom TLV Fields #

For more structured or variable-length control data (like route lists or neighbor status arrays), use TLV (Type-Length-Value) fields. TLVs are flexible and widely used in underwater protocols to handle diverse data types efficiently.

First, define your custom TLV type (pick a unique byte value to avoid conflicts with built-in types):

// Define a unique TLV type for your routing info
static final byte ROUTING_INFO_TLV = 0x05

Then, add the TLV to your beacon:

// Serialize your routing data into a byte array
byte[] routingData = serializeMyRouteInfo(node.routeTable)
// Add the TLV to the beacon's TLV list
beacon.tlv.add(new TLV(ROUTING_INFO_TLV, routingData))

Don’t forget to tune beacon parameters to fit your underwater environment:

• Adjust the beacon.interval (default is 10s) to balance freshness of control info and energy/bandwidth usage. For dynamic underwater networks, you might use adaptive intervals based on link changes.
• Set beacon.power appropriately to reach your target neighbors without wasting energy.

Example interval adjustment:

// Set beacon interval to 5 seconds for a dynamic network
beacon.interval = 5000

On the receiving end, you’ll subscribe to BeaconNtf notifications to process incoming beacons and extract your control data.

Example parsing script:

// Subscribe to beacon notifications
subscribe(BeaconNtf) { ntf ->
  // Parse custom parameters
  def metric = ntf.param['routingMetric']
  def nextHop = ntf.param['preferredNextHop']
  if (metric != null) {
    // Update your routing table with the new metric from node ntf.from
    updateRoutingMetric(ntf.from, metric)
  }

  // Parse custom TLV
  def routingTlv = ntf.tlv.find { it.type == ROUTING_INFO_TLV }
  if (routingTlv != null) {
    // Deserialize the byte array back into your route info object
    RouteInfo routeInfo = deserializeRouteInfo(routingTlv.value)
    // Integrate the received route data into your protocol logic
    mergeRouteTables(ntf.from, routeInfo)
  }
}

• Keep control payload minimal: Underwater acoustic channels have limited bandwidth and high latency—avoid stuffing beacons with unnecessary data. Use compression for large TLV payloads if needed.
• Handle packet loss: Beacons might get lost, so design your routing logic to be resilient (e.g., rely on multiple beacon updates before making routing decisions).
• Avoid beacon collisions: In dense networks, consider using adaptive beacon timing or TDMA (Time Division Multiple Access) to reduce collisions.

内容的提问来源于stack exchange，提问作者PRADEEP NAZARETH