ReticulumTelemetryHub 0.1.0__tar.gz

reticulumtelemetryhub-0.1.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: ReticulumTelemetryHub
+Version: 0.1.0
+Summary: 
+Author: naman108
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: lxmf (>=0.4.4,<0.5.0)
+Requires-Dist: msgpack (>=1.0.8,<2.0.0)
+Requires-Dist: pytest (>=8.3.2,<9.0.0)
+Requires-Dist: sqlalchemy (>=2.0.32,<3.0.0)
+Description-Content-Type: text/markdown
+
+

reticulumtelemetryhub-0.1.0/lxmf_telemetry/model/fields/field_telemetry_stream.py

@@ -0,0 +1,7 @@
+from lxmf_telemetry.model.persistance.telemeter import Telemeter
+
+
+class FieldTelmetryStream():
+
+    telemeters: list[Telemeter]
+    

reticulumtelemetryhub-0.1.0/lxmf_telemetry/model/persistance/__init__.py

@@ -0,0 +1,3 @@
+from sqlalchemy.ext.declarative import declarative_base
+
+Base = declarative_base()

reticulumtelemetryhub-0.1.0/lxmf_telemetry/model/persistance/appearance.py

@@ -0,0 +1,19 @@
+from sqlalchemy import Column, Integer, String, ForeignKey, BLOB
+from sqlalchemy.orm import relationship
+from . import Base
+
+
+class Appearance(Base):
+
+    __tablename__ = "Appearance"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    icon = Column(String, nullable=False)
+    foreground = Column(String, nullable=False)
+    background = Column(String, nullable=False)
+    peer_id = Column(String, ForeignKey("Peer.destination_hash"))
+    peer = relationship("Peer", back_populates="appearance")
+
+    def __init__(self, peer, icon = "Default"):
+        self.peer = peer
+        self.icon = icon

reticulumtelemetryhub-0.1.0/lxmf_telemetry/model/persistance/peer.py

@@ -0,0 +1,13 @@
+from . import Base
+from typing import TYPE_CHECKING, Optional
+from sqlalchemy import Column, Integer, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+if TYPE_CHECKING:
+    from .telemeter import Telemeter
+
+class Peer(Base):
+    __tablename__ = 'Peer'
+
+    destination_hash: Mapped[str] = mapped_column(String, nullable=False, primary_key=True)
+    telemeters = relationship("Telemeter")
+    #appearance = relationship("Appearance", back_populates='peer')

reticulumtelemetryhub-0.1.0/lxmf_telemetry/model/persistance/sensors/location.py

@@ -0,0 +1,69 @@
+from sqlalchemy import Column
+from lxmf_telemetry.model.persistance.sensors.sensor import Sensor
+from .sensor_enum import SID_LOCATION
+import struct
+import RNS
+from sqlalchemy import Integer, ForeignKey, Float, DateTime
+from sqlalchemy.orm import Mapped, mapped_column
+from datetime import datetime
+
+class Location(Sensor):
+    __tablename__ = 'Location'
+
+    id: Mapped[int] = mapped_column(ForeignKey('Sensor.id'), primary_key=True)
+    latitude: Mapped[float] = mapped_column()
+    longitude: Mapped[float] = mapped_column()
+    altitude: Mapped[float] = mapped_column()
+    speed: Mapped[float] = mapped_column()
+    bearing: Mapped[float] = mapped_column()
+    accuracy: Mapped[float] = mapped_column()
+    last_update: Mapped[datetime] = mapped_column(DateTime)
+
+    def __init__(self):
+        super().__init__(stale_time=15)
+        self.latitude = None
+        self.longitude = None
+        self.altitude = None
+        self.speed = None
+        self.bearing = None
+        self.accuracy = None
+
+    def pack(self):
+        try:
+            return [
+                struct.pack("!i", int(round(self.latitude, 6) * 1e6)),
+                struct.pack("!i", int(round(self.longitude, 6) * 1e6)),
+                struct.pack("!I", int(round(self.altitude, 2) * 1e2)),
+                struct.pack("!I", int(round(self.speed, 2) * 1e2)),
+                struct.pack("!I", int(round(self.bearing, 2) * 1e2)),
+                struct.pack("!H", int(round(self.accuracy, 2) * 1e2)),
+                self.last_update.timestamp(),
+            ]
+        except (KeyError, ValueError, struct.error) as e:
+            RNS.log(
+                "An error occurred while packing location sensor data. "
+                "The contained exception was: " + str(e),
+                RNS.LOG_ERROR,
+            )
+            return None
+
+    def unpack(self, packed):
+        try:
+            if packed is None:
+                return None
+            else:
+                self.latitude = struct.unpack("!i", packed[0])[0] / 1e6
+                self.longitude = struct.unpack("!i", packed[1])[0] / 1e6
+                self.altitude = struct.unpack("!I", packed[2])[0] / 1e2
+                self.speed = struct.unpack("!I", packed[3])[0] / 1e2
+                self.bearing = struct.unpack("!I", packed[4])[0] / 1e2
+                self.accuracy = struct.unpack("!H", packed[5])[0] / 1e2
+                self.last_update = datetime.fromtimestamp(packed[6])
+        except (struct.error, IndexError):
+            return None
+
+
+    __mapper_args__ = {
+        'polymorphic_identity': SID_LOCATION,
+        'with_polymorphic': '*'
+    }

