mayhem-firmware/firmware/application/baseband_api.cpp

381 lines
11 KiB
C++
Raw Normal View History

/*
* Copyright (C) 2016 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 "baseband_api.hpp"
#include "audio.hpp"
#include "tonesets.hpp"
#include "dsp_iir_config.hpp"
#include "portapack_shared_memory.hpp"
#include "portapack_persistent_memory.hpp"
#include "core_control.hpp"
/* Set true to enable additional checks to ensure
* M4 and M0 are synchronized before passing messages. */
static constexpr bool enforce_core_sync = true;
/* Set true to enable check for baseband messages getting stuck.
* This implies the baseband thread is not dequeuing and has probably stalled.
* NB: This check adds a small amout of overhead to the message sending code
* and may impact application perf if it is sending a lot of messages. */
static constexpr bool check_for_message_hang = true;
using namespace portapack;
namespace baseband {
static void send_message(const Message* const message) {
// If message is only sent by this function via one thread, no need to check if
// another message is present before setting new message.
shared_memory.baseband_message = message;
creg::m0apptxevent::assert_event();
if constexpr (check_for_message_hang) {
auto count = UINT32_MAX;
while (shared_memory.baseband_message && --count)
/* spin */;
if (count == 0)
chDbgPanic("Baseband Send Fail");
} else {
while (shared_memory.baseband_message)
/* spin */;
}
}
void AMConfig::apply() const {
const AMConfigureMessage message{
taps_6k0_decim_0, // common FIR filter taps pre-decim_0 to all 5 x AM mod types.(AM-9K, AM-6K, USB, LSB, CW)
taps_6k0_decim_1, // common FIR filter taps pre-decim_1 to all 5 x AM mod. types.
decim_2, // var decim_2 FIR taps filter , variable values, depending selected AM mod(AM 9k / 6k all rest AM modes)
channel, // var channel FIR taps filter , variable values, depending selected AM mode, each one different (DSB-9K, DSB-6K, USB-3K, LSB-3K,CW)
modulation, // var parameter .
audio_12k_hpf_300hz_config};
send_message(&message);
audio::set_rate(audio::Rate::Hz_12000);
}
void NBFMConfig::apply(const uint8_t squelch_level) const {
const NBFMConfigureMessage message{
decim_0,
decim_1,
channel,
2,
deviation,
audio_24k_hpf_300hz_config,
audio_24k_deemph_300_6_config,
squelch_level};
send_message(&message);
audio::set_rate(audio::Rate::Hz_24000);
}
void WFMConfig::apply() const {
const WFMConfigureMessage message{
decim_0, // taps_200k_decim_0 , taps_180k_wfm_decim_0, taps_40k_wfm_decim_0
decim_1, // taps_200k_decim_1 or taps_180k_wfm_decim_1, taps_40k_wfm_decim_1
taps_64_lp_156_198,
75000,
audio_48k_hpf_30hz_config,
audio_48k_deemph_2122_6_config};
send_message(&message);
audio::set_rate(audio::Rate::Hz_48000);
}
void set_tone(const uint32_t index, const uint32_t delta, const uint32_t duration) {
shared_memory.bb_data.tones_data.tone_defs[index].delta = delta;
shared_memory.bb_data.tones_data.tone_defs[index].duration = duration;
}
void set_tones_config(const uint32_t bw, const uint32_t pre_silence, const uint16_t tone_count, const bool dual_tone, const bool audio_out) {
const TonesConfigureMessage message{
bw,
pre_silence,
tone_count,
dual_tone,
audio_out};
send_message(&message);
}
void kill_tone() {
const TonesConfigureMessage message{
0,
0,
0,
false,
false};
send_message(&message);
}
void set_sstv_data(const uint8_t vis_code, const uint32_t pixel_duration) {
const SSTVConfigureMessage message{
vis_code,
pixel_duration};
send_message(&message);
}
void set_afsk(const uint32_t baudrate, const uint32_t word_length, const uint32_t trigger_value, const bool trigger_word) {
const AFSKRxConfigureMessage message{
baudrate,
word_length,
trigger_value,
trigger_word};
send_message(&message);
}
2021-03-07 22:05:23 +00:00
void set_aprs(const uint32_t baudrate) {
const APRSRxConfigureMessage message{
baudrate};
send_message(&message);
2021-03-07 22:05:23 +00:00
}
void set_btle(const uint32_t baudrate, const uint32_t word_length, const uint32_t trigger_value, const bool trigger_word) {
const BTLERxConfigureMessage message{
baudrate,
word_length,
trigger_value,
trigger_word};
send_message(&message);
}
2022-12-05 14:51:23 +00:00
void set_nrf(const uint32_t baudrate, const uint32_t word_length, const uint32_t trigger_value, const bool trigger_word) {
const NRFRxConfigureMessage message{
baudrate,
word_length,
trigger_value,
trigger_word};
send_message(&message);
}
void set_afsk_data(const uint32_t afsk_samples_per_bit, const uint32_t afsk_phase_inc_mark, const uint32_t afsk_phase_inc_space, const uint8_t afsk_repeat, const uint32_t afsk_bw, const uint8_t symbol_count) {
const AFSKTxConfigureMessage message{
afsk_samples_per_bit,
afsk_phase_inc_mark,
afsk_phase_inc_space,
afsk_repeat,
afsk_bw,
symbol_count};
send_message(&message);
}
void kill_afsk() {
const AFSKTxConfigureMessage message{
0,
0,
0,
0,
0,
false};
send_message(&message);
}
void set_audiotx_config(const uint32_t divider, const float deviation_hz, const float audio_gain, uint8_t audio_shift_bits_s16, const uint32_t tone_key_delta, const bool am_enabled, const bool dsb_enabled, const bool usb_enabled, const bool lsb_enabled) {
const AudioTXConfigMessage message{
divider,
deviation_hz,
audio_gain,
audio_shift_bits_s16,
tone_key_delta,
(float)persistent_memory::tone_mix() / 100.0f,
am_enabled,
dsb_enabled,
usb_enabled,
lsb_enabled};
send_message(&message);
}
void set_fifo_data(const int8_t* data) {
const FIFODataMessage message{
data};
send_message(&message);
}
void set_pitch_rssi(int32_t avg, bool enabled) {
const PitchRSSIConfigureMessage message{
enabled,
avg};
send_message(&message);
2016-07-28 03:25:33 +00:00
}
void set_ook_data(const uint32_t stream_length, const uint32_t samples_per_bit, const uint8_t repeat, const uint32_t pause_symbols, const uint8_t de_bruijn_length) {
const OOKConfigureMessage message{
stream_length,
samples_per_bit,
repeat,
pause_symbols,
de_bruijn_length};
send_message(&message);
2022-12-05 14:51:23 +00:00
}
void kill_ook() {
const OOKConfigureMessage message{
0,
0,
0,
0,
0};
send_message(&message);
}
void set_fsk_data(const uint32_t stream_length, const uint32_t samples_per_bit, const uint32_t shift, const uint32_t progress_notice) {
const FSKConfigureMessage message{
stream_length,
samples_per_bit,
shift,
progress_notice};
send_message(&message);
2016-08-03 06:53:50 +00:00
}
void set_pocsag() {
const POCSAGConfigureMessage message{};
send_message(&message);
}
void set_adsb() {
const ADSBConfigureMessage message{
1};
send_message(&message);
}
void set_jammer(const bool run, const jammer::JammerType type, const uint32_t speed) {
const JammerConfigureMessage message{
run,
type,
speed};
send_message(&message);
}
void set_rds_data(const uint16_t message_length) {
const RDSConfigureMessage message{
message_length};
send_message(&message);
}
void set_spectrum(const size_t sampling_rate, const size_t trigger) {
const WidebandSpectrumConfigMessage message{
sampling_rate, trigger};
send_message(&message);
}
void set_siggen_tone(const uint32_t tone) {
const SigGenToneMessage message{
TONES_F2D(tone, TONES_SAMPLERATE)};
send_message(&message);
}
void set_siggen_config(const uint32_t bw, const uint32_t shape, const uint32_t duration) {
const SigGenConfigMessage message{
bw, shape, duration * TONES_SAMPLERATE};
send_message(&message);
}
void set_spectrum_painter_config(const uint16_t width, const uint16_t height, bool update, int32_t bw) {
SpectrumPainterBufferConfigureRequestMessage message{width, height, update, bw};
send_message(&message);
}
static bool baseband_image_running = false;
void run_image(const spi_flash::image_tag_t image_tag) {
if (baseband_image_running) {
chDbgPanic("BBRunning");
}
creg::m4txevent::clear();
shared_memory.clear_baseband_ready();
m4_init(image_tag, memory::map::m4_code, false);
baseband_image_running = true;
creg::m4txevent::enable();
if constexpr (enforce_core_sync) {
// Wait up to 3 seconds for baseband to start handling events.
auto count = 3'000u;
while (!shared_memory.baseband_ready && --count)
chThdSleepMilliseconds(1);
if (count == 0)
chDbgPanic("Baseband Sync Fail");
}
}
void shutdown() {
if (!baseband_image_running) {
return;
}
creg::m4txevent::disable();
ShutdownMessage message;
send_message(&message);
shared_memory.application_queue.reset();
2022-12-05 14:51:23 +00:00
baseband_image_running = false;
}
void spectrum_streaming_start() {
SpectrumStreamingConfigMessage message{
SpectrumStreamingConfigMessage::Mode::Running};
send_message(&message);
}
void spectrum_streaming_stop() {
SpectrumStreamingConfigMessage message{
SpectrumStreamingConfigMessage::Mode::Stopped};
send_message(&message);
}
void set_sample_rate(uint32_t sample_rate, OversampleRate oversample_rate) {
SampleRateConfigMessage message{sample_rate, oversample_rate};
send_message(&message);
}
void capture_start(CaptureConfig* const config) {
CaptureConfigMessage message{config};
send_message(&message);
}
void capture_stop() {
CaptureConfigMessage message{nullptr};
send_message(&message);
}
void replay_start(ReplayConfig* const config) {
ReplayConfigMessage message{config};
send_message(&message);
}
void replay_stop() {
ReplayConfigMessage message{nullptr};
send_message(&message);
}
void request_beep() {
RequestSignalMessage message{RequestSignalMessage::Signal::BeepRequest};
send_message(&message);
}
} /* namespace baseband */