portapack-mayhem/firmware/baseband/proc_pocsag2.hpp

285 lines
8.2 KiB
C++
Raw Normal View History

/*
* Copyright (C) 1996 Thomas Sailer (sailer@ife.ee.ethz.ch, hb9jnx@hb9w.che.eu)
* Copyright (C) 2012-2014 Elias Oenal (multimon-ng@eliasoenal.com)
* Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
* Copyright (C) 2016 Furrtek
* Copyright (C) 2023 Kyle Reed
*
* This file is part of PortaPack.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street,
* Boston, MA 02110-1301, USA.
*/
#ifndef __PROC_POCSAG2_H__
#define __PROC_POCSAG2_H__
/* https://www.aaroncake.net/schoolpage/pocsag.htm */
#include "audio_output.hpp"
#include "baseband_processor.hpp"
#include "baseband_thread.hpp"
#include "dsp_decimate.hpp"
#include "dsp_demodulate.hpp"
#include "dsp_iir_config.hpp"
#include "message.hpp"
#include "pocsag.hpp"
#include "pocsag_packet.hpp"
#include "portapack_shared_memory.hpp"
#include "rssi_thread.hpp"
#include <array>
#include <cstdint>
#include <functional>
/* Normalizes audio stream to +/-1.0f */
class AudioNormalizer {
public:
void execute_in_place(const buffer_f32_t& audio);
private:
void calculate_thresholds();
uint32_t counter_ = 0;
float min_ = 99.0f;
float max_ = -99.0f;
float t_hi_ = 1.0;
float t_lo_ = 1.0;
};
/* FIFO wrapper over a uint32_t's bits. */
class BitQueue {
public:
void push(bool bit);
bool pop();
void reset();
uint8_t size() const;
uint32_t data() const;
private:
uint32_t data_ = 0;
uint8_t count_ = 0;
static constexpr uint8_t max_size_ = sizeof(data_) * 8;
};
/* Extracts bits and bitrate from audio stream. */
class BitExtractor {
public:
BitExtractor(BitQueue& bits)
: bits_{bits} {}
void extract_bits(const buffer_f32_t& audio);
void configure(uint32_t sample_rate);
void reset();
uint16_t baud_rate() const;
private:
/* Number of rate misses that would cause a rate update. */
static constexpr uint8_t rate_miss_reset_threshold = 5;
/* Number of rate misses that would cause a rate update. */
static constexpr uint8_t bad_transition_reset_threshold = 10;
struct BaudInfo {
uint16_t baud_rate = 0;
float bit_length = 0.0;
float min_bit_length = 0.0;
float max_bit_length = 0.0;
};
/* Handle a transition, returns true if "good". */
bool handle_transition();
/* Count the number of bits the length represents.
* Returns true if valid given the current baud rate. */
bool count_bits(uint32_t length, uint16_t& bit_count);
/* Gets the best baud info associated with the specified bit length. */
const BaudInfo* get_baud_info(float bit_length) const;
std::array<BaudInfo, 3> known_rates_{
BaudInfo{512},
BaudInfo{1200},
BaudInfo{2400}};
BitQueue& bits_;
uint32_t sample_rate_ = 0;
uint16_t min_valid_length_ = 0;
const BaudInfo* current_rate_ = nullptr;
uint8_t rate_misses_ = 0;
float sample_ = 0.0;
float last_sample_ = 0.0;
float next_bit_center_ = 0.0;
uint32_t sample_index_ = 0;
uint32_t last_transition_index_ = 0;
uint32_t bad_transitions_ = 0;
};
/* Extracts codeword batches from the BitQueue. */
class CodewordExtractor {
public:
using batch_t = pocsag::batch_t;
using batch_handler_t = std::function<void(CodewordExtractor&)>;
CodewordExtractor(BitQueue& bits, batch_handler_t on_batch)
: bits_{bits}, on_batch_{on_batch} {}
/* Process the BitQueue to extract codeword batches. */
void process_bits();
/* Pad then send any pending frames. */
void flush();
/* Completely reset to prepare for a new message. */
void reset();
/* Gets the underlying batch array. */
const batch_t& batch() const { return batch_; }
/* Gets in-progress codeword. */
uint32_t current() const { return data_; }
/* Gets the count of completed codewords. */
uint8_t count() const { return word_count_; }
/* Returns true if the batch has as sync frame. */
bool has_sync() const { return has_sync_; }
private:
/* Sync frame codeword. */
static constexpr uint32_t sync_codeword = 0x7cd215d8;
/* Idle codeword used to pad a 16 codeword "batch". */
static constexpr uint32_t idle_codeword = 0x7a89c197;
/* Number of bits in 'data_' member. */
static constexpr uint8_t data_bit_count = sizeof(uint32_t) * 8;
/* Clears data_ and bit_count_ to prepare for next codeword. */
void clear_data_bits();
/* Pop a bit off the queue and add it to data_. */
void take_one_bit();
/* Handles receiving the sync frame codeword, start of batch. */
void handle_sync(bool inverted);
/* Saves the current codeword in data_ to the batch. */
void save_current_codeword();
/* Sends the batch to the handler, resets for next batch. */
void handle_batch_complete();
/* Fill the rest of the batch with 'idle' codewords. */
void pad_idle();
BitQueue& bits_;
batch_handler_t on_batch_{};
/* When true, sync frame has been received. */
bool has_sync_ = false;
/* When true, bit vales are flipped in the codewords. */
bool inverted_ = false;
uint32_t data_ = 0;
uint8_t bit_count_ = 0;
uint8_t word_count_ = 0;
batch_t batch_{};
};
/* Processes POCSAG signal into codeword batches. */
class POCSAGProcessor : public BasebandProcessor {
public:
void execute(const buffer_c8_t& buffer) override;
void on_message(const Message* const message) override;
private:
static constexpr size_t baseband_fs = 3072000;
static constexpr uint8_t stat_update_interval = 10;
static constexpr uint32_t stat_update_threshold =
baseband_fs / stat_update_interval;
void configure();
void flush();
void reset();
void send_stats() const;
void send_packet();
/* Set once app is ready to receive messages. */
bool configured = false;
/* Buffer for decimated IQ data. */
std::array<complex16_t, 256> dst{};
const buffer_c16_t dst_buffer{dst.data(), dst.size()};
/* Buffer for demodulated audio. */
std::array<float, 16> audio{};
const buffer_f32_t audio_buffer{audio.data(), audio.size()};
/* Decimate to 48kHz. */
dsp::decimate::FIRC8xR16x24FS4Decim8 decim_0{};
dsp::decimate::FIRC16xR16x32Decim8 decim_1{};
/* Filter to 24kHz and demodulate. */
dsp::decimate::FIRAndDecimateComplex channel_filter{};
dsp::demodulate::FM demod{};
/* Squelch to ignore noise. */
FMSquelch squelch{};
uint64_t squelch_history = 0;
/* LPF to reduce noise. POCSAG supports 2400 baud, but that falls
* nicely into the transition band of this 1800Hz filter.
* scipy.signal.butter(2, 1800, "lowpass", fs=24000, analog=False) */
IIRBiquadFilter lpf{{{0.04125354f, 0.082507070f, 0.04125354f},
{1.00000000f, -1.34896775f, 0.51398189f}}};
/* Attempts to de-noise and normalize signal. */
AudioNormalizer normalizer{};
/* Handles writing audio stream to hardware. */
AudioOutput audio_output{};
/* Holds the data sent to the app. */
pocsag::POCSAGPacket packet{};
/* Used to keep track of how many samples were processed
* between status update messages. */
uint32_t samples_processed = 0;
BitQueue bits{};
/* Processes audio into bits. */
BitExtractor bit_extractor{bits};
/* Processes bits into codewords. */
CodewordExtractor word_extractor{
bits, [this](CodewordExtractor&) {
send_packet();
}};
/* NB: Threads should be the last members in the class definition. */
BasebandThread baseband_thread{baseband_fs, this, baseband::Direction::Receive};
RSSIThread rssi_thread{};
};
#endif /*__PROC_POCSAG2_H__*/