[PYTHON] Beobachten Sie die Futago-Meteorgruppe mit Raspberry Pi4

Überblick

Seit ich Raspai 4 gekauft habe, werde ich darüber sprechen, mit Raspai ein Sternwellen-Beobachtungssystem für Sternschnuppen herzustellen. Da der 12. bis 15. Dezember jedes Jahr die Zeit der Futago-Meteorgruppe ist, habe ich versucht zu sehen, ob dies tatsächlich beobachtet werden kann.

Es wird eine lange Geschichte sein, weil sie aus dem Prinzip erklärt wird.

Beobachtungsprinzip

Sternschnuppen erscheinen, wenn im Weltraum schwebender Staub in die Erdatmosphäre springt, heftig kollidiert und Plasma emittiert. Das als Ionisationssäule bezeichnete Gas, das zu diesem Zeitpunkt erzeugt wurde, hat die Eigenschaft, Radiowellen zu reflektieren, und unter Verwendung dieses Phänomens ist es möglich zu wissen, dass ein Meteor geflossen ist.

Wie in der obigen Abbildung gezeigt, werden Funkwellen aus einer Entfernung, die normalerweise nicht physisch erreicht werden, reflektiert und erreichen die Atmosphäre nur in dem Moment, in dem der Meteor fließt.

System

Dieses Mal erhalten wir die 53,755-MHz-Beacon-Welle von der Fukui Prefectural University mit SDR (Software Radio). Die von der Antenne kommenden Funkwellen werden vom SDR in Schall umgewandelt, der Schall wird über USB-Audio ausgegeben, dann unverändert in den Mikrofoneingang eingegeben und die FFT wird zur Analyse des Meteorechos durchgeführt.

Dinge notwendig

・ Himbeer Pi4 ・ USB-Audio-Konvertierungskabel · Audio Kabel ・ AirspyMini (Software Radio) ・ 50-MHz-Bandantenne ・ Koaxialkabel ・ Verschiedene Anschlüsse (Im Fall der obigen Antenne wird sie zu einem M-Typ-Anschluss, sodass eine M-SMA-Typ-Konvertierung erforderlich ist.)

Insgesamt etwa 30.000 bis 40.000 Yen. Wenn das Verfahren wie in der Vergangenheit einen analogen Empfänger verwendet, sind ein analoger Empfänger und ein PC erforderlich, sodass die Kosten wahrscheinlich niedriger sind, da es sich um SDR + Raspeltorte handelt. Wenn Sie der Meinung sind, dass Sternschnuppen ein Traumsystem sind, das Ihre Wünsche erfüllt, sollten 30.000 Yen nicht so teuer sein.

Sie können es auch in eine Schachtel legen und bedienen, damit es Ihr Herz nicht verletzt, selbst wenn Sie es im Freien in der Kälte lassen.

Installation

Alles was Sie tun müssen, ist zusammenzubauen und zu verbinden.

Anstatt sich um die frostigen Augen der Nachbarschaft zu sorgen, binden Sie die Antenne einfach an einen hohen Platz und richten Sie sie auf den Zielhimmel (Fukui).

Das kürzere Element ist die Vorwärtsrichtung.

installieren

Ich werde die Raspeltorte aufstellen.

** 1. SDR aktivieren ** Dieses Mal verwenden wir gqrx, eine SDR-Software, um sie auf der GUI auszuführen.

#gqrx herunterladen
$wget https://github.com/csete/gqrx/releases/download/v2.6/gqrx-2.6-rpi3-2.tar.xz

#Einsatz
$tar xvf gqrx-2.6-rpi3-2.tar.xz

$cd gqrx-2.6-rpi3-2/

$./setup_gqrx.sh

#Lauf
$sh run_gqrx.sh

Zunächst wird der folgende Konfigurationsbildschirm angezeigt.

・ I / Q-Eingang ist "AirSpy AIRSPY" ・ Die Eingaberate beträgt 3000000 Dann sollten die Standardeinstellungen in Ordnung sein.

Lassen Sie uns versuchen zu sehen, ob Sie etwas entsprechend der Frequenz des UKW-Radios hören können.

