Archiv der Kategorie: Software

WebSDR Server von sdr.hu = OpenWebRX

Zum Testen für die Relaisstation auf dem Ravensberg DB0RVB habe ich auf meinem Linux-Mint-Rechner die Installation der OpenWebRX-Software vorgenommen. Das Ziel ist es auf dem Standort mitten in Deutschland für das 2m-Band ein WebSDR zur Beobachtung von Ausbreitungsbedingungen vorzuhalten.

Die Materialliste sieht in etwa so aus:

  • 1 Linux-Rechner mit Internetanbindung
  • 1 DVB-T-Stick mit RTL-Technologie
  • 1 Rundstrahlantenne mit horizontaler Polarisation
  • 1 Software von András Retzler OpenWebRX
  • 1 Feste IP-Adresse (z.B. DynDNS) für den öffentlichen Auftritt
  • nicht vergessen: Stromversorgung, Verbindungs- und Antennenkabel etc.

Ob ein Raspberry für diesen Zweck ausreicht, muss ich noch ausprobieren. Bei meinem Brackel-Rechner mit Intel Dual-Core wird die CPU aber schon sehr belastet. Ein Pi2 sollte mit seinen vier Kernen vielleicht schon ausreichen. Kann ich nicht testen, weil ich habe im Moment keinen. Allerdings wollen wir auf dem Relaisstandort recht stromsparend arbeiten. Netzteile mit 60W und mehr sind quasi tabu.

Die Installation ist recht schnell und einfach, wenn man sich an die Installationsanleitung von András hält. Die bekommt man hier: http://blog.sdr.hu/2015/06/30/quick-setup-openwebrx.html

Nachdem dann auch mit einem Editor die ../openwebrx/config_webrx.py mit meinen Daten ausgestattet wurde, startet man den SDR-Server mit

cd ../openwebrx
./openwebrx.py

 

Aufruf des Clients am lokalen Browser mit http://localhost:8073.

So habe ich noch einen DynDNS-Eintrag spendiert, um aus dem Internet auf den Server zugreifen zu können: http://dl8aap.ddns.net:8073

Durch eine pfiffige Kompression des Datenstroms ist die Netzwerkbelastung ziemlich schlank. Statt 2MBit/s fahren nur noch 200k/s durch die Leitung.

So in etwa soll es dann aussehen:

Gut zu erkennen ist bei 145,750 MHz der Kabelkanal S6 mit einem unnötigen Sender. Um den zu entfernen, arbeite ich grad an einem Sperrfilter für meine Kabelanlage. Und der Nachbar bekommt dann auch gleich eines verpasst…!

Datenübertragung im Subaudiobereich

Im Amateurfunk wird es auf den frequenzmodulierten VHF und UHF-Bändern immer enger. Die Bandbreiten schrumpfen. Wenn man also mal eine Datenübertragung parallel zum Träger und der Sprachsignale übertragen will (ähnlich RDS im UKW-Rundfunk), bleibt eigentlich nur noch der Bereich unter 300 Hertz. Normalerweise ist dieser Bereich für CTCSS-Töne “reserviert”. Also nutzen wir sie doch experimentell… Sprachfrequenzen werden im Audiobereich 300 … 2700 Hz übertragen. Da stört sich also nix.

Hier eine Idee, wie man z.B. einen Arduino Nano beibringen könnte Daten in diesem Bereich dem Trägersignal hinzuzusetzen. Die eingebaute Tone()-Funktion erzeugt 5V-Rechtecksignale von 31 … 65535 Hz. So also mal schnell ein Arduino-Sketch niedergeschrieben und in den Nano geschoben:

Fakt ist: Die tone()-Funktion des Arduino kann nur unsigned int Werte annehmen. Bis hinunter zu 31 Hz kann ein Signal unterhalb 300 Hz erzeugt werden. Aber eben nur ganzzahlige Werte. Ein CTCSS-Pilotton von 88,5 Hz ist demnach nicht darstellbar. Was bleibt ist die Erzeugung der 10-fachen Frequenz und dann mit einem Teiler-IC durch 10 zu teilen. Das kann dann ein CD4018 erledigen, also 885 : 10 = 88,5.

