mayhem-firmware/firmware/application/apps/ui_looking_glass_app.hpp

/*
 * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
 * Copyright (C) 2020 euquiq
 *
 * 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 _UI_GLASS
#define _UI_GLASS

#include "ui.hpp"
#include "portapack.hpp"
#include "baseband_api.hpp"
#include "receiver_model.hpp"
#include "ui_widget.hpp"
#include "ui_navigation.hpp"
#include "ui_receiver.hpp"
#include "string_format.hpp"
#include "analog_audio_app.hpp"
#include "spectrum_color_lut.hpp"

namespace ui
{
#define LOOKING_GLASS_SLICE_WIDTH	20000000 // Each slice bandwidth 20 MHz
#define MHZ_DIV	            1000000
#define X2_MHZ_DIV	        2000000

    class GlassView : public View
    {
        public:
            GlassView(NavigationView &nav);

            GlassView( const GlassView &);
            GlassView& operator=(const GlassView &nav);

            ~GlassView();
            std::string title() const override { return "LookingGlass"; };

            void on_show() override;
            void on_hide() override;
            void focus() override;

        private:
            NavigationView& nav_;

            struct preset_entry
            {
                rf::Frequency min{};
                rf::Frequency max{};
                std::string label{};
            };

            std::vector<preset_entry> presets_db{};

            void on_channel_spectrum(const ChannelSpectrum& spectrum);
            void do_timers();
            void on_range_changed();
            void on_lna_changed(int32_t v_db);
            void on_vga_changed(int32_t v_db);
            void add_spectrum_pixel(Color color);
            void PlotMarker(rf::Frequency pos);
            void load_Presets();
            void txtline_process(std::string& line);
            void populate_Presets();
            void presets_Default();

            rf::Frequency f_min { 0 }, f_max { 0 };
            rf::Frequency search_span { 0 };
            rf::Frequency f_center { 0 };
            rf::Frequency f_center_ini { 0 };
            rf::Frequency marker_pixel_step { 0 };
            rf::Frequency each_bin_size { LOOKING_GLASS_SLICE_WIDTH  / 240 };
            rf::Frequency bins_Hz_size { 0 };
            uint8_t min_color_power { 0 };
            uint32_t pixel_index { 0 };
            std::array<Color, 240> spectrum_row = { 0 };
            ChannelSpectrumFIFO* fifo { nullptr }; 
            uint8_t max_power = 0;
            int32_t steps = 250 ; // default of 250 Mhz steps

            Labels labels{
                {{0, 0}, "MIN:     MAX:     LNA   VGA  ", Color::light_grey()},
                    {{0, 1 * 16}, " RANGE:     FILTER:      AMP:", Color::light_grey()},
                    {{0, 2 * 16}, "PRESET:", Color::light_grey()},
                    {{0, 3 * 16}, "MARKER:     MHz +/-    MHz", Color::light_grey()},
                    {{0, 4 * 16}, "RESOLUTION:     STEPS:", Color::light_grey()}
            };

            NumberField field_frequency_min {
                { 4 * 8, 0 * 16 },
                    4,
                    { 0, 7199 },
                    1, // number of steps by encoder delta
                    ' '
            };

            NumberField field_frequency_max {
                { 13 * 8, 0 * 16 },
                    4,
                    { 1, 7200 },
                    1, // number of steps by encoder delta
                    ' '
            };

            LNAGainField field_lna {
                { 21 * 8, 0 * 16 }
            };

            VGAGainField field_vga {
                { 27 * 8, 0 * 16 }
            };

            Text text_range{
                {7 * 8, 1 * 16, 4 * 8, 16},
                    ""};

            OptionsField steps_config{
                { 22 * 8, 4 * 16},
                    4,
                    {
                        {"1",    1},
                        {"50",   50},
                        {"100",  100},
                        {"250",  250}, 
                        {"500",  500},
                        {"1000", 1000}, 
                    }};

            OptionsField filter_config{
                {19 * 8, 1 * 16},
                    4,
                    {
                        {"OFF ", 0},
                        {"MID ", 118}, //85 +25 (110) + a bit more to kill all blue
                        {"HIGH", 202}, //168 + 25 (193)
                    }};

            RFAmpField field_rf_amp{
                {29 * 8, 1 * 16}};

            OptionsField range_presets{
                {7 * 8, 2 * 16},
                    20,
                    {
                        {" NONE (WIFI 2.4GHz)", 0},
                    }};

            NumberField field_marker{
                {7 * 8, 3 * 16},
                    4,
                    {0, 7200},
                    25,
                    ' '};

            Text text_marker_pm{
                {20 * 8, 3 * 16, 2 * 8, 16},
                    ""};

            NumberField field_trigger{
                {11 * 8, 4 * 16},
                    3,
                    {2, 128},
                    2,
                    ' '};


            MessageHandlerRegistration message_handler_spectrum_config {
                Message::ID::ChannelSpectrumConfig,
                    [this](const Message* const p) {
                        const auto message = *reinterpret_cast<const ChannelSpectrumConfigMessage*>(p);
                        this->fifo = message.fifo;
                    }
            };
            MessageHandlerRegistration message_handler_frame_sync {
                Message::ID::DisplayFrameSync,
                    [this](const Message* const) {
                        if( this->fifo ) {
                            ChannelSpectrum channel_spectrum;
                            while( fifo->out(channel_spectrum) ) {
                                this->on_channel_spectrum(channel_spectrum);
                            }
                        }
                    }
            };
    };
} 
#endif