** 2. Installation der Bibliothek für die Klanganalyse **

#Diagrammzeichnung
$sudo apt install python3-scipy
$sudo pip3 install drawnow

#Audiosystem
$sudo apt-get install python3-pyaudio
$sudo apt-get install lame

SDR durchführen

Die Einstellung von SDR erfordert eine kleine detaillierte Einstellung.

Öffnen Sie die Empfängeroptionen im Einstellungsbildschirm rechts und öffnen Sie sie ・ Die Filterbreite ist schmal ・ Die Filterform ist scharf ・ Modus auf USB

Zu Der Modus bezieht sich auf die USB-Modulationsmethode, bei der Frequenzkomponenten niedriger als die beim Empfang eingestellte Frequenz geschnitten und moduliert werden.

Als nächstes ist es in Bezug auf die Frequenzspezifikation oben links erforderlich, die Empfangsfrequenz geringfügig von der Sendefrequenz zu verschieben, um Ton zu erzeugen.

In Kombination mit einer Frequenz von 53,754 MHz, die 1000 Hz niedriger ist als die senderseitige Frequenz von 53,755 MHz Der Ton von 1000 Hz wird ausgegeben.

** [Sendefrequenz-Empfangsfrequenz = Schallfrequenz] **

Meteorecho analysieren

Wenn der SDR ordnungsgemäß funktioniert und ein Meteor fließt, werden ein Telefon ♪ und ein hoher Ton von etwa 1000 Hz ausgegeben. Wenn die Reflexion von Radiowellen lang ist, ist der Ton möglicherweise 30 Sekunden oder länger zu hören.

↓ So. Achten Sie auf die Lautstärke! https://soundcloud.com/user-395229817/20191218-175747a

Wir werden diesen Sound mit Python analysieren.

streamfft.py

# -*- coding: utf-8 -*-

from subprocess import getoutput

import argparse
from scipy.fftpack import fft

import numpy as np
import itertools
import matplotlib
matplotlib.use("TkAgg")
import matplotlib.pyplot as plt
import pyaudio
import wave
from datetime import datetime, timedelta


#Häufigkeit zu analysieren(Hz)
FREQ_LOW = 800
FREQ_HIGH = 1200

#Maximale Lautstärke
VOL_LIMIT = 2800


#Erkennungsschwelle 0~255
THRESHOLD = 70

#Aufnahmezeit zum Zeitpunkt der Erkennung(s)
RECORD_SECONDS = 30

#Aufzeichnungsdaten speichern Ziel
SAVE_PATH = '/PATHtoSAVE/'

def str2bool(v):
    if v.lower() in ('true', 't', 'y', '1'):
        return True
    elif v.lower() in ('false', 'f', 'n', '0'):
        return False
    else:
        raise argparse.ArgumentTypeError('Boolean value expected.')

#Gibt an, ob ein Diagramm ausgegeben werden soll
dataplot = False
parser = argparse.ArgumentParser(description="data plot enable")
parser.add_argument("-p",
                    metavar="--p",
                    type=str2bool,
                    nargs="+",
                    help="data plot enable"
                    )


#Gibt an, ob MP3 gespeichert werden soll, wenn ein Meteor erkannt wird
datasave = False
parser.add_argument("-s",
                    metavar="--s",
                    type=str2bool,
                    nargs="+",
                    help="MP3 Save"
                    )

args = parser.parse_args()

dataplot = bool(args.p[0])
datasave = bool(args.s[0])
print("data plot enable : " + str(dataplot))
print("MP3 Save : " + str(datasave))