reticulumtelemetryhub-0.1.0/lxmf_telemetry/model/persistance/sensors/magnetic_field.py

@@ -0,0 +1,36 @@
+from sqlalchemy import Column
+from lxmf_telemetry.model.persistance.sensors.sensor import Sensor
+from .sensor_enum import SID_MAGNETIC_FIELD
+import struct
+import RNS
+from sqlalchemy import Integer, ForeignKey, Float, DateTime
+from sqlalchemy.orm import Mapped, mapped_column
+from datetime import datetime
+
+class MagneticField(Sensor):
+    __tablename__ = 'MagneticField'
+
+    id: Mapped[int] = mapped_column(ForeignKey('Sensor.id'), primary_key=True)
+    x: Mapped[float] = mapped_column()
+    y: Mapped[float] = mapped_column()
+    z: Mapped[float] = mapped_column()
+
+    def __init__(self):
+        super().__init__(stale_time=15)
+        self.x = None
+        self.y = None
+        self.z = None
+
+    def pack(self):
+        return [self.x, self.y, self.z]
+
+    def unpack(self, packed):
+        try:
+            return {"x": packed[0], "y": packed[1], "z": packed[2]}
+        except:
+            return None
+
+    __mapper_args__ = {
+        'polymorphic_identity': SID_MAGNETIC_FIELD,
+        'with_polymorphic': '*'
+    }

reticulumtelemetryhub-0.1.0/lxmf_telemetry/model/persistance/sensors/sensor.py

@@ -0,0 +1,44 @@
+from sqlalchemy import Column, ForeignKey, Integer, Float, Boolean, String, create_engine, BLOB
+from msgpack import packb, unpackb
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker, relationship, Mapped, mapped_column
+import time
+from typing import TYPE_CHECKING
+from .. import Base
+
+class Sensor(Base):
+    __tablename__ = 'Sensor'
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    sid = Column(Integer, nullable=False, default=0x00)
+    stale_time = Column(Float, nullable=True)
+    data = Column(BLOB, nullable=True)
+    synthesized = Column(Boolean, default=False)
+    telemeter_id: Mapped[int] = mapped_column(ForeignKey('Telemeter.id'))
+    telemeter = relationship("Telemeter", back_populates='sensors')
+
+    def __init__(self, stale_time=None, data=None, active=False, synthesized=False, last_update=0, last_read=0):
+        self.stale_time = stale_time
+        self.data = data
+        self.active = active
+        self.synthesized = synthesized
+        self.last_update = last_update
+        self.last_read = last_read
+
+    def packb(self):
+        return packb(self.pack())
+
+    def unpackb(self, packed):
+        return unpackb(self.unpack(packed))
+
+    def pack(self):
+        return self.data
+
+    def unpack(self, packed):
+        return packed
+
+    __mapper_args__ = {
+        'polymorphic_identity': 'Sensor',
+        'with_polymorphic': '*',
+        "polymorphic_on": sid
+    }

reticulumtelemetryhub-0.1.0/lxmf_telemetry/model/persistance/sensors/sensor_enum.py

