add control responder example

Author: rightup

examples/discover_nodes.py

@@ -23,12 +23,15 @@
 
 from pymc_core.protocol.packet_builder import PacketBuilder
 
+# ADV_TYPE_REPEATER = 2, so filter mask is (1 << 2) = 0x04
+FILTER_REPEATERS = 0x04  # Bit 2 set for repeater node type
+
 
 async def discover_nodes(
     radio_type: str = "waveshare",
     serial_port: str = "/dev/ttyUSB0",
     timeout: float = 5.0,
-    filter_mask: int = 0x02,
+    filter_mask: int = FILTER_REPEATERS,
 ):
     """
     Discover nearby mesh nodes using control packets.
@@ -37,7 +40,7 @@ async def discover_nodes(
         radio_type: Radio hardware type ("waveshare", "uconsole", etc.)
         serial_port: Serial port for KISS TNC
         timeout: How long to wait for responses (seconds)
-        filter_mask: Node types to discover (0x02 = repeaters only)
+        filter_mask: Node types to discover (CONTACT_TYPE_REPEATER = repeaters only)
     """
     mesh_node, identity = create_mesh_node("DiscoveryNode", radio_type, serial_port)
 
@@ -90,7 +93,7 @@ def on_discovery_response(response_data: dict):
     control_handler.set_response_callback(discovery_tag, on_discovery_response)
 
     # Create discovery request packet
