unleashed-firmware/applications/spectrum_analyzer/spectrum_analyzer_worker.c

195 lines
5.7 KiB
C
Raw Normal View History

2022-05-10 02:33:45 +00:00
#include "spectrum_analyzer.h"
#include "spectrum_analyzer_worker.h"
#include <furi_hal.h>
#include <furi.h>
#include <lib/drivers/cc1101_regs.h>
struct SpectrumAnalyzerWorker {
FuriThread* thread;
bool should_work;
SpectrumAnalyzerWorkerCallback callback;
void* callback_context;
uint32_t channel0_frequency;
uint32_t spacing;
uint8_t width;
double max_rssi;
2022-05-10 02:33:45 +00:00
uint8_t max_rssi_dec;
uint8_t max_rssi_channel;
uint8_t channel_ss[NUM_CHANNELS];
};
/* set the channel bandwidth */
void spectrum_analyzer_worker_set_filter(SpectrumAnalyzerWorker* instance) {
uint8_t filter_config[2][2] = {
{CC1101_MDMCFG4, 0},
{0, 0},
};
// FURI_LOG_D("SpectrumWorker", "spectrum_analyzer_worker_set_filter: width = %u", instance->width);
/* channel spacing should fit within 80% of channel filter bandwidth */
switch(instance->width) {
case NARROW:
filter_config[0][1] = 0xFC; /* 39.2 kHz / .8 = 49 kHz --> 58 kHz */
break;
case ULTRAWIDE:
filter_config[0][1] = 0x0C; /* 784 kHz / .8 = 980 kHz --> 812 kHz */
break;
default:
filter_config[0][1] = 0x6C; /* 196 kHz / .8 = 245 kHz --> 270 kHz */
break;
}
furi_hal_subghz_load_registers(filter_config);
}
static int32_t spectrum_analyzer_worker_thread(void* context) {
furi_assert(context);
SpectrumAnalyzerWorker* instance = context;
FURI_LOG_D("SpectrumWorker", "spectrum_analyzer_worker_thread: Start");
// Start CC1101
furi_hal_subghz_reset();
furi_hal_subghz_load_preset(FuriHalSubGhzPresetOok650Async);
furi_hal_subghz_set_frequency(433920000);
furi_hal_subghz_flush_rx();
furi_hal_subghz_rx();
static const uint8_t radio_config[][2] = {
{CC1101_FSCTRL1, 0x12},
{CC1101_FSCTRL0, 0x00},
{CC1101_AGCCTRL2, 0xC0},
{CC1101_MDMCFG4, 0x6C},
{CC1101_TEST2, 0x88},
{CC1101_TEST1, 0x31},
{CC1101_TEST0, 0x09},
/* End */
{0, 0},
};
while(instance->should_work) {
furi_hal_delay_ms(50);
// FURI_LOG_T("SpectrumWorker", "spectrum_analyzer_worker_thread: Worker Loop");
furi_hal_subghz_idle();
furi_hal_subghz_load_registers(radio_config);
// TODO: Check filter!
// spectrum_analyzer_worker_set_filter(instance);
instance->max_rssi_dec = 0;
for(uint8_t ch = 0; ch < NUM_CHANNELS - 1; ch++) {
furi_hal_subghz_set_frequency(instance->channel0_frequency + (ch * instance->spacing));
furi_hal_subghz_rx();
furi_hal_delay_ms(3);
// dec dBm
//max_ss = 127 -> -10.5
//max_ss = 0 -> -74.0
//max_ss = 255 -> -74.5
//max_ss = 128 -> -138.0
instance->channel_ss[ch] = (furi_hal_subghz_get_rssi() + 138) * 2;
if(instance->channel_ss[ch] > instance->max_rssi_dec) {
instance->max_rssi_dec = instance->channel_ss[ch];
instance->max_rssi = (instance->channel_ss[ch] / 2) - 138;
instance->max_rssi_channel = ch;
}
furi_hal_subghz_idle();
}
// FURI_LOG_T("SpectrumWorker", "channel_ss[0]: %u", instance->channel_ss[0]);
// Report results back to main thread
if(instance->callback) {
instance->callback(
(void*)&(instance->channel_ss),
instance->max_rssi,
instance->max_rssi_dec,
instance->max_rssi_channel,
instance->callback_context);
}
}
return 0;
}
SpectrumAnalyzerWorker* spectrum_analyzer_worker_alloc() {
FURI_LOG_D("Spectrum", "spectrum_analyzer_worker_alloc: Start");
SpectrumAnalyzerWorker* instance = malloc(sizeof(SpectrumAnalyzerWorker));
instance->thread = furi_thread_alloc();
furi_thread_set_name(instance->thread, "SpectrumWorker");
furi_thread_set_stack_size(instance->thread, 2048);
furi_thread_set_context(instance->thread, instance);
furi_thread_set_callback(instance->thread, spectrum_analyzer_worker_thread);
FURI_LOG_D("Spectrum", "spectrum_analyzer_worker_alloc: End");
return instance;
}
void spectrum_analyzer_worker_free(SpectrumAnalyzerWorker* instance) {
FURI_LOG_D("Spectrum", "spectrum_analyzer_worker_free");
furi_assert(instance);
furi_thread_free(instance->thread);
free(instance);
}
void spectrum_analyzer_worker_set_callback(
SpectrumAnalyzerWorker* instance,
SpectrumAnalyzerWorkerCallback callback,
void* context) {
furi_assert(instance);
instance->callback = callback;
instance->callback_context = context;
}
void spectrum_analyzer_worker_set_frequencies(
SpectrumAnalyzerWorker* instance,
uint32_t channel0_frequency,
uint32_t spacing,
uint8_t width) {
furi_assert(instance);
FURI_LOG_D(
"SpectrumWorker",
"spectrum_analyzer_worker_set_frequencies - channel0_frequency= %u - spacing = %u - width = %u",
channel0_frequency,
spacing,
width);
instance->channel0_frequency = channel0_frequency;
instance->spacing = spacing;
instance->width = width;
}
void spectrum_analyzer_worker_start(SpectrumAnalyzerWorker* instance) {
FURI_LOG_D("Spectrum", "spectrum_analyzer_worker_start");
furi_assert(instance);
furi_assert(instance->should_work == false);
instance->should_work = true;
furi_thread_start(instance->thread);
}
void spectrum_analyzer_worker_stop(SpectrumAnalyzerWorker* instance) {
FURI_LOG_D("Spectrum", "spectrum_analyzer_worker_stop");
furi_assert(instance);
furi_assert(instance->should_work == true);
instance->should_work = false;
furi_thread_join(instance->thread);
}