Automatisieren Sie HF-Berechnungen in Python mit rftools

Warum HF-Berechnungen automatisieren?

Schauen Sie, eine VSWR-Berechnung von Hand durchzuführen ist keine große Sache. Aber wenn Sie 50 verschiedene Kabellängen abfragen, die Verbindungsbudgets für ein Dutzend Antennenoptionen vergleichen oder ein Jupyter-Notizbuch für Ihre nächste Designüberprüfung zusammenstellen, wird das Durchklicken von Webformularen schnell langweilig.

Das Python-Paket rftools integriert die gesamte rftools.io Calculator-Engine direkt in Ihre Python-Umgebung. Kein Web-Scraping, kein Kopieren von Zahlen zwischen Fenstern — nur einfache Funktionsaufrufen mit den richtigen Typen. Ich habe zu viele Tabellen mit fehlerhaften Formeln und Fehlern beim Kopieren und Einfügen gesehen. Das ist sauberer.

Installation

pip install rftools-io

Sie benötigen einen kostenlosen API-Schlüssel von rftools.io/pricing. Im kostenlosen Tarif erhalten Sie 5 Aufrufe pro Monat, was in Ordnung ist, um die Reifen zu verlassen. Wenn Sie dies in einen tatsächlichen Workflow einbauen oder regelmäßig Sweeps ausführen, erhöht sich die API-Stufe auf 10.000 Aufrufe/Monat. Das reicht für die meisten realen Arbeiten.

Deine erste Berechnung

import rftools

result = rftools.calculate('vswr-return-loss', {'vswr': 2.5})
print(f'Return Loss: {result["returnLoss"]:.2f} dB')  # 9.54 dB
print(f'Reflection Coeff: {result["reflectionCoeff"]:.3f}')  # 0.333

Die Funktion rftools.calculate() gibt ein CalculatorResult Objekt zurück. Sie verhält sich wie ein Wörterbuch, sodass Sie Ergebnisse per Schlüssel abrufen können. Ganz einfach: Sie geben den Rechner und ein Diktat mit Eingaben ein und Sie erhalten Ihre Antworten zurück.

Getippte Stubs für die automatische IDE-Vervollständigung

Wenn Sie eine bessere Auffindbarkeit und eine korrekte IDE-Autovervollständigung wünschen (und das sollten Sie), verwenden Sie die typisierten Kategorienmodule anstelle der generischen calculate()-Funktion:

from rftools.calculators import rf, antenna, pcb

# Parameter names and defaults match what you see on the rftools.io web UI
fspl = rf.free_space_path_loss(frequency=2400.0, distance=100.0)
print(f'FSPL: {fspl["pathLoss"]:.1f} dB')  # 80.0 dB

dipole = antenna.dipole_antenna(frequency=433.0)
print(f'Dipole length: {dipole["length"]:.0f} mm')

Alle 13 Kategorien sind verfügbar:rf , pcb , power , signal , antenna , general , motor , protocol , emc , thermal , sensor , unit_conversion und audio . Ihre IDE zeigt Ihnen die Funktionssignaturen an. Das ist besser, als jedes Mal, wenn Sie vergessen, ob es sich um txPower oder tx_powerhandelt, in der Dokumentation zu stöbern.

Batch-Modus (API-Tier)

Hier werden die Dinge für echte Arbeit nützlich. Mit der Batch-API können Sie bis zu 50 Berechnungen in einer einzigen HTTP-Anfrage ausführen. Dies ist perfekt für Parameter-Sweeps, bei denen Sie sonst Dutzende einzelner API-Aufrufe tätigen würden:

import rftools

client = rftools.Client(api_key='rfc_live_xxx')
# or just: export RFTOOLS_API_KEY=rfc_live_xxx

distances = [10, 50, 100, 500, 1000]
results = client.batch([
    ('free-space-path-loss', {'frequency': 2400, 'distance': d})
    for d in distances
])

for d, r in zip(distances, results):
    if r.ok:
        print(f'{d:>6}m  →  {r.values["pathLoss"]:.1f} dB')

Leistung:

    10m  →  60.0 dB
    50m  →  74.0 dB
   100m  →  80.0 dB
   500m  →  94.0 dB
  1000m  →  100.0 dB

Das ist viel schneller als das Durchlaufen einzelner Aufrufe und überlastet die API nicht mit einer Flut von Anfragen. Der Batch-Endpunkt ist genau für solche Dinge konzipiert.

Asynchrone Unterstützung

Wenn Sie einen FastAPI-Dienst erstellen oder in einem asynchronen Jupyter-Kernel arbeiten, gibt es einen AsyncClient, der gut mit Pythons async/await-Muster zusammenspielt:

import asyncio
import rftools

async def main():
    async with rftools.AsyncClient(api_key='rfc_live_xxx') as client:
        result = await client.calculate('rf-link-budget', {
            'txPower': 20,
            'txGain': 6,
            'rxGain': 3,
            'frequency': 2400,
            'distance': 500,
        })
        print(f'Received power: {result["rxPower"]:.1f} dBm')