Hier die Idee:

CD 4018 Beschaltung als Teiler durch 10

CD 4018 Beschaltung als Teiler durch 10

Hier der aktuelle Arduino-Sketch:

/*
  Dieser Sketch wurde mit dem Arduino Nano entwickelt
  und sollte aber auch auf allen anderen Arduinotypen lauffähig sein.
  Ich hatte eben keinen anderen, die Dinger sind so saubillig geworden...
  Natürlich kann man immer etwas verbessern, also tu es, ich tu auch was
  
  Carsten Koch, DL8AAP - Letzter Stand 22.9.2016
*/

// Der Timer muss eingebunden werden
#include "TimerOne.h"

//            0   1   2   3   4   5   6   7   8   9  Beg End
int T[12] = {915,693,710,719,744,770,797,825,854,885,670,2541}; // CTCSS-Frequenzen mal 10 in Hertz, werden später durch Hardware durch 10 geteilt
int dur = 180;                                                  // Dauer eines Datenbits in ms
int dur_roger = 120;                                            // Dauer des Rogerbeep in ms
int freq_roger = 3000;                                          // Frequenz des Rogerbeep in Hertz
int dur_break = 500;                                            // Pause zum nächsten Datenwort in ms
int pin_id = 10;                                                // Ausgabepin für die zu sendende String-ID
int pin_roger = 11;                                             // Ausgabepin für den Rogerbeep
String ID = "1234567890";                                       // zu sendende Ziffern
String zeichen = "";                                            // Puffervariable
int x;                                                          // Puffervariable
int pttPin = 7;                                                 // Pin 7 ist HIGH, schaltet nach Masse auf LOW als PTT gedrückt
int ledPin = 13;                                                // Visuelle Darstellung des PTT-Status
long intervall = 10000;                                         // Timerintervall in µsek
int send_id = 1;                                                // 0=String-ID aus, 1=String-ID an
int send_roger = 1;                                             // 0=Rogerbeep aus, 1=Rogerbeep an
int play = 0;                                                   // Zusatzvariable für den Rogerbeep

void setup() {
  pinMode(pttPin, INPUT_PULLUP);             // pttPin wird als Input mit einem Pullup-Widerstand auf HIGH gesetzt
  pinMode(ledPin, OUTPUT);                   // ledPin wird als Output gesetzt
  Timer1.initialize(intervall);              // Der Timer wird mit dem Timerintervall gesetzt
  Timer1.attachInterrupt(switch_ptt_state);  // Die Funktion switch_ptt_state wird als Timer-Funktion gesetzt
}

void loop() {
  // In der loop() wird der ID-String an der pin_id ausgegeben
  // aber nur, wenn der Schalter send_id auf 1 steht
  if (send_id == 1) {
    start_id();
    for(int i = 0; i<ID.length(); i++) {
      zeichen = ID[i];
      x = zeichen.toInt();
      play_id(T[x]);
    }
    end_id();
    pause_id();
  }
}

// Weitere eigene Funktionen

void switch_ptt_state() {
  // Diese Funktion wird vorrangig vor der loop()-Funktion aufgerufen
  //digitalWrite(ledPin,digitalRead(ledPin)^1);
  if (digitalRead(pttPin) == LOW) {
    // Wenn die PTT getastet wird = LOW, dann sind wir im TX-Modus
    //ptt = tx;
    digitalWrite(ledPin,HIGH); // Lass die TX-Lampe brennen
    play = 1; // Um den Rogerbeep später auszulösen, wird play auf 1 gesetzt
  }
  else {
    //ptt = rx;
    // Sobald wir im RX Modus sind und der Rogerbeep gesendet werden soll, dann tu das
    if (play==1) {
      // Wenn der Rogerbeep gesendet werden soll,
      if (send_roger == 1) {
        // Dann unterbreche den Pin bei dem, was er grad spielt
        noTone(pin_id);
        // und spiele den Rogerbeep
        play_roger(); 
      }
      // Der Rogerbeep wurde erzeugt, play kann wieder auf 0 gesetzt werden
      play = 0;
    }
    // Schalte die TX-Lampe aus
    digitalWrite(ledPin,LOW);
  }
}