@@ -0,0 +1,24 @@
+SID_NONE              = 0x00
+SID_TIME              = 0x01
+SID_LOCATION          = 0x02
+SID_PRESSURE          = 0x03
+SID_BATTERY           = 0x04
+SID_PHYSICAL_LINK     = 0x05
+SID_ACCELERATION      = 0x06
+SID_TEMPERATURE       = 0x07
+SID_HUMIDITY          = 0x08
+SID_MAGNETIC_FIELD    = 0x09
+SID_AMBIENT_LIGHT     = 0x0A
+SID_GRAVITY           = 0x0B
+SID_ANGULAR_VELOCITY  = 0x0C
+SID_PROXIMITY         = 0x0E
+SID_INFORMATION       = 0x0F
+SID_RECEIVED          = 0x10
+SID_POWER_CONSUMPTION = 0x11
+SID_POWER_PRODUCTION  = 0x12
+SID_PROCESSOR         = 0x13
+SID_RAM               = 0x14
+SID_NVM               = 0x15
+SID_TANK              = 0x16
+SID_FUEL              = 0x17
+SID_CUSTOM            = 0xff

reticulumtelemetryhub-0.1.0/lxmf_telemetry/model/persistance/sensors/sensor_mapping.py

@@ -0,0 +1,9 @@
+from .sensor_enum import *
+from .location import Location
+from .time import Time
+from .magnetic_field import MagneticField
+sid_mapping = {
+    SID_LOCATION: Location,
+    SID_TIME: Time,
+    SID_MAGNETIC_FIELD: MagneticField,
+}

reticulumtelemetryhub-0.1.0/lxmf_telemetry/model/persistance/sensors/time.py

@@ -0,0 +1,32 @@
+from datetime import datetime
+from typing import Optional
+
+from sqlalchemy import ForeignKey, DateTime
+from sqlalchemy.orm import Mapped, mapped_column
+
+from lxmf_telemetry.model.persistance.sensors.sensor_enum import SID_TIME
+from lxmf_telemetry.model.persistance.sensors.sensor import Sensor
+
+class Time(Sensor):
+    __tablename__ = 'Time'
+
+    id: Mapped[int] = mapped_column(ForeignKey('Sensor.id'), primary_key=True)
+    utc: Mapped[datetime] = mapped_column(DateTime)
+
+    def __init__(self, utc: Optional[datetime] = None):
+        super().__init__(stale_time=15)
+        self.utc = utc or datetime.now()
+
+    def pack(self):
+        return self.utc.timestamp()
+    
+    def unpack(self, packed):
+        if packed is None:
+            return None
+        else:
+            self.utc = datetime.fromtimestamp(packed)
+
+    __mapper_args__ = {
+        'polymorphic_identity': SID_TIME,
+        'with_polymorphic': '*'
+    }

reticulumtelemetryhub-0.1.0/lxmf_telemetry/model/persistance/telemeter.py

@@ -0,0 +1,23 @@
+from typing import TYPE_CHECKING, Optional
+from . import Base
+from sqlalchemy import Column, Integer, DateTime, String, ForeignKey
+from sqlalchemy.orm import relationship, Mapped, mapped_column
+from datetime import datetime
+from msgpack import packb, unpackb
+
+if TYPE_CHECKING:
+    from .sensors.sensor import Sensor
+
+class Telemeter(Base):
+    __tablename__ = "Telemeter"
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    time: Mapped[datetime] = mapped_column(DateTime, nullable=False)
+
+    sensors: Mapped[list["Sensor"]] = relationship("Sensor", back_populates="telemeter")
+
+    peer_dest: Mapped[str] = mapped_column(String, nullable=False) # mapped_column(ForeignKey("Peer.destination_hash"))
+    #peer = relationship("Peer", back_populates="telemeters")
+
+    def __init__(self, peer_dest: str, time: Optional[datetime] = None):
+        self.peer_dest = peer_dest
+        self.time = time or datetime.now()

reticulumtelemetryhub-0.1.0/lxmf_telemetry/telemetry_controller.py

