mmrelay 1.0__py3-none-any.whl

mmrelay/plugins/ping_plugin.py

@@ -0,0 +1,118 @@
+import asyncio
+import re
+import string
+
+from meshtastic.mesh_interface import BROADCAST_NUM
+
+from mmrelay.plugins.base_plugin import BasePlugin
+
+
+def match_case(source, target):
+    return "".join(
+        c.upper() if s.isupper() else c.lower() for s, c in zip(source, target)
+    )
+
+
+class Plugin(BasePlugin):
+    plugin_name = "ping"
+    punctuation = string.punctuation
+
+    def __init__(self):
+        self.plugin_name = "ping"
+        super().__init__()
+
+    @property
+    def description(self):
+        return "Check connectivity with the relay or respond to pings over the mesh"
+
+    async def handle_meshtastic_message(
+        self, packet, formatted_message, longname, meshnet_name
+    ):
+        if "decoded" in packet and "text" in packet["decoded"]:
+            message = packet["decoded"]["text"].strip()
+            channel = packet.get("channel", 0)  # Default to channel 0 if not provided
+
+            from mmrelay.meshtastic_utils import connect_meshtastic
+
+            meshtastic_client = connect_meshtastic()
+
+            # Determine if the message is a direct message
+            toId = packet.get("to")
+            myId = meshtastic_client.myInfo.my_node_num  # Get relay's own node number
+
+            if toId == myId:
+                # Direct message to us
+                is_direct_message = True
+            elif toId == BROADCAST_NUM:
+                is_direct_message = False
+            else:
+                # Message to someone else; we may ignore it
+                is_direct_message = False
+
+            # Pass is_direct_message to is_channel_enabled
+            if not self.is_channel_enabled(
+                channel, is_direct_message=is_direct_message
+            ):
+                # Removed unnecessary logging
+                return False
+
+            # Updated regex to match optional punctuation before and after "ping"
+            match = re.search(
+                r"(?<!\w)([!?]*)(ping)([!?]*)(?!\w)", message, re.IGNORECASE
+            )
+            if match:
+                # Log that the plugin is processing the message
+                self.logger.info(
+                    f"Processing message from {longname} on channel {channel} with plugin '{self.plugin_name}'"
+                )
+
+                # Extract matched text and punctuation
+                pre_punc = match.group(1)
+                matched_text = match.group(2)
+                post_punc = match.group(3)
+
+                total_punc_length = len(pre_punc) + len(post_punc)
+
+                # Define the base response
+                base_response = "pong"
+
+                # Adjust base_response to match the case pattern of matched_text
+                base_response = match_case(matched_text, base_response)
+
+                # Construct the reply message
+                if total_punc_length > 5:
+                    reply_message = "Pong..."
+                else:
+                    reply_message = pre_punc + base_response + post_punc
+
+                # Wait for the response delay
+                await asyncio.sleep(self.get_response_delay())
+
+                fromId = packet.get("fromId")
+
+                if is_direct_message:
+                    # Send reply as DM
+                    meshtastic_client.sendText(
+                        text=reply_message,
+                        destinationId=fromId,
+                    )
+                else:
+                    # Send the reply back to the same channel
+                    meshtastic_client.sendText(text=reply_message, channelIndex=channel)
+                return True
+            else:
+                return False  # No match, do not process
+
+    def get_matrix_commands(self):
+        return [self.plugin_name]
+
+    def get_mesh_commands(self):
+        return [self.plugin_name]
+
+    async def handle_room_message(self, room, event, full_message):
+        # Pass the event to matches()
+        if not self.matches(event):
+            return False
+
+        await self.send_matrix_message(room.room_id, "pong!")
+        return True

mmrelay/plugins/telemetry_plugin.py