void start_id() {
  // Startsignal für Datenwort
  // wird doppelt so lange gespielt, wie ein Datenbit
  tone(pin_id,T[10],dur*2);
  delay(dur*2+10);
}

void play_id(unsigned int f) {
  // Datenbit eines Datenworts
  // f=übergebene Frequenz des Tones
  tone(pin_id,f,dur);
  delay(dur+10);
}

void end_id() {
  // Endsignal für Datenwort
  // wird doppelt so lange gespielt, wie ein Datenbit
  tone(pin_id,T[11],dur*2);
  delay(dur*2+10);
}

void pause_id() {
  // Pause zum nächsten Datenwort
  noTone(pin_id);
  delay(dur_break);
}

void play_roger() {
  // Rogerbeep
  tone(pin_roger,freq_roger,dur_roger);
  delay(dur+10);
}

Danach durchläuft das Signal einen aktiven Tiefpassfilter 4. Ordnung mit einer Grenzfrequenz von 300 Hz nach vorheriger Verstärkung von 3 dB. Das Signal des Rogerbeeps (ca. 1 … 3 kHz) wird daran vorbei geschleust. Damit werden dann alle Obertöne des Rechtecksignals unterdrückt. Im Idealfall bleibt ein (relativ) sauberer Sinus als Nutzsignal.

Auf http://www.analog.com/designtools/en/filterwizard/ kann man sich seinen Filter zusammen stellen. Die Ergebnisse für meine Zwecke sehen dann in der Theorie wie folgt aus:

TP-Filter Vorgaben

TP-Filter Vorgaben 3dB Verstärkung mit 300 Hz Grenzfrequenz, 40 dB Dämpfung bei 1 kHz

TP-Filter 4. Ordnung nach Sallen Key

TP-Filter 4. Ordnung nach Sallen Key

TP-Filter 2 x 2. Ordnung

TP-Filter 2 x 2. Ordnung

TP-Filter zu erwartende Kurve

TP-Filter zu erwartende Kurve

Eine entsprechende Schaltung habe ich mal mit LTSpice simuliert. Dabei habe ich die Werte eines TL084 OP benutzt und komme auf die gleichen Filterergebnisse.

300 Hz Tiefpassfilter in der Spice-Simulation

300 Hz Tiefpassfilter in der Spice-Simulation

250 Hz-Signal - rot=Input, grün = Output,

250 Hz-Signal – rot=Input, grün = Output,

Das 500 Hz-Signal (grün) wird schon deutlich vom Eingangssignal (rot) gedämpft

Das 500 Hz-Signal (grün) wird schon deutlich vom Eingangssignal (rot) gedämpft

Deutlich ist die Dämpfung des Signals von fast 50 dB bei 1 kHz zu erkennen.

Deutlich ist die Dämpfung des Signals von fast 50 dB bei 1 kHz zu erkennen.

Blockschaltbild Subaudio-Encoder

Blockschaltbild Subaudio-Encoder mit Rogerbeep

Soweit die Theorie…

Wohlgemerkt, es handelt sich hier zunächst erstmal um einen Encoder. Um das Decodieren kümmern wir uns an anderer Stelle.

Nun geht’s an die Praxis!

Mal ganz schnell Hochfrequenz…

