TheArchive/mayhem-firmware
1
0
Fork 0
mirror of https://github.com/portapack-mayhem/mayhem-firmware.git synced 2025-08-23 15:27:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

POCSAG RX saves ignored address

Browse Source 
Made AFSK code more generic (not tied to LCR)
Added modem presets and more options in AFSK setup
String-ized and simplified LCR UI code
Simplified AFSK baseband code, made to always work on 16bit words
This commit is contained in:
furrtek
2017-04-21 06:22:31 +01:00
parent eff96276c3
commit 90feadd9f5
28 changed files with 423 additions and 423 deletions
Download Patch File Download Diff File Expand all files Collapse all files

136
firmware/baseband/proc_afsk.cpp
View File

@@ -35,88 +35,60 @@ void AFSKProcessor::execute(const buffer_c8_t& buffer) {
for (size_t i = 0; i<buffer.count; i++) {
// Tone synthesis at 2.28M/10 = 228kHz
if (s >= (5 - 1)) {
s = 0;
if (sample_count >= afsk_samples_per_bit) {
if (configured) {
cur_byte = shared_memory.bb_data.data[byte_pos];
ext_byte = shared_memory.bb_data.data[byte_pos + 1];
if (!(cur_byte | ext_byte)) {
// End of data
if (repeat_counter < afsk_repeat) {
// Repeat
bit_pos = 0;
byte_pos = 0;
cur_byte = shared_memory.bb_data.data[0];
ext_byte = shared_memory.bb_data.data[1];
message.progress = repeat_counter + 1;
shared_memory.application_queue.push(message);
repeat_counter++;
} else {
// Stop
cur_byte = 0;
ext_byte = 0;
message.progress = 0;
shared_memory.application_queue.push(message);
configured = false;
}
if (sample_count >= afsk_samples_per_bit) {
if (configured) {
cur_word = *word_ptr;
if (!cur_word) {
// End of data
if (repeat_counter < afsk_repeat) {
// Repeat
bit_pos = 0;
word_ptr = (uint16_t*)shared_memory.bb_data.data;
cur_word = *word_ptr;
message.progress = repeat_counter + 1;
shared_memory.application_queue.push(message);
repeat_counter++;
} else {
// Stop
cur_word = 0;
message.progress = 0;
shared_memory.application_queue.push(message);
configured = false;
}
}
if (afsk_format == 0) {
// 0bbbbbbbp1
// Start, 7-bit data, parity, stop
gbyte = (cur_byte << 1) | 1;
} else if (afsk_format == 1) {
// 0bbbbbbbbp
// Start, 8-bit data, parity
gbyte = (cur_byte << 1) | (ext_byte & 1);
}
cur_bit = (gbyte >> (9 - bit_pos)) & 1;
if (bit_pos >= 9) {
bit_pos = 0;
if (afsk_format == 0)
byte_pos++;
else if (afsk_format == 1)
byte_pos += 2;
} else {
bit_pos++;
}
sample_count = 0;
} else {
sample_count++;
}
if (cur_bit)
tone_phase += afsk_phase_inc_mark;
else
tone_phase += afsk_phase_inc_space;
cur_bit = (cur_word >> (symbol_count - bit_pos)) & 1;
if (bit_pos >= symbol_count) {
bit_pos = 0;
word_ptr++;
} else {
bit_pos++;
}
sample_count = 0;
} else {
s--;
sample_count++;
}
if (cur_bit)
tone_phase += afsk_phase_inc_mark;
else
tone_phase += afsk_phase_inc_space;
//tone_phase += 432759; // 1981Hz
tone_sample = (sine_table_i8[(tone_phase & 0x03FC0000) >> 18]);
// FM
// 1<<18 = 262144
// m = (262144 * a) / 2280000
// a = 262144 / 2280000 (*1000 = 115, see ui_lcr afsk_bw setting)
frq = tone_sample * afsk_bw;
phase = (phase + frq);
sphase = phase + (64 << 18);
tone_sample = sine_table_i8[(tone_phase & 0xFF000000U) >> 24];
re = (sine_table_i8[(sphase & 0x03FC0000) >> 18]);
im = (sine_table_i8[(phase & 0x03FC0000) >> 18]);
delta = tone_sample * fm_delta;
buffer.p[i] = {(int8_t)re, (int8_t)im};
phase += delta;
sphase = phase + (64 << 24);
re = (sine_table_i8[(sphase & 0xFF000000U) >> 24]);
im = (sine_table_i8[(phase & 0xFF000000U) >> 24]);
buffer.p[i] = {re, im};
}
}
@@ -126,19 +98,17 @@ void AFSKProcessor::on_message(const Message* const msg) {
if (message.id == Message::ID::AFSKConfigure) {
if (message.samples_per_bit) {
afsk_samples_per_bit = message.samples_per_bit;
afsk_phase_inc_mark = message.phase_inc_mark;
afsk_phase_inc_space = message.phase_inc_space;
afsk_phase_inc_mark = message.phase_inc_mark * AFSK_DELTA_COEF;
afsk_phase_inc_space = message.phase_inc_space * AFSK_DELTA_COEF;
afsk_repeat = message.repeat - 1;
afsk_bw = message.bw;
afsk_format = message.format;
s = 0;
fm_delta = message.fm_delta * (0xFFFFFFULL / 1536000);
symbol_count = message.symbol_count - 1;
sample_count = afsk_samples_per_bit;
repeat_counter = 0;
bit_pos = 0;
byte_pos = 0;
cur_byte = 0;
ext_byte = 0;
word_ptr = (uint16_t*)shared_memory.bb_data.data;
cur_word = 0;
cur_bit = 0;
configured = true;
} else

19
firmware/baseband/proc_afsk.hpp
View File

@@ -26,6 +26,9 @@
#include "baseband_processor.hpp"
#include "baseband_thread.hpp"
#define AFSK_SAMPLERATE 1536000
#define AFSK_DELTA_COEF ((1ULL << 32) / AFSK_SAMPLERATE)
class AFSKProcessor : public BasebandProcessor {
public:
void execute(const buffer_c8_t& buffer) override;
@@ -41,21 +44,19 @@ private:
uint32_t afsk_phase_inc_mark { 0 };
uint32_t afsk_phase_inc_space { 0 };
uint8_t afsk_repeat { 0 };
uint32_t afsk_bw { 0 };
uint8_t afsk_format { 0 };
uint32_t fm_delta { 0 };
uint8_t symbol_count { 0 };
uint8_t repeat_counter { 0 };
int8_t re { 0 }, im { 0 };
uint8_t s { 0 };
uint8_t bit_pos { 0 };
uint16_t byte_pos { 0 };
char cur_byte { 0 };
char ext_byte { 0 };
uint16_t gbyte { 0 };
uint16_t * word_ptr { };
uint16_t cur_word { 0 };
uint8_t cur_bit { 0 };
uint32_t sample_count { 0 };
uint32_t tone_phase { 0 }, phase { 0 }, sphase { 0 };
int32_t tone_sample { 0 }, sig { 0 }, frq { 0 };
int32_t tone_sample { 0 }, delta { 0 };
int8_t re { 0 }, im { 0 };
TXDoneMessage message { };
};

9
firmware/baseband/proc_replay.cpp
View File

@@ -22,8 +22,6 @@
#include "proc_replay.hpp"
//#include "dsp_fir_taps.hpp"
#include "event_m4.hpp"
#include "utility.hpp"
@@ -34,16 +32,12 @@ ReplayProcessor::ReplayProcessor() {
void ReplayProcessor::execute(const buffer_c8_t& buffer) {
/* 2.4576MHz, 2048 samples */
//const auto decim_0_out = decim_0.execute(buffer, dst_buffer);
//const auto decim_1_out = decim_1.execute(decim_0_out, dst_buffer);
//const auto& decimator_out = decim_1_out;
//const auto& channel = decimator_out;
size_t pos = 0;
for (size_t c = 0; c < 4; c++) {
if( stream ) {
const size_t bytes_to_read = sizeof(*buffer.p) * buffer.count / 4; // ?
const size_t bytes_to_read = sizeof(*buffer.p) * buffer.count / 4;
const auto result = stream->read(iq_buffer.p, bytes_to_read);
}
@@ -52,7 +46,6 @@ void ReplayProcessor::execute(const buffer_c8_t& buffer) {
for (size_t i = 0; i < (buffer.count / 4); i++) {
buffer.p[pos] = { iq_buffer.p[i].real() >> 8, iq_buffer.p[i].imag() >> 8 };
pos++;
//buffer.p[i] = { iq_buffer.p[i].real(), iq_buffer.p[i].imag() };
}
}

7
firmware/baseband/proc_replay.hpp
View File

@@ -25,11 +25,6 @@
#include "baseband_processor.hpp"
#include "baseband_thread.hpp"
//#include "rssi_thread.hpp"
//#include "dsp_decimate.hpp"
//#include "spectrum_collector.hpp"
#include "stream_output.hpp"
@@ -52,7 +47,7 @@ private:
BasebandThread baseband_thread { baseband_fs, this, NORMALPRIO + 20, baseband::Direction::Transmit };
//RSSIThread rssi_thread { NORMALPRIO + 10 };
std::array<complex16_t, 512> iq { }; // 2048
std::array<complex16_t, 512> iq { }; // 2048 doesn't fit in allocated RAM
const buffer_c16_t iq_buffer {
iq.data(),
iq.size()

9
firmware/baseband/stream_output.cpp
View File

@@ -48,7 +48,7 @@ size_t StreamOutput::read(void* const data, const size_t length) {
if( !active_buffer ) {
// We need a full buffer...
if( !fifo_buffers_full.out(active_buffer) ) {
// ...but none are available. Samples were dropped.
// ...but none are available. Hole in transmission (inform app and stop ?)
break;
}
}
@@ -59,11 +59,12 @@ size_t StreamOutput::read(void* const data, const size_t length) {
if( active_buffer->is_empty() ) {
if( !fifo_buffers_empty.in(active_buffer) ) {
// FIFO is completly empty.
// Bail out of the loop, and try retrieving the buffer in the
// next pass.
// Empty buffers FIFO is already full.
// This should never happen if the number of buffers is less
// than the capacity of the FIFO.
break;
}
// Tell M0 (IRQ) that a buffer has been consumed.
active_buffer = nullptr;
creg::m4txevent::assert();
}