@@ -0,0 +1,179 @@
+import io
+import json
+import re
+from datetime import datetime, timedelta
+
+import matplotlib.pyplot as plt
+from PIL import Image
+
+from mmrelay.plugins.base_plugin import BasePlugin
+
+
+class Plugin(BasePlugin):
+    plugin_name = "telemetry"
+    max_data_rows_per_node = 50
+
+    def commands(self):
+        return ["batteryLevel", "voltage", "airUtilTx"]
+
+    def description(self):
+        return "Graph of avg Mesh telemetry value for last 12 hours"
+
+    def _generate_timeperiods(self, hours=12):
+        # Calculate the start and end times
+        end_time = datetime.now()
+        start_time = end_time - timedelta(hours=hours)
+
+        # Create a list of hourly intervals for the last 12 hours
+        hourly_intervals = []
+        current_time = start_time
+        while current_time <= end_time:
+            hourly_intervals.append(current_time)
+            current_time += timedelta(hours=1)
+        return hourly_intervals
+
+    async def handle_meshtastic_message(
+        self, packet, formatted_message, longname, meshnet_name
+    ):
+        # Support deviceMetrics only for now
+        if (
+            "decoded" in packet
+            and "portnum" in packet["decoded"]
+            and packet["decoded"]["portnum"] == "TELEMETRY_APP"
+            and "telemetry" in packet["decoded"]
+            and "deviceMetrics" in packet["decoded"]["telemetry"]
+        ):
+            telemetry_data = []
+            data = self.get_node_data(meshtastic_id=packet["fromId"])
+            if data:
+                telemetry_data = data
+            packet_data = packet["decoded"]["telemetry"]
+
+            telemetry_data.append(
+                {
+                    "time": packet_data["time"],
+                    "batteryLevel": (
+                        packet_data["deviceMetrics"]["batteryLevel"]
+                        if "batteryLevel" in packet_data["deviceMetrics"]
+                        else 0
+                    ),
+                    "voltage": (
+                        packet_data["deviceMetrics"]["voltage"]
+                        if "voltage" in packet_data["deviceMetrics"]
+                        else 0
+                    ),
+                    "airUtilTx": (
+                        packet_data["deviceMetrics"]["airUtilTx"]
+                        if "airUtilTx" in packet_data["deviceMetrics"]
+                        else 0
+                    ),
+                }
+            )
+            self.set_node_data(meshtastic_id=packet["fromId"], node_data=telemetry_data)
+            return False
+
+    def get_matrix_commands(self):
+        return ["batteryLevel", "voltage", "airUtilTx"]
+
+    def get_mesh_commands(self):
+        return []
+
+    def matches(self, event):
+        from mmrelay.matrix_utils import bot_command
+
+        # Use bot_command() to check if any of the commands match
+        for command in self.get_matrix_commands():
+            if bot_command(command, event):
+                return True
+        return False
+
+    async def handle_room_message(self, room, event, full_message):
+        # Pass the event to matches()
+        if not self.matches(event):
+            return False
+
+        match = re.search(
+            r":\s+!(batteryLevel|voltage|airUtilTx)(?:\s+(.+))?$", full_message
+        )
+        if not match:
+            return False
+
+        telemetry_option = match.group(1)
+        node = match.group(2)
+
+        hourly_intervals = self._generate_timeperiods()
+        from mmrelay.matrix_utils import connect_matrix
+
+        matrix_client = await connect_matrix()
+
+        # Compute the hourly averages for each node
+        hourly_averages = {}
+
+        def calculate_averages(node_data_rows):
+            for record in node_data_rows:
+                record_time = datetime.fromtimestamp(
+                    record["time"]
+                )  # Replace with your timestamp field name
+                telemetry_value = record[
+                    telemetry_option
+                ]  # Replace with your battery level field name
+                for i in range(len(hourly_intervals) - 1):
+                    if hourly_intervals[i] <= record_time < hourly_intervals[i + 1]:
+                        if i not in hourly_averages:
+                            hourly_averages[i] = []
+                        hourly_averages[i].append(telemetry_value)
+                        break
+
+        if node:
+            node_data_rows = self.get_node_data(node)
+            calculate_averages(node_data_rows)
+        else:
+            for node_data_json in self.get_data():
+                node_data_rows = json.loads(node_data_json[0])
+                calculate_averages(node_data_rows)
+
+        # Compute the final hourly averages
+        final_averages = {}
+        for i, interval in enumerate(hourly_intervals[:-1]):
+            if i in hourly_averages:
+                final_averages[interval] = sum(hourly_averages[i]) / len(
+                    hourly_averages[i]
+                )
+            else:
+                final_averages[interval] = 0.0
+
+        # Extract the hourly intervals and average values into separate lists
+        hourly_intervals = list(final_averages.keys())
+        average_values = list(final_averages.values())
+
+        # Convert the hourly intervals to strings
+        hourly_strings = [hour.strftime("%H") for hour in hourly_intervals]
+
+        # Create the plot
+        fig, ax = plt.subplots()
+        ax.plot(hourly_strings, average_values)
+
+        # Set the plot title and axis labels
+        if node:
+            title = f"{node} Hourly {telemetry_option} Averages"
+        else:
+            title = f"Network Hourly {telemetry_option} Averages"
+        ax.set_title(title)
+        ax.set_xlabel("Hour")
+        ax.set_ylabel(f"{telemetry_option}")
+
+        # Rotate the x-axis labels for readability
+        plt.xticks(rotation=45)
+
+        # Save the plot as a PIL image
+        buf = io.BytesIO()
+        fig.canvas.print_png(buf)
+        buf.seek(0)
+        img = Image.open(buf)
+        pil_image = Image.frombytes(mode="RGBA", size=img.size, data=img.tobytes())
+
+        from mmrelay.matrix_utils import send_room_image, upload_image
+
+        upload_response = await upload_image(matrix_client, pil_image, "graph.png")
+        await send_room_image(matrix_client, room.room_id, upload_response)
+        return True

