Merge branch 'next'

firmware/application/CMakeLists.txt

@@ -231,6 +231,7 @@ set(CPPSRC
 	apps/ui_keyfob.cpp
 	apps/ui_lcr.cpp
 	apps/lge_app.cpp
+	apps/ui_looking_glass_app.cpp
 	apps/ui_mictx.cpp
 	apps/ui_modemsetup.cpp
 	apps/ui_morse.cpp

firmware/application/apps/ui_aprs_tx.hpp

@@ -82,6 +82,7 @@ private:
 		6,
 		SymField::SYMFIELD_ALPHANUM
 	};
+	
 	NumberField num_ssid_dest {
 		{ 19 * 8, 2 * 16 },
 		2,

firmware/application/apps/ui_looking_glass_app.cpp

@@ -0,0 +1,334 @@
+/*
+ * 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.
+ */
+
+#include "ui_looking_glass_app.hpp"
+
+
+using namespace portapack;
+
+namespace ui
+{
+
+void GlassView::focus() {
+	field_marker.focus();
+}
+
+GlassView::~GlassView() {
+    receiver_model.set_sampling_rate(3072000); // Just a hack to avoid hanging other apps
+	receiver_model.disable();
+	baseband::shutdown();
+}
+
+void GlassView::on_lna_changed(int32_t v_db) {
+	receiver_model.set_lna(v_db);
+}
+
+void GlassView::on_vga_changed(int32_t v_db) {
+	receiver_model.set_vga(v_db);
+}
+
+void GlassView::add_spectrum_pixel(Color color)
+{
+    spectrum_row[pixel_index++] = color;
+    if (pixel_index == 240) //got an entire waterfall line
+    { 
+        const auto draw_y = display.scroll(1); //Scroll 1 pixel down
+        display.draw_pixels( {{0, draw_y}, {240, 1}}, spectrum_row); //new line at top
+        pixel_index = 0; //Start New cascade line
+    }
+}
+
+//Apparently, the spectrum object returns an array of 256 bins
+//Each having the radio signal power for it's corresponding frequency slot
+void GlassView::on_channel_spectrum(const ChannelSpectrum &spectrum)
+{
+    baseband::spectrum_streaming_stop();
+
+    // Convert bins of this spectrum slice into a representative max_power and when enough, into pixels
+    // Spectrum.db has 256 bins. Center 12 bins are ignored (DC spike is blanked) Leftmost and rightmost 2 bins are ignored
+    // All things said and done, we actually need 240 of those bins:
+    for(uint8_t bin = 0; bin < 240; bin++) 
+    {
+        if (bin < 120) {
+            if (spectrum.db[134 + bin] > max_power)
+                max_power = spectrum.db[134 + bin];
+        }         
+        else
+        {
+            if (spectrum.db[bin - 118] > max_power)
+                    max_power = spectrum.db[bin - 118];  
+        }
+
+        bins_Hz_size += each_bin_size;   //add this bin Hz count into the "pixel fulfilled bag of Hz"
+
+        if (bins_Hz_size >= marker_pixel_step) //new pixel fullfilled
+        {
+            if (min_color_power < max_power)
+                add_spectrum_pixel(spectrum_rgb3_lut[max_power]); //Pixel will represent max_power
+            else
+                add_spectrum_pixel(0);  //Filtered out, show black
+
+            max_power = 0;
+
+            if (!pixel_index) //Received indication that a waterfall line has been completed
+            {
+                bins_Hz_size = 0;  //Since this is an entire pixel line, we don't carry "Pixels into next bin"
+                break;
+            } else {
+                bins_Hz_size -= marker_pixel_step; //reset bins size, but carrying the eventual excess Hz into next pixel
+            }
+        }
+    }
+
+    if (pixel_index) 
+        f_center += SEARCH_SLICE_WIDTH; //Move into the next bandwidth slice NOTE: spectrum.sampling_rate = SEARCH_SLICE_WIDTH
+    else
+        f_center = f_center_ini; //Start a new sweep
+
+    receiver_model.set_tuning_frequency(f_center); //tune rx for this slice
+    baseband::spectrum_streaming_start();          //Do the RX
+}
+
+void GlassView::on_hide()
+{
+    baseband::spectrum_streaming_stop();
+    display.scroll_disable();
+}
+
+void GlassView::on_show()
+{
+    display.scroll_set_area( 109, 319); //Restart scroll on the correct coordinates
+    baseband::spectrum_streaming_start();
+}
+
+void GlassView::on_range_changed()
+{
+    f_min = field_frequency_min.value();
+    f_max = field_frequency_max.value();
+    search_span = f_max - f_min;
+
+    field_marker.set_range(f_min, f_max);              //Move the marker between range
+    field_marker.set_value(f_min + (search_span / 2)); //Put MARKER AT MIDDLE RANGE
+    text_range.set(to_string_dec_uint(search_span));
+
+    f_min = (f_min)*MHZ_DIV; //Transpose into full frequency realm
+    f_max = (f_max)*MHZ_DIV;
+    search_span = search_span * MHZ_DIV;
+
+    marker_pixel_step = search_span / 240;                                        //Each pixel value in Hz
+    text_marker_pm.set(to_string_dec_uint((marker_pixel_step / X2_MHZ_DIV) + 1)); // Give idea of +/- marker precision
+
+    int32_t marker_step = marker_pixel_step / MHZ_DIV;
+    if (!marker_step) 
+        field_marker.set_step(1); //in case selected range is less than 240 (pixels)
+    else
+        field_marker.set_step(marker_step); //step needs to be a pixel wide.
+
+    f_center_ini = f_min + (SEARCH_SLICE_WIDTH / 2);    //Initial center frequency for sweep
+    f_center_ini += SEARCH_SLICE_WIDTH;                 //euquiq: Why do I need to move the center ???!!! (shift needed for marker accuracy)
+
+    PlotMarker(field_marker.value()); //Refresh marker on screen
+
+    f_center = f_center_ini;                        //Reset sweep into first slice
+    pixel_index = 0;                                //reset pixel counter
+    max_power = 0;
+    bins_Hz_size = 0;                               //reset amount of Hz filled up by pixels
+    
+    baseband::set_spectrum(SEARCH_SLICE_WIDTH, field_trigger.value());   
+    receiver_model.set_tuning_frequency(f_center_ini); //tune rx for this slice
+}
+
+void GlassView::PlotMarker(rf::Frequency pos)
+{
+    pos = pos * MHZ_DIV;
+    pos -= f_min;
+    pos = pos / marker_pixel_step; //Real pixel 
+
+    portapack::display.fill_rectangle({0, 100, 240, 8}, Color::black()); //Clear old marker and whole marker rectangle btw
+    portapack::display.fill_rectangle({pos - 2, 100, 5, 3}, Color::red()); //Red marker middle
+    portapack::display.fill_rectangle({pos - 1, 103, 3, 3}, Color::red()); //Red marker middle
+    portapack::display.fill_rectangle({pos, 106, 1, 2}, Color::red()); //Red marker middle
+}
+
+GlassView::GlassView(
+    NavigationView &nav) : nav_(nav)
+{
+    baseband::run_image(portapack::spi_flash::image_tag_wideband_spectrum);
+
+    add_children({&labels,
+                  &field_frequency_min,
+                  &field_frequency_max,
+                  &field_lna,
+                  &field_vga,
+                  &text_range,
+                  &filter_config,
+                  &field_rf_amp,
+                  &range_presets,
+                  &field_marker,
+                  &text_marker_pm,
+                  &field_trigger
+                });
+
+    load_Presets(); //Load available presets from TXT files (or default)
+    
+    field_frequency_min.set_value(presets_db[0].min);   //Defaults to first preset
+    field_frequency_min.on_change = [this](int32_t v) {
+        if (v >= field_frequency_max.value())
+            field_frequency_max.set_value(v + 240);
+        this->on_range_changed();
+    };
+
+    field_frequency_max.set_value(presets_db[0].max);   //Defaults to first preset
+    field_frequency_max.on_change = [this](int32_t v) {
+        if (v <= field_frequency_min.value())
+            field_frequency_min.set_value(v - 240);
+        this->on_range_changed();
+    };
+
+    field_lna.set_value(receiver_model.lna());
+    field_lna.on_change = [this](int32_t v) {
+        this->on_lna_changed(v);
+    };
+
+    field_vga.set_value(receiver_model.vga());
+    field_vga.on_change = [this](int32_t v_db) {
+        this->on_vga_changed(v_db);
+    };
+
+    filter_config.set_selected_index(0);
+	filter_config.on_change = [this](size_t n, OptionsField::value_t v) {
+		min_color_power = v;
+	};
+
+	range_presets.on_change = [this](size_t n, OptionsField::value_t v) {
+		field_frequency_min.set_value(presets_db[v].min,false);
+        field_frequency_max.set_value(presets_db[v].max,false);
+        this->on_range_changed();
+	};
+
+    field_marker.on_change = [this](int32_t v) {
+        PlotMarker(v); //Refresh marker on screen
+    };
+
+    field_marker.on_select = [this](NumberField&) {
+        f_center = field_marker.value();
+        f_center = f_center * MHZ_DIV;
+        receiver_model.set_tuning_frequency(f_center); //Center tune rx in marker freq.
+        receiver_model.set_frequency_step(MHZ_DIV); // Preset a 1 MHz frequency step into RX -> AUDIO
+        nav_.pop();
+		nav_.push<AnalogAudioView>(); //Jump into audio view
+    };
+
+    field_trigger.set_value(32);   //Defaults to 32, as normal triggering resolution
+    field_trigger.on_change = [this](int32_t v) {
+        baseband::set_spectrum(SEARCH_SLICE_WIDTH, v);
+    };
+
+    display.scroll_set_area( 109, 319);
+    baseband::set_spectrum(SEARCH_SLICE_WIDTH, field_trigger.value());	//trigger:
+    // Discord User jteich:  WidebandSpectrum::on_message to set the trigger value. In WidebandSpectrum::execute ,
+    // it keeps adding the output of the fft to the buffer until "trigger" number of calls are made, 
+    //at which time it pushes the buffer up with channel_spectrum.feed
+
+    on_range_changed();
+
+    receiver_model.set_modulation(ReceiverModel::Mode::SpectrumAnalysis);
+	receiver_model.set_sampling_rate(SEARCH_SLICE_WIDTH); //20mhz
+    receiver_model.set_baseband_bandwidth(SEARCH_SLICE_WIDTH); // possible values: 1.75/2.5/3.5/5/5.5/6/7/8/9/10/12/14/15/20/24/28MHz
+    receiver_model.set_squelch_level(0);
+	receiver_model.enable();
+}
+
+void GlassView::load_Presets() {
+	File presets_file; 		//LOAD /WHIPCALC/ANTENNAS.TXT from microSD
+	auto result = presets_file.open("LOOKINGGLASS/PRESETS.TXT");
+	presets_db.clear();			//Start with fresh db
+	if (result.is_valid()) {
+		presets_Default(); 		//There is no txt, store a default range
+	} else {
+
+		std::string line;		//There is a txt file
+		char one_char[1];		//Read it char by char
+		for (size_t pointer=0; pointer < presets_file.size();pointer++) {
+			presets_file.seek(pointer);
+			presets_file.read(one_char, 1);
+			if ((int)one_char[0] > 31) {			//ascii space upwards
+				line += one_char[0];				//Add it to the textline
+			}
+			else if (one_char[0] == '\n') {			//New Line
+				txtline_process(line);				//make sense of this textline
+				line.clear();						//Ready for next textline
+			} 
+		}
+		if (line.length() > 0) txtline_process(line);	//Last line had no newline at end ?
+		if (!presets_db.size()) presets_Default();		//no antenna on txt, use default
+    }
+
+    populate_Presets();
+}
+
+void GlassView::txtline_process(std::string& line) 
+{
+	if (line.find("#") != std::string::npos) return;	//Line is just a comment
+
+	size_t comma = line.find(",");          //Get first comma position
+    if (comma == std::string::npos) return; //No comma at all
+
+	size_t previous = 0;
+	preset_entry new_preset;
+
+    new_preset.min = std::stoi(line.substr(0,comma));
+    if (!new_preset.min) return;    //No frequency!
+    
+    previous = comma + 1;
+    comma = line.find(",",previous);		//Search for next delimiter
+    if (comma == std::string::npos) return; //No comma at all
+
+    new_preset.max = std::stoi(line.substr(previous,comma - previous));
+    if (!new_preset.max) return;    //No frequency!
+
+    new_preset.label = line.substr(comma + 1);
+    if (new_preset.label.size() == 0) return; //No label ?
+    
+    presets_db.push_back(new_preset);   //Add this preset.
+}
+
+void GlassView::populate_Presets() 
+{
+    using option_t = std::pair<std::string, int32_t>;
+	using options_t = std::vector<option_t>;
+    options_t entries;
+
+	for (preset_entry preset : presets_db) 
+        {	//go thru all available presets
+            entries.emplace_back(preset.label,entries.size());
+        }
+    range_presets.set_options(entries);
+}
+
+void GlassView::presets_Default() 
+{
+        presets_db.clear();
+        presets_db.push_back({2320, 2560, "DEFAULT WIFI 2.4GHz"});
+}
+
+}

firmware/application/apps/ui_looking_glass_app.hpp

@@ -0,0 +1,183 @@
+/*
+  * 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.
+  */
+
+ #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 SEARCH_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();
+         std::string title() const override { return "Looking Glass"; };
+
+ 	    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 { SEARCH_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;
+
+        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:    (fft trigger)", Color::light_grey()}
+        };
+
+         NumberField field_frequency_min {
+             { 4 * 8, 0 * 16 },
+             4,
+             { 0, 6960 },
+             240,
+             ' '
+         };
+
+         NumberField field_frequency_max {
+             { 13 * 8, 0 * 16 },
+             4,
+             { 240, 7200 },
+             240,
+             ' '
+         };
+
+         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 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);
+ 				}
+ 			}
+ 		}
+ 	};
+
+     };
+ } 
+ 