asyncio.run(main())

Der asynchrone Client verwendet dieselbe API unter der Haube, nur mit nicht blockierenden I/O. Wenn Sie sich bereits in einer asynchronen Codebasis befinden, bleibt alles konsistent.

CLI

Manchmal braucht man einfach eine schnelle Antwort im Terminal. Das Befehlszeilentool rftools erledigt das:

# Single calculation
rftools calc vswr-return-loss --vswr 2.5

# JSON output — pipe to jq or whatever
rftools calc vswr-return-loss --vswr 2.5 --json | jq '.values.returnLoss'

# List available calculators in a category
rftools list --category rf

# Show what inputs and outputs a calculator expects
rftools info free-space-path-loss

Ich verwende das hauptsächlich für Plausibilitätsprüfungen, wenn ich bereits in der Befehlszeile bin und Python nicht starten möchte. Es ist auch praktisch in Shell-Skripten, wenn Sie etwas Schnelles und Schmutziges automatisieren.

Fehlerbehandlung

Die Bibliothek löst typisierte Ausnahmen aus, sodass Sie spezifische Probleme statt generischer Fehler erkennen können:

from rftools.exceptions import AuthError, RateLimitError, ValidationError

try:
    result = client.calculate('vswr-return-loss', {'vswr': 2.5})
except RateLimitError as e:
    print(f'Quota exceeded. Retry after {e.retry_after}s')
except AuthError:
    print('Invalid API key')
except ValidationError as e:
    print(f'Bad inputs: {e.detail}')

Den Rechner-Katalog durchsuchen

Es sind 203 Rechner verfügbar. Sie können sie programmgesteuert auflisten, wenn Sie darauf aufbauende Tools erstellen müssen:

# All calculators
calcs = rftools.list_calculators()
print(f'{len(calcs)} calculators available')

# Filter by category
rf_calcs = rftools.list_calculators(category='rf')
for c in rf_calcs:
    print(f'{c.slug}: {c.title}')

# Inspect a specific calculator's inputs and outputs
info = rftools.get_calculator('noise-figure-cascade')
for field in info.inputs:
    print(f'  in:  {field.id} ({field.unit})')
for field in info.outputs:
    print(f'  out: {field.id} ({field.unit})')

Dies ist besonders nützlich, wenn Sie eine Benutzeroberfläche oder eine Automatisierungsebene erstellen, die herausfinden muss, welche Rechner verfügbar sind und welche Parameter sie akzeptieren. Die Metadaten enthalten Einheiten, Standardwerte und Beschreibungen für jedes Feld.

Ein praktisches Beispiel: Link Budget Sweep

Hier ist ein Beispiel aus der Praxis: Darstellung der Empfangsleistung im Vergleich zur Entfernung für eine 915-MHz-Verbindung. Das ist die Art von Dingen, die Sie in einem Jupyter-Notebook tun würden, wenn Sie abschätzen, ob eine Verbindung bei Ihrer maximalen Reichweite geschlossen wird.

import numpy as np
import matplotlib.pyplot as plt
from rftools.calculators import rf

distances = np.logspace(1, 4, 40)  # 10m to 10km
rx_powers = []

for d in distances:
    r = rf.rf_link_budget(
        txPower=30,     # dBm
        txGain=6,       # dBi
        rxGain=6,       # dBi
        frequency=915,  # MHz
        distance=float(d),
    )
    rx_powers.append(r['rxPower'])

plt.semilogx(distances, rx_powers)
plt.axhline(-100, color='r', linestyle='--', label='Sensitivity (-100 dBm)')
plt.xlabel('Distance (m)')
plt.ylabel('Received Power (dBm)')
plt.title('915 MHz Link Budget')
plt.legend()
plt.grid(True)
plt.show()

Dadurch erhalten Sie ein schönes logarithmisches Diagramm, das zeigt, wo Ihr Link unter die Empfängerempfindlichkeit fällt. Sie können die Sendeleistung, die Antennenverstärkung oder die Frequenz anpassen und sofort sehen, wie sich das auswirkt. Viel schneller, als alles von Hand neu zu berechnen oder 40 Mal durch ein Webformular zu klicken.

Sie könnten dies um den Fade-Rand erweitern, verschiedene Antennenkonfigurationen vergleichen oder Messdaten aus Feldtests überlagern. Der Punkt ist, dass Ihnen die gesamte Rechner-Engine in einer skriptfähigen Umgebung zur Verfügung steht, sodass Sie alle Analysetools erstellen können, die Sie tatsächlich benötigen.

Erste Schritte

Installieren Sie es mit pip install rftools-io. Der Quellcode und der Issue Tracker befinden sich unter github.com/rftools/rftools-py. Gehen Sie zu rftools.io/pricing, um einen API-Schlüssel zu erhalten und die Preisstufen zu sehen. Die kostenlose Stufe ist in Ordnung, um Dinge auszuprobieren, aber wenn Sie ernsthaft arbeiten, ist die kostenpflichtige Stufe billig genug, dass Sie nicht zweimal darüber nachdenken werden.