@@ -0,0 +1,124 @@
+from typing import Optional
+from datetime import datetime
+import LXMF
+import RNS
+from msgpack import packb, unpackb
+from lxmf_telemetry.model.persistance import Base
+from lxmf_telemetry.model.persistance.sensors.sensor import Sensor
+from lxmf_telemetry.model.persistance.telemeter import Telemeter
+
+from lxmf_telemetry.model.persistance.sensors.sensor_mapping import sid_mapping
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, Session, joinedload
+
+_engine = create_engine("sqlite:///telemetry.db")
+Base.metadata.create_all(_engine)
+Session_cls = sessionmaker(bind=_engine)
+
+
+class TelemetryController:
+    """This class is responsible for managing the telemetry data."""
+
+    TELEMETRY_REQUEST = 1
+
+    def __init__(self) -> None:
+        pass
+
+    def get_telemetry(
+        self, start_time: Optional[datetime] = None, end_time: Optional[datetime] = None
+    ) -> list[Telemeter]:
+        """Get the telemetry data."""
+        with Session_cls() as ses:
+            query = ses.query(Telemeter)
+            if start_time:
+                query = query.filter(Telemeter.time >= start_time)
+            if end_time:
+                query = query.filter(Telemeter.time <= end_time)
+            tels = query.options(joinedload(Telemeter.sensors)).all()
+            return tels
+
+    def save_telemetry(self, telemetry_data: dict, peer_dest) -> None:
+        """Save the telemetry data."""
+        tel = self._deserialize_telemeter(telemetry_data, peer_dest)
+        with Session_cls() as ses:
+            ses.add(tel)
+            ses.commit()
+
+    def handle_message(self, message: LXMF.LXMessage) -> bool:
+        """Handle the incoming message."""
+        handled = False
+        if LXMF.FIELD_TELEMETRY in message.fields:
+            tel_data: dict = unpackb(
+                message.fields[LXMF.FIELD_TELEMETRY], strict_map_key=False
+            )
+            RNS.log(f"Telemetry data: {tel_data}")
+            self.save_telemetry(tel_data, RNS.hexrep(message.source_hash, False))
+            handled = True
+        if LXMF.FIELD_TELEMETRY_STREAM in message.fields:
+            tels_data = unpackb(
+                message.fields[LXMF.FIELD_TELEMETRY_STREAM], strict_map_key=False
+            )
+            for tel_data in tels_data:
+                self.save_telemetry(tel_data, RNS.hexrep(tel_data.pop(0)))
+            handled = True
+
+        return handled
+
+    def handle_command(self, command: dict, message: LXMF.LXMessage, my_lxm_dest) -> Optional[LXMF.LXMessage]:
+        """Handle the incoming command."""
+        if TelemetryController.TELEMETRY_REQUEST in command:
+            timebase = command[TelemetryController.TELEMETRY_REQUEST]
+            tels = self.get_telemetry(start_time=datetime.fromtimestamp(timebase))
+            packed_tels = []
+            dest = RNS.Destination(
+                message.source.identity,
+                RNS.Destination.OUT,
+                RNS.Destination.SINGLE,
+                "lxmf",
+                "delivery",
+            )
+            message = LXMF.LXMessage(
+                    dest,
+                    my_lxm_dest,
+                    "Telemetry data",
+                    desired_method=LXMF.LXMessage.DIRECT,
+                )
+            for tel in tels:
+                tel_data = self._serialize_telemeter(tel)
+                packed_tels.append(
+                    [
+                        bytes.fromhex(tel.peer_dest),
+                        round(tel.time.timestamp()),
+                        packb(tel_data),
+                        ['account', b'\x00\x00\x00', b'\xff\xff\xff'],
+                    ]
+                )
+            message.fields[LXMF.FIELD_TELEMETRY_STREAM] = packed_tels
+            print("+--- Sending telemetry data---------------------------------")
+            print(f"| Telemetry data: {packed_tels}")
+            print(f"| Message: {message}")
+            print("+------------------------------------------------------------")
+            return message
+        else:
+            return None
+
+    def _serialize_telemeter(self, telemeter: Telemeter) -> dict:
+        """Serialize the telemeter data."""
+        telemeter_data = {}
+        for sensor in telemeter.sensors:
+            sensor_data = sensor.pack()
+            telemeter_data[sensor.sid] = sensor_data
+        return telemeter_data
+
+    def _deserialize_telemeter(self, tel_data: dict, peer_dest: str) -> Telemeter:
+        """Deserialize the telemeter data."""
+        tel = Telemeter(peer_dest)
+        for sid in tel_data:
+            if sid in sid_mapping:
+                if tel_data[sid] is None:
+                    RNS.log(f"Sensor data for {sid} is None")
+                    continue
+                sensor = sid_mapping[sid]()
+                sensor.unpack(tel_data[sid])
+                tel.sensors.append(sensor)
+        return tel