class SpectrumAnalyzer:
    FORMAT = pyaudio.paInt16
    CHANNELS = 1
    RATE = 44100
    CHUNK = 22050
    N = 22050

    #Erkennungsflag
    detect = False

    #Aufnahmeflag
    isRecording = False

    data = []
    frames = []
    y = []
    maxVol = 0

    startTime = datetime.now()
    endTime = startTime + timedelta(seconds=RECORD_SECONDS)
    filename = startTime.strftime("%Y%m%d_%H%M%S")

    def __init__(self):

        self.audio = pyaudio.PyAudio()
        DEVICE_IDX = 0
        for i in range(self.audio.get_device_count()):
            dev = self.audio.get_device_info_by_index(i)
            if dev['name'].find('USB PnP Sound Device') != -1:
                DEVICE_IDX = i

        self.stream = self.audio.open(
            format = self.FORMAT,
            channels = self.CHANNELS,
            rate = self.RATE,
            input_device_index = DEVICE_IDX,
            input = True,
            output = False,
            frames_per_buffer = self.CHUNK,
            stream_callback = self.callback)

        self.stream.start_stream()
        print('SpectrumAnalyzer init')


    def close(self):
        self.stream.stop_stream()
        self.stream.close()
        self.audio.terminate()
        print("Quitting...")

    def callback(self, in_data, frame_count, time_info, status):
        yf = fft(np.frombuffer(in_data, dtype=np.int16)) / self.CHUNK
        self.y = np.abs(yf)[1:int(self.CHUNK/2)]

        freqRange = self.RATE / self.N
        lowIdx = int(FREQ_LOW / freqRange)
        highIdx = int(FREQ_HIGH / freqRange)
        vol = self.y[lowIdx:highIdx]

        self.maxVol = 0
        idx = 0
        for v in vol:
            #Weißes Rauschen ist 5~10%Auf 25 oder weniger eingestellt
            vol[idx] = v.round()

            # VOL_Mit LIMIT schneiden
            if VOL_LIMIT <= vol[idx]:
                vol[idx] = VOL_LIMIT

            #Normalisiert bei 255
            vol[idx] = int(round(vol[idx] / VOL_LIMIT * 255, 0))

            #Maximalwert
            if (self.maxVol <= vol[idx]):
                self.maxVol = vol[idx]

            if (vol[idx] > 255):
                vol[idx] = 255

            idx = idx + 1


        if(dataplot):
            self.data = vol.tolist()
            self.drawGraph()

        #Schwellenwertvergleich
        if THRESHOLD <= self.maxVol:
            self.detect = True
        else:
            self.detect = False

        #Starte die Aufnahme
        if self.isRecording == False and self.detect:
            self.isRecording = True
            self.startRecording()

        #Verarbeitung während der Aufnahme
        if self.isRecording:
            self.frames.append(in_data)

            #Verarbeitung am Ende der Aufnahme
            if datetime.now() > self.endTime:
                self.isRecording = False
                self.stopRecording()


        return(None, pyaudio.paContinue)


    def drawGraph(self):
        plt.subplot(1,1,1)
        plt.clf()
        plt.plot(self.data)
        plt.draw()
        plt.pause(0.05)

    def startRecording(self):
        self.startTime = datetime.now()
        self.endTime = self.startTime + timedelta(seconds=RECORD_SECONDS)
        self.filename = self.startTime.strftime("%Y%m%d_%H%M%S")

        print(self.startTime.strftime("%Y%m%d_%H%M%S") + " Recording Start")


    def stopRecording(self):
        waveFile = wave.open(SAVE_PATH + self.filename + '.wav', 'wb')
        waveFile.setnchannels(self.CHANNELS)
        waveFile.setsampwidth(self.audio.get_sample_size(self.FORMAT))
        waveFile.setframerate(self.RATE)
        waveFile.writeframes(b''.join(self.frames))
        waveFile.close()

        self.frames = []

        print("Recording Stop")

        #MP3-Konvertierung
        self.convertMp3()

    def convertMp3(self):
        checkConvert = getoutput("lame -b 128 " + SAVE_PATH + self.filename + '.wav' + " " + SAVE_PATH + self.filename + '.mp3')
        print(checkConvert)

        #WAV-Entfernung
        srcDel = getoutput("rm -rf " + SAVE_PATH + self.filename + '.wav')
        print(srcDel)


def keyInterrupt():
    while True:
        try:
            pass
        except KeyboardInterrupt:
            spec.close()
            return

spec = None
if __name__ == "__main__":
    spec = SpectrumAnalyzer()
    keyInterrupt()