Für die kommenden Projekte (wie z.B. den Spektrumanalyzer) habe ich mir einen kleinen Baustein angeschafft, der mir zwei unabhängige Oszillatoren auf drei Ausgänge (50 Ohm) erzeugt. Hierauf ist ein Si5351 mit einem 25 MHz Takt verbaut. Durch eine geschickte Frequenzteilung werden an den Ausgängen Rechtecksignale im Bereich von 8 kHz bis 160 MHz mit einer Ausgangsspannung von 3 VSS erzeugt. In einem Langzeittest hat sich die Schaltung auf meinem Werktisch als sehr stabil erwiesen, obwohl der Steuerquarz keine Temperaturstabilisierung hat.

Programmiert wird dieser Baustein über einen Arduino Nano oder Mini. Die erforderliche Bibliothek ist bei Adafruit erhältlich. Ein paar Zeilen Programmcode und in den Arduino hochgeladen, und schon steht die programmierte Frequenz am gewünschten Ausgang zur Verfügung.

Hier der Minimal-Code für den Arduino:

#include "si5351.h"
#include "Wire.h"

Si5351 si5351;

void setup() {
  si5351.init(SI5351_CRYSTAL_LOAD_8PF, 0);
  si5351.set_pll(SI5351_PLL_FIXED, SI5351_PLLA);
  // Setzen der Frequenz 29,700.000.00 MHz
  si5351.set_freq(2970000000ULL, 0ULL, SI5351_CLK0);
}

void loop() {
  // der Inhalt dieser loop()-Funktion darf auch gerne leer sein
  // oder man baut sich in dieser Schleife noch Abfragen für Up/Down-Taster hinzu
  si5351.update_status();
  delay(100);
}
Arduino und Si5351

Arduino und Si5351

Si5351 mit 400 Hz Offset

Si5351 mit 400 Hz zuviel – kann aber über eine Correction-Funktion angepasst werden

Der Si5351 "stört" sogar auf der richtigen Frequenz

Der Si5351 “stört” sogar auf der richtigen Frequenz

Arduino Code für den Si5351

Arduino Code für den Si5351

Wenn man also mal ganz schnell eine Frequenz benötigt – so wie ich für 64 MHz, so ist man mit Kosten von insgesamt weniger als 15 € für die beiden Bausteine bestens ausgestattet.

Noch mehr im Sachen im Internet rund um den Si5351:

 

DIY Programmierkabel Yaesu FT-7900

Es ist schon recht mühselig das Yaesu FT-7900 über das Panel zu programmieren. Zugegeben es geht auch, aber über ein Programm ist das wesentlich komfortabler und übersichtlicher. So habe ich mir von G4HFQ ein kleines (aber mächtiges) Programm mit dem Namen FTB7900 für Windows herunter geladen, installiert und gekauft. Diese 15 Euro waren es mir wert.

Das FT-7900 hat an der Rückseite einen 6-poligen Eingang angebracht, über den der Speicherinhalt übertragen werden kann. Außerdem kann hier auch ein TNC angeschlossen werden. Die Belegung dieser Buchse sieht so aus:

6-pin FT-7900

6-pin FT-7900 von der Rückseite betrachtet

Ein altes PS/2-Kabel diente dabei als Grundlage.

6-pin Stecker PS/2

6-pin Stecker PS/2

Für eine Zweidraht-Programmierung des Gerätes benötigt man lediglich den Pin 2 GND und Pin 3 PTT. Ja, richtig, PTT. Hierüber wird die Schnittstelle mit Daten gefüttert, sowohl aus dem Gerät heraus, als auch in das Gerät hinein. Dabei sollte man aber bitte auf die richtigen Pegel achten. Also brauchte ich noch einen RS232-TTL-Konverter.

Fündig wurde ich bei DL8WA, der eine solche Konverter-Schaltung auf seiner Seite veröffentlich hat.

DL8WA 2-wire level converter

DL8WA 2-wire level converter

