feat: new command freq implemented to toggle data logging freq

Author: Sang-Buster

src/cli.py

@@ -15,6 +15,7 @@
     toggle_monitor,
     get_pi_ip,
     get_system_stats,
+    set_frequency,
 )
 
 import sys
@@ -31,7 +32,7 @@
 def get_parser():
     parser = argparse.ArgumentParser(
         description="Weather data management CLI",
-        usage="meteorix [-h] {upload, delete, check, head, tail, info, spit, plot, monitor, ifconfig, top, eda, ml, who}",
+        usage="meteorix [-h] {upload, delete, check, head, tail, info, spit, plot, monitor, freq, ifconfig, top, eda, ml, who}",
     )
 
     subparsers = parser.add_subparsers(dest="command", required=True)
@@ -154,6 +155,21 @@ def get_parser():
                 ),
             ],
         },
+        "freq": {
+            "help": "Control data logging frequency",
+            "description": "Set or check the data logging frequency on the Raspberry Pi. Use '0' for high frequency (32Hz) or '1' for low frequency (1Hz).",
+            "args": [
+                ("action", {"choices": ["set", "status"], "help": "Action to perform"}),
+                (
+                    "value",
+                    {
+                        "nargs": "?",
+                        "choices": ["0", "1"],
+                        "help": "Frequency value: 0 (32Hz) or 1 (1Hz). Only used with 'set' action",
+                    },
+                ),
+            ],
+        },
         "ifconfig": {
             "help": "Show Raspberry Pi network information",
             "description": "Display network interface information from the weather station Raspberry Pi.",
@@ -220,6 +236,7 @@ def main():
         "monitor": lambda: toggle_monitor(args.action),
         "ifconfig": lambda: get_pi_ip(),
         "top": lambda: get_system_stats(),
+        "freq": lambda: handle_freq_command(args),
     }
 
     # Date-based command handlers
@@ -284,5 +301,14 @@ def handle_plot_command(start_date, end_date, save_locally=True):
         rprint(f"[red]Error creating plot: {str(e)}[/red]")
 
 
+def handle_freq_command(args):
+    """Handle frequency control command."""
+    if args.action == "set" and args.value is None:
+        rprint("[red]Error: Frequency value (0 or 1) required for 'set' action[/red]")
+        return
+
+    set_frequency(args.value if args.action == "set" else None)
+
+
 if __name__ == "__main__":
     main()

src/cli_components/__init__.py

@@ -13,6 +13,7 @@
 from .monitor import toggle_monitor
 from .ifconfig import get_pi_ip
 from .top import get_system_stats
+from .freq import set_frequency
 
 __all__ = [
     "check_analysis_results",
@@ -32,4 +33,5 @@
     "toggle_monitor",
     "get_pi_ip",
     "get_system_stats",
+    "set_frequency",
 ]

src/cli_components/freq.py

@@ -0,0 +1,115 @@
+from rich import print as rprint
+from .ifconfig import SSHClient, find_pi_address
+
+
+def set_frequency(freq=None):
+    """Set or check the data logging frequency on the Raspberry Pi
+
+    Args:
+        freq (str, optional): '1' for high frequency (32Hz), '0' for low frequency (1Hz)
+    """
+    try:
+        # Find the Pi's current address
+        pi_address = find_pi_address()
+        if not pi_address:
+            raise Exception("Could not locate the Raspberry Pi on the network")
+
+        # Get SSH client instance for status check
+        ssh = SSHClient.get_instance().get_client(pi_address)
+
+        # If no frequency specified, check current status
+        if freq is None:
+            # Check if the Weather Station logger is running using multiple methods
+            # First check screen session
+            stdin, stdout, stderr = ssh.exec_command("sudo screen -ls | grep logger")
+            screen_output = stdout.read().decode().strip()
+
+            if not screen_output:
+                rprint("[yellow]Weather Station logger is not running[/yellow]")
+                return
+
+            # Check for active high frequency files
+            stdin, stdout, stderr = ssh.exec_command(
+                "ls -t /var/tmp/wx/*_weather_station_data.csv 2>/dev/null | head -1"
+            )
+            latest_file = stdout.read().decode().strip()
+
+            if not latest_file:
+                rprint("[yellow]No active data files found[/yellow]")
+                return
+
+            # Get file's last modification time
+            stdin, stdout, stderr = ssh.exec_command(f"stat -c %Y {latest_file}")
+            file_time = int(stdout.read().decode().strip())
+            current_time = int(ssh.exec_command("date +%s")[1].read().decode().strip())
+
+            # Check the actual frequency by looking at timestamps in real-time
+            stdin, stdout, stderr = ssh.exec_command(
+                f"tail -n 1 -f {latest_file} | head -n 2"
+            )
+
+            # Read two consecutive lines
+            timestamps = []
+            for _ in range(2):
+                line = stdout.readline()
+                if not line:
+                    break
+                timestamp_str = line.strip().split(",")[0]
+                try:
+                    stdin2, stdout2, stderr2 = ssh.exec_command(
+                        f"date -d '{timestamp_str}' +%s.%N"
+                    )
+                    timestamp = float(stdout2.read().decode().strip())
+                    timestamps.append(timestamp)
+                except (ValueError, IndexError):
+                    break
+
+            # Calculate time difference and determine frequency
+            if len(timestamps) == 2:
+                time_diff = timestamps[1] - timestamps[0]
+                is_high_freq = time_diff < 0.1
+            else:
+                is_high_freq = False
+
+            # Display current status
+            if current_time - file_time < 5 and is_high_freq:
+                rprint(
+                    "[green]Currently running in HIGH frequency mode (32 Hz)[/green]"
+                )
+                rprint(
+                    f"[yellow]High frequency data being logged to: {latest_file}[/yellow]"
+                )
+            else:
+                rprint("[green]Currently running in LOW frequency mode (1 Hz)[/green]")
+                rprint(f"[yellow]Data being logged to: {latest_file}[/yellow]")
+            return
+
+        # Validate frequency input
+        if freq not in ["0", "1"]:
+            raise ValueError("Frequency must be '1' (32Hz) or '0' (1Hz)")
+
+        try:
+            # Run the appropriate script with sudo
+            if freq == "1":
+                rprint("[yellow]Starting HIGH frequency logging...[/yellow]")
+                ssh.exec_command("sudo python3 /home/pi/SDL_Starter.py")
+                rprint(
+                    "[green]Successfully enabled HIGH frequency logging (32 Hz)[/green]"
+                )
+            else:
+                rprint("[yellow]Stopping HIGH frequency logging...[/yellow]")
+                ssh.exec_command("sudo python3 /home/pi/SDL_Stopper.py")
+                rprint(
+                    "[green]Successfully disabled HIGH frequency logging (returning to 1 Hz)[/green]"
+                )
+
+        except Exception as e:
+            raise Exception(f"Failed to run frequency control script: {str(e)}")
+
+    except Exception as e:
+        rprint(f"[red]Error: {str(e)}[/red]")
+        # If there's an error, try to close the SSH connection
+        SSHClient.get_instance().close()
+        return False
+
+    return True

