Mastering OpenMHz Ultimate Guide Real Time Spectrum Monitoring

Published

openmhz ultimate guide real time
Table of Contents

OpenMHz represents a transformative leap in real-time spectrum monitoring, offering an open-source alternative that democratizes access to professional-grade signal analysis. By leveraging RTL-SDR hardware and cutting-edge signal processing, this platform eliminates the barriers of proprietary solutions while delivering unparalleled flexibility for users ranging from hobbyists to enterprise deployments. This guide serves as a definitive resource, dissecting OpenMHz’s technical foundation, hardware optimization, and advanced visualization techniques to empower practitioners in achieving precise, real-time spectral insights.

The core advantage of OpenMHz lies in its ability to combine affordability with high-performance capabilities, including real-time FFT processing, seamless SDR integration, and an open API that fosters third-party innovation. Unlike commercial spectrum analyzers burdened by licensing costs and proprietary constraints, OpenMHz thrives on community collaboration, continuously evolving through collective contributions. Whether monitoring wireless communications, detecting interference, or analyzing RF environments, this platform provides the tools to transform raw data into actionable intelligence—bridging the gap between theoretical concepts and practical implementation.

openmhz ultimate guide real time

OpenMHz as a Real-Time Spectrum Monitoring Platform

OpenMHz represents a paradigm shift in spectrum monitoring by offering a fully open-source, real-time platform designed for hobbyists, researchers, and professionals. Unlike traditional spectrum analyzers, which are often proprietary, expensive, and limited in customization, OpenMHz leverages Software-Defined Radio (SDR) technology to provide an affordable, extensible, and community-driven alternative. Its core strength lies in combining RTL-SDR hardware with a robust signal processing pipeline, enabling users to visualize and analyze radio frequency (RF) signals in real time. The platform’s open architecture fosters innovation, allowing developers to contribute plugins, algorithms, and integrations that extend its functionality beyond conventional spectrum analysis.

The "Ultimate Guide" serves as a definitive resource for users across all proficiency levels, from beginners setting up their first SDR device to advanced practitioners implementing custom signal processing workflows. It consolidates technical documentation, best practices, and troubleshooting insights into a structured format, ensuring accessibility for those new to SDR while providing depth for experienced users. The guide emphasizes practical applications, such as interference detection, wireless protocol analysis, and IoT signal monitoring, while maintaining a focus on the technical foundations that underpin OpenMHz’s capabilities.

Technical Foundation: Hardware and Signal Processing

OpenMHz’s functionality is built upon three foundational components: RTL-SDR hardware, real-time signal processing pipelines, and data visualization frameworks. The RTL-SDR (Realtek Tuner-based Software-Defined Radio) serves as the primary input device, offering cost-effective RF reception across a broad frequency range (typically 24 MHz to 1.7 GHz for RTL-SDR dongles). These devices, originally designed for digital TV reception, are repurposed for spectrum analysis due to their low cost (typically under $30 USD) and compatibility with open-source tools like OpenMHz.