Als Verarbeitungsablauf

** 1. FFT alle 0,5 Sekunden 2. Extrahieren Sie Daten von 800 bis 1200 Hz 3. Stellen Sie fest, ob die Lautstärke im obigen Bereich den Schwellenwert überschreitet 4. Wenn es überschritten wird, speichern Sie es 30 Sekunden lang als WAV 5. Konvertieren Sie WAV in MP3 **

Mit diesem Gefühl wird jedes Mal, wenn ein Shooting Star fließt, eine MP3-Datei erstellt.

Schwellenwert einstellen

Zeigen Sie ein Spektrogramm an, um die Meteorerkennungsschwelle anzupassen.

#Spektrogrammzeichnung
# p → True
python3 /home/pi/streamfft.py -p True -s False

Da die FFT alle 0,5 Sekunden durchgeführt wird, beträgt die Frequenzauflösung 2 Hz. Da wir 400 Hz von 800 bis 1200 Hz analysieren, können wir 200 Datenpunkte in einer FFT erhalten. Es tut mir leid, dass es unfreundlich ist, kein Etikett zu haben, aber die X-Achse ist 800 Hz am linken Ende und 1200 Hz am rechten Ende. Die Y-Achse ist ein von 0 bis 255 normierter Wert.

In der obigen Abbildung wird die Lautstärke VOL_LIMIT so eingestellt, dass der Grundrauschen etwa 10 von 255 beträgt, wobei nur weißes Rauschen auftritt. Wenn nach dieser Einstellung die Erkennungsschwelle überschritten wird, handelt es sich um einen Meteor! Es ist ein grobes Urteil.

↓ Wenn die Funkwelle des Meteors eintrifft, wird sie wie in der folgenden Abbildung gezeigt ansteigen.

Nun zu beobachten!

#Beobachtungsbefehl
#s → Auf True setzen und Daten speichern
python3 /home/pi/streamfft.py -p False -s True

Beobachtungsergebnisse der Futago-Meteorgruppe 2019

Die Beobachtung begann am 14.12. Um 2 Uhr und endete am 16.12. Um 10 Uhr, so dass es ungefähr 56 Stunden dauerte. Es scheint, dass Fukuis Leuchtfeuerwelle für ungefähr 12 Stunden anhielt und während dieser Zeit keine Daten erhalten werden konnten.

Es gab ungefähr 400 Daten, und anscheinend überlappte sich ein anderes rauschähnliches Ding, oder ich spielte etwas, das kein Meteorecho war, und der Eindruck war ungefähr 200. Ich konnte kein gutes Gefühl bekommen, weil der AGC-Zustand von SDR und das Urteil über den festen Schwellenwert nicht sehr gut zusammenpassten oder es eine Datenverlustzeit gab.

Dies sind die Daten von Sternschnuppen-Beobachtungsstationen, die vor etwa zwei Jahren in verschiedenen Teilen Japans installiert wurden. Der von Raspeye FFTed-Wert wird an AWS gesendet und das Meteorecho wird in Echtzeit auf dem Server erkannt. Ursprünglich stieg die Anzahl der Meteore von etwa 12/12 allmählich an, und das Merkmal der Futago-Sternbild-Meteorgruppe war, dass sie nach dem Höhepunkt vom 14.12.15 stark abfiel.

Zusammenfassung

Die Leistung von RaspberryPi4 hat sich erheblich verbessert, und es ist jetzt möglich, eine Echoanalyse während des SDR durchzuführen. RaspberryPi3 ist voller SDR ...

Außerdem habe ich es diesmal mit einem einfachen Urteil darüber eingeführt, ob der Schwellenwert überschritten wurde oder nicht, aber wenn ich es tatsächlich beobachte, werden verschiedene Geräusche eingeführt, so dass ich es noch interessanter finde, eine erweiterte Urteilsverarbeitung hinzuzufügen, um es abzuwehren.

Bsp. Doppler wird auf das vom Flugzeug reflektierte Echo angewendet. Es wird anhand der Frequenzverschiebung beurteilt und abgestoßen. Toka Toka