src/cli_components/monitor.py

@@ -1,10 +1,10 @@
 from datetime import datetime, timedelta
 from pathlib import Path
 from rich import print as rprint
-import pandas as pd
 import glob
 from typing import Optional
 import json
+import os
 
 from src import CSV_DIR
 
@@ -61,32 +61,41 @@ def get_latest_data_time() -> Optional[datetime]:
 
         latest_file = max(csv_files)
 
-        # Get total number of rows
-        total_rows = sum(1 for _ in open(latest_file)) - 1  # -1 for header
-
-        # Define column names (matching tail.py)
-        columns = [
-            "tNow",
-            "u_m_s",
-            "v_m_s",
-            "w_m_s",
-            "2dSpeed_m_s",
-            "3DSpeed_m_s",
-            "Azimuth_deg",
-            "Elev_deg",
-            "Press_Pa",
-            "Temp_C",
-            "Hum_RH",
-            "SonicTemp_C",
-            "Error",
-        ]
-
-        # Read only the last row (matching tail.py approach)
-        df = pd.read_csv(latest_file, skiprows=max(0, total_rows - 1), names=columns)
-        timestamp_str = df.iloc[-1]["tNow"]
-
-        # Parse the timestamp string directly using datetime
-        return datetime.strptime(timestamp_str, "%Y-%m-%d %H:%M:%S")
+        # Use tail command to get last line reliably
+        with open(latest_file, "rb") as f:
+            try:
+                f.seek(-2, os.SEEK_END)
+                while f.read(1) != b"\n":
+                    f.seek(-2, os.SEEK_CUR)
+            except OSError:
+                f.seek(0)
+            last_line = f.readline().decode().strip()
+
+        if not last_line:
+            return None
+
+        # Get timestamp from first column
+        timestamp_str = last_line.split(",")[0]
+        if timestamp_str == "tNow":  # Skip header row
+            return None
+
+        # Try parsing with different formats
+        try:
+            # Try with microseconds first
+            return datetime.strptime(timestamp_str, "%Y-%m-%d %H:%M:%S.%f")
+        except ValueError:
+            try:
+                # Try without microseconds
+                return datetime.strptime(timestamp_str, "%Y-%m-%d %H:%M:%S")
+            except ValueError:
+                # Handle decimal seconds
+                base_str = timestamp_str.split(".")[0]
+                decimal_str = (
+                    timestamp_str.split(".")[1] if "." in timestamp_str else "0"
+                )
+                base_time = datetime.strptime(base_str, "%Y-%m-%d %H:%M:%S")
+                microseconds = int(float("0." + decimal_str) * 1000000)
+                return base_time.replace(microsecond=microseconds)
 
     except Exception as e:
         rprint(f"[red]Error checking latest data: {str(e)}[/red]")
@@ -122,8 +131,10 @@ def show_monitor_status() -> None:
         "[green]enabled[/green]" if config["enabled"] else "[yellow]disabled[/yellow]"
     )
     time_str = latest_time.strftime("%Y-%m-%d %H:%M:%S") if latest_time else "N/A"
+    data_state = "[green]fresh[/green]" if fresh else "[red]stale[/red]"
 
     rprint(f"Monitor state: {status}")
+    rprint(f"Data state: {data_state}")
     rprint(f"Alert threshold: {config['alert_threshold_minutes']} minutes")
     rprint(f"Check interval: {config['check_interval_minutes']} minutes")
     rprint(f"Latest data point: {time_str}")