Diese kleine Schaltung habe ich kurzerhand mit Bauteilen und Kabelresten aus der Kiste auf einer Lochstreifenplatine aufgebaut.

Stückliste

  • D1,D2 = 1N4148 oder 1N4001 oder ähnlich
  • C1 = 4,7µF, 35V
  • T1,T2,T3 = BC546B oder ähnlich
  • R1 = 470 Ohm
  • R2=1 kOhm
  • R4,R6 = 10 kOhm
  • R3,R5 = 100 kOhm
  • D3 = Zener Diode 5,6V
  • P1 = Trimmer 10kOhm
    (So einstellen, dass eine Spannung von 3,3V zwischen Data und GND anliegt, bezogen auf einen nicht angeschlossenen VX-3)

Hier das Ergebnis:

RS232-TTL Konverter nach DL8WA

RS232-TTL Konverter nach DL8WA

Yaesu FT-7900 Programmierkabel

Yaesu FT-7900 Programmierkabel

Nun, schön sieht das Ganze nicht aus, aber es funktioniert hervorragend!

Noch ein Hinweis:
(damit ich das nicht vergesse und hier immer wieder nachschlagen kann)

Um das Yaesu FT-7900 in den Programmiermodus zu versetzen geht man folgendermaßen vor:

  • Taste MHz/PRI gedrückt halten und dabei das Gerät einschalten
  • Mit dem Abstimmknopf die Funktion auf F-7 Clone drehen
  • Taste BAND/SET eine 1/2 Sek. lang drücken Dabei geht das Gerät kurz aus und schaltet sich wieder ein.
  • Zum Empfangen von Daten nun Taste LOW/ACC drücken. Es erscheint — — RX — —
    Software zum Schreiben in das FT-7900 setzen
  • Zum Senden von Daten Taste V/M/MW drücken. Es erscheint — — TX — —
    Software zum Empfang vom FT-7900 setzen
  • Danach FT-7900 ausschalten und wieder normal einschalten

Wenn irgendwas schief geht erscheint ERROR

Mit der selben Prozedur kann man übrigens die Speicher und Konfiguration des Gerätes auf ein anderes FT-7900 klonen.

Nachtrag

Diese erste Schaltung eines anderen OMs hat nicht funktioniert. Die Pegel reichten nicht aus, um annähernd die 3,3V auf TTL zu bringen.

RS232-TTL Konverter nicht brauchbar

RS232-TTL Konverter nicht brauchbar

Konverter für JT65 CSV Logdaten in das ADIF-Format

Offensichtlich besteht momentan noch der Bedarf die Logdaten aus dem JT65 HF Comfort Programm im CSV-Format in das für Amateurfunkzwecke schon fast genormte Format ADIF zu übertragen. Ich habe einige Konvertierungsprogramme ausprobiert, jedoch sind die Bedienungen für nicht Eingeweihte schlecht oder irgendwas anderes funktioniert dann nicht, wie es soll. Download am Ende der Seite. Weiterlesen

Fernsteuerung mit Windows PC für den Kenwood TS-870S

Der Kenwood TS-870 verfügt über eine genormte serielle Schnittstelle zur Steuerung durch einen PC. Und da mein Laptop keine solche serielle Schnittstelle mehr enthält, musste ich mit einem RS232-Konverter das Gerät ansteuern. Bevor ich mir hierzu ein sog. CAT-Kabel besorge, wollte ich erstmal vorher testen, wie man mit dieser Steuerungs-Kontrolle umgeht.

Weiterlesen

SDR# mit Scanner-Plugin

Für meinen jüngst erworbenen DVB-T-Stick mit dem R820T Chip habe ich die Installation des SDR#-Programms durchgeführt. Leider lässt das als stabile Version 1.0.0.1000 zum Download angebotene Version keine großartige Datenbank für die Frequenzverwaltung zu. Dafür gibt es aber ein Plugin, das das SDR# um weitere Funktionen erweitert: Weiterlesen