reticulumtelemetryhub-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[tool.poetry]
+name = "ReticulumTelemetryHub"
+version = "0.1.0"
+description = ""
+authors = ["naman108"]
+readme = "README.md"
+packages = [
+    { include = "lxmf_telemetry" },
+    { include = "reticulum_server" },
+]
+
+[tool.poetry.dependencies]
+python = "^3.12"
+lxmf = "^0.4.4"
+msgpack = "^1.0.8"
+sqlalchemy = "^2.0.32"
+pytest = "^8.3.2"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

reticulumtelemetryhub-0.1.0/reticulum_server/main.py

@@ -0,0 +1,182 @@
+import os
+import time
+import LXMF
+import RNS
+from lxmf_telemetry.telemetry_controller import TelemetryController
+
+# Constants
+STORAGE_PATH = "./tmp1"  # Path to store temporary files
+IDENTITY_PATH = os.path.join(STORAGE_PATH, "identity")  # Path to store identity file
+APP_NAME = LXMF.APP_NAME + ".delivery"  # Application name for LXMF
+
+tel_controller = TelemetryController()
+
+class AnnounceHandler:
+    def __init__(self, connections, my_lxmf_dest, lxm_router):
+        self.aspect_filter = APP_NAME  # Filter for LXMF announcements
+        self.connections = connections  # List to store connections
+        self.my_lxmf_dest = my_lxmf_dest  # LXMF destination
+        self.lxm_router = lxm_router  # LXMF router
+
+    def received_announce(self, destination_hash, announced_identity, app_data):
+        # Log the received announcement details
+        RNS.log("\t+--- LXMF Announcement -----------------------------------------")
+        RNS.log(f"\t| Source hash            : {RNS.prettyhexrep(destination_hash)}")
+        RNS.log(f"\t| Announced identity     : {announced_identity}")
+        RNS.log(f"\t| App data               : {app_data}")
+        RNS.log("\t+---------------------------------------------------------------")
+
+        # Create a new destination from the announced identity
+        dest = RNS.Destination(
+            announced_identity,
+            RNS.Destination.OUT,
+            RNS.Destination.SINGLE,
+            "lxmf",
+            "delivery",
+        )
+        self.connections.append(dest)  # Add the new destination to connections
+
+        # Create and send a message to the new destination
+        message = LXMF.LXMessage(
+            dest, self.my_lxmf_dest, "Hi there", desired_method=LXMF.LXMessage.DIRECT
+        )
+        self.lxm_router.handle_outbound(message)  # Handle outbound message
+
+def command_handler(commands: list, message: LXMF.LXMessage, lxm_router, my_lxmf_dest):
+    for command in commands:
+        print(f"Command: {command}")
+        msg = tel_controller.handle_command(command, message, my_lxmf_dest)
+        if msg:
+            lxm_router.handle_outbound(msg)
+
+def delivery_callback(message: LXMF.LXMessage, connections, my_lxmf_dest, lxm_router):
+    # Format the timestamp of the message
+    try:
+        time_string = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(message.timestamp))
+        signature_string = "Signature is invalid, reason undetermined"
+
+        # Determine the signature validation status
+        if message.signature_validated:
+            signature_string = "Validated"
+        elif message.unverified_reason == LXMF.LXMessage.SIGNATURE_INVALID:
+            signature_string = "Invalid signature"
+        elif message.unverified_reason == LXMF.LXMessage.SOURCE_UNKNOWN:
+            signature_string = "Cannot verify, source is unknown"
+
+        if message.signature_validated and LXMF.FIELD_COMMANDS in message.fields:
+            command_handler(message.fields[LXMF.FIELD_COMMANDS], message, lxm_router, my_lxmf_dest)
+            return
+        
+        if tel_controller.handle_message(message):
+            RNS.log("Telemetry data saved")
+            return
+
+        # Log the delivery details
+        RNS.log("\t+--- LXMF Delivery ---------------------------------------------")
+        RNS.log(f"\t| Source hash            : {RNS.prettyhexrep(message.source_hash)}")
+        RNS.log(f"\t| Source instance        : {message.get_source()}")
+        RNS.log(
+            f"\t| Destination hash       : {RNS.prettyhexrep(message.destination_hash)}"
+        )
+        #RNS.log(f"\t| Destination identity   : {message.source_identity}")
+        RNS.log(f"\t| Destination instance   : {message.get_destination()}")
+        RNS.log(f"\t| Transport Encryption   : {message.transport_encryption}")
+        RNS.log(f"\t| Timestamp              : {time_string}")
+        RNS.log(f"\t| Title                  : {message.title_as_string()}")
+        RNS.log(f"\t| Content                : {message.content_as_string()}")
+        RNS.log(f"\t| Fields                 : {message.fields}")
+        RNS.log(f"\t| Message signature      : {signature_string}")
+        RNS.log("\t+---------------------------------------------------------------")
+        for connection in connections:
+            if connection.hash != message.source_hash:
+                response = LXMF.LXMessage(
+                    connection,
+                    my_lxmf_dest,
+                    message.content_as_string(),
+                    desired_method=LXMF.LXMessage.DIRECT,
+                )
+                lxm_router.handle_outbound(response)  # Handle outbound response
+    except Exception as e:
+        RNS.log(f"Error: {e}")
+
+def load_or_generate_identity(identity_path):
+    # Load existing identity or generate a new one
+    if os.path.exists(identity_path):
+        try:
+            RNS.log("Loading existing identity")
+            return RNS.Identity.from_file(identity_path)
+        except:
+            RNS.log("Failed to load existing identity, generating new")
+    else:
+        RNS.log("Generating new identity")
+
+    identity = RNS.Identity()  # Create a new identity
+    identity.to_file(identity_path)  # Save the new identity to file
+    return identity
+
+
+
+def main():
+    global my_lxmf_dest
+    connections = []  # List to store connections
+    r = RNS.Reticulum()  # Initialize Reticulum
+    lxm_router = LXMF.LXMRouter(storagepath=STORAGE_PATH)  # Initialize LXMF router
+    # lxm_router.enable_propagation()
+    identity = load_or_generate_identity(IDENTITY_PATH)  # Load or generate identity
+    my_lxmf_dest = lxm_router.register_delivery_identity(
+        identity, "test_server"
+    )  # Register delivery identity
+    lxm_router.set_message_storage_limit(megabytes=5)
+    lxm_router.enable_propagation()
+
+    # Register delivery callback
+    lxm_router.register_delivery_callback(
+        lambda msg: delivery_callback(msg, connections, my_lxmf_dest, lxm_router)
+    )
+    # Register announce handler
+    RNS.Transport.register_announce_handler(
+        AnnounceHandler(connections, my_lxmf_dest, lxm_router)
+    )
+
+    # Announce LXMF identity
+    my_lxmf_dest.announce()
+    lxm_router.announce_propagation_node()
+    RNS.log("LXMF identity announced")
+    RNS.log("\t+--- LXMF Identity ---------------------------------------------")
+    RNS.log(f"\t| Hash                   : {RNS.prettyhexrep(my_lxmf_dest.hash)}")
+    RNS.log(
+        f"\t| Public key             : {RNS.prettyhexrep(my_lxmf_dest.identity.pub.public_bytes())}"
+    )
+    RNS.log("\t+---------------------------------------------------------------")
+
+    # Periodically announce the LXMF identity
+    while True:
+        choice = input("Enter your choice (exit/announce/telemetry): ")
+        
+        if choice == "exit":
+            break
+        elif choice == "announce":
+            my_lxmf_dest.announce()
+        elif choice == "announce_prop":
+            lxm_router.announce_propagation_node()
+        elif choice == "telemetry":
+            connection_hash = input("Enter the connection hash: ")
+            found = False
+            for connection in connections:
+                if connection.hexhash == connection_hash:
+                    message = LXMF.LXMessage(
+                    connection,
+                    my_lxmf_dest,
+                    "Requesting telemetry",
+                    desired_method=LXMF.LXMessage.DIRECT,
+                    fields={LXMF.FIELD_COMMANDS: [{TelemetryController.TELEMETRY_REQUEST: 1000000000}]}
+                    )
+                    lxm_router.handle_outbound(message)
+                    found = True
+                    break
+            if not found:
+                print("Connection not found")
+
+
+if __name__ == "__main__":
+    main()