firmware/application/apps/ui_scanner.cpp

@@ -21,6 +21,7 @@
  */
 
 #include "ui_scanner.hpp"
+#include "ui_fileman.hpp"
 
 using namespace portapack;
 
@@ -182,6 +183,7 @@ ScannerView::ScannerView(
 		&field_bw,
 		&field_squelch,
 		&field_wait,
+		&button_load,
 		&rssi,
 		&text_cycle,
 		&text_max,
@@ -211,6 +213,25 @@ ScannerView::ScannerView(
 	frequency_range.max = stored_freq + 1000000;
 	button_manual_end.set_text(to_string_short_freq(frequency_range.max));
 
+	button_load.on_select = [this, &nav](Button&) {
+		// load txt files from the FREQMAN folder
+		auto open_view = nav.push<FileLoadView>(".TXT");
+		open_view->on_changed = [this](std::filesystem::path new_file_path) {
+
+			std::string dir_filter = "FREQMAN/";
+			std::string str_file_path = new_file_path.string();
+
+			if (str_file_path.find(dir_filter) != string::npos) { // assert file from the FREQMAN folder
+				scan_pause();
+				// get the filename without txt extension so we can use load_freqman_file fcn
+				std::string str_file_name = new_file_path.stem().string();
+				frequency_file_load(str_file_name, true);
+			} else {
+				nav_.display_modal("LOAD ERROR", "A valid file from\nFREQMAN directory is\nrequired.");
+			}
+		};
+	};
+
 	button_manual_start.on_select = [this, &nav](Button& button) {
 		auto new_view = nav_.push<FrequencyKeypadView>(frequency_range.min);
 		new_view->on_changed = [this, &button](rf::Frequency f) {
@@ -314,7 +335,8 @@ ScannerView::ScannerView(
 
 	button_add.on_select = [this](Button&) {  //frequency_list[current_index]
 		File scanner_file;
-		auto result = scanner_file.open("FREQMAN/SCANNER.TXT");	//First search if freq is already in txt
+		std::string freq_file_path = "FREQMAN/" + loaded_file_name + ".TXT";
+		auto result = scanner_file.open(freq_file_path);	//First search if freq is already in txt
 		if (!result.is_valid()) {
 			std::string frequency_to_add = "f=" 
 				+ to_string_dec_uint(frequency_list[current_index] / 1000) 
@@ -342,12 +364,12 @@ ScannerView::ScannerView(
 				big_display.set(frequency_list[current_index]);		//After showing an error
 			}
 			else {
-				auto result = scanner_file.append("FREQMAN/SCANNER.TXT"); //Second: append if it is not there
+				auto result = scanner_file.append(freq_file_path); //Second: append if it is not there
 				scanner_file.write_line(frequency_to_add + ",d=ADD FQ");
 			}
 		} else
 		{
-			nav_.display_modal("Error", "Cannot open SCANNER.TXT\nfor appending freq.");
+			nav_.display_modal("Error", "Cannot open " + loaded_file_name + ".TXT\nfor appending freq.");
 			big_display.set(frequency_list[current_index]);		//After showing an error
 		}
 	};
@@ -357,22 +379,37 @@ ScannerView::ScannerView(
 	field_squelch.on_change = [this](int32_t v) {	squelch = v;	}; 	field_squelch.set_value(-10);
 	field_volume.set_value((receiver_model.headphone_volume() - audio::headphone::volume_range().max).decibel() + 99);
 	field_volume.on_change = [this](int32_t v) { this->on_headphone_volume_changed(v);	};
+
 	// LEARN FREQUENCIES
 	std::string scanner_txt = "SCANNER";
-	if ( load_freqman_file(scanner_txt, database)  ) {
+	frequency_file_load(scanner_txt);
+}
+
+void ScannerView::frequency_file_load(std::string file_name, bool stop_all_before) {
+
+	// stop everything running now if required
+	if (stop_all_before) {
+		scan_thread->stop();
+		frequency_list.clear(); // clear the existing frequency list (expected behavior)
+		description_list.clear();
+		def_step = step_mode.selected_index_value();		//Use def_step from manual selector
+	}
+
+	if ( load_freqman_file(file_name, database)  ) {
+		loaded_file_name = file_name; // keep loaded filename in memory
 		for(auto& entry : database) {									// READ LINE PER LINE
 			if (frequency_list.size() < MAX_DB_ENTRY) {					//We got space!
 				if (entry.type == RANGE)  {								//RANGE	
 					switch (entry.step) {
-					case AM_US:	def_step = 10000;  	break ;
-					case AM_EUR:def_step = 9000;  	break ;
-					case NFM_1: def_step = 12500;  	break ;
-					case NFM_2: def_step = 6250;	break ;	
-					case FM_1:	def_step = 100000; 	break ;
-					case FM_2:	def_step = 50000; 	break ;
-					case N_1:	def_step = 25000;  	break ;
-					case N_2:	def_step = 250000; 	break ;
-					case AIRBAND:def_step= 8330;  	break ;
+						case AM_US:	def_step = 10000;  	break ;
+						case AM_EUR:def_step = 9000;  	break ;
+						case NFM_1: def_step = 12500;  	break ;
+						case NFM_2: def_step = 6250;	break ;	
+						case FM_1:	def_step = 100000; 	break ;
+						case FM_2:	def_step = 50000; 	break ;
+						case N_1:	def_step = 25000;  	break ;
+						case N_2:	def_step = 250000; 	break ;
+						case AIRBAND:def_step= 8330;  	break ;
 					}
 					frequency_list.push_back(entry.frequency_a);		//Store starting freq and description
 					description_list.push_back("R" + to_string_short_freq(entry.frequency_a)
@@ -398,7 +435,8 @@ ScannerView::ScannerView(
 	} 
 	else 
 	{
-		desc_cycle.set(" NO SCANNER.TXT FILE ..." );
+		loaded_file_name = 'SCANNER'; // back to the default frequency file
+		desc_cycle.set(" NO " + file_name + ".TXT FILE ..." );
 	}
 	audio::output::stop();
 	step_mode.set_by_value(def_step); //Impose the default step into the manual step selector

firmware/application/apps/ui_scanner.hpp

@@ -126,6 +126,7 @@ private:
 	void scan_pause();
 	void scan_resume();
 	void user_resume();
+	void frequency_file_load(std::string file_name, bool stop_all_before = false);
 
 	void on_statistics_update(const ChannelStatistics& statistics);
 	void on_headphone_volume_changed(int32_t v);
@@ -137,6 +138,7 @@ private:
 	uint32_t wait { 0 };
 	size_t	def_step { 0 };
 	freqman_db database { };
+	std::string loaded_file_name;
 	uint32_t current_index { 0 };
 	bool userpause { false };
 	
@@ -278,6 +280,11 @@ private:
 		"ADD FQ"
 	};
 
+	Button button_load {
+		{ 24 * 8, 3 * 16 - 8, 6 * 8, 22 },
+		"Load"
+	};
+
 	Button button_remove {
 		{ 168, (35 * 8) - 4, 72, 28 },
 		"DEL FQ"

firmware/application/apps/ui_settings.cpp

@@ -144,6 +144,10 @@ SetRadioView::SetRadioView(
 	}
 
 	add_children({
+		&check_clkout,
+		&field_clkout_freq,
+		&labels_clkout_khz,
+		&value_freq_step,
 		&labels_bias,
 		&check_bias,
 		&button_done,
@@ -156,6 +160,39 @@ SetRadioView::SetRadioView(
 
 	form_init(model);
 
+	check_clkout.set_value(portapack::persistent_memory::clkout_enabled());
+	check_clkout.on_select = [this](Checkbox&, bool v) {
+		clock_manager.enable_clock_output(v);
+		portapack::persistent_memory::set_clkout_enabled(v);
+		StatusRefreshMessage message { };
+		EventDispatcher::send_message(message);
+	};
+
+	field_clkout_freq.set_value(portapack::persistent_memory::clkout_freq());
+	value_freq_step.set_style(&style_text);
+
+	field_clkout_freq.on_select = [this](NumberField&) {
+		freq_step_khz++;
+		if(freq_step_khz > 3) {
+			freq_step_khz = 0;
+		}
+		switch(freq_step_khz) {
+			case 0:
+				value_freq_step.set("   |");
+				break;
+			case 1:
+				value_freq_step.set("  | ");
+				break;
+			case 2:
+				value_freq_step.set(" |  ");
+				break;
+			case 3:
+				value_freq_step.set("|   ");
+				break;
+		}
+		field_clkout_freq.set_step(pow(10, freq_step_khz));
+	};
+
 	check_bias.set_value(portapack::get_antenna_bias());
 	check_bias.on_select = [this](Checkbox&, bool v) {
 		portapack::set_antenna_bias(v);
@@ -166,6 +203,8 @@ SetRadioView::SetRadioView(
 	button_done.on_select = [this, &nav](Button&){
 		const auto model = this->form_collect();
 		portapack::persistent_memory::set_correction_ppb(model.ppm * 1000);
+		portapack::persistent_memory::set_clkout_freq(model.freq);
+		clock_manager.enable_clock_output(portapack::persistent_memory::clkout_enabled());
 		nav.pop();
 	};
 }
@@ -181,6 +220,7 @@ void SetRadioView::form_init(const SetFrequencyCorrectionModel& model) {
 SetFrequencyCorrectionModel SetRadioView::form_collect() {
 	return {
 		.ppm = static_cast<int8_t>(field_ppm.value()),
+		.freq = static_cast<uint32_t>(field_clkout_freq.value()),
 	};
 }
 

firmware/application/apps/ui_settings.hpp

@@ -114,6 +114,7 @@ private:
 
 struct SetFrequencyCorrectionModel {
 	int8_t ppm;
+	uint32_t freq;
 };
 
 class SetRadioView : public View {
@@ -130,6 +131,7 @@ private:
 		.background = Color::black(),
 		.foreground = Color::light_grey(),
 	};
+	uint8_t freq_step_khz = 3;
 
 	Text label_source {
 		{ 0, 1 * 16, 17 * 8, 16 },
@@ -147,8 +149,31 @@ private:
 	};
 
 	Labels labels_correction {
-		{ { 2 * 8, 4 * 16 }, "Frequency correction:", Color::light_grey() },
-		{ { 6 * 8, 5 * 16 }, "PPM", Color::light_grey() },
+		{ { 2 * 8, 3 * 16 }, "Frequency correction:", Color::light_grey() },
+		{ { 6 * 8, 4 * 16 }, "PPM", Color::light_grey() },
+	};
+
+	Checkbox check_clkout {
+		{ 18, (6 * 16 - 4) },
+		13,
+		"Enable CLKOUT"
+	};
+
+	NumberField field_clkout_freq {
+		{ 20 * 8, 6 * 16 },
+		5,
+		{ 10, 60000 },
+		1000,
+		' '
+	};
+
+	Labels labels_clkout_khz {
+		{ { 26 * 8, 6 * 16 }, "kHz", Color::light_grey() }
+	};
+
+	Text value_freq_step {
+		{ 21 * 8, (7 * 16 ), 4 * 8, 16 },
+		"|   "
 	};
 
 	Labels labels_bias {
@@ -159,7 +184,7 @@ private:
 	};
 
 	NumberField field_ppm {
-		{ 2 * 8, 5 * 16 },
+		{ 2 * 8, 4 * 16 },
 		3,
 		{ -50, 50 },
 		1,

firmware/application/clock_manager.cpp

@@ -21,6 +21,7 @@
 
 #include "clock_manager.hpp"
 
+#include "portapack_persistent_memory.hpp"
 #include "portapack_io.hpp"
 
 #include "hackrf_hal.hpp"
@@ -463,3 +464,21 @@ void ClockManager::stop_audio_pll() {
 	cgu::pll0audio::power_down();
 	while( cgu::pll0audio::is_locked() );
 }
+
+void ClockManager::enable_clock_output(bool enable) {
+	if(enable) {
+		clock_generator.enable_output(clock_generator_output_clkout);
+		if(portapack::persistent_memory::clkout_freq() < 1000) {
+			clock_generator.set_ms_frequency(clock_generator_output_clkout, portapack::persistent_memory::clkout_freq() * 128000, si5351_vco_f, 7);
+		} else {
+			clock_generator.set_ms_frequency(clock_generator_output_clkout, portapack::persistent_memory::clkout_freq() * 1000, si5351_vco_f, 0);
+		}
+	} else {
+		clock_generator.disable_output(clock_generator_output_clkout);
+	}
+
+	if(enable)
+		clock_generator.set_clock_control(clock_generator_output_clkout, si5351_clock_control_common[clock_generator_output_clkout].ms_src(get_reference_clock_generator_pll(reference.source)).clk_pdn(ClockControl::ClockPowerDown::Power_On));
+	else
+		clock_generator.set_clock_control(clock_generator_output_clkout, ClockControl::power_off());
+}

firmware/application/clock_manager.hpp

@@ -79,6 +79,8 @@ public:
 
 	Reference get_reference() const;
 
+	void enable_clock_output(bool enable);
+
 private:
 	I2C& i2c0;
 	si5351::Si5351& clock_generator;

firmware/application/protocols/aprs.cpp

@@ -38,9 +38,13 @@ void make_aprs_frame(const char * src_address, const uint32_t src_ssid,
 	char address[14] = { 0 };
 	
 	memcpy(&address[0], dest_address, 6);
-	address[6] = (dest_ssid & 15) << 1;
 	memcpy(&address[7], src_address, 6);
-	address[13] = (src_ssid & 15) << 1;
+	//euquiq: According to ax.25 doc section 2.2.13.x.x and 2.4.1.2
+	// SSID need bits 5.6 set, so later when shifted it will end up being 011xxxx0 (xxxx = SSID number)
+	// Notice that if need to signal usage of AX.25 V2.0, (dest_ssid | 112); (MSb will need to be set at the end)
+	address[6] = (dest_ssid | 48); 
+	address[13] = (src_ssid | 48);
+
 	
 	frame.make_ui_frame(address, 0x03, protocol_id_t::NO_LAYER3, payload);
 }

firmware/application/protocols/ax25.cpp

@@ -51,32 +51,37 @@ void AX25Frame::NRZI_add_bit(const uint32_t bit) {
 	}
 }
 
-void AX25Frame::add_byte(uint8_t byte, bool is_flag, bool is_data) {
-	uint32_t bit;
+void AX25Frame::add_byte(uint8_t byte, bool is_flag, bool is_data)
+{
+	bool bit;
 
 	if (is_data)
 		crc_ccitt.process_byte(byte);
 
-	for (uint32_t i = 0; i < 8; i++) {
+	for (uint32_t i = 0; i < 8; i++)
+	{
 		bit = (byte >> i) & 1;
 
+		NRZI_add_bit(bit);
+
 		if (bit)
+		{
 			ones_counter++;
+			if ((ones_counter == 5) && (!is_flag))
+			{
+				NRZI_add_bit(0);
+				ones_counter = 0;
+			}
+		}
 		else
 			ones_counter = 0;
-		
-		if ((ones_counter == 6) && (!is_flag)) {
-			NRZI_add_bit(0);
-			ones_counter = 0;
-		}
-		
-		NRZI_add_bit(bit);
 	}
 }
 
-void AX25Frame::flush() {
+void AX25Frame::flush()
+{
 	if (bit_counter)
-		*bb_data_ptr = current_byte << (7 - bit_counter);
+		*bb_data_ptr = current_byte << (8 - bit_counter); //euquiq: This was 7 but there are 8 bits
 };
 
 void AX25Frame::add_flag() {

firmware/application/ui_navigation.cpp

@@ -81,7 +81,7 @@
 #include "tpms_app.hpp"
 
 #include "core_control.hpp"
-
+#include "ui_looking_glass_app.hpp"
 #include "file.hpp"
 #include "png_writer.hpp"
 
@@ -113,7 +113,7 @@ SystemStatusView::SystemStatusView(
 		&button_camera,
 		&button_sleep,
 		&button_bias_tee,
-		&image_clock_status,
+		&button_clock_status,
 		&sd_card_status_view,
 	});
 	
@@ -168,6 +168,10 @@ SystemStatusView::SystemStatusView(
 		DisplaySleepMessage message;
 		EventDispatcher::send_message(message);
 	};
+
+	button_clock_status.on_select = [this](ImageButton&) {
+		this->on_clk();
+	};
 }
 
 void SystemStatusView::refresh() {
@@ -188,11 +192,16 @@ void SystemStatusView::refresh() {
 	}
 	
 	if (portapack::clock_manager.get_reference().source == ClockManager::ReferenceSource::External) {
-		image_clock_status.set_bitmap(&bitmap_icon_clk_ext);
-		button_bias_tee.set_foreground(ui::Color::green());
+		button_clock_status.set_bitmap(&bitmap_icon_clk_ext);
+//		button_bias_tee.set_foreground(ui::Color::green());   Typo?
 	} else {
-		image_clock_status.set_bitmap(&bitmap_icon_clk_int);
-		button_bias_tee.set_foreground(ui::Color::light_grey());
+		button_clock_status.set_bitmap(&bitmap_icon_clk_int);
+//		button_bias_tee.set_foreground(ui::Color::green());
+	}
+	if(portapack::persistent_memory::clkout_enabled()) {
+		button_clock_status.set_foreground(ui::Color::green());
+	} else {
+		button_clock_status.set_foreground(ui::Color::light_grey());
 	}
 	
 	set_dirty();
@@ -302,6 +311,18 @@ void SystemStatusView::on_camera() {
 	}
 }
 
+void SystemStatusView::on_clk() {
+	bool v = portapack::persistent_memory::clkout_enabled();
+	if(v) {
+		v = false;
+	} else {
+		v = true;
+	}
+	portapack::clock_manager.enable_clock_output(v);
+	portapack::persistent_memory::set_clkout_enabled(v);
+	refresh();
+}
+
 void SystemStatusView::on_title() {
 	if(nav_.is_top())
 		nav_.push<AboutView>();
@@ -464,7 +485,7 @@ TransmittersMenuView::TransmittersMenuView(NavigationView& nav) {
 	add_items({
 		//{ "..",				ui::Color::light_grey(),&bitmap_icon_previous,	[&nav](){ nav.pop(); } },
 		{ "ADS-B [S]",		ui::Color::yellow(), 	&bitmap_icon_adsb,		[&nav](){ nav.push<ADSBTxView>(); } },
-		{ "APRS", 			ui::Color::orange(),	&bitmap_icon_aprs,		[&nav](){ nav.push<APRSTXView>(); } },
+		{ "APRS", 			ui::Color::green(),		&bitmap_icon_aprs,		[&nav](){ nav.push<APRSTXView>(); } },
 		{ "BHT Xy/EP", 		ui::Color::green(), 	&bitmap_icon_bht,		[&nav](){ nav.push<BHTView>(); } },
 		{ "GPS Sim",		ui::Color::yellow(),	&bitmap_icon_gps_sim,		[&nav](){ nav.push<GpsSimAppView>(); } },
 		{ "Jammer", 		ui::Color::yellow(),	&bitmap_icon_jammer,	[&nav](){ nav.push<JammerView>(); } },
@@ -522,8 +543,9 @@ SystemMenuView::SystemMenuView(NavigationView& nav) {
 		{ "Capture",	ui::Color::red(),			&bitmap_icon_capture,	[&nav](){ nav.push<CaptureAppView>(); } },
 		{ "Replay",		ui::Color::green(),			&bitmap_icon_replay,	[&nav](){ nav.push<ReplayAppView>(); } },
 		{ "Calls",		ui::Color::yellow(),	    &bitmap_icon_search,	[&nav](){ nav.push<SearchView>(); } },
-		{ "Scanner",	ui::Color::green(),			&bitmap_icon_scanner,	[&nav](){ nav.push<ScannerView>(); } },
+		{ "Scanner",	ui::Color::yellow(),			&bitmap_icon_scanner,	[&nav](){ nav.push<ScannerView>(); } },
 		{ "Microphone",	ui::Color::yellow(),		&bitmap_icon_microphone,[&nav](){ nav.push<MicTXView>(); } },
+		{ "Looking Glass",	ui::Color::yellow(),		&bitmap_icon_looking,	[&nav](){ nav.push<GlassView>(); } },
 		{ "Tools",		ui::Color::cyan(),			&bitmap_icon_utilities,	[&nav](){ nav.push<UtilitiesMenuView>(); } },
 		{ "Options", 	ui::Color::cyan(),			&bitmap_icon_setup,	  	[&nav](){ nav.push<SettingsMenuView>(); } },
 		{ "Debug",		ui::Color::light_grey(),	&bitmap_icon_debug,		[&nav](){ nav.push<DebugMenuView>(); } },

firmware/application/ui_navigation.hpp

@@ -180,7 +180,7 @@ private:
 		Color::dark_grey()
 	};
 	
-	Image image_clock_status {
+	ImageButton button_clock_status {
 		{ 27 * 8, 0 * 16,  2 * 8, 1 * 16 },
 		&bitmap_icon_clk_int,
 		Color::light_grey(),
@@ -198,6 +198,7 @@ private:
 	void on_camera();
 	void on_title();
 	void refresh();
+	void on_clk();
 	
 	MessageHandlerRegistration message_handler_refresh {
 		Message::ID::StatusRefresh,
@@ -213,7 +214,7 @@ public:
 	InformationView(NavigationView& nav);
 	
 private:
-	static constexpr auto version_string = "v1.2.3";
+	static constexpr auto version_string = "v1.3.0";
 	NavigationView& nav_;
 
 	Rectangle backdrop {

firmware/common/portapack_persistent_memory.cpp

@@ -63,6 +63,10 @@ using modem_repeat_range_t = range_t<int32_t>;
 constexpr modem_repeat_range_t modem_repeat_range { 1, 99 };
 constexpr int32_t modem_repeat_reset_value { 5 };
 
+using clkout_freq_range_t = range_t<uint32_t>;
+constexpr clkout_freq_range_t clkout_freq_range { 10, 60000 };
+constexpr uint32_t clkout_freq_reset_value { 10000 };
+
 /* struct must pack the same way on M4 and M0 cores. */
 struct data_t {
 	int64_t tuned_frequency;
@@ -287,5 +291,28 @@ void set_pocsag_ignore_address(uint32_t address) {
 	data->pocsag_ignore_address = address;
 }
 
+bool clkout_enabled() {
+	return (data->ui_config & 0x08000000UL);
+}
+
+void set_clkout_enabled(bool enable) {
+	data->ui_config = (data->ui_config & ~0x08000000UL) | (enable << 27);
+}
+
+uint32_t clkout_freq() {
+	uint16_t freq = (data->ui_config & 0x000FFFF0) >> 4;
+	if(freq < clkout_freq_range.minimum || freq > clkout_freq_range.maximum) {
+		data->ui_config = (data->ui_config & ~0x000FFFF0) | clkout_freq_reset_value << 4;
+		return clkout_freq_reset_value;
+	}
+	else {
+		return freq;
+	}
+}
+
+void set_clkout_freq(uint32_t freq) {
+	data->ui_config = (data->ui_config & ~0x000FFFF0) | (clkout_freq_range.clip(freq) << 4);
+}
+
 } /* namespace persistent_memory */
 } /* namespace portapack */

firmware/common/portapack_persistent_memory.hpp

@@ -93,6 +93,11 @@ void set_pocsag_last_address(uint32_t address);
 uint32_t pocsag_ignore_address();
 void set_pocsag_ignore_address(uint32_t address);
 
+bool clkout_enabled();
+void set_clkout_enabled(bool enable);
+uint32_t clkout_freq();
+void set_clkout_freq(uint32_t freq);
+
 } /* namespace persistent_memory */
 } /* namespace portapack */
 

firmware/tools/generate_world_map.bin.py

@@ -33,6 +33,8 @@ pix = im.load()
 outfile.write(struct.pack('H', im.size[0]))
 outfile.write(struct.pack('H', im.size[1]))
 
+print("Generating: \t" + outfile.name + "\n from\t\t" + im.filename + "\n please wait...");
+
 for y in range (0, im.size[1]):
 	line = ''
 	for x in range (0, im.size[0]):
@@ -45,6 +47,8 @@ for y in range (0, im.size[1]):
 		# pixel_lcd = (pix[x, y][0] >> 5) << 5
 		# pixel_lcd |= (pix[x, y][1] >> 5) << 2
 		# pixel_lcd |= (pix[x, y][2] >> 6)
-		line += struct.pack('H', pixel_lcd)
-	outfile.write(line)
+		line += str(struct.pack('H', pixel_lcd))
+	outfile.write(line.encode('utf-8'))
 	print(str(y) + '/' + str(im.size[1]) + '\r', end="")
+
+print("Ready.");

sdcard/FREQMAN/TIMEFREQ.TXT

@@ -0,0 +1,14 @@
+f=2500000,d=WWV/BPM 2 MHz
+f=5000000,d=WWV/BPM 5 MHz
+f=10000000,d=WWV/BPM 10 MHz
+f=15000000,d=WWV/BPM 15 MHz
+f=20000000,d=WWV 20 MHz
+f=3300000,d=CHU 3 MHz
+f=7850000,d=CHU 7 MHz
+f=14670000,d=CHU 14 MHz
+f=3810000,d=HD2IOA 3 MHz
+f=4996000,d=RWM 4 MHz
+f=9996000,d=RWM 9 MHz
+f=14996000,d=RWM 14 MHz
+f=4998000,d=EBC 4 MHz
+f=15006000,d=EBC 15 MHz

sdcard/LOOKINGGLASS/PRESETS.TXT

@@ -0,0 +1,11 @@
+# INI,END,DESCRIPTION 
+# (Freq range in MHz, min separation 240MHz)
+# (Description up to 20 char)
+# (fields comma delimiter)
+260,500,315/433 MHz KEYFOBS
+2320,2560,BL / WIFI 2.4GHz
+5160,5900,WIFI 5GHz
+10,7250,FULL RANGE
+140,380,VHF MICS AND MARINE
+390,420,RADIOSONDES
+420,660,UHF MICS