258 lines
6.2 KiB
C++
258 lines
6.2 KiB
C++
/*
|
|
* Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
|
|
* Copyright (C) 2016 Furrtek
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#include "proc_aprsrx.hpp"
|
|
#include "portapack_shared_memory.hpp"
|
|
|
|
#include "event_m4.hpp"
|
|
|
|
#include "stdio.h"
|
|
|
|
void APRSRxProcessor::execute(const buffer_c8_t& buffer) {
|
|
// This is called at 3072000 / 2048 = 1500Hz
|
|
|
|
if (!configured) return;
|
|
|
|
// FM demodulation
|
|
const auto decim_0_out = decim_0.execute(buffer, dst_buffer); // 2048 / 8 = 256 (512 I/Q samples)
|
|
const auto decim_1_out = decim_1.execute(decim_0_out, dst_buffer); // 256 / 8 = 32 (64 I/Q samples)
|
|
const auto channel_out = channel_filter.execute(decim_1_out, dst_buffer); // 32 / 2 = 16 (32 I/Q samples)
|
|
|
|
feed_channel_stats(channel_out);
|
|
|
|
auto audio = demod.execute(channel_out, audio_buffer);
|
|
|
|
audio_output.write(audio);
|
|
|
|
// Audio signal processing
|
|
for (size_t c = 0; c < audio.count; c++) {
|
|
|
|
const int32_t sample_int = audio.p[c] * 32768.0f;
|
|
int32_t current_sample = __SSAT(sample_int, 16);
|
|
|
|
current_sample /= 128;
|
|
|
|
// Delay line put
|
|
delay_line[delay_line_index & 0x3F] = current_sample;
|
|
|
|
// Delay line get, and LPF
|
|
sample_mixed = (delay_line[(delay_line_index - (samples_per_bit/2)) & 0x3F] * current_sample) / 4;
|
|
sample_filtered = prev_mixed + sample_mixed + (prev_filtered / 2);
|
|
|
|
delay_line_index++;
|
|
|
|
prev_filtered = sample_filtered;
|
|
prev_mixed = sample_mixed;
|
|
|
|
// Slice
|
|
sample_bits <<= 1;
|
|
|
|
uint8_t bit = (sample_filtered < -20) ? 1 : 0;
|
|
sample_bits |= bit;
|
|
|
|
/*
|
|
int16_t scaled = bit == 1 ? 32767 : -32767;
|
|
|
|
if( stream ) {
|
|
const size_t bytes_to_write = sizeof(scaled) * 1;
|
|
const auto result = stream->write(&scaled, bytes_to_write);
|
|
}
|
|
*/
|
|
|
|
// Check for "clean" transition: either 0011 or 1100
|
|
if ((((sample_bits >> 2) ^ sample_bits) & 3) == 3) {
|
|
// Adjust phase
|
|
if (phase < 0x8000)
|
|
phase += 0x800; // Is this a proper value ?
|
|
else
|
|
phase -= 0x800;
|
|
}
|
|
|
|
phase += phase_inc;
|
|
|
|
if (phase >= 0x10000) {
|
|
phase &= 0xFFFF;
|
|
|
|
if (true) {
|
|
uint8_t bit;
|
|
if(__builtin_popcount(sample_bits & 0xFF) >= 0x05){
|
|
bit = 0x1;
|
|
}
|
|
else {
|
|
bit = 0x0;
|
|
}
|
|
|
|
if(parse_bit(bit)){
|
|
parse_packet();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void APRSRxProcessor::parse_packet(){
|
|
//validate crc
|
|
if(packet_buffer_size >= aprs::APRS_MIN_LENGTH){
|
|
uint16_t crc = 0xFFFF;
|
|
|
|
for(size_t i = 0; i < packet_buffer_size; i++){
|
|
uint8_t byte = packet_buffer[i];
|
|
crc = ((crc >> 8) ^ crc_ccitt_tab[(crc ^ byte) & 0xFF]) & 0xFFFF;
|
|
}
|
|
|
|
if(crc == 0xF0B8){
|
|
parse_ax25();
|
|
}
|
|
}
|
|
}
|
|
|
|
void APRSRxProcessor::parse_ax25(){
|
|
aprs_packet.clear();
|
|
aprs_packet.set_valid_checksum(true);
|
|
|
|
for(size_t i = 0; i < packet_buffer_size; i++){
|
|
aprs_packet.set(i, packet_buffer[i]);
|
|
}
|
|
|
|
APRSPacketMessage packet_message { aprs_packet };
|
|
shared_memory.application_queue.push(packet_message);
|
|
}
|
|
|
|
bool APRSRxProcessor::parse_bit(const uint8_t current_bit){
|
|
uint8_t decoded_bit = ~(current_bit ^ last_bit) & 0x1;
|
|
last_bit = current_bit;
|
|
|
|
//int16_t log = decoded_bit == 0 ? -32768 : 32767;
|
|
//if(stream){
|
|
// const size_t bytes_to_write = sizeof(log) * 1;
|
|
// const auto result = stream->write(&log, bytes_to_write);
|
|
//}
|
|
|
|
if(decoded_bit & 0x1){
|
|
if(ones_count < 8){
|
|
ones_count++;
|
|
}
|
|
}
|
|
else {
|
|
if(ones_count > 6){ //not valid
|
|
state = WAIT_FLAG;
|
|
current_byte = 0;
|
|
ones_count = 0;
|
|
byte_index = 0;
|
|
packet_buffer_size = 0;
|
|
return false;
|
|
}
|
|
else if(ones_count == 6){ //flag
|
|
bool done = false;
|
|
if(state == IN_FRAME){
|
|
done = true;
|
|
}
|
|
else {
|
|
packet_buffer_size = 0;
|
|
}
|
|
state = WAIT_FRAME;
|
|
current_byte = 0;
|
|
ones_count = 0;
|
|
byte_index = 0;
|
|
|
|
return done;
|
|
}
|
|
else if(ones_count == 5){ //bit stuff
|
|
ones_count = 0;
|
|
return false;
|
|
}
|
|
else {
|
|
ones_count = 0;
|
|
}
|
|
}
|
|
|
|
//store
|
|
current_byte = current_byte >> 1;
|
|
current_byte |= (decoded_bit == 0x1 ? 0x80 : 0x0);
|
|
byte_index++;
|
|
|
|
if(byte_index >= 8){
|
|
byte_index = 0;
|
|
if(state == WAIT_FRAME){
|
|
state = IN_FRAME;
|
|
}
|
|
|
|
if(state == IN_FRAME){
|
|
if(packet_buffer_size + 1 >= 256){
|
|
state = WAIT_FLAG;
|
|
current_byte = 0;
|
|
ones_count = 0;
|
|
byte_index = 0;
|
|
packet_buffer_size = 0;
|
|
return false;
|
|
}
|
|
packet_buffer[packet_buffer_size++] = current_byte;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void APRSRxProcessor::on_message(const Message* const message) {
|
|
if (message->id == Message::ID::APRSRxConfigure)
|
|
configure(*reinterpret_cast<const APRSRxConfigureMessage*>(message));
|
|
if(message->id == Message::ID::CaptureConfig)
|
|
capture_config(*reinterpret_cast<const CaptureConfigMessage*>(message));
|
|
}
|
|
|
|
void APRSRxProcessor::capture_config(const CaptureConfigMessage& message) {
|
|
if( message.config ) {
|
|
//stream = std::make_unique<StreamInput>(message.config);
|
|
audio_output.set_stream(std::make_unique<StreamInput>(message.config));
|
|
} else {
|
|
//stream.reset();
|
|
audio_output.set_stream(nullptr);
|
|
}
|
|
}
|
|
|
|
void APRSRxProcessor::configure(const APRSRxConfigureMessage& message) {
|
|
decim_0.configure(taps_11k0_decim_0.taps, 33554432);
|
|
decim_1.configure(taps_11k0_decim_1.taps, 131072);
|
|
channel_filter.configure(taps_11k0_channel.taps, 2);
|
|
demod.configure(audio_fs, 5000);
|
|
|
|
audio_output.configure(audio_24k_hpf_300hz_config, audio_24k_deemph_300_6_config, 0);
|
|
|
|
samples_per_bit = audio_fs / message.baudrate;
|
|
|
|
phase_inc = (0x10000 * message.baudrate) / audio_fs;
|
|
phase = 0;
|
|
|
|
// Delay line
|
|
delay_line_index = 0;
|
|
|
|
state = WAIT_FLAG;
|
|
|
|
configured = true;
|
|
}
|
|
|
|
int main() {
|
|
EventDispatcher event_dispatcher { std::make_unique<APRSRxProcessor>() };
|
|
event_dispatcher.run();
|
|
return 0;
|
|
}
|