mmrelay/plugins/weather_plugin.py

@@ -0,0 +1,208 @@
+import asyncio
+
+import requests
+from meshtastic.mesh_interface import BROADCAST_NUM
+
+from mmrelay.plugins.base_plugin import BasePlugin
+
+
+class Plugin(BasePlugin):
+    plugin_name = "weather"
+
+    def __init__(self):
+        self.plugin_name = "weather"
+        super().__init__()
+
+    @property
+    def description(self):
+        return "Show weather forecast for a radio node using GPS location"
+
+    def generate_forecast(self, latitude, longitude):
+        units = self.config.get("units", "metric")  # Default to metric
+        temperature_unit = "°C" if units == "metric" else "°F"
+
+        url = (
+            f"https://api.open-meteo.com/v1/forecast?"
+            f"latitude={latitude}&longitude={longitude}&"
+            f"hourly=temperature_2m,precipitation_probability,weathercode,cloudcover&"
+            f"forecast_days=1&current_weather=true"
+        )
+
+        try:
+            response = requests.get(url, timeout=10)
+            data = response.json()
+
+            # Extract relevant weather data
+            current_temp = data["current_weather"]["temperature"]
+            current_weather_code = data["current_weather"]["weathercode"]
+            is_day = data["current_weather"]["is_day"]
+
+            # Get indices for +2h and +5h forecasts
+            # Assuming hourly data starts from current hour
+            forecast_2h_index = 2
+            forecast_5h_index = 5
+
+            forecast_2h_temp = data["hourly"]["temperature_2m"][forecast_2h_index]
+            forecast_2h_precipitation = data["hourly"]["precipitation_probability"][
+                forecast_2h_index
+            ]
+            forecast_2h_weather_code = data["hourly"]["weathercode"][forecast_2h_index]
+
+            forecast_5h_temp = data["hourly"]["temperature_2m"][forecast_5h_index]
+            forecast_5h_precipitation = data["hourly"]["precipitation_probability"][
+                forecast_5h_index
+            ]
+            forecast_5h_weather_code = data["hourly"]["weathercode"][forecast_5h_index]
+
+            if units == "imperial":
+                # Convert temperatures from Celsius to Fahrenheit
+                current_temp = current_temp * 9 / 5 + 32
+                forecast_2h_temp = forecast_2h_temp * 9 / 5 + 32
+                forecast_5h_temp = forecast_5h_temp * 9 / 5 + 32
+
+            current_temp = round(current_temp, 1)
+            forecast_2h_temp = round(forecast_2h_temp, 1)
+            forecast_5h_temp = round(forecast_5h_temp, 1)
+
+            def weather_code_to_text(weather_code, is_day):
+                weather_mapping = {
+                    0: "☀️ Clear sky" if is_day else "🌙 Clear sky",
+                    1: "🌤️ Mainly clear" if is_day else "🌙🌤️ Mainly clear",
+                    2: "⛅️ Partly cloudy" if is_day else "🌙⛅️ Partly cloudy",
+                    3: "☁️ Overcast" if is_day else "🌙☁️ Overcast",
+                    45: "🌫️ Fog" if is_day else "🌙🌫️ Fog",
+                    48: (
+                        "🌫️ Depositing rime fog" if is_day else "🌙🌫️ Depositing rime fog"
+                    ),
+                    51: "🌧️ Light drizzle",
+                    53: "🌧️ Moderate drizzle",
+                    55: "🌧️ Dense drizzle",
+                    56: "🌧️ Light freezing drizzle",
+                    57: "🌧️ Dense freezing drizzle",
+                    61: "🌧️ Light rain",
+                    63: "🌧️ Moderate rain",
+                    65: "🌧️ Heavy rain",
+                    66: "🌧️ Light freezing rain",
+                    67: "🌧️ Heavy freezing rain",
+                    71: "❄️ Light snow fall",
+                    73: "❄️ Moderate snow fall",
+                    75: "❄️ Heavy snow fall",
+                    77: "❄️ Snow grains",
+                    80: "🌧️ Light rain showers",
+                    81: "🌧️ Moderate rain showers",
+                    82: "🌧️ Violent rain showers",
+                    85: "❄️ Light snow showers",
+                    86: "❄️ Heavy snow showers",
+                    95: "⛈️ Thunderstorm",
+                    96: "⛈️ Thunderstorm with slight hail",
+                    99: "⛈️ Thunderstorm with heavy hail",
+                }
+
+                return weather_mapping.get(weather_code, "❓ Unknown")
+
+            # Generate one-line weather forecast
+            forecast = (
+                f"Now: {weather_code_to_text(current_weather_code, is_day)} - "
+                f"{current_temp}{temperature_unit} | "
+            )
+            forecast += (
+                f"+2h: {weather_code_to_text(forecast_2h_weather_code, is_day)} - "
+                f"{forecast_2h_temp}{temperature_unit} {forecast_2h_precipitation}% | "
+            )
+            forecast += (
+                f"+5h: {weather_code_to_text(forecast_5h_weather_code, is_day)} - "
+                f"{forecast_5h_temp}{temperature_unit} {forecast_5h_precipitation}%"
+            )
+
+            return forecast
+
+        except requests.exceptions.RequestException as e:
+            self.logger.error(f"Error fetching weather data: {e}")
+            return "Error fetching weather data."
+
+    async def handle_meshtastic_message(
+        self, packet, formatted_message, longname, meshnet_name
+    ):
+        if (
+            "decoded" in packet
+            and "portnum" in packet["decoded"]
+            and packet["decoded"]["portnum"] == "TEXT_MESSAGE_APP"
+            and "text" in packet["decoded"]
+        ):
+            message = packet["decoded"]["text"].strip()
+            channel = packet.get("channel", 0)  # Default to channel 0 if not provided
+
+            from mmrelay.meshtastic_utils import connect_meshtastic
+
+            meshtastic_client = connect_meshtastic()
+
+            # Determine if the message is a direct message
+            toId = packet.get("to")
+            myId = meshtastic_client.myInfo.my_node_num  # Get relay's own node number
+
+            if toId == myId:
+                # Direct message to us
+                is_direct_message = True
+            elif toId == BROADCAST_NUM:
+                is_direct_message = False
+            else:
+                # Message to someone else; we may ignore it
+                is_direct_message = False
+
+            # Pass is_direct_message to is_channel_enabled
+            if not self.is_channel_enabled(
+                channel, is_direct_message=is_direct_message
+            ):
+                # Channel not enabled for plugin
+                return False
+
+            if f"!{self.plugin_name}" not in message.lower():
+                return False
+
+            # Log that the plugin is processing the message
+            self.logger.info(
+                f"Processing message from {longname} on channel {channel} with plugin '{self.plugin_name}'"
+            )
+
+            fromId = packet.get("fromId")
+            if fromId in meshtastic_client.nodes:
+                weather_notice = "Cannot determine location"
+                requesting_node = meshtastic_client.nodes.get(fromId)
+                if (
+                    requesting_node
+                    and "position" in requesting_node
+                    and "latitude" in requesting_node["position"]
+                    and "longitude" in requesting_node["position"]
+                ):
+                    weather_notice = self.generate_forecast(
+                        latitude=requesting_node["position"]["latitude"],
+                        longitude=requesting_node["position"]["longitude"],
+                    )
+
+                # Wait for the response delay
+                await asyncio.sleep(self.get_response_delay())
+
+                if is_direct_message:
+                    # Respond via DM
+                    meshtastic_client.sendText(
+                        text=weather_notice,
+                        destinationId=fromId,
+                    )
+                else:
+                    # Respond in the same channel (broadcast)
+                    meshtastic_client.sendText(
+                        text=weather_notice,
+                        channelIndex=channel,
+                    )
+            return True
+        else:
+            return False  # Not a text message or port does not match
+
+    def get_matrix_commands(self):
+        return []
+
+    def get_mesh_commands(self):
+        return [self.plugin_name]
+
+    async def handle_room_message(self, room, event, full_message):
+        return False  # Not handling Matrix messages in this plugin