-    # filter_mask: 0x02 = bit 1 set = discover repeaters
+    # filter_mask: 0x04 = bit 2 set (1 << ADV_TYPE_REPEATER where ADV_TYPE_REPEATER=2)
     # since: 0 = discover all nodes regardless of modification time
     pkt = PacketBuilder.create_discovery_request(
         tag=discovery_tag, filter_mask=filter_mask, since=0, prefix_only=False
@@ -164,8 +167,8 @@ def main():
     parser.add_argument(
         "--filter",
         type=lambda x: int(x, 0),
-        default=0x02,
-        help="Node type filter mask (default: 0x02 for repeaters)",
+        default=FILTER_REPEATERS,
+        help="Node type filter mask (default: 0x04 for repeaters, bit position = node type)",
     )
 
     args = parser.parse_args()

examples/respond_to_discovery.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+"""
+Minimal example: Respond to discovery requests.
+
+This example demonstrates how to listen for discovery requests from other nodes
+and automatically respond with this node's information.
+
+Simply run this script and it will respond to any discovery requests until stopped.
+"""
+
+import asyncio
+
+from common import create_mesh_node
+
+from pymc_core.protocol.packet_builder import PacketBuilder
+
+# Node type values from C++ AdvertDataHelpers.h
+ADV_TYPE_REPEATER = 2
+ADV_TYPE_CHAT_NODE = 1
+ADV_TYPE_ROOM_SERVER = 3
+
+
+async def respond_to_discovery(
+    radio_type: str = "waveshare",
+    serial_port: str = "/dev/ttyUSB0",
+    node_type: int = ADV_TYPE_CHAT_NODE,
+):
+    """
+    Listen for discovery requests and respond with node information.
+
+    Args:
+        radio_type: Radio hardware type ("waveshare", "uconsole", etc.)
+        serial_port: Serial port for KISS TNC
+        node_type: Type of this node (1=chat, 2=repeater, 3=room_server)
+    """
+    mesh_node, identity = create_mesh_node("DiscoveryResponder", radio_type, serial_port)
+
+    # Get our public key for responses
+    our_pub_key = identity.get_public_key()
+    
+    # Node type names for logging
+    node_type_names = {
+        ADV_TYPE_CHAT_NODE: "Chat Node",
+        ADV_TYPE_REPEATER: "Repeater",
+        ADV_TYPE_ROOM_SERVER: "Room Server",
+    }
+    node_type_name = node_type_names.get(node_type, f"Unknown({node_type})")
+
+    # Create callback to handle discovery requests
+    def on_discovery_request(request_data: dict):
+        """Handle incoming discovery request."""
+        tag = request_data.get("tag", 0)
+        filter_byte = request_data.get("filter", 0)
+        prefix_only = request_data.get("prefix_only", False)
+        snr = request_data.get("snr", 0.0)
+        rssi = request_data.get("rssi", 0)
+
+        print(
+            f"📡 Discovery request: tag=0x{tag:08X}, "
+            f"filter=0x{filter_byte:02X}, SNR={snr:+.1f}dB, RSSI={rssi}dBm"
+        )
+
+        # Check if filter matches our node type
+        filter_mask = 1 << node_type
+        if (filter_byte & filter_mask) == 0:
+            print(f"   ↳ Filter doesn't match, ignoring")
+            return
+
+        # Create and send discovery response
+        print(f"   ↳ Sending response...")
+        
+        pkt = PacketBuilder.create_discovery_response(
+            tag=tag,
+            node_type=node_type,
+            inbound_snr=snr,
+            pub_key=our_pub_key,
+            prefix_only=prefix_only,
+        )
+
+        # Send the response
+        asyncio.create_task(send_response(mesh_node, pkt, tag))
+
+    async def send_response(node, pkt, tag):
+        """Send discovery response packet."""
+        try:
+            success = await node.dispatcher.send_packet(pkt, wait_for_ack=False)
+            if success:
+                print(f"   ✓ Response sent\n")
+            else:
+                print(f"   ✗ Failed to send\n")
+        except Exception as e:
+            print(f"   ✗ Error: {e}\n")
+
+    # Get the control handler and set up request callback
+    control_handler = mesh_node.dispatcher.control_handler
+    if not control_handler:
+        print("Error: Control handler not available")
+        return
+
+    control_handler.set_request_callback(on_discovery_request)
+
+    print(f"   Listening for discovery requests as {node_type_name}")
+    print(f"   Node type: {node_type} (filter: 0x{1 << node_type:02X})")
+    print(f"   Public key: {our_pub_key.hex()[:32]}...")
+    print(f"   Press Ctrl+C to stop\n")
+
+    # Listen forever
+    try:
+        while True:
+            await asyncio.sleep(1)
+    except KeyboardInterrupt:
+        print("\n\n  Stopped\n")
+
+    control_handler.clear_request_callback()
+
+
+def main():
+    """Main function for running the discovery responder example."""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Respond to mesh node discovery requests")
+    parser.add_argument(
+        "--radio-type",
+        choices=["waveshare", "uconsole", "meshadv-mini", "kiss-tnc"],
+        default="waveshare",
+        help="Radio hardware type (default: waveshare)",
+    )
+    parser.add_argument(
+        "--serial-port",
+        default="/dev/ttyUSB0",
+        help="Serial port for KISS TNC (default: /dev/ttyUSB0)",
+    )
+    parser.add_argument(
+        "--node-type",
+        type=int,
+        choices=[1, 2, 3],
+        default=ADV_TYPE_CHAT_NODE,
+        help="Node type: 1=chat, 2=repeater, 3=room_server (default: 1)",
+    )
+
+    args = parser.parse_args()
+
+    print(f"Using {args.radio_type} radio configuration")
+    if args.radio_type == "kiss-tnc":
+        print(f"Serial port: {args.serial_port}")
+
+    asyncio.run(respond_to_discovery(args.radio_type, args.serial_port, args.node_type))
+
+
+if __name__ == "__main__":
+    main()

src/pymc_core/node/handlers/control.py

@@ -15,9 +15,6 @@
 CTL_TYPE_NODE_DISCOVER_REQ = 0x80  # Discovery request
 CTL_TYPE_NODE_DISCOVER_RESP = 0x90  # Discovery response
 
-# Node type filter flags (bit positions in filter byte)
-ADV_TYPE_REPEATER = 1
-
 
 class ControlHandler:
     """Handler for control packets (payload type 0x0B).

src/pymc_core/protocol/packet_builder.py

@@ -907,8 +907,8 @@ def create_discovery_request(
             ```python
             import random
             tag = random.randint(0, 0xFFFFFFFF)
-            # Filter for repeaters (bit 1)
-            packet = PacketBuilder.create_discovery_request(tag, filter_mask=0x02)
+            # Filter for repeaters: ADV_TYPE_REPEATER=2, so (1 << 2) = 0x04
+            packet = PacketBuilder.create_discovery_request(tag, filter_mask=0x04)
             # Send as zero-hop broadcast
             ```
         """

src/pymc_core/protocol/utils.py

@@ -49,6 +49,8 @@
     0x07: "ANON_REQ",
     0x08: "PATH",
     0x09: "TRACE",
+    0x0A: "MULTIPART",
+    0x0B: "CONTROL",
     0x0F: "RAW_CUSTOM",
 }