The signal processing pipeline in OpenMHz involves several critical stages:

  • RF Frontend: The RTL-SDR captures raw in-phase (I) and quadrature (Q) samples from the antenna, which represent the complex signal amplitude and phase.
  • Digital Downconversion (DDC): The sampled signal is mixed down to a baseband frequency, enabling analysis of specific bands (e.g., 2.4 GHz Wi-Fi or 433 MHz ISM).
  • Fast Fourier Transform (FFT): The core of spectrum analysis, the FFT converts time-domain samples into frequency-domain data, revealing signal strength across the spectrum.
  • Post-Processing: Filters, decimation, and noise reduction algorithms refine the output for visualization or further analysis.

    • OpenMHz’s real-time capabilities are achieved through optimized FFT implementations (e.g., using libraries like `librtlsdr` and `fftw`) and efficient data streaming to the visualization layer. The platform supports multiple output formats, including waterfall displays, peak hold, and custom plots, all rendered in near real time.

    Comparison with Commercial Spectrum Analyzers

    OpenMHz distinguishes itself from commercial spectrum analyzers through its open-source architecture, cost efficiency, and customization potential. Below is a structured comparison highlighting key differentiators:
    Feature OpenMHz Commercial Spectrum Analyzers (e.g., Rohde & Schwarz, Keysight)
    Cost
    • Hardware: $20–$50 (RTL-SDR dongle).
    • Software: Free (open-source).
    • Total: ~$50–$100 for basic setup.
    • Entry-level: $3,000–$10,000 (e.g., Rohde & Schwarz FPC1000).
    • Mid-range: $10,000–$50,000 (e.g., Keysight N9040B).
    • High-end: $50,000+ (e.g., Rohde & Schwarz FSV).
    Real-Time FFT
    • Supports real-time FFT with adjustable sample rates (e.g., 2.048 MS/s).
    • Limited by RTL-SDR’s bandwidth (typically <3 MHz instantaneous).
    • Customizable FFT windowing (Hanning, Hamming, etc.).
    • High-resolution FFT with wide instantaneous bandwidth (e.g., 100 MHz+).
    • Advanced demodulation (AM, FM, PM, digital modulations).
    • Predefined analysis modes (e.g., CW, SSB, TV).
    Hardware Integration
    • Compatible with RTL-SDR, HackRF, and other SDR devices.
    • Extensible via plugins (e.g., GNU Radio, PySDR).
    • No proprietary hardware lock-in.
    • Dedicated hardware with calibrated performance.
    • Limited to manufacturer-supported devices.
    • Closed firmware/software ecosystems.
    API and Automation
    • Open REST API for remote control and data export.
    • Python/JavaScript SDKs for integration.
    • Community-driven plugins (e.g., IoT protocol parsers).
    • Proprietary APIs with licensing restrictions.
    • Limited scripting support (e.g., SCPI commands).
    • No third-party plugin ecosystem.
    Customization and Extensibility
    • Full source code access for modifications.
    • Support for custom signal processing (e.g., machine learning filters).
    • Community contributions (e.g., new demodulators, visualization tools).
    • Closed-source software with no modification rights.
    • Firmware updates controlled by manufacturer.
    • Limited to built-in features.
    Use Cases
    • RF exploration, IoT signal analysis, and educational purposes.
    • Ideal for hobbyists and researchers with budget constraints.
    • Example: Monitoring Wi-Fi channels, detecting interference in smart homes.
    • Professional applications (e.g., EMC testing, military communications).
    • Certification and compliance (e.g., FCC, CE).
    • Example: High-precision measurements in aerospace or telecom.
    Key Takeaway:
    OpenMHz excels in accessibility and innovation, making advanced spectrum analysis feasible for non-experts while enabling developers to push the boundaries of SDR applications. Commercial analyzers, while superior in precision and bandwidth, are constrained by cost and proprietary restrictions. The choice between the two depends on the user’s needs: OpenMHz for exploration and customization, commercial tools for precision and compliance.

    Hardware Requirements and Setup for Real-Time Spectrum Monitoring

    OpenMHz’s real-time spectrum monitoring capabilities rely on a combination of hardware and software components optimized for low-latency signal processing. The performance of the system—including detection sensitivity, frequency coverage, and processing stability—directly depends on the selected hardware stack. This section outlines the minimum and recommended specifications for CPU, RAM, and storage, followed by a detailed guide on selecting compatible RTL-SDR devices, designing cost-effective antennas, and assembling a reliable hardware configuration for 24/7 operation.
    The core hardware requirements for OpenMHz are dictated by the need to process high-throughput SDR data streams in real time. Below are the minimum and recommended specifications for stable operation, based on empirical testing and community benchmarks.
    Key Considerations for Hardware Selection:
  • CPU: Real-time processing demands low-latency scheduling; multi-core architectures (e.g., Intel i5/i7 or AMD Ryzen) with hyper-threading improve parallel task handling.
  • RAM: Sufficient memory is critical to buffer incoming samples without drops. DDR4 (or faster) is preferred for sustained performance.
  • Storage: SSD storage (NVMe preferred) reduces I/O bottlenecks for logging and database operations. RAID configurations (e.g., RAID 1 for redundancy) are advisable for 24/7 deployments.
  • Power Supply: Stable, high-efficiency PSUs (e.g., 80+ Gold) with sufficient wattage (500W+) prevent voltage fluctuations during peak loads.
    • ComponentMinimum SpecificationRecommended Specification
    CPUDual-core, 2.5GHz+ (e.g., Intel Celeron)Quad-core, 3.0GHz+ (e.g., Intel i5-8400, AMD Ryzen 5 3600)
    RAM8GB DDR4 (ECC preferred)16GB–32GB DDR4 (ECC for critical deployments)
    Storage256GB SSD (SATA)512GB–1TB NVMe SSD (RAID 1 for redundancy)
    Power Supply400W 80+ Bronze650W–850W 80+ Gold/Platinum
    CoolingStock or low-noise fansLiquid cooling or high-airflow setups (e.g., Noctua NH-D15)
    Note: For multi-channel setups (e.g., multiple RTL-SDR dongles), scale RAM and CPU resources linearly. Virtualization (e.g., Docker/KVM) may introduce overhead; dedicated hardware is ideal for production environments.

    Selecting Compatible RTL-SDR Devices and Their Limitations

    RTL-SDR devices (e.g., RTL2832U-based dongles) are the most cost-effective solution for OpenMHz deployments, but their performance varies based on chipset, firmware, and tuning. Below are the most compatible devices, their frequency ranges, and sample rate limitations, along with troubleshooting tips for common issues.
    Critical Limitations of RTL-SDR Devices:
  • Frequency Range: Most RTL2832U dongles cover 24MHz–1.7GHz (with tunable ranges extending to 2.2GHz via modified firmware). HackRF and SDRplay devices support wider bands (e.g., 1MHz–6GHz) but at higher cost.
  • Sample Rates: Native rates are typically 2.048MS/s (RTL2832U), but decimation (e.g., via `rtl_sdr` or `SoapySDR`) enables lower rates (e.g., 1MS/s) for narrower bandwidths.
  • USB Bandwidth: USB 2.0 limits throughput to ~30–40MB/s; USB 3.0 improves this but requires compatible dongles (e.g., RTL-SDR Blog V3).
    • Step-by-Step Selection Process:
    1. Identify Use Case Requirements
  • Narrowband monitoring (e.g., 25kHz–200kHz): RTL2832U (e.g., NooElec NESDR SMArt) suffices.
  • Wideband scanning (e.g., 10MHz+): HackRF One or SDRplay RSPduo (with appropriate licenses).
  • Multi-channel setups: Use multiple RTL-SDR dongles with separate USB ports (avoid hubs for stability).

    • 2. Verify Chipset and Firmware Compatibility

  • RTL2832U: Default firmware supports 24MHz–1.7GHz; custom firmware (e.g., `rtl-sdr` with `osmocom` tweaks) extends to 1.2–1.9GHz.
  • HackRF: Requires `libhackrf` and `SoapySDR` for integration; supports 1MHz–6GHz but with lower sensitivity (~10dB worse than RTL-SDR).
  • SDRplay: Proprietary drivers (`SDRplay API`) required; supports 1MHz–2GHz (RSP1A) or 144kHz–2GHz (RSPduo).

    • 3. Test Sample Rates and Stability

  • Use `rtl_test` (RTL-SDR) or `hackrf_transfer` (HackRF) to benchmark:

    • rtl_test -t # Check sample rate stability (aim for <1% error)

    - For OpenMHz, configure `openmhz.conf` to match the dongle’s max stable rate (e.g., `sample_rate=2.048M` for RTL-SDR).

    4. Mitigate Common Issues

  • USB Interference: Use powered USB hubs (if necessary) or disable USB power saving in BIOS.
  • Driver Conflicts: Blacklist conflicting modules (e.g., `dvb_usb_rtl28xxu`) via `/etc/modprobe.d/blacklist.conf`.
  • Firmware Updates: For RTL-SDR, use `rtl-sdr`’s `update-eeprom` script to flash latest firmware.

    • Designing a Low-Cost Antenna Setup for Optimal Signal Reception

    Antenna design significantly impacts OpenMHz’s sensitivity and coverage. Below are practical antenna types, gain calculations, and placement strategies for budget deployments, along with tools to simulate performance.
    Fundamental Antenna Parameters for OpenMHz:
  • Gain (dBi): Higher gain (e.g., 6–10dBi) improves weak-signal detection but narrows beamwidth. Omnidirectional antennas (e.g., discones) are ideal for general monitoring.
  • Impedance Matching: Mismatched impedance (e.g., 50Ω vs. 75Ω) reduces efficiency; use baluns or matching networks for dipole/loop antennas.
  • Ground Plane: A proper ground plane (e.g., radials for vertical antennas) minimizes signal loss, especially below 100MHz.
    • Antenna Types and Use Cases:
    Antenna TypeFrequency RangeGain (dBi)ProsConsCost (USD)
    Dipole10MHz–300MHz2.15Simple, omnidirectional, widebandRequires precise tuning, no gain$5–$20
    Loop (Small)10MHz–100MHz0–3Compact, low cost, good for LF/MFNarrow bandwidth, requires amplifier$10–$30
    Discone20MHz–1GHz5–8Wideband, omnidirectionalBulky, requires height for performance$50–$150
    Colinear (4-element)50MHz–1GHz8–12High gain, directionalNarrow beamwidth, complex assembly$80–$200
    Turnstile100MHz–1GHz6–10Circular polarization, good for satellitesRequires phasing network$60–$180
    Gain Calculation for Dipole/Loop Antennas:
    For a half-wave dipole, gain is theoretically 2.15dBi. For loops, use the small loop formula:
    \[
    \text{Gain (dBi)} =

    openmhz ultimate guide real time - Ilustrasi 2

    Software Installation and Configuration for Real-Time Spectrum Monitoring

    OpenMHz’s real-time spectrum monitoring capabilities rely on precise software configuration, optimized performance settings, and seamless integration with third-party tools. This section covers the installation process on Linux (Ubuntu/Debian), configuration of the `config.json` file for low-latency operation, and integration with monitoring platforms. Proper setup ensures minimal latency, efficient CPU utilization, and reliable data streaming for applications requiring immediate spectrum analysis.

    Installation of OpenMHz on Ubuntu/Debian

    The installation process requires Python 3.8+ and dependencies for RTL-SDR hardware compatibility. Version compatibility is critical, as older Python versions or mismatched libraries may introduce instability or performance bottlenecks. Below are the steps for a clean installation, including dependency resolution and verification.

    Prerequisites and Dependencies
    OpenMHz depends on the following packages for real-time operation:

  • Python 3.8+ (recommended: 3.10+ for performance optimizations).
  • librtlsdr (for RTL-SDR devices; ensure kernel support via `rtl-sdr` and `dvb-usb-rtl-sdr` drivers).
  • FFTW3 (Fastest Fourier Transform in the West) for efficient signal processing.
  • NumPy and SciPy for numerical computations.
  • PyYAML for configuration file parsing.
  • ZeroMQ (PyZMQ) for real-time data streaming (if using the API).

    • Installation Steps

    1. Update System Packages
      Ensure all system packages are up-to-date to avoid conflicts:
      sudo apt update && sudo apt upgrade -y
    2. Install Python and Dependencies
      Use the following commands to install Python and required libraries:
      sudo apt install -y python3-pip python3-dev python3-numpy python3-scipy python3-yaml python3-pyzmq libfftw3-dev librtlsdr-dev
      For newer Python versions (e.g., 3.10), add the `deadsnakes` PPA:
      sudo add-apt-repository ppa:deadsnakes/ppa
      
        sudo apt update
      
        sudo apt install -y python3.10 python3.10-dev python3.10-pip
    3. Install OpenMHz via pip
      Clone the OpenMHz repository and install in a virtual environment to isolate dependencies:
      git clone https://github.com/jasmcole/openmhz.git
      
        cd openmhz
      
        python3 -m venv venv
      
        source venv/bin/activate
      
        pip install --upgrade pip
      
        pip install -r requirements.txt
      Verify the installation by running:
      python3 -c "import openmhz; print(openmhz.__version__)"
    4. Kernel Module for RTL-SDR
      Load the `dvb-usb-rtl-sdr` kernel module (if not already active):
      sudo modprobe dvb-usb-rtl-sdr
      To persist across reboots, add it to `/etc/modules`:
      echo "dvb-usb-rtl-sdr" | sudo tee -a /etc/modules
    5. Test RTL-SDR Device
      Confirm the device is detected and functional:
      rtl_test -t
      Expected output: A stream of signal strength values (e.g., `-123 dBm`).
    Version Compatibility Notes
  • Python 3.7: May work but lacks optimizations for newer NumPy/SciPy versions.
  • FFTW3: Version 3.3.10+ recommended for stability. Older versions may cause FFT computation errors.
  • librtlsdr: Ensure compatibility with the RTL-SDR driver version (e.g., `librtlsdr0` vs. `librtlsdr-dev`).
  • OpenMHz Version: Use the latest stable release (check `git tag` for releases). Unstable branches may introduce bugs in real-time mode.

    • Configuration of `config.json` for Real-Time Performance

    The `config.json` file governs OpenMHz’s real-time behavior, including FFT windowing, decimation, and API settings. Optimizing these parameters reduces latency and CPU load while maintaining spectral fidelity. Below are critical configurations and their impact on performance.

    Key Configuration Parameters

    Real-time performance depends on three primary factors:
    1. FFT Window Function: Affects spectral leakage and dynamic range.
    2. Decimation Factor: Reduces sample rate to manageable levels for FFT computation.
    3. Sample Rate: Must align with hardware capabilities (e.g., RTL-SDR max 3.2 MS/s).
    FFT Window Settings
    The choice of window function impacts spectral resolution and side-lobe suppression. Common options include:
  • Hann Window: Balanced leakage/side-lobe performance (default in many SDR tools).
  • Blackman-Harris: Superior side-lobe suppression but wider main lobe (higher spectral leakage).
  • Rectangular (None): Maximum resolution but severe side-lobes (avoid for real-time unless necessary).

    • Example `config.json` Snippet for Real-Time Mode

    {
    "device": {
    "type": "rtlsdr",
    "sample_rate": 2048000, // 2.048 MS/s (adjust based on hardware)
    "gain": "auto",
    "ppm_error": 0,
    "center_freq": 100000000 // 100 MHz center frequency
    },
    "fft": {
    "window": "blackman-harris", // Optimized for low leakage
    "size": 4096, // FFT size (power of 2)
    "overlap": 0.75, // 75% overlap for smoother spectra
    "decimation": 4 // Reduces sample rate by factor of 4
    },
    "api": {
    "enabled": true,
    "port": 8080,
    "host": "0.0.0.0", // Bind to all interfaces for remote access
    "auth": false // Disable for testing; enable in production
    },
    "logging": {
    "level": "info",
    "file": "/var/log/openmhz/real-time.log"
    }
    }

    Decimation and Sample Rate Adjustments
    Decimation reduces the sample rate before FFT computation, lowering CPU usage but potentially losing high-frequency details. The relationship between sample rate (`Fs`), decimation (`D`), and effective FFT input rate (`Fe`) is:

    Fe = Fs / D
  • Rule of Thumb: Set `Fe` to the Nyquist rate of the target signal (e.g., for 1 MHz bandwidth, `Fe ≥ 2 MHz`).
  • CPU Impact: Higher decimation reduces CPU load but may introduce aliasing if `Fs` is insufficient.

    • API Port Bindings for Remote Access
    Enable the API for integration with Grafana, Node-RED, or custom dashboards:

  • Port 8080: Default HTTP port for JSON spectrum data.
  • Authentication: Disable during testing (`"auth": false`), but enable in production with a shared secret:

    • "api": {
    "auth": true,
    "secret": "your_shared_secret_here"
    }

    - Firewall Rules: Allow inbound traffic on the API port:

    sudo ufw allow 8080/tcp

    Comparison of Default vs. Optimized Settings for Real-Time Performance

    Default OpenMHz configurations prioritize flexibility over real-time efficiency. Below is a side-by-side comparison of default and optimized settings, including benchmarks for latency and CPU usage on a system with an Intel i5-8400 (3.8 GHz) and RTL-SDR Blog V3.
    ParameterDefault SettingOptimized SettingImpact on LatencyCPU Usage (Avg.)
    FFT WindowHannBlackman-Harris+10% (higher leakage)+5%
    FFT Size20484096+20% (higher resolution)+15%
    Overlap0.50.75+15% (smoother spectra)+8%
    Decimation Factor1 (no decimation)4-40

    Real-Time Signal Processing and Visualization Techniques in OpenMHz

    OpenMHz leverages real-time signal processing to transform raw radio frequency (RF) data into actionable spectral insights. At its core, the platform employs Fast Fourier Transform (FFT) algorithms to decompose time-domain signals into their frequency components, enabling instantaneous visualization of spectral activity. The efficiency of these calculations is further optimized through windowing functions, which mitigate spectral leakage and improve frequency resolution. Customization of the web interface extends beyond raw data display, allowing users to tailor visualizations for specific monitoring needs—such as adjusting color scales, enabling dynamic spectrograms, or annotating critical frequencies. Beyond standard visualizations, OpenMHz supports advanced techniques, including multi-input directional analysis, heatmap generation, and metadata-rich signal annotations. These features are complemented by troubleshooting tables for common artifacts, ensuring robust real-time monitoring in diverse RF environments.

    Mathematical Principles of Real-Time FFT in OpenMHz

    The FFT algorithm in OpenMHz converts time-domain samples into frequency-domain representations using the Discrete Fourier Transform (DFT). For a signal sampled at frequency fs, the FFT computes N frequency bins, where N is the number of samples in the window. The Nyquist theorem dictates that the maximum detectable frequency is fs/2, while aliasing occurs if signals exceed this limit. To mitigate spectral leakage—a distortion caused by abrupt signal truncation—OpenMHz applies windowing functions such as Hamming, Hann, or Blackman-Harris. These functions taper the signal edges, reducing side lobes in the frequency domain at the cost of slightly broader main lobes.
    Key FFT Parameters in OpenMHz:
  • Window Size (N): Determines frequency resolution (fs/N) and processing latency.
  • Overlap Factor: Balances computational load and spectral continuity (e.g., 50% overlap for smoother updates).
  • Window Function: Trade-off between spectral purity (low side lobes) and frequency resolution (main lobe width).
    • The choice of window function impacts spectral purity—measured by the ratio of peak amplitude to side-lobe levels. For example, the Blackman-Harris window offers ~92 dB side-lobe suppression but widens the main lobe by ~1.8 times compared to a rectangular window. OpenMHz defaults to the Hann window (65 dB suppression) for a balance between resolution and leakage reduction. Users can adjust these parameters via the `config.json` file under the `fft` section, though modifications require restarting the service.

    Customizing the OpenMHz Web Interface for Real-Time Displays

    The OpenMHz web interface provides modular controls to adapt visualizations to specific monitoring scenarios. Customization focuses on three primary areas: color mapping, dynamic updates, and frequency annotations. These adjustments enhance interpretability without altering the underlying signal data.
    Default Visualization Settings in OpenMHz:
  • Color Scale: Logarithmic dBm range (e.g., -120 to -20 dBm) with a gradient from blue (weak) to red (strong).
  • Waterfall Update Rate: 1–10 Hz (configurable via `waterfall_refresh_ms` in `config.json`).
  • Frequency Markers: Predefined for GPS (1.57542 GHz), ISM bands (2.4 GHz, 5.8 GHz), and ham radio allocations.
    • Adjusting Color Scales for Signal Strength
    The web interface uses a logarithmic color scale to represent signal strength in dBm, where human perception aligns with exponential power differences. To customize:
    1. Edit the `ui/colors.js` file in the OpenMHz source directory.
    2. Modify the `getColorForDbm()` function to redefine the gradient thresholds (e.g., shift the red threshold from -30 dBm to -40 dBm for higher sensitivity).
    3. Rebuild the frontend using `npm run build` and restart the service.

    Enabling/Disabling Waterfall Spectrogram Updates
    The waterfall spectrogram provides temporal context by stacking FFT results over time. To adjust:

  • Set `waterfall_enabled: true` in `config.json`.
  • Configure `waterfall_refresh_ms` (e.g., `100` for 10 Hz updates) to balance latency and smoothness.
  • Disable via `waterfall_enabled: false` to reduce CPU load in high-latency environments.

    • Adding Custom Frequency Markers
    Predefined markers (e.g., GPS, Wi-Fi) can be supplemented with user-defined frequencies:
    1. Edit `ui/markers.json` and add entries in the format:

    {
    "name": "Custom Band",
    "frequency": 433.92,
    "color": "#FF00FF",
    "label": "Paging System"
    }

    2. Restart the web service to apply changes.

    Step-by-Step Guide to Embedding OpenMHz API Data in an External Dashboard

    OpenMHz exposes a REST API to integrate spectral data into third-party dashboards. Below is a responsive HTML/CSS template using the OpenMHz API to display real-time FFT data in an embedded iframe or dynamic chart.

    Prerequisites:

  • OpenMHz server running with API enabled (`api_enabled: true` in `config.json`).
  • CORS configured if embedding across domains (add `api_cors_origins: ["*"]` to `config.json`).

    • HTML/CSS Template for Embedded Dashboard

    OpenMHz Real-Time Dashboard

    OpenMHz Real-Time Spectrum Dashboard

    API Metrics

    Loading...