Merge pull request #915 from gullradriel/recon-update

Recon description flashing on range fix

CMakeLists.txt

@@ -45,7 +45,7 @@ endif()
 set(LICENSE_PATH ${CMAKE_CURRENT_LIST_DIR}/LICENSE)
 set(HARDWARE_PATH ${CMAKE_CURRENT_LIST_DIR}/hardware)
 
-add_subdirectory(hackrf/firmware/hackrf_usb)
+add_subdirectory(hackrf-portapack)
 
 set(HACKRF_FIRMWARE_DFU_FILENAME hackrf_usb.dfu)
 set(HACKRF_FIRMWARE_BIN_FILENAME hackrf_usb_ram.bin)

README.md

@@ -39,7 +39,7 @@ The current **stable release** is on the [![GitHub release (latest by date)](htt
 ## How can I collaborate
 You can write [documentation](https://github.com/eried/portapack-mayhem/wiki), fix bugs and [answer issues](https://github.com/eried/portapack-mayhem/issues) or add new functionality. Please check the following [guide](https://github.com/eried/portapack-mayhem/wiki/How-to-collaborate) with details.
 
-Consider that the hardware and firmware has been created and maintain by a [lot](https://github.com/mossmann/hackrf/graphs/contributors) of [people](https://github.com/eried/portapack-mayhem/graphs/contributors), so always try colaborating your time and effort first. For coding related questions, if something does not fit as an issue, please join our Discord by clicking the chat badge on [top](#portapack-mayhem).
+Consider that the hardware and firmware has been created and maintain by a [lot](https://github.com/mossmann/hackrf/graphs/contributors) of [people](https://github.com/eried/portapack-mayhem/graphs/contributors), so always try collaborating your time and effort first. For coding related questions, if something does not fit as an issue, please join our Discord by clicking the chat badge on [top](#portapack-mayhem).
 
 [![Contributors](https://contrib.rocks/image?repo=eried/portapack-mayhem)](https://github.com/eried/portapack-mayhem/graphs/contributors)
 

firmware/application/CMakeLists.txt

@@ -155,6 +155,7 @@ set(CPPSRC
 	${COMMON}/ui_widget.cpp
 	${COMMON}/utility.cpp
 	${COMMON}/wm8731.cpp
+	${COMMON}/performance_counter.cpp
 	app_settings.cpp
 	audio.cpp
 	baseband_api.cpp
@@ -230,6 +231,7 @@ set(CPPSRC
 	apps/ui_nrf_rx.cpp
 	apps/ui_aprs_tx.cpp
 	apps/ui_bht_tx.cpp
+	apps/ui_dfu_menu.cpp
 	apps/ui_coasterp.cpp
 	apps/ui_debug.cpp
 	apps/ui_encoders.cpp

firmware/application/apps/analog_audio_app.hpp

@@ -117,6 +117,7 @@ private:
 			{ " 2m ", 2000000 },
 			{ " 1m ", 1000000 },
 			{ "500k", 500000 },
+			{ "100k", 100000 },
 		}
 	};
 	

firmware/application/apps/replay_app.cpp

@@ -161,10 +161,16 @@ void ReplayAppView::start() {
 		sample_rate * 8,
 		baseband_bandwidth,
 		rf::Direction::Transmit,
-        rf_amp,         //  previous code line : "receiver_model.rf_amp()," was passing the same rf_amp of all Receiver Apps  
+		rf_amp,         //  previous code line : "receiver_model.rf_amp()," was passing the same rf_amp of all Receiver Apps  
 		static_cast<int8_t>(receiver_model.lna()),
 		static_cast<int8_t>(receiver_model.vga())
 	});  
+	
+	if (portapack::persistent_memory::stealth_mode()){
+		DisplaySleepMessage message;
+		EventDispatcher::send_message(message);
+	}
+	
 } 
 
 void ReplayAppView::stop(const bool do_loop) {

firmware/application/apps/tpms_app.cpp

@@ -35,6 +35,7 @@ namespace tpms {
 namespace format {
 
 static bool use_kpa = true;
+static bool use_celsius = true;
 
 std::string type(Reading::Type type) {
 	return to_string_dec_uint(toUType(type), 2);
@@ -45,15 +46,11 @@ std::string id(TransponderID id) {
 }
 
 std::string pressure(Pressure pressure) {
-	if(use_kpa){
-		return to_string_dec_int(pressure.kilopascal(), 3);
-	}
-	return to_string_dec_int(pressure.psi(), 3);
-	
+	return to_string_dec_int(use_kpa? pressure.kilopascal():pressure.psi(), 3);
 }
 
 std::string temperature(Temperature temperature) {
-	return to_string_dec_int(temperature.celsius(), 3);
+	return to_string_dec_int(use_celsius? temperature.celsius():temperature.fahrenheit(), 3);
 }
 
 std::string flags(Flags flags) {
@@ -111,15 +108,15 @@ void RecentEntriesTable<TPMSRecentEntries>::draw(
 	std::string line = tpms::format::type(entry.type) + " " + tpms::format::id(entry.id);
 
 	if( entry.last_pressure.is_valid() ) {
-		line += " " + tpms::format::pressure(entry.last_pressure.value());
+		line += "  " + tpms::format::pressure(entry.last_pressure.value());
 	} else {
-		line += " " "   ";
+		line += "  " "   ";
 	}
 
 	if( entry.last_temperature.is_valid() ) {
-		line += " " + tpms::format::temperature(entry.last_temperature.value());
+		line += "  " + tpms::format::temperature(entry.last_temperature.value());
 	} else {
-		line += " " "   ";
+		line += "  " "   ";
 	}
 
 	if( entry.received_count > 999 ) {
@@ -145,10 +142,12 @@ TPMSAppView::TPMSAppView(NavigationView&) {
 		&rssi,
 		&channel,
 		&options_band,
+		&options_pressure,
+		&options_temperature,	
 		&field_rf_amp,
 		&field_lna,
 		&field_vga,
-		&options_type,
+		&recent_entries_view
 	});
 
 	// load app settings
@@ -181,16 +180,19 @@ TPMSAppView::TPMSAppView(NavigationView&) {
 	};
 	options_band.set_by_value(target_frequency());
 
-	options_type.on_change = [this](size_t, int32_t i) {		
-		if (i == 0){
-			tpms::format::use_kpa = true;
-		} else if (i == 1){
-			tpms::format::use_kpa = false;
-		}	
-		update_type();
+	options_pressure.on_change = [this](size_t, int32_t i) {		
+		tpms::format::use_kpa = !i;
+		update_view();
 	};
 
-	options_type.set_selected_index(0, true);
+	options_pressure.set_selected_index(0, true);
+
+	options_temperature.on_change = [this](size_t, int32_t i) {		
+		tpms::format::use_celsius = !i;
+		update_view();
+	};
+
+	options_temperature.set_selected_index(0, true);
 
 	logger = std::make_unique<TPMSLogger>();
 	if( logger ) {
@@ -214,16 +216,8 @@ void TPMSAppView::focus() {
 	options_band.focus();
 }
 
-void TPMSAppView::update_type() {
-	if (tpms::format::use_kpa){
-		remove_child(&recent_entries_view_psi);
-		add_child(&recent_entries_view_kpa);
-		recent_entries_view_kpa.set_parent_rect(view_normal_rect);
-	} else {
-		remove_child(&recent_entries_view_kpa);
-		add_child(&recent_entries_view_psi);
-		recent_entries_view_psi.set_parent_rect(view_normal_rect);
-	}	
+void TPMSAppView::update_view() {
+	recent_entries_view.set_parent_rect(view_normal_rect);
 }
 
 void TPMSAppView::set_parent_rect(const Rect new_parent_rect) {
@@ -231,7 +225,7 @@ void TPMSAppView::set_parent_rect(const Rect new_parent_rect) {
 
 	view_normal_rect  = { 0, header_height, new_parent_rect.width(), new_parent_rect.height() - header_height };
 
-	update_type();
+	update_view();
 }
 
 void TPMSAppView::on_packet(const tpms::Packet& packet) {
@@ -244,23 +238,13 @@ void TPMSAppView::on_packet(const tpms::Packet& packet) {
 		const auto reading = reading_opt.value();
 		auto& entry = ::on_packet(recent, TPMSRecentEntry::Key { reading.type(), reading.id() });
 		entry.update(reading);
-		
-		if(tpms::format::use_kpa){
-			recent_entries_view_kpa.set_dirty();
-		} else {
-			recent_entries_view_psi.set_dirty();
-		}
+		recent_entries_view.set_dirty();
 	}
 }
 
 void TPMSAppView::on_show_list() {
-	if(tpms::format::use_kpa){
-		recent_entries_view_kpa.hidden(false);
-		recent_entries_view_kpa.focus();
-	} else {
-		recent_entries_view_psi.hidden(false);
-		recent_entries_view_psi.focus();
-	}
+	recent_entries_view.hidden(false);
+	recent_entries_view.focus();
 }
 
 void TPMSAppView::on_band_changed(const uint32_t new_band_frequency) {

firmware/application/apps/tpms_app.hpp

@@ -144,7 +144,7 @@ private:
 		}
 	};
 
-	OptionsField options_type {
+	OptionsField options_pressure {
 		{ 5 * 8, 0 * 16 },
 		3,
 		{
@@ -153,6 +153,15 @@ private:
 		}
 	};
 
+	OptionsField options_temperature {
+		{ 9 * 8, 0 * 16 },
+		1,
+		{
+			{ "C", 0 },
+			{ "F", 1 }
+		}
+	};
+
 	RFAmpField field_rf_amp {
 		{ 13 * 8, 0 * 16 }
 	};
@@ -168,31 +177,21 @@ private:
 	TPMSRecentEntries recent { };
 	std::unique_ptr<TPMSLogger> logger { };
 
-	const RecentEntriesColumns columns_kpa { {
+	const RecentEntriesColumns columns { {
 		{ "Tp", 2 },
 		{ "ID", 8 },
-		{ "kPa", 3 },
-		{ "C", 3 },
+		{ "Pres", 4 },
+		{ "Temp", 4 },
 		{ "Cnt", 3 },
 		{ "Fl", 2 },
 	} };
-	TPMSRecentEntriesView recent_entries_view_kpa { columns_kpa, recent };
-
-	const RecentEntriesColumns columns_psi { {
-		{ "Tp", 2 },
-		{ "ID", 8 },
-		{ "PSI", 3 },
-		{ "C", 3 },
-		{ "Cnt", 3 },
-		{ "Fl", 2 },
-	} };
-	TPMSRecentEntriesView recent_entries_view_psi { columns_psi, recent };
+	TPMSRecentEntriesView recent_entries_view { columns, recent };
 
 	uint32_t target_frequency_ = initial_target_frequency;
 
 	void on_packet(const tpms::Packet& packet);
 	void on_show_list();
-	void update_type();
+	void update_view();
 
 	void on_band_changed(const uint32_t new_band_frequency);
 

firmware/application/apps/ui_debug.cpp

@@ -266,7 +266,9 @@ bool ControlsSwitchesWidget::on_key(const KeyEvent key) {
 }
 
 void ControlsSwitchesWidget::paint(Painter& painter) {
-	const std::array<Rect, 7> button_rects { {
+	const auto pos = screen_pos();
+
+	const std::array<Rect, 8> button_rects { {
 		{ 64, 32, 16, 16 }, // Right
 		{  0, 32, 16, 16 }, // Left
 		{ 32, 64, 16, 16 }, // Down
@@ -274,27 +276,63 @@ void ControlsSwitchesWidget::paint(Painter& painter) {
 		{ 32, 32, 16, 16 }, // Select
 		{ 16, 96, 16, 16 }, // Encoder phase 0
 		{ 48, 96, 16, 16 }, // Encoder phase 1
+		{ 96,  0, 16, 16 }, // Dfu
 	} };
-	const auto pos = screen_pos();
-	auto switches_raw = control::debug::switches();
-	auto switches_debounced = get_switches_state().to_ulong();
-	auto switches_event = key_event_mask;
 
 	for(const auto r : button_rects) {
-		const auto c =
-			((switches_event & 1) ?
-				Color::red() :
-				((switches_debounced & 1) ?
-					Color::green() :
-					((switches_raw & 1) ?
-						Color::yellow() :
-						Color::blue()
-					)
-				)
-			);
-		painter.fill_rectangle(r + pos, c);
+		painter.fill_rectangle(r + pos, Color::blue());
+	}
+
+	const std::array<Rect, 8> raw_rects { {
+		{ 64 + 1, 32 + 1, 16 - 2, 16 - 2 }, // Right
+		{  0 + 1, 32 + 1, 16 - 2, 16 - 2 }, // Left
+		{ 32 + 1, 64 + 1, 16 - 2, 16 - 2 }, // Down
+		{ 32 + 1,  0 + 1, 16 - 2, 16 - 2 }, // Up
+		{ 32 + 1, 32 + 1, 16 - 2, 16 - 2 }, // Select
+		{ 16 + 1, 96 + 1, 16 - 2, 16 - 2 }, // Encoder phase 0
+		{ 48 + 1, 96 + 1, 16 - 2, 16 - 2 }, // Encoder phase 1
+		{ 96 + 1,  0 + 1, 16 - 2, 16 - 2 }, // Dfu
+	} };
+
+	auto switches_raw = control::debug::switches();
+	for(const auto r : raw_rects) {
+		if (switches_raw & 1)
+			painter.fill_rectangle(r + pos, Color::yellow());
+
 		switches_raw >>= 1;
+	}
+
+	const std::array<Rect, 6> debounced_rects { {
+		{ 64 + 2, 32 + 2, 16 - 4, 16 - 4 }, // Right
+		{  0 + 2, 32 + 2, 16 - 4, 16 - 4 }, // Left
+		{ 32 + 2, 64 + 2, 16 - 4, 16 - 4 }, // Down
+		{ 32 + 2,  0 + 2, 16 - 4, 16 - 4 }, // Up
+		{ 32 + 2, 32 + 2, 16 - 4, 16 - 4 }, // Select
+		{ 96 + 2,  0 + 2, 16 - 4, 16 - 4 }, // Dfu
+	} };
+
+	auto switches_debounced = get_switches_state().to_ulong();
+	for(const auto r : debounced_rects) {
+		if (switches_debounced & 1)
+			painter.fill_rectangle(r + pos, Color::green());
+
 		switches_debounced >>= 1;
+	}
+
+	const std::array<Rect, 6> events_rects { {
+		{ 64 + 3, 32 + 3, 16 - 6, 16 - 6 }, // Right
+		{  0 + 3, 32 + 3, 16 - 6, 16 - 6 }, // Left
+		{ 32 + 3, 64 + 3, 16 - 6, 16 - 6 }, // Down
+		{ 32 + 3,  0 + 3, 16 - 6, 16 - 6 }, // Up
+		{ 32 + 3, 32 + 3, 16 - 6, 16 - 6 }, // Select
+		{ 96 + 3,  0 + 3, 16 - 6, 16 - 6 }, // Dfu
+	} };
+
+	auto switches_event = key_event_mask;
+	for(const auto r : events_rects) {
+		if (switches_event & 1)
+			painter.fill_rectangle(r + pos, Color::red());
+
 		switches_event >>= 1;
 	}
 }

firmware/application/apps/ui_dfu_menu.cpp

@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * 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_dfu_menu.hpp"
+#include "portapack_shared_memory.hpp"
+#include "performance_counter.hpp"
+
+namespace ui {
+
+DfuMenu::DfuMenu(NavigationView& nav) : nav_ (nav) {
+	add_children({
+		&text_head,
+		&labels,
+		&text_info_line_1,
+		&text_info_line_2,
+		&text_info_line_3,
+		&text_info_line_4,
+		&text_info_line_5,
+		&text_info_line_6,
+		&text_info_line_7
+	});
+}
+
+void DfuMenu::paint(Painter& painter) {
+	auto utilisation = get_cpu_utilisation_in_percent();
+
+	text_info_line_1.set(to_string_dec_uint(chCoreStatus(), 6));
+	text_info_line_2.set(to_string_dec_uint((uint32_t)get_free_stack_space(), 6));
+	text_info_line_3.set(to_string_dec_uint(utilisation, 6));
+	text_info_line_4.set(to_string_dec_uint(shared_memory.m4_heap_usage, 6));
+	text_info_line_5.set(to_string_dec_uint(shared_memory.m4_stack_usage, 6));
+	text_info_line_6.set(to_string_dec_uint(shared_memory.m4_cpu_usage, 6));
+	text_info_line_7.set(to_string_dec_uint(chTimeNow()/1000, 6));
+
+	constexpr auto margin = 5;
+
+	painter.fill_rectangle(
+		{
+			{6 * CHARACTER_WIDTH - margin, 3 * LINE_HEIGHT - margin},
+			{15 * CHARACTER_WIDTH + margin * 2, 9 * LINE_HEIGHT + margin * 2}
+		},
+		ui::Color::black()
+	);
+
+	painter.fill_rectangle(
+		{
+			{5 * CHARACTER_WIDTH - margin, 3 * LINE_HEIGHT - margin},
+			{CHARACTER_WIDTH, 9 * LINE_HEIGHT + margin * 2}
+		},
+		ui::Color::dark_cyan()
+	);
+
+	painter.fill_rectangle(
+		{
+			{21 * CHARACTER_WIDTH + margin, 3 * LINE_HEIGHT - margin},
+			{CHARACTER_WIDTH, 9 * LINE_HEIGHT + margin * 2}
+		},
+		ui::Color::dark_cyan()
+	);
+
+	painter.fill_rectangle(
+		{
+			{5 * CHARACTER_WIDTH - margin, 3 * LINE_HEIGHT - margin - 8},
+			{17 * CHARACTER_WIDTH + margin * 2, 8}
+		},
+		ui::Color::dark_cyan()
+	);
+
+	painter.fill_rectangle(
+		{
+			{5 * CHARACTER_WIDTH - margin, 12 * LINE_HEIGHT + margin},
+			{17 * CHARACTER_WIDTH + margin * 2, 8}
+		},
+		ui::Color::dark_cyan()
+	);
+}
+
+} /* namespace ui */

firmware/application/apps/ui_dfu_menu.hpp

@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * 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_DFU_MENU_H__
+#define __UI_DFU_MENU_H__
+
+#include <cstdint>
+
+#include "ui_widget.hpp"
+#include "event_m0.hpp"
+#include "debug.hpp"
+#include "string_format.hpp"
+
+#define LINE_HEIGHT 16
+#define CHARACTER_WIDTH 8
+
+namespace ui {
+class NavigationView;
+
+class DfuMenu : public View {
+public:
+	DfuMenu(NavigationView& nav);
+	~DfuMenu() = default;
+
+	void paint(Painter& painter) override;
+
+private:
+	NavigationView& nav_;
+	
+	Text text_head {{ 6 * CHARACTER_WIDTH, 3 * LINE_HEIGHT, 11 * CHARACTER_WIDTH, 1 * LINE_HEIGHT }, "Performance"};
+
+	Labels labels {
+		{ { 6 * CHARACTER_WIDTH, 5 * LINE_HEIGHT }, "M0 heap:", Color::dark_cyan() },
+		{ { 6 * CHARACTER_WIDTH, 6 * LINE_HEIGHT }, "M0 stack:", Color::dark_cyan() },
+		{ { 6 * CHARACTER_WIDTH, 7 * LINE_HEIGHT }, "M0 cpu %:", Color::dark_cyan() },
+		{ { 6 * CHARACTER_WIDTH, 8 * LINE_HEIGHT }, "M4 heap:", Color::dark_cyan() },
+		{ { 6 * CHARACTER_WIDTH, 9 * LINE_HEIGHT }, "M4 stack:", Color::dark_cyan() },
+		{ { 6 * CHARACTER_WIDTH,10 * LINE_HEIGHT }, "M4 cpu %:", Color::dark_cyan() },
+		{ { 6 * CHARACTER_WIDTH,11 * LINE_HEIGHT }, "uptime:", Color::dark_cyan() }
+	};
+
+	Text text_info_line_1 {{ 15 * CHARACTER_WIDTH, 5 * LINE_HEIGHT, 5 * CHARACTER_WIDTH, 1 * LINE_HEIGHT }, ""};
+	Text text_info_line_2 {{ 15 * CHARACTER_WIDTH, 6 * LINE_HEIGHT, 5 * CHARACTER_WIDTH, 1 * LINE_HEIGHT }, ""};
+	Text text_info_line_3 {{ 15 * CHARACTER_WIDTH, 7 * LINE_HEIGHT, 5 * CHARACTER_WIDTH, 1 * LINE_HEIGHT }, ""};
+	Text text_info_line_4 {{ 15 * CHARACTER_WIDTH, 8 * LINE_HEIGHT, 5 * CHARACTER_WIDTH, 1 * LINE_HEIGHT }, ""};
+	Text text_info_line_5 {{ 15 * CHARACTER_WIDTH, 9 * LINE_HEIGHT, 5 * CHARACTER_WIDTH, 1 * LINE_HEIGHT }, ""};
+	Text text_info_line_6 {{ 15 * CHARACTER_WIDTH,10 * LINE_HEIGHT, 5 * CHARACTER_WIDTH, 1 * LINE_HEIGHT }, ""};
+	Text text_info_line_7 {{ 15 * CHARACTER_WIDTH,11 * LINE_HEIGHT, 5 * CHARACTER_WIDTH, 1 * LINE_HEIGHT }, ""};
+};
+
+} /* namespace ui */
+
+#endif/*__UI_DFU_MENU_H__*/

firmware/application/apps/ui_fileman.cpp

@@ -262,6 +262,35 @@ void FileManagerView::on_rename(NavigationView& nav) {
 	});
 }
 
+void FileManagerView::on_refactor(NavigationView& nav) {
+	text_prompt(nav, name_buffer, max_filename_length, [this](std::string& buffer) {
+		std::string destination_path = current_path.string();
+		if (destination_path.back() != '/')
+			destination_path += '/';
+		destination_path = destination_path + buffer;
+
+		rename_file(get_selected_path(), destination_path);  //rename the selected file
+
+		auto selected_path = get_selected_path();
+		auto extension = selected_path.extension().string();
+
+		if (!extension.empty() && selected_path.string().back() != '/' && extension.substr(1) == "C16") {
+			// Rename its partner ( C16 <-> TXT ) file.
+			auto partner_file_path = selected_path.string().substr(0, selected_path.string().size() - 4) + ".TXT";
+			destination_path = destination_path.substr(0, destination_path.size() - 4) + ".TXT";
+			rename_file(partner_file_path, destination_path);
+		} else if (!extension.empty() && selected_path.string().back() != '/' && extension.substr(1) == "TXT") {
+			// If the file user choose is a TXT file.
+			auto partner_file_path = selected_path.string().substr(0, selected_path.string().size() - 4) + ".C16";
+			destination_path = destination_path.substr(0, destination_path.size() - 4) + ".C16";
+			rename_file(partner_file_path, destination_path);
+		}
+
+		load_directory_contents(current_path);
+		refresh_list();
+	});
+}
+
 void FileManagerView::on_delete() {
 	delete_file(get_selected_path());
 	load_directory_contents(current_path);
@@ -271,6 +300,7 @@ void FileManagerView::on_delete() {
 void FileManagerView::refresh_widgets(const bool v) {
 	button_rename.hidden(v);
 	button_new_dir.hidden(v);
+	button_refactor.hidden(v);
 	button_delete.hidden(v);
 	set_dirty();
 }
@@ -293,6 +323,7 @@ FileManagerView::FileManagerView(
 			&labels,
 			&text_date,
 			&button_rename,
+			&button_refactor,
 			&button_new_dir,
 			&button_delete
 		});
@@ -325,7 +356,12 @@ FileManagerView::FileManagerView(
 			name_buffer = entry_list[menu_view.highlighted_index()].entry_path.filename().string().substr(0, max_filename_length);
 			on_rename(nav);
 		};
-		
+
+		button_refactor.on_select = [this, &nav](Button&) {
+			name_buffer = entry_list[menu_view.highlighted_index()].entry_path.filename().string().substr(0, max_filename_length);
+			on_refactor(nav);
+		};
+
 		button_delete.on_select = [this, &nav](Button&) {
 			// Use display_modal ?
 			nav.push<ModalMessageView>("Delete", "Delete " + entry_list[menu_view.highlighted_index()].entry_path.filename().string() + "\nAre you sure?", YESNO,

firmware/application/apps/ui_fileman.hpp

@@ -146,6 +146,7 @@ private:
 	
 	void refresh_widgets(const bool v);
 	void on_rename(NavigationView& nav);
+	void on_refactor(NavigationView& nav);
 	void on_delete();
 	
 	Labels labels {
@@ -158,11 +159,17 @@ private:
 	};
 
 	Button button_rename {
-		{ 0 * 8, 29 * 8, 14 * 8, 32 },
+		{ 0 * 8, 29 * 8, 9 * 8, 32 },
 		"Rename"
 	};
+
+	Button button_refactor{
+		{ 10 * 8, 29 * 8, 10 * 8, 32 },
+		"Refactor"
+	};
+
 	Button button_delete {
-		{ 16 * 8, 29 * 8, 14 * 8, 32 },
+		{ 21 * 8, 29 * 8, 9 * 8, 32 },
 		"Delete"
 	};
 	

firmware/application/apps/ui_looking_glass_app.cpp

@@ -26,7 +26,6 @@ using namespace portapack;
 
 namespace ui
 {
-
     void GlassView::focus()
     {
         field_marker.focus();
@@ -39,6 +38,29 @@ namespace ui
         baseband::shutdown();
     }
 
+    // Returns the next multiple of num that is a multiple of multiplier
+    int64_t GlassView::next_mult_of(int64_t num, int64_t multiplier) {
+        return ((num / multiplier) + 1) * multiplier;
+    }
+
+    // Returns the previous multiple of num that is a multiple of multiplier
+    //int64_t GlassView::prev_mult_of(int64_t num, int64_t multiplier) {
+    //    return (num / multiplier) * multiplier;
+    //}
+
+    void GlassView::adjust_range(int64_t* f_min, int64_t* f_max, int64_t width) {
+        int64_t span = *f_max - *f_min;
+        int64_t num_intervals = span / width;
+        if( span % width != 0 )
+        {
+            num_intervals++;
+        }
+        int64_t new_span = num_intervals * width;
+        int64_t delta_span = (new_span - span) / 2;
+        *f_min -= delta_span;
+        *f_max += delta_span;
+    }
+
     void GlassView::on_lna_changed(int32_t v_db)
     {
         receiver_model.set_lna(v_db);
@@ -49,12 +71,71 @@ namespace ui
         receiver_model.set_vga(v_db);
     }
 
-    void GlassView::add_spectrum_pixel(Color color)
+    void GlassView::reset_live_view( bool clear_screen )
     {
-        spectrum_row[pixel_index++] = color;
+        max_freq_hold = 0 ;
+        max_freq_power = -1000 ;
+        if( clear_screen )
+        {
+            // only clear screen in peak mode
+            if( live_frequency_view == 2 )
+            {
+                display.fill_rectangle( { { 0 , 108 + 16 } , { 240 , 320 - (108 + 16) } } , { 0 , 0 , 0 } );
+            }
+        }
+    }
+
+    void GlassView::add_spectrum_pixel( uint8_t power )
+    {
+        static int64_t last_max_freq = 0 ;
+
+        spectrum_row[pixel_index] = spectrum_rgb3_lut[power] ; // row of colors
+        spectrum_data[pixel_index] = ( live_frequency_integrate * spectrum_data[pixel_index] + power ) / (live_frequency_integrate + 1); // smoothing 
+        pixel_index ++ ;
+
         if (pixel_index == 240) // got an entire waterfall line
         {
-            display.draw_pixels({{0, display.scroll(1)}, {240, 1}}, spectrum_row); // new line at top, one less var, speedier
+            if( live_frequency_view > 0 )
+            {
+                constexpr int rssi_sample_range = 256;
+                constexpr float rssi_voltage_min = 0.4;
+                constexpr float rssi_voltage_max = 2.2;
+                constexpr float adc_voltage_max = 3.3;
+                constexpr int raw_min = rssi_sample_range * rssi_voltage_min / adc_voltage_max;
+                constexpr int raw_max = rssi_sample_range * rssi_voltage_max / adc_voltage_max;
+                constexpr int raw_delta = raw_max - raw_min;
+                const range_t<int> y_max_range { 0 , 320 - ( 108 + 16 ) };
+
+                //drawing and keeping track of max freq
+                for( uint16_t xpos = 0 ; xpos < 240 ; xpos ++ )
+                {
+                    // save max powerwull freq 
+                    if( spectrum_data[ xpos ] > max_freq_power )
+                    {
+                        max_freq_power = spectrum_data[ xpos ];
+                        max_freq_hold = f_min + ( (f_max - f_min) * xpos) / 240 ;
+                    }
+
+                    int16_t point = y_max_range.clip( ( ( spectrum_data[ xpos ] - raw_min ) * ( 320 - ( 108 + 16 ) ) ) / raw_delta );
+                    uint8_t color_gradient = (point * 255) / 212 ;
+                    // clear if not in peak view
+                    if( live_frequency_view != 2 )
+                    {
+                        display.fill_rectangle( { { xpos , 108 + 16 } , { 1 , 320 - point } } , { 0 , 0 , 0 } );
+                    }
+                    display.fill_rectangle( { { xpos , 320 - point } , { 1 , point } } , { color_gradient , 0 , uint8_t( 255 - color_gradient ) } );
+                } 
+                if( last_max_freq != max_freq_hold )
+                {
+                    last_max_freq = max_freq_hold ;
+                    freq_stats.set( "MAX HOLD: "+to_string_short_freq( max_freq_hold ) );
+                }
+                PlotMarker(field_marker.value());
+            }
+            else
+            {
+                display.draw_pixels({{0, display.scroll(1)}, {240, 1}}, spectrum_row); // new line at top, one less var, speedier
+            }
             pixel_index = 0;                                                       // Start New cascade line
         }
     }
@@ -64,52 +145,83 @@ namespace ui
     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( fast_scan || ( LOOKING_GLASS_SLICE_WIDTH < LOOKING_GLASS_SLICE_WIDTH_MAX ) )
         {
-            if (bin < 120)
+            // 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) // 134
+                        max_power = spectrum.db[134 + bin];
+                }
+                else
+                {
+                    if (spectrum.db[bin - 118] > max_power) // 118
+                        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(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"
+                        f_center = f_center_ini - 2 * each_bin_size ;               // Start a new sweep
+                        radio::set_tuning_frequency(f_center); // tune rx for this new slice directly, faster than using persistent memory saving
+                        chThdSleepMilliseconds(10);
+                        baseband::spectrum_streaming_start(); // Do the RX
+                        return;
+                    }
+                    bins_Hz_size -= marker_pixel_step; // reset bins size, but carrying the eventual excess Hz into next pixel
+                }
+            }
+            f_center += 240 * each_bin_size ; // Move into the next bandwidth slice NOTE: spectrum.sampling_rate = LOOKING_GLASS_SLICE_WIDTH
+        }
+        else //slow scan
+        { 
+            for (uint8_t bin = 0; bin < 120 ; bin++)
             {
                 if (spectrum.db[134 + bin] > max_power) // 134
                     max_power = spectrum.db[134 + bin];
-            }
-            else
-            {
-                if (spectrum.db[bin - 118] > max_power) // 118
-                    max_power = spectrum.db[bin - 118];
-            }
 
-            bins_Hz_size += each_bin_size; // add this bin Hz count into the "pixel fulfilled bag of Hz"
+                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
+                if (bins_Hz_size >= marker_pixel_step) // new pixel fullfilled
                 {
-                    bins_Hz_size = 0;                      // Since this is an entire pixel line, we don't carry "Pixels into next bin"
-                    f_center = f_center_ini;               // Start a new sweep
-                    radio::set_tuning_frequency(f_center); // tune rx for this new slice directly, faster than using persistent memory saving
-                    chThdSleepMilliseconds(10);
-                    baseband::spectrum_streaming_start(); // Do the RX
-                    return;
-                }
-                bins_Hz_size -= marker_pixel_step; // reset bins size, but carrying the eventual excess Hz into next pixel
-            }
-        }
+                    if (min_color_power < max_power)
+                        add_spectrum_pixel(max_power); // Pixel will represent max_power
+                    else
+                        add_spectrum_pixel(0); // Filtered out, show black
 
-        f_center += LOOKING_GLASS_SLICE_WIDTH; // Move into the next bandwidth slice NOTE: spectrum.sampling_rate = LOOKING_GLASS_SLICE_WIDTH
+                    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"
+                        f_center = f_center_ini - 2 * each_bin_size ;  // Start a new sweep
+                        radio::set_tuning_frequency(f_center); // tune rx for this new slice directly, faster than using persistent memory saving
+                        chThdSleepMilliseconds(10);
+                        baseband::spectrum_streaming_start(); // Do the RX
+                        return;
+                    }
+                    bins_Hz_size -= marker_pixel_step; // reset bins size, but carrying the eventual excess Hz into next pixel
+                }
+            }
+            f_center += 120 * each_bin_size ;
+        }
         radio::set_tuning_frequency(f_center); // tune rx for this new slice directly, faster than using persistent memory saving
         chThdSleepMilliseconds(5);
-
-        // receiver_model.set_tuning_frequency(f_center); //tune rx for this slice
         baseband::spectrum_streaming_start(); // Do the RX
     }
 
@@ -127,19 +239,27 @@ namespace ui
 
     void GlassView::on_range_changed()
     {
+        reset_live_view( false );
         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));
+        if( locked_range )
+        {
+            button_range.set_text(">"+to_string_dec_uint(search_span)+"<");
+        }
+        else
+        {
+            button_range.set_text(" "+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;
+        adjust_range( &f_min , &f_max , 240 );
 
-        marker_pixel_step = search_span / 240;                                        // Each pixel value in Hz
+        marker_pixel_step = (f_max - f_min) / 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;
@@ -156,7 +276,20 @@ namespace ui
         pixel_index = 0;         // reset pixel counter
         max_power = 0;
         bins_Hz_size = 0; // reset amount of Hz filled up by pixels
-
+        if( next_mult_of( (f_max - f_min) , 240 ) <= LOOKING_GLASS_SLICE_WIDTH_MAX )
+        {
+            LOOKING_GLASS_SLICE_WIDTH = next_mult_of( (f_max - f_min) , 240 );
+            receiver_model.set_sampling_rate(LOOKING_GLASS_SLICE_WIDTH);      
+            receiver_model.set_baseband_bandwidth(LOOKING_GLASS_SLICE_WIDTH/2); 
+        }
+        else if( LOOKING_GLASS_SLICE_WIDTH != LOOKING_GLASS_SLICE_WIDTH_MAX )
+        {
+            LOOKING_GLASS_SLICE_WIDTH = LOOKING_GLASS_SLICE_WIDTH_MAX ;
+            receiver_model.set_sampling_rate(LOOKING_GLASS_SLICE_WIDTH);      
+            receiver_model.set_baseband_bandwidth(LOOKING_GLASS_SLICE_WIDTH); 
+        }
+        receiver_model.set_squelch_level(0);
+        each_bin_size = LOOKING_GLASS_SLICE_WIDTH / 240 ; 
         baseband::set_spectrum(LOOKING_GLASS_SLICE_WIDTH, field_trigger.value());
         receiver_model.set_tuning_frequency(f_center_ini); // tune rx for this slice
     }
@@ -166,11 +299,16 @@ namespace ui
         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({(int)pos - 2, 100, 5, 3}, Color::red()); // Red marker top
-        portapack::display.fill_rectangle({(int)pos - 1, 103, 3, 3}, Color::red()); // Red marker middle
-        portapack::display.fill_rectangle({(int)pos, 106, 1, 2}, Color::red());     // Red marker bottom
+        
+        uint8_t shift_y = 0 ;
+        if( live_frequency_view > 0 )
+        {
+            shift_y = 16 ;
+        }
+        portapack::display.fill_rectangle({0, 100 + shift_y, 240, 8}, Color::black());        // Clear old marker and whole marker rectangle btw
+        portapack::display.fill_rectangle({(int)pos - 2, 100 + shift_y, 5, 3}, Color::red()); // Red marker top
+        portapack::display.fill_rectangle({(int)pos - 1, 103 + shift_y, 3, 3}, Color::red()); // Red marker middle
+        portapack::display.fill_rectangle({(int)pos, 106 + shift_y, 1, 2}, Color::red());     // Red marker bottom
     }
 
     GlassView::GlassView(
@@ -183,96 +321,117 @@ namespace ui
                       &field_frequency_max,
                       &field_lna,
                       &field_vga,
-                      &text_range,
+                      &button_range,
                       &steps_config,
+                      &scan_type,
+                      &view_config,
+                      &level_integration,
                       &filter_config,
                       &field_rf_amp,
                       &range_presets,
                       &field_marker,
                       &text_marker_pm,
-                      &field_trigger});
+                      &field_trigger,
+                      &button_jump,
+                      &button_rst,
+                      &freq_stats});
 
         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.set_step( steps );
         field_frequency_min.on_change = [this](int32_t v)
         {
-            int32_t steps_ = steps ;
-            if( steps_ < 24 )
-                steps_ = 24 ;
-            if( v > 7200 - steps_ )
+            reset_live_view( true );
+            int32_t min_size = steps ;
+            if( locked_range )
+                min_size = search_span ;
+            if( min_size < 2 )
+                min_size = 2 ;
+            if( v > 7200 - min_size )
             {
-                v = 7200 - steps_ ;
+                v = 7200 - min_size ;
                 field_frequency_min.set_value( v ); 
             }
-            if (v >= (field_frequency_max.value() - steps_ ) )
-                field_frequency_max.set_value( v + steps_ );
+            if (v > (field_frequency_max.value() - min_size ) )
+                field_frequency_max.set_value( v + min_size );
+            if( locked_range )
+                field_frequency_max.set_value( v + min_size );
             this->on_range_changed();
         };
+        field_frequency_min.set_value(presets_db[0].min); // Defaults to first preset
+        field_frequency_min.set_step( steps );
 
         field_frequency_min.on_select = [this, &nav](NumberField& field) {
             auto new_view = nav_.push<FrequencyKeypadView>(field_frequency_min.value()*1000000);
             new_view->on_changed = [this, &field](rf::Frequency f) {
                 int32_t freq = f / 1000000 ;
-                int32_t steps_ = steps ;
-                if( steps_ < 24 )
-                    steps_ = 24 ;
-                if( freq > (7200 - steps_ ) )
-                    freq= 7200 - steps_  ;
+                int32_t min_size = steps ;
+                if( locked_range )
+                    min_size = search_span ;
+                if( min_size < 2 )
+                    min_size = 2 ;
+                if( freq > (7200 - min_size ) )
+                    freq = 7200 - min_size  ;
                 field_frequency_min.set_value( freq );
-                if( field_frequency_max.value() < ( freq + steps_ ) )
-                    field_frequency_max.set_value( freq + steps_ );
+                if( field_frequency_max.value() < ( freq + min_size ) )
+                    field_frequency_max.set_value( freq + min_size );
                 this->on_range_changed();
             };
         };
 
-        field_frequency_max.set_value(presets_db[0].max); // Defaults to first preset
-        field_frequency_max.set_step( steps );
         field_frequency_max.on_change = [this](int32_t v)
         {          
-            int32_t steps_ = steps ;
-            if( steps_ < 24 )
-                steps_ = 24 ;
-            if( v < steps_ )
+            reset_live_view( true );
+            int32_t min_size = steps ;
+            if( locked_range )
+                min_size = search_span ;
+            if( min_size < 2 )
+                min_size = 2 ;
+            if( v < min_size )
             {
-                v = steps_ ;
+                v = min_size ;
                 field_frequency_max.set_value( v ); 
             }
-            if (v < (field_frequency_min.value() + steps_) )
-                field_frequency_min.set_value(v - steps_);
+            if (v < (field_frequency_min.value() + min_size) )
+                field_frequency_min.set_value(v - min_size);
+            if( locked_range )
+                field_frequency_min.set_value( v - min_size );
             this->on_range_changed();
         };
+        field_frequency_max.set_value(presets_db[0].max); // Defaults to first preset
+        field_frequency_max.set_step( steps );
 
         field_frequency_max.on_select = [this, &nav](NumberField& field) {
             auto new_view = nav_.push<FrequencyKeypadView>(field_frequency_max.value()*1000000);
             new_view->on_changed = [this, &field](rf::Frequency f) {
-                int32_t steps_ = steps ;
-                if( steps_ < 24 )
-                    steps_ = 24 ;
+                int32_t min_size = steps ;
+                if( locked_range )
+                    min_size = search_span ;
+                if( min_size < 2 )
+                    min_size = 2 ;
                 int32_t freq = f / 1000000 ;
-                if( freq < 24 )
-                    freq = 24 ;
+                if( freq < min_size )
+                    freq = min_size ;
                 field_frequency_max.set_value( freq );
-                if( field_frequency_min.value() > ( freq - steps) ) 
-                    field_frequency_min.set_value( freq - steps );
+                if( field_frequency_min.value() > ( freq - min_size) ) 
+                    field_frequency_min.set_value( freq - min_size );
                 this->on_range_changed();
             };
         };
 
-        field_lna.set_value(receiver_model.lna());
         field_lna.on_change = [this](int32_t v)
         {
+            reset_live_view( true );
             this->on_lna_changed(v);
         };
+        field_lna.set_value(receiver_model.lna());
 
-        field_vga.set_value(receiver_model.vga());
         field_vga.on_change = [this](int32_t v_db)
         {
+            reset_live_view( true );
             this->on_vga_changed(v_db);
         };
+        field_vga.set_value(receiver_model.vga());
 
-        steps_config.set_selected_index(3); //default of 250 Mhz steps
         steps_config.on_change = [this](size_t n, OptionsField::value_t v)
         {
             (void)n;
@@ -280,6 +439,67 @@ namespace ui
             field_frequency_max.set_step( v );
             steps = v ;
         };
+        steps_config.set_selected_index(0); //default of 1 Mhz steps
+                                            
+        scan_type.on_change = [this](size_t n, OptionsField::value_t v)
+        {
+            (void)n;
+            fast_scan = v ;
+        };
+        scan_type.set_selected_index(0); // default legacy fast scan
+
+        view_config.on_change = [this](size_t n, OptionsField::value_t v)
+        {
+            (void)n;
+            // clear between changes
+            reset_live_view( true );
+            if( v == 0 )
+            {
+                live_frequency_view = 0 ;
+                level_integration.hidden( true );
+                freq_stats.hidden( true );
+                button_jump.hidden( true );
+                button_rst.hidden( true );
+                display.scroll_set_area(109, 319); // Restart scroll on the correct coordinates
+            }
+            else if( v == 1 )
+            {
+                display.fill_rectangle( { { 0 , 108 } , { 240 , 24 } } , { 0 , 0 , 0 } );
+                live_frequency_view = 1 ;
+                display.scroll_disable();
+                level_integration.hidden( false );
+                freq_stats.hidden( false );
+                button_jump.hidden( false );
+                button_rst.hidden( false );
+            }
+            else if( v == 2 )
+            {
+                display.fill_rectangle( { { 0 , 108 } , { 240 , 24 } } , { 0 , 0 , 0 } );
+                live_frequency_view = 2 ;
+                display.scroll_disable();
+                level_integration.hidden( false );
+                freq_stats.hidden( false );
+                button_jump.hidden( false );
+                button_rst.hidden( false );
+            }
+            set_dirty();
+        };
+        view_config.set_selected_index(0); //default spectrum
+
+        level_integration.on_change = [this](size_t n, OptionsField::value_t v)
+        {
+            (void)n;
+            reset_live_view( true );
+            live_frequency_integrate = v ;
+        };
+        level_integration.set_selected_index(3); //default integration of ( 3 * old value + new_value ) / 4
+
+        filter_config.on_change = [this](size_t n, OptionsField::value_t v) {
+            (void)n;
+            reset_live_view( true );
+            min_color_power = v;
+        };
+        filter_config.set_selected_index(0);
 
         range_presets.on_change = [this](size_t n, OptionsField::value_t v)
         {
@@ -304,11 +524,37 @@ namespace ui
             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(LOOKING_GLASS_SLICE_WIDTH, v);
         };
+        field_trigger.set_value(32); // Defaults to 32, as normal triggering resolution
+                                     
+        button_range.on_select = [this](Button&) {
+            if( locked_range )
+            {
+                locked_range = false ;
+                button_range.set_style(&style_white);
+                button_range.set_text(" "+to_string_dec_uint(search_span)+" ");
+            }
+            else
+            {
+                locked_range = true ;
+                button_range.set_style(&style_red);
+                button_range.set_text(">"+to_string_dec_uint(search_span)+"<");
+            }
+        };
+
+        button_jump.on_select = [this](Button&) {
+            receiver_model.set_tuning_frequency(max_freq_hold); // 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
+        };
+
+        button_rst.on_select = [this](Button&) {
+            reset_live_view( true );
+        };
 
         display.scroll_set_area(109, 319);
         baseband::set_spectrum(LOOKING_GLASS_SLICE_WIDTH, field_trigger.value()); // trigger:

firmware/application/apps/ui_looking_glass_app.hpp

@@ -1,6 +1,7 @@
 /*
  * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
  * Copyright (C) 2020 euquiq
+ * Copyright (C) 2023 gullradriel, Nilorea Studio Inc.
  *
  * This file is part of PortaPack.
  *
@@ -36,13 +37,14 @@
 
 namespace ui
 {
-#define LOOKING_GLASS_SLICE_WIDTH	20000000 // Each slice bandwidth 20 MHz
+#define LOOKING_GLASS_SLICE_WIDTH_MAX 19999920
 #define MHZ_DIV	            1000000
 #define X2_MHZ_DIV	        2000000
 
     class GlassView : public View
     {
         public:
+			
             GlassView(NavigationView &nav);
 
             GlassView( const GlassView &);
@@ -64,15 +66,38 @@ namespace ui
                 rf::Frequency max{};
                 std::string label{};
             };
+            
+            const Style style_white {		// free range
+                .font = font::fixed_8x16,
+                .background = Color::black(),
+                .foreground = Color::white(),
+            };
+
+            const Style style_red {		// locked range
+                .font = font::fixed_8x16,
+                .background = Color::black(),
+                .foreground = Color::red(),
+            };
 
             std::vector<preset_entry> presets_db{};
+            
+            // Each slice bandwidth 20 MHz and a multiple of 240
+            // since we are using LOOKING_GLASS_SLICE_WIDTH/240 as the each_bin_size
+            // it should also be a multiple of 2 since we are using LOOKING_GLASS_SLICE_WIDTH / 2 as centering freq
+            int64_t LOOKING_GLASS_SLICE_WIDTH = 19999920;
+
+            // frequency rounding helpers
+            int64_t next_mult_of(int64_t num, int64_t multiplier);
+            //int64_t prev_mult_of(int64_t num, int64_t multiplier);
+            void adjust_range(int64_t* f_min, int64_t* f_max, int64_t width);
 
             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 reset_live_view( bool clear_screen );
+            void add_spectrum_pixel(uint8_t power);
             void PlotMarker(rf::Frequency pos);
             void load_Presets();
             void txtline_process(std::string& line);
@@ -89,16 +114,23 @@ namespace ui
             uint8_t min_color_power { 0 };
             uint32_t pixel_index { 0 };
             std::array<Color, 240> spectrum_row = { 0 };
+            std::array<uint8_t, 240> spectrum_data = { 0 };
             ChannelSpectrumFIFO* fifo { nullptr }; 
             uint8_t max_power = 0;
-            int32_t steps = 250 ; // default of 250 Mhz steps
+            int32_t steps = 0 ;
+            uint8_t live_frequency_view = 0 ;
+            int16_t live_frequency_integrate = 3 ;
+            int64_t max_freq_hold = 0 ;
+            int16_t max_freq_power = -1000 ;
+            bool fast_scan = true ; // default to legacy fast scan
+            bool locked_range = false ; 
 
             Labels labels{
                 {{0, 0}, "MIN:     MAX:     LNA   VGA  ", Color::light_grey()},
-                    {{0, 1 * 16}, " RANGE:     FILTER:      AMP:", 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()}
+                    {{0, 4 * 16}, "RES:    STEP:", Color::light_grey()}
             };
 
             NumberField field_frequency_min {
@@ -125,24 +157,12 @@ namespace ui
                 { 27 * 8, 0 * 16 }
             };
 
-            Text text_range{
+            Button  button_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},
+                {20 * 8, 1 * 16},
                     4,
                     {
                         {"OFF ", 0},
@@ -172,12 +192,74 @@ namespace ui
                     ""};
 
             NumberField field_trigger{
-                {11 * 8, 4 * 16},
+                {4 * 8, 4 * 16},
                     3,
                     {2, 128},
                     2,
                     ' '};
 
+            OptionsField steps_config{
+                { 13 * 8, 4 * 16},
+                3,
+                {
+                    {"1",    1},
+                    {"25",   25},
+                    {"50",   50},
+                    {"100",  100},
+                    {"250",  250}, 
+                    {"500",  500},
+                }
+            };
+
+			OptionsField scan_type{
+                { 17 * 8, 4 * 16},
+                2,
+                {
+                    {"F-", true },
+                    {"S-", false },
+                }
+            };
+
+            OptionsField view_config{
+                { 19 * 8, 4 * 16},
+                7,
+                {
+                    {"SPCTR-V", 0 },
+                    {"LEVEL-V", 1 },
+                    {"PEAK-V" , 2 },
+                }
+            };
+
+            OptionsField level_integration{
+                { 27 * 8, 4 * 16},
+                2,
+                {
+                    {"x0", 0 },
+                    {"x1", 1 },
+                    {"x2", 2 },
+                    {"x3", 3 },
+                    {"x4", 4 },
+                    {"x5", 5 },
+                    {"x6", 6 },
+                    {"x7", 7 },
+                    {"x8", 8 },
+                    {"x9", 9 },
+                    }};
+
+            Button button_jump {
+                { 240 - 4 * 8 , 5 * 16 , 4 * 8, 16 },
+                "JMP"
+            };
+
+            Button button_rst {
+                { 240 - 9 * 8 , 5 * 16 , 4 * 8, 16 },
+                "RST"
+            };
+
+            Text freq_stats{
+                {0 * 8, 5 * 16 , 240 - 10 * 8 , 8 },
+                ""
+            };
 
             MessageHandlerRegistration message_handler_spectrum_config {
                 Message::ID::ChannelSpectrumConfig,

firmware/application/apps/ui_recon.cpp

@@ -528,32 +528,28 @@ namespace ui {
 					}
 				}
 			}
-		}
-
-		uint32_t freq_lock = recon_thread->is_freq_lock();
-
-		if( freq_lock == 0 ) {
-			//NO FREQ LOCK, ONGOING STANDARD SCANNING
-			if( index < 1000 && index < frequency_list.size() )
+ 			text_cycle.set_text( to_string_dec_uint( index + 1 , 3 ) );
+			if(frequency_list[index].description.size() > 0) 
 			{
-				text_cycle.set_text( to_string_dec_uint( index + 1 , 3 ) );
-				if(frequency_list[index].description.size() > 0) 
+				switch( frequency_list[current_index].type )
 				{
-					switch( frequency_list[current_index].type )
-					{
-						case RANGE:
-							desc_cycle.set( "R: " + frequency_list[current_index].description ); //Show new description
-							break ;
-						case HAMRADIO:
-							desc_cycle.set( "H: " + frequency_list[current_index].description ); //Show new description
-							break ;
-						default:
-						case SINGLE:
-							desc_cycle.set( "S: " + frequency_list[current_index].description ); //Show new description
-							break ;
-					}
+					case RANGE:
+						desc_cycle.set( "R: " + frequency_list[current_index].description ); //Show new description
+						break ;
+					case HAMRADIO:
+						desc_cycle.set( "H: " + frequency_list[current_index].description ); //Show new description
+						break ;
+					default:
+					case SINGLE:
+						desc_cycle.set( "S: " + frequency_list[current_index].description ); //Show new description
+						break ;
 				}
 			}
+		}
+	
+		uint32_t freq_lock = recon_thread->is_freq_lock();
+		if( freq_lock == 0 ) {
+			//NO FREQ LOCK, ONGOING STANDARD SCANNING
 			big_display.set_style(&style_white);
 			if( !userpause )
 				button_pause.set_text("<PAUSE>");	

firmware/application/event_m0.cpp

@@ -43,6 +43,7 @@ using namespace lpc43xx;
 #include <array>
 
 #include "ui_font_fixed_8x16.hpp"
+#include "ui_navigation.hpp"
 
 extern "C" {
 
@@ -262,6 +263,8 @@ void EventDispatcher::on_touch_event(ui::TouchEvent event) {
 void EventDispatcher::handle_lcd_frame_sync() {
 	DisplayFrameSyncMessage message;
 	message_map.send(&message);
+
+	static_cast<ui::SystemView *>(top_widget)->paint_overlay();
 	painter.paint_widget_tree(top_widget);
 
 	portapack::backlight()->on();
@@ -304,7 +307,12 @@ void EventDispatcher::handle_switches() {
 		if( switches_state[i] ) {
 			const auto event = static_cast<ui::KeyEvent>(i);
 			if( !event_bubble_key(event) ) {
-				context.focus_manager().update(top_widget, event);
+				if (switches_state[(size_t)ui::KeyEvent::Dfu]) {
+					static_cast<ui::SystemView *>(top_widget)->toggle_overlay();
+				}
+				else {
+					context.focus_manager().update(top_widget, event);
+				}
 			}
 
 			in_key_event = true;

firmware/application/irq_controls.cpp

@@ -42,7 +42,7 @@ using namespace hackrf::one;
 
 static Thread* thread_controls_event = NULL;
 
-static std::array<Debounce, 7> switch_debounce;
+static std::array<Debounce, 8> switch_debounce;
 
 static Encoder encoder;
 
@@ -193,11 +193,13 @@ void controls_init() {
 
 SwitchesState get_switches_state() {
 	SwitchesState result;
-	for(size_t i=0; i<result.size(); i++) {
+	for(size_t i=0; i<result.size()-1; i++) {
  		// TODO: Ignore multiple keys at the same time?
  		result[i] = switch_debounce[i].state();
 	}
 
+	result[result.size()-1] = switch_debounce[switch_debounce.size()-1].state();
+
 	return result;
 }
 

firmware/application/irq_controls.hpp

@@ -33,9 +33,10 @@ enum class Switch {
 	Down = 2,
 	Up = 3,
 	Sel = 4,
+	Dfu = 5,
 };
 
-using SwitchesState = std::bitset<5>;
+using SwitchesState = std::bitset<6>;
 
 using EncoderPosition = uint32_t;
 

firmware/application/main.cpp

@@ -145,14 +145,14 @@ Continuous (Fox-oring)
 rffc507x::RFFC507x first_if;
 
 static void event_loop() {
-	ui::Context context;
-	ui::SystemView system_view {
+	static ui::Context context;
+	static ui::SystemView system_view {
 		context,
 		portapack::display.screen_rect()
 	};
 
 	EventDispatcher event_dispatcher { &system_view, context };
-	MessageHandlerRegistration message_handler_display_sleep {
+	static MessageHandlerRegistration message_handler_display_sleep {
 		Message::ID::DisplaySleep,
 		[&event_dispatcher](const Message* const) {
 			event_dispatcher.set_display_sleep(true);

firmware/application/portapack.cpp

@@ -61,7 +61,7 @@ portapack::IO io {
 	portapack::gpio_io_stbx,
 	portapack::gpio_addr,
 	portapack::gpio_lcd_te,
-	portapack::gpio_unused,
+	portapack::gpio_dfu,
 };
 
 portapack::BacklightCAT4004 backlight_cat4004;

firmware/application/ui_navigation.cpp

@@ -29,6 +29,7 @@
 #include "bmp_splash.hpp"
 #include "bmp_modal_warning.hpp"
 #include "portapack_persistent_memory.hpp"
+#include "portapack_shared_memory.hpp"
 
 #include "ui_about_simple.hpp"
 #include "ui_adsb_rx.hpp"
@@ -748,6 +749,36 @@ Context& SystemView::context() const {
 	return context_;
 }
 
+void SystemView::toggle_overlay() {
+	if (overlay_active){
+		this->remove_child(&this->overlay);
+		this->set_dirty();
+		shared_memory.request_m4_performance_counter = 0;
+	}
+	else{
+		this->add_child(&this->overlay);
+		this->set_dirty();
+		shared_memory.request_m4_performance_counter = 1;
+		shared_memory.m4_cpu_usage = 0;
+		shared_memory.m4_heap_usage = 0;
+		shared_memory.m4_stack_usage = 0;
+	}
+
+	overlay_active = !overlay_active;
+}
+
+void SystemView::paint_overlay() {
+	static bool last_paint_state = false;
+	if (overlay_active){
+		// paint background only every other second
+		if ((((chTimeNow()>>10) & 0x01) == 0x01) == last_paint_state)
+			return;
+
+		last_paint_state = !last_paint_state;
+		this->overlay.set_dirty();
+	}
+}
+
 /* ***********************************************************************/
 
 void BMPView::focus() {

firmware/application/ui_navigation.hpp

@@ -33,6 +33,7 @@
 #include "ui_channel.hpp"
 #include "ui_audio.hpp"
 #include "ui_sd_card_status_view.hpp"
+#include "ui_dfu_menu.hpp"
 
 #include "bitmap.hpp"
 #include "ff.h"
@@ -125,7 +126,7 @@ namespace ui
 			Color::dark_grey()};
 
 		ImageButton button_back{
-			{2, 0 * 16, 16, 16},
+			{0, 0 * 16, 12 * 8, 16},//back button is long enough to cover the title area to make it easier to touch
 			&bitmap_icon_previous,
 			Color::white(),
 			Color::dark_grey()};
@@ -290,10 +291,15 @@ namespace ui
 			const Rect parent_rect);
 
 		Context &context() const override;
+		void toggle_overlay();
+		void paint_overlay();
 
 	private:
+		bool overlay_active {false};
+
 		SystemStatusView status_view{navigation_view};
 		InformationView info_view{navigation_view};
+		DfuMenu overlay{navigation_view};
 		NavigationView navigation_view{};
 		Context &context_;
 	};

firmware/baseband/CMakeLists.txt

@@ -139,6 +139,7 @@ set(CPPSRC
 	${COMMON}/chibios_cpp.cpp
 	debug.cpp
 	${COMMON}/gcc.cpp
+	${COMMON}/performance_counter.cpp
 	tone_gen.cpp
 )
 

firmware/baseband/chconf.h

@@ -508,6 +508,8 @@
 }
 #endif
 
+
+
 /**
  * @brief   System tick event hook.
  * @details This hook is invoked in the system tick handler immediately
@@ -516,6 +518,8 @@
 #if !defined(SYSTEM_TICK_EVENT_HOOK) || defined(__DOXYGEN__)
 #define SYSTEM_TICK_EVENT_HOOK() {                                          \
   /* System tick event code here.*/                                         \
+  extern void update_performance_counters();  \
+  update_performance_counters();  \
 }
 #endif
 

firmware/baseband/debug.cpp

@@ -26,6 +26,7 @@
 #include <hal.h>
 
 #include "portapack_shared_memory.hpp"
+#include "performance_counter.hpp"
 
 void write_m4_panic_msg(const char *panic_message, struct extctx *ctxp) {
     if (ctxp == nullptr) {
@@ -116,5 +117,28 @@ CH_IRQ_HANDLER(HardFaultVector) {
 #endif
 }
 
+void update_performance_counters() {
+	auto performance_counter_active = shared_memory.request_m4_performance_counter;
+	if (performance_counter_active == 0x00)
+		return;
+
+	static bool last_paint_state = false;
+	if ((((chTimeNow()>>10) & 0x01) == 0x01) == last_paint_state)
+		return;
+
+    // Idle thread state is sometimes unuseable
+   	if (chThdGetTicks(chSysGetIdleThread()) > 0x10000000)
+        return;
+
+	last_paint_state = !last_paint_state;
+
+	auto utilisation = get_cpu_utilisation_in_percent();
+	auto free_stack = (uint32_t)get_free_stack_space();
+	auto free_heap = chCoreStatus();
+
+	shared_memory.m4_cpu_usage = utilisation;
+	shared_memory.m4_stack_usage = free_stack;
+	shared_memory.m4_heap_usage = free_heap;
 }
 
+} /* extern "C" */

firmware/baseband/event_m4.cpp

@@ -20,6 +20,7 @@
  */
 
 #include "event_m4.hpp"
+#include "debug.hpp"
 
 #include "portapack_shared_memory.hpp"
 
@@ -120,3 +121,4 @@ void EventDispatcher::handle_spectrum() {
 	const UpdateSpectrumMessage message;
 	baseband_processor->on_message(&message);
 }
+

firmware/baseband/sd_over_usb/proc_sd_over_usb.cpp

@@ -45,3 +45,5 @@ int main() {
 
 	return 0;
 }
+
+void update_performance_counters() {}

firmware/chibios-portapack/boards/PORTAPACK_APPLICATION/board.cpp

@@ -508,7 +508,7 @@ static const std::array<scu_setup_t, 26> pins_setup_portapack { {
     {  2,  1, scu_config_normal_drive_t { .mode=4, .epd=0, .epun=1, .ehs=0, .ezi=1, .zif=0 } }, /* U0_RXD: PortaPack P2_1/ADDR */
     {  2,  3, scu_config_normal_drive_t { .mode=4, .epd=0, .epun=1, .ehs=0, .ezi=1, .zif=0 } }, /* I2C1_SDA: PortaPack P2_3/LCD_TE */
     {  2,  4, scu_config_normal_drive_t { .mode=4, .epd=0, .epun=1, .ehs=0, .ezi=1, .zif=0 } }, /* I2C1_SCL: PortaPack P2_4/LCD_RDX */
-    {  2,  8, scu_config_normal_drive_t { .mode=4, .epd=0, .epun=1, .ehs=0, .ezi=0, .zif=0 } }, /* P2_8: 10K PD, BOOT2, DFU switch, PortaPack P2_8/<unused> */
+    {  2,  8, scu_config_normal_drive_t { .mode=1, .epd=0, .epun=0, .ehs=0, .ezi=1, .zif=1 } }, /* P2_8: 10K PD, BOOT2, DFU switch, PortaPack P2_8/<unused> */
     {  2,  9, scu_config_normal_drive_t { .mode=0, .epd=0, .epun=1, .ehs=0, .ezi=1, .zif=0 } }, /* P2_9: 10K PD, BOOT3, PortaPack P2_9/LCD_WRX */
     {  2, 13, scu_config_normal_drive_t { .mode=0, .epd=0, .epun=1, .ehs=0, .ezi=1, .zif=0 } }, /* P2_13: PortaPack P2_13/DIR */
     {  7,  0, scu_config_normal_drive_t { .mode=0, .epd=0, .epun=1, .ehs=0, .ezi=1, .zif=0 } }, /* GPIO3_8: PortaPack GPIO3_8(IO) */

firmware/common/performance_counter.cpp

@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * 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 "performance_counter.hpp"
+#include "ch.h"
+
+uint8_t get_cpu_utilisation_in_percent() {
+	static systime_t last_time = 0;
+	static systime_t last_idle_ticks = 0;
+
+	auto now = chTimeNow();
+	auto idle_ticks = chThdGetTicks(chSysGetIdleThread());
+
+	if (last_time == 0) {
+		last_time = now;
+		last_idle_ticks = idle_ticks;
+
+		return 0;
+	}
+
+	int32_t time_elapsed = now - last_time;
+	int32_t idle_elapsed = idle_ticks - last_idle_ticks;
+
+	int32_t working_ticks = time_elapsed - idle_elapsed;
+
+	if (working_ticks < 0)
+		working_ticks = 0;
+
+	auto utilisation = working_ticks * 100 / time_elapsed;
+
+	last_time = now;
+	last_idle_ticks = idle_ticks;
+
+	if (utilisation > 100) {
+		return 100;
+	}
+
+    return (uint8_t) utilisation;
+}

firmware/common/performance_counter.hpp

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2023 Bernd Herzog
+ *
+ * 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 __PERFORMANCE_COUNTER_H__
+#define __PERFORMANCE_COUNTER_H__
+
+#include <stdint.h>
+
+uint8_t get_cpu_utilisation_in_percent();
+
+#endif /* __PERFORMANCE_COUNTER_H__ */

firmware/common/portapack_hal.hpp

@@ -36,7 +36,7 @@ namespace portapack {
 constexpr GPIO gpio_io_stbx		= gpio[GPIO5_0];	/* P2_0 */
 constexpr GPIO gpio_addr		= gpio[GPIO5_1];	/* P2_1 */
 constexpr GPIO gpio_lcd_te		= gpio[GPIO5_3];	/* P2_3 */
-constexpr GPIO gpio_unused		= gpio[GPIO5_7];	/* P2_8 */
+constexpr GPIO gpio_dfu			= gpio[GPIO5_7];	/* P2_8 */
 constexpr GPIO gpio_lcd_rdx		= gpio[GPIO5_4];	/* P2_4 */
 constexpr GPIO gpio_lcd_wrx		= gpio[GPIO1_10];	/* P2_9 */
 constexpr GPIO gpio_dir			= gpio[GPIO1_13];	/* P2_13 */

firmware/common/portapack_io.cpp

@@ -110,7 +110,8 @@ uint32_t IO::io_update(const TouchPinsConfig write_value) {
 	}
 	gpio_addr.write(addr);
 
-	return switches_raw;
+	auto dfu_btn = portapack::io.dfu_read() & 0x01;
+	return (switches_raw & 0x7f) | (dfu_btn << 7);
 }
 
 }

firmware/common/portapack_io.hpp

@@ -214,6 +214,10 @@ public:
 		return gpio_rot_a.read();
 	}
 
+	uint32_t dfu_read() {
+		return gpio_rot_b.read();
+	}
+
 private:
 	const GPIO gpio_dir;
 	const GPIO gpio_lcd_rdx;

firmware/common/portapack_shared_memory.hpp

@@ -64,6 +64,11 @@ struct SharedMemory {
 		JammerChannel jammer_channels[24];
 		uint8_t data[512];
 	} bb_data { { { { 0, 0 } }, 0, { 0 } } };
+
+	uint8_t volatile request_m4_performance_counter{ 0 };
+	uint8_t volatile m4_cpu_usage{ 0 };
+	uint16_t volatile m4_stack_usage{ 0 };
+	uint16_t volatile m4_heap_usage{ 0 };
 };
 
 extern SharedMemory& shared_memory;

firmware/common/ui.hpp

@@ -325,7 +325,8 @@ enum class KeyEvent {
 	Down = 2,
 	Up = 3,
 	Select = 4,
-	Back = 5, /* Left and Up together */
+	Dfu = 5,
+	Back = 6, /* Left and Up together */
 };
 
 using EncoderEvent = int32_t;

hackrf-portapack/CMakeLists.txt

@@ -0,0 +1,93 @@
+# Copyright 2012 Jared Boone <jared@sharebrained.com>
+#
+# This file is part of HackRF.
+#
+# 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.
+#
+
+cmake_minimum_required(VERSION 3.1.3)
+set(CMAKE_TOOLCHAIN_FILE ../toolchain-arm-cortex-m.cmake)
+
+project(hackrf_usb C)
+
+include(../hackrf/firmware/hackrf-common.cmake)
+
+set(PATH_HACKRF_USB ../hackrf/firmware/hackrf_usb)
+
+add_custom_command(
+	OUTPUT ${PATH_HACKRF_CPLD_DATA_C}
+	COMMAND ${PATH_CPLD_BITSTREAM_TOOL} --xsvf ${PATH_HACKRF_CPLD_XSVF} --hackrf-data ${PATH_HACKRF_CPLD_DATA_C}
+	DEPENDS ${PATH_CPLD_BITSTREAM_TOOL} ${PATH_HACKRF_CPLD_XSVF}
+)
+
+set(SRC_M4
+	${PATH_HACKRF_USB}/hackrf_usb.c
+	"${PATH_HACKRF_FIRMWARE_COMMON}/tuning.c"
+	"${PATH_HACKRF_FIRMWARE_COMMON}/streaming.c"
+	"${PATH_HACKRF_FIRMWARE_COMMON}/usb.c"
+	"${PATH_HACKRF_FIRMWARE_COMMON}/usb_request.c"
+	"${PATH_HACKRF_FIRMWARE_COMMON}/usb_standard_request.c"
+	${PATH_HACKRF_USB}/usb_descriptor.c
+	${PATH_HACKRF_USB}/usb_device.c
+	${PATH_HACKRF_USB}/usb_endpoint.c
+	${PATH_HACKRF_USB}/usb_api_board_info.c
+	${PATH_HACKRF_USB}/usb_api_cpld.c
+	${PATH_HACKRF_USB}/usb_api_m0_state.c
+	${PATH_HACKRF_USB}/usb_api_register.c
+	${PATH_HACKRF_USB}/usb_api_spiflash.c
+	${PATH_HACKRF_USB}/usb_api_transceiver.c
+	${PATH_HACKRF_USB}/usb_api_operacake.c
+	${PATH_HACKRF_USB}/usb_api_sweep.c
+	${PATH_HACKRF_USB}/usb_api_ui.c
+	"${PATH_HACKRF_FIRMWARE_COMMON}/usb_queue.c"
+	"${PATH_HACKRF_FIRMWARE_COMMON}/fault_handler.c"
+	"${PATH_HACKRF_FIRMWARE_COMMON}/cpld_jtag.c"
+	"${PATH_HACKRF_FIRMWARE_COMMON}/cpld_xc2c.c"
+	"${PATH_HACKRF_CPLD_DATA_C}"
+	"${PATH_HACKRF_FIRMWARE_COMMON}/xapp058/lenval.c"
+	"${PATH_HACKRF_FIRMWARE_COMMON}/xapp058/micro.c"
+	"${PATH_HACKRF_FIRMWARE_COMMON}/xapp058/ports.c"
+	"${PATH_HACKRF_FIRMWARE_COMMON}/crc.c"
+	"${PATH_HACKRF_FIRMWARE_COMMON}/rom_iap.c"
+	"${PATH_HACKRF_FIRMWARE_COMMON}/operacake.c"
+	"${PATH_HACKRF_FIRMWARE_COMMON}/operacake_sctimer.c"
+)
+
+set(SRC_M0 ${PATH_HACKRF_USB}/sgpio_m0.s)
+
+if(BOARD STREQUAL "HACKRF_ONE")
+	SET(SRC_M4
+		${SRC_M4}
+		portapack.c
+		"${PATH_HACKRF_FIRMWARE_COMMON}/ui_portapack.c"
+	)
+endif()
+
+if(BOARD STREQUAL "RAD1O")
+	SET(SRC_M4
+		${SRC_M4}
+		"${PATH_HACKRF_FIRMWARE_COMMON}/rad1o/display.c"
+		"${PATH_HACKRF_FIRMWARE_COMMON}/rad1o/print.c"
+		"${PATH_HACKRF_FIRMWARE_COMMON}/rad1o/render.c"
+		"${PATH_HACKRF_FIRMWARE_COMMON}/rad1o/decoder.c"
+		"${PATH_HACKRF_FIRMWARE_COMMON}/rad1o/smallfonts.c"
+		"${PATH_HACKRF_FIRMWARE_COMMON}/rad1o/draw.c"
+		"${PATH_HACKRF_FIRMWARE_COMMON}/rad1o/ubuntu18.c"
+		"${PATH_HACKRF_FIRMWARE_COMMON}/ui_rad1o.c"
+	)
+endif()
+
+DeclareTargets()

hackrf-portapack/portapack.c

@@ -0,0 +1,640 @@
+/*
+ * Copyright 2018-2022 Great Scott Gadgets <info@greatscottgadgets.com>
+ * Copyright 2018 Jared Boone
+ *
+ * This file is part of HackRF.
+ *
+ * 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 "portapack.h"
+
+#include "hackrf_core.h"
+#include "gpio_lpc.h"
+
+#include <libopencm3/lpc43xx/scu.h>
+
+static void portapack_sleep_milliseconds(const uint32_t milliseconds)
+{
+	/* NOTE: Naively assumes 204 MHz instruction cycle clock and five instructions per count */
+	delay(milliseconds * 40800);
+}
+
+// clang-format off
+static struct gpio_t gpio_io_stbx = GPIO(5,  0); /* P2_0 */
+static struct gpio_t gpio_addr    = GPIO(5,  1); /* P2_1 */
+__attribute__((unused))
+static struct gpio_t gpio_lcd_te  = GPIO(5,  3); /* P2_3 */
+__attribute__((unused))
+static struct gpio_t gpio_unused  = GPIO(5,  7); /* P2_8 */
+static struct gpio_t gpio_lcd_rdx = GPIO(5,  4); /* P2_4 */
+static struct gpio_t gpio_lcd_wrx = GPIO(1, 10); /* P2_9 */
+static struct gpio_t gpio_dir     = GPIO(1, 13); /* P2_13 */
+
+// clang-format on
+
+typedef struct portapack_if_t {
+	gpio_t gpio_dir;
+	gpio_t gpio_lcd_rdx;
+	gpio_t gpio_lcd_wrx;
+	gpio_t gpio_io_stbx;
+	gpio_t gpio_addr;
+	gpio_port_t* const gpio_port_data;
+	uint8_t io_reg;
+} portapack_if_t;
+
+static portapack_if_t portapack_if = {
+	.gpio_dir = &gpio_dir,
+	.gpio_lcd_rdx = &gpio_lcd_rdx,
+	.gpio_lcd_wrx = &gpio_lcd_wrx,
+	.gpio_io_stbx = &gpio_io_stbx,
+	.gpio_addr = &gpio_addr,
+	.gpio_port_data = GPIO_LPC_PORT(3),
+	.io_reg = 0x03,
+};
+
+/* NOTE: Code below assumes the shift value is "8". */
+#define GPIO_DATA_SHIFT (8)
+static const uint32_t gpio_data_mask = 0xFFU << GPIO_DATA_SHIFT;
+
+static void portapack_data_mask_set()
+{
+	portapack_if.gpio_port_data->mask = ~gpio_data_mask;
+}
+
+static void portapack_data_write_low(const uint32_t value)
+{
+	portapack_if.gpio_port_data->mpin = (value << GPIO_DATA_SHIFT);
+}
+
+static void portapack_data_write_high(const uint32_t value)
+{
+	/* NOTE: Assumes no other bits in the port are masked. */
+	/* NOTE: Assumes that bits 15 through 8 are masked. */
+	portapack_if.gpio_port_data->mpin = value;
+}
+
+static void portapack_dir_read()
+{
+	portapack_if.gpio_port_data->dir &= ~gpio_data_mask;
+	gpio_set(portapack_if.gpio_dir);
+}
+
+static void portapack_dir_write()
+{
+	gpio_clear(portapack_if.gpio_dir);
+	portapack_if.gpio_port_data->dir |= gpio_data_mask;
+	/* TODO: Manipulating DIR[3] makes me queasy. The RFFC5072 DATA pin
+	 * is also on port 3, and switches direction periodically...
+	 * Time to resort to bit-banding to enforce atomicity? But then, how
+	 * to change direction on eight bits efficiently? Or do I care, since
+	 * the PortaPack data bus shouldn't change direction too frequently?
+	 */
+}
+
+__attribute__((unused)) static void portapack_lcd_rd_assert()
+{
+	gpio_clear(portapack_if.gpio_lcd_rdx);
+}
+
+static void portapack_lcd_rd_deassert()
+{
+	gpio_set(portapack_if.gpio_lcd_rdx);
+}
+
+static void portapack_lcd_wr_assert()
+{
+	gpio_clear(portapack_if.gpio_lcd_wrx);
+}
+
+static void portapack_lcd_wr_deassert()
+{
+	gpio_set(portapack_if.gpio_lcd_wrx);
+}
+
+static void portapack_io_stb_assert()
+{
+	gpio_clear(portapack_if.gpio_io_stbx);
+}
+
+static void portapack_io_stb_deassert()
+{
+	gpio_set(portapack_if.gpio_io_stbx);
+}
+
+static void portapack_addr(const bool value)
+{
+	gpio_write(portapack_if.gpio_addr, value);
+}
+
+static void portapack_lcd_command(const uint32_t value)
+{
+	portapack_data_write_high(0); /* Drive high byte (with zero -- don't care) */
+	portapack_dir_write();        /* Turn around data bus, MCU->CPLD */
+	portapack_addr(0);            /* Indicate command */
+	__asm__("nop");
+	__asm__("nop");
+	__asm__("nop");
+	portapack_lcd_wr_assert(); /* Latch high byte */
+
+	portapack_data_write_low(value); /* Drive low byte (pass-through) */
+	__asm__("nop");
+	__asm__("nop");
+	__asm__("nop");
+	portapack_lcd_wr_deassert(); /* Complete write operation */
+
+	portapack_addr(1); /* Set up for data phase (most likely after a command) */
+}
+
+static void portapack_lcd_write_data(const uint32_t value)
+{
+	// NOTE: Assumes and DIR=0 and ADDR=1 from command phase.
+	portapack_data_write_high(value); /* Drive high byte */
+	__asm__("nop");
+	portapack_lcd_wr_assert(); /* Latch high byte */
+
+	portapack_data_write_low(value); /* Drive low byte (pass-through) */
+	__asm__("nop");
+	__asm__("nop");
+	__asm__("nop");
+	portapack_lcd_wr_deassert(); /* Complete write operation */
+}
+
+static void portapack_io_write(const bool address, const uint_fast16_t value)
+{
+	portapack_data_write_low(value);
+	portapack_dir_write();
+	portapack_addr(address);
+	__asm__("nop");
+	__asm__("nop");
+	__asm__("nop");
+	portapack_io_stb_assert();
+	__asm__("nop");
+	__asm__("nop");
+	__asm__("nop");
+	portapack_io_stb_deassert();
+}
+
+static void portapack_if_init()
+{
+	portapack_data_mask_set();
+	portapack_data_write_high(0);
+
+	portapack_dir_read();
+	portapack_lcd_rd_deassert();
+	portapack_lcd_wr_deassert();
+	portapack_io_stb_deassert();
+	portapack_addr(0);
+
+	gpio_output(portapack_if.gpio_dir);
+	gpio_output(portapack_if.gpio_lcd_rdx);
+	gpio_output(portapack_if.gpio_lcd_wrx);
+	gpio_output(portapack_if.gpio_io_stbx);
+	gpio_output(portapack_if.gpio_addr);
+	/* gpio_input(portapack_if.gpio_rot_a); */
+	/* gpio_input(portapack_if.gpio_rot_b); */
+
+	scu_pinmux(SCU_PINMUX_PP_D0, SCU_CONF_FUNCTION0 | SCU_GPIO_PDN);
+	scu_pinmux(SCU_PINMUX_PP_D1, SCU_CONF_FUNCTION0 | SCU_GPIO_PDN);
+	scu_pinmux(SCU_PINMUX_PP_D2, SCU_CONF_FUNCTION0 | SCU_GPIO_PDN);
+	scu_pinmux(SCU_PINMUX_PP_D3, SCU_CONF_FUNCTION0 | SCU_GPIO_PDN);
+	scu_pinmux(SCU_PINMUX_PP_D4, SCU_CONF_FUNCTION0 | SCU_GPIO_PDN);
+	scu_pinmux(SCU_PINMUX_PP_D5, SCU_CONF_FUNCTION0 | SCU_GPIO_PDN);
+	scu_pinmux(SCU_PINMUX_PP_D6, SCU_CONF_FUNCTION0 | SCU_GPIO_PDN);
+	scu_pinmux(SCU_PINMUX_PP_D7, SCU_CONF_FUNCTION0 | SCU_GPIO_PDN);
+
+	scu_pinmux(SCU_PINMUX_PP_DIR, SCU_CONF_FUNCTION0 | SCU_GPIO_NOPULL);
+	scu_pinmux(SCU_PINMUX_PP_LCD_RDX, SCU_CONF_FUNCTION4 | SCU_GPIO_NOPULL);
+	scu_pinmux(SCU_PINMUX_PP_LCD_WRX, SCU_CONF_FUNCTION0 | SCU_GPIO_NOPULL);
+	scu_pinmux(SCU_PINMUX_PP_IO_STBX, SCU_CONF_FUNCTION4 | SCU_GPIO_NOPULL);
+	scu_pinmux(SCU_PINMUX_PP_ADDR, SCU_CONF_FUNCTION4 | SCU_GPIO_NOPULL);
+	/* scu_pinmux(SCU_PINMUX_PP_LCD_TE,   SCU_CONF_FUNCTION4 | SCU_GPIO_NOPULL); */
+	/* scu_pinmux(SCU_PINMUX_PP_UNUSED,   SCU_CONF_FUNCTION4 | SCU_GPIO_NOPULL); */
+}
+
+static void portapack_lcd_reset_state(const bool active)
+{
+	portapack_if.io_reg = (portapack_if.io_reg & 0xfe) | (active ? (1 << 0) : 0);
+	portapack_io_write(1, portapack_if.io_reg);
+}
+
+static void portapack_lcd_data_write_command_and_data(
+	const uint_fast8_t command,
+	const uint8_t* data,
+	const size_t data_count)
+{
+	portapack_lcd_command(command);
+	for (size_t i = 0; i < data_count; i++) {
+		portapack_lcd_write_data(data[i]);
+	}
+}
+
+static void portapack_lcd_sleep_out()
+{
+	const uint8_t cmd_11[] = {};
+	portapack_lcd_data_write_command_and_data(0x11, cmd_11, ARRAY_SIZEOF(cmd_11));
+	// "It will be necessary to wait 120msec after sending Sleep Out
+	// command (when in Sleep In Mode) before Sleep In command can be
+	// sent."
+	portapack_sleep_milliseconds(120);
+}
+
+static void portapack_lcd_display_on()
+{
+	const uint8_t cmd_29[] = {};
+	portapack_lcd_data_write_command_and_data(0x29, cmd_29, ARRAY_SIZEOF(cmd_29));
+}
+
+static void portapack_lcd_ramwr_start()
+{
+	const uint8_t cmd_2c[] = {};
+	portapack_lcd_data_write_command_and_data(0x2c, cmd_2c, ARRAY_SIZEOF(cmd_2c));
+}
+
+static void portapack_lcd_set(
+	const uint_fast8_t command,
+	const uint_fast16_t start,
+	const uint_fast16_t end)
+{
+	const uint8_t data[] = {(start >> 8), (start & 0xff), (end >> 8), (end & 0xff)};
+	portapack_lcd_data_write_command_and_data(command, data, ARRAY_SIZEOF(data));
+}
+
+static void portapack_lcd_caset(
+	const uint_fast16_t start_column,
+	const uint_fast16_t end_column)
+{
+	portapack_lcd_set(0x2a, start_column, end_column);
+}
+
+static void portapack_lcd_paset(
+	const uint_fast16_t start_page,
+	const uint_fast16_t end_page)
+{
+	portapack_lcd_set(0x2b, start_page, end_page);
+}
+
+static void portapack_lcd_start_ram_write(const ui_rect_t rect)
+{
+	portapack_lcd_caset(rect.point.x, rect.point.x + rect.size.width - 1);
+	portapack_lcd_paset(rect.point.y, rect.point.y + rect.size.height - 1);
+	portapack_lcd_ramwr_start();
+}
+
+static void portapack_lcd_write_pixel(const ui_color_t pixel)
+{
+	portapack_lcd_write_data(pixel.v);
+}
+
+static void portapack_lcd_write_pixels_color(const ui_color_t c, size_t n)
+{
+	while (n--) {
+		portapack_lcd_write_data(c.v);
+	}
+}
+
+static void portapack_lcd_wake()
+{
+	portapack_lcd_sleep_out();
+	portapack_lcd_display_on();
+}
+
+static void portapack_lcd_reset()
+{
+	portapack_lcd_reset_state(false);
+	portapack_sleep_milliseconds(1);
+	portapack_lcd_reset_state(true);
+	portapack_sleep_milliseconds(10);
+	portapack_lcd_reset_state(false);
+	portapack_sleep_milliseconds(120);
+}
+
+static void portapack_lcd_init()
+{
+	// LCDs are configured for IM[2:0] = 001
+	// 8080-I system, 16-bit parallel bus
+
+	//
+	// 0x3a: DBI[2:0] = 101
+	// MDT[1:0] = XX (if not in 18-bit mode, right?)
+
+	// Power control B
+	// 0
+	// PCEQ=1, DRV_ena=0, Power control=3
+	const uint8_t cmd_cf[] = {0x00, 0xD9, 0x30};
+	portapack_lcd_data_write_command_and_data(0xCF, cmd_cf, ARRAY_SIZEOF(cmd_cf));
+
+	// Power on sequence control
+	const uint8_t cmd_ed[] = {0x64, 0x03, 0x12, 0x81};
+	portapack_lcd_data_write_command_and_data(0xED, cmd_ed, ARRAY_SIZEOF(cmd_ed));
+
+	// Driver timing control A
+	const uint8_t cmd_e8[] = {0x85, 0x10, 0x78};
+	portapack_lcd_data_write_command_and_data(0xE8, cmd_e8, ARRAY_SIZEOF(cmd_e8));
+
+	// Power control A
+	const uint8_t cmd_cb[] = {0x39, 0x2C, 0x00, 0x34, 0x02};
+	portapack_lcd_data_write_command_and_data(0xCB, cmd_cb, ARRAY_SIZEOF(cmd_cb));
+
+	// Pump ratio control
+	const uint8_t cmd_f7[] = {0x20};
+	portapack_lcd_data_write_command_and_data(0xF7, cmd_f7, ARRAY_SIZEOF(cmd_f7));
+
+	// Driver timing control B
+	const uint8_t cmd_ea[] = {0x00, 0x00};
+	portapack_lcd_data_write_command_and_data(0xEA, cmd_ea, ARRAY_SIZEOF(cmd_ea));
+
+	const uint8_t cmd_b1[] = {0x00, 0x1B};
+	portapack_lcd_data_write_command_and_data(0xB1, cmd_b1, ARRAY_SIZEOF(cmd_b1));
+
+	// Blanking Porch Control
+	// VFP = 0b0000010 = 2 (number of HSYNC of vertical front porch)
+	// VBP = 0b0000010 = 2 (number of HSYNC of vertical back porch)
+	// HFP = 0b0001010 = 10 (number of DOTCLOCK of horizontal front porch)
+	// HBP = 0b0010100 = 20 (number of DOTCLOCK of horizontal back porch)
+	const uint8_t cmd_b5[] = {0x02, 0x02, 0x0a, 0x14};
+	portapack_lcd_data_write_command_and_data(0xB5, cmd_b5, ARRAY_SIZEOF(cmd_b5));
+
+	// Display Function Control
+	// PT[1:0] = 0b10
+	// PTG[1:0] = 0b10
+	// ISC[3:0] = 0b0010 (scan cycle interval of gate driver: 5 frames)
+	// SM = 0 (gate driver pin arrangement in combination with GS)
+	// SS = 1 (source output scan direction S720 -> S1)
+	// GS = 0 (gate output scan direction G1 -> G320)
+	// REV = 1 (normally white)
+	// NL = 0b100111 (default)
+	// PCDIV = 0b000000 (default?)
+	const uint8_t cmd_b6[] = {0x0A, 0xA2, 0x27, 0x00};
+	portapack_lcd_data_write_command_and_data(0xB6, cmd_b6, ARRAY_SIZEOF(cmd_b6));
+
+	// Power Control 1
+	//VRH[5:0]
+	const uint8_t cmd_c0[] = {0x1B};
+	portapack_lcd_data_write_command_and_data(0xC0, cmd_c0, ARRAY_SIZEOF(cmd_c0));
+
+	// Power Control 2
+	//SAP[2:0];BT[3:0]
+	const uint8_t cmd_c1[] = {0x12};
+	portapack_lcd_data_write_command_and_data(0xC1, cmd_c1, ARRAY_SIZEOF(cmd_c1));
+
+	// VCOM Control 1
+	const uint8_t cmd_c5[] = {0x32, 0x3C};
+	portapack_lcd_data_write_command_and_data(0xC5, cmd_c5, ARRAY_SIZEOF(cmd_c5));
+
+	// VCOM Control 2
+	const uint8_t cmd_c7[] = {0x9B};
+	portapack_lcd_data_write_command_and_data(0xC7, cmd_c7, ARRAY_SIZEOF(cmd_c7));
+
+	// Memory Access Control
+	// Invert X and Y memory access order, so upper-left of
+	// screen is (0,0) when writing to display.
+	const uint8_t cmd_36[] = {
+		(1 << 7) | // MY=1
+		(1 << 6) | // MX=1
+		(0 << 5) | // MV=0
+		(1 << 4) | // ML=1: reverse vertical refresh to simplify scrolling logic
+		(1 << 3)   // BGR=1: For Kingtech LCD, BGR filter.
+	};
+	portapack_lcd_data_write_command_and_data(0x36, cmd_36, ARRAY_SIZEOF(cmd_36));
+
+	// COLMOD: Pixel Format Set
+	// DPI=101 (16 bits/pixel), DBI=101 (16 bits/pixel)
+	const uint8_t cmd_3a[] = {0x55};
+	portapack_lcd_data_write_command_and_data(0x3A, cmd_3a, ARRAY_SIZEOF(cmd_3a));
+
+	//portapack_lcd_data_write_command_and_data(0xF6, { 0x01, 0x30 });
+	// WEMODE=1 (reset column and page number on overflow)
+	// MDT[1:0]
+	// EPF[1:0]=00 (use channel MSB for LSB)
+	// RIM=0 (If COLMOD[6:4]=101 (65k color), 16-bit RGB interface (1 transfer/pixel))
+	// RM=0 (system interface/VSYNC interface)
+	// DM[1:0]=00 (internal clock operation)
+	// ENDIAN=0 (doesn't matter with 16-bit interface)
+	const uint8_t cmd_f6[] = {0x01, 0x30, 0x00};
+	portapack_lcd_data_write_command_and_data(0xF6, cmd_f6, ARRAY_SIZEOF(cmd_f6));
+
+	// 3Gamma Function Disable
+	const uint8_t cmd_f2[] = {0x00};
+	portapack_lcd_data_write_command_and_data(0xF2, cmd_f2, ARRAY_SIZEOF(cmd_f2));
+
+	// Gamma curve selected
+	const uint8_t cmd_26[] = {0x01};
+	portapack_lcd_data_write_command_and_data(0x26, cmd_26, ARRAY_SIZEOF(cmd_26));
+
+	// Set Gamma
+	const uint8_t cmd_e0[] = {
+		0x0F,
+		0x1D,
+		0x19,
+		0x0E,
+		0x10,
+		0x07,
+		0x4C,
+		0x63,
+		0x3F,
+		0x03,
+		0x0D,
+		0x00,
+		0x26,
+		0x24,
+		0x04};
+	portapack_lcd_data_write_command_and_data(0xE0, cmd_e0, ARRAY_SIZEOF(cmd_e0));
+
+	// Set Gamma
+	const uint8_t cmd_e1[] = {
+		0x00,
+		0x1C,
+		0x1F,
+		0x02,
+		0x0F,
+		0x03,
+		0x35,
+		0x25,
+		0x47,
+		0x04,
+		0x0C,
+		0x0B,
+		0x29,
+		0x2F,
+		0x05};
+	portapack_lcd_data_write_command_and_data(0xE1, cmd_e1, ARRAY_SIZEOF(cmd_e1));
+
+	portapack_lcd_wake();
+
+	// Turn on Tearing Effect Line (TE) output signal.
+	const uint8_t cmd_35[] = {0b00000000};
+	portapack_lcd_data_write_command_and_data(0x35, cmd_35, ARRAY_SIZEOF(cmd_35));
+}
+
+void portapack_backlight(const bool on)
+{
+	portapack_if.io_reg = (portapack_if.io_reg & 0x7f) | (on ? (1 << 7) : 0);
+	portapack_io_write(1, portapack_if.io_reg);
+}
+
+void portapack_reference_oscillator(const bool on)
+{
+	const uint8_t mask = 1 << 6;
+	portapack_if.io_reg = (portapack_if.io_reg & ~mask) | (on ? mask : 0);
+	portapack_io_write(1, portapack_if.io_reg);
+}
+
+void portapack_fill_rectangle(const ui_rect_t rect, const ui_color_t color)
+{
+	portapack_lcd_start_ram_write(rect);
+	portapack_lcd_write_pixels_color(color, rect.size.width * rect.size.height);
+}
+
+void portapack_clear_display(const ui_color_t color)
+{
+	const ui_rect_t rect_screen = {{0, 0}, {240, 320}};
+	portapack_fill_rectangle(rect_screen, color);
+}
+
+void portapack_draw_bitmap(
+	const ui_point_t point,
+	const ui_bitmap_t bitmap,
+	const ui_color_t foreground,
+	const ui_color_t background)
+{
+	const ui_rect_t rect = {.point = point, .size = bitmap.size};
+
+	portapack_lcd_start_ram_write(rect);
+
+	const size_t count = bitmap.size.width * bitmap.size.height;
+	for (size_t i = 0; i < count; i++) {
+		const uint8_t pixel = bitmap.data[i >> 3] & (1U << (i & 0x7));
+		portapack_lcd_write_pixel(pixel ? foreground : background);
+	}
+}
+
+ui_bitmap_t portapack_font_glyph(const ui_font_t* const font, const char c)
+{
+	if (c >= font->c_start) {
+		const uint_fast8_t index = c - font->c_start;
+		if (index < font->c_count) {
+			const ui_bitmap_t bitmap = {
+				.size = font->glyph_size,
+				.data = &font->data[index * font->data_stride]};
+			return bitmap;
+		}
+	}
+
+	const ui_bitmap_t bitmap = {
+		.size = font->glyph_size,
+		.data = font->data,
+	};
+	return bitmap;
+}
+
+static bool jtag_pp_tck(const bool tms_value)
+{
+	gpio_write(jtag_cpld.gpio->gpio_pp_tms, tms_value);
+
+	// 8 ns TMS/TDI to TCK setup
+	__asm__("nop");
+	__asm__("nop");
+	__asm__("nop");
+
+	gpio_set(jtag_cpld.gpio->gpio_tck);
+
+	// 15 ns TCK to TMS/TDI hold time
+	// 20 ns TCK high time
+	__asm__("nop");
+	__asm__("nop");
+	__asm__("nop");
+	__asm__("nop");
+	__asm__("nop");
+
+	gpio_clear(jtag_cpld.gpio->gpio_tck);
+
+	// 20 ns TCK low time
+	// 25 ns TCK falling edge to TDO valid
+	__asm__("nop");
+	__asm__("nop");
+	__asm__("nop");
+	__asm__("nop");
+	__asm__("nop");
+	__asm__("nop");
+	__asm__("nop");
+
+	return gpio_read(jtag_cpld.gpio->gpio_pp_tdo);
+}
+
+static uint32_t jtag_pp_shift(const uint32_t tms_bits, const size_t count)
+{
+	uint32_t result = 0;
+	size_t bit_in_index = count - 1;
+	size_t bit_out_index = 0;
+	while (bit_out_index < count) {
+		const uint32_t tdo = jtag_pp_tck((tms_bits >> bit_in_index) & 1) & 1;
+		result |= (tdo << bit_out_index);
+
+		bit_in_index--;
+		bit_out_index++;
+	}
+
+	return result;
+}
+
+static uint32_t jtag_pp_idcode(void)
+{
+	cpld_jtag_take(&jtag_cpld);
+
+	/* TODO: Check if PortaPack TMS is floating or driven by an external device. */
+	gpio_output(jtag_cpld.gpio->gpio_pp_tms);
+
+	/* Test-Logic/Reset -> Run-Test/Idle -> Select-DR/Scan -> Capture-DR */
+	jtag_pp_shift(0b11111010, 8);
+
+	/* Shift-DR */
+	const uint32_t idcode = jtag_pp_shift(0, 32);
+
+	/* Exit1-DR -> Update-DR -> Run-Test/Idle -> ... -> Test-Logic/Reset */
+	jtag_pp_shift(0b11011111, 8);
+
+	cpld_jtag_release(&jtag_cpld);
+
+	return idcode;
+}
+
+static bool portapack_detect(void)
+{
+	const uint32_t idcode = jtag_pp_idcode();
+	return idcode == 0x00025610 || idcode == 0x020A50DD;
+}
+
+static const portapack_t portapack_instance = {};
+
+static const portapack_t* portapack_pointer = NULL;
+
+const portapack_t* portapack(void)
+{
+	return portapack_pointer;
+}
+
+void portapack_init(void)
+{
+	if (portapack_detect()) {
+		portapack_if_init();
+		portapack_lcd_reset();
+		portapack_lcd_init();
+		portapack_pointer = &portapack_instance;
+	} else {
+		portapack_pointer = NULL;
+	}
+}

hardware/portapack_h2/3d_printed/enclosure/revisited_support.stp

@@ -0,0 +1,986 @@
+ISO-10303-21;
+HEADER;
+/* Generated by software containing ST-Developer
+ * from STEP Tools, Inc. (www.steptools.com) 
+ */
+
+FILE_DESCRIPTION(
+/* description */ (''),
+/* implementation_level */ '2;1');
+
+FILE_NAME(
+/* name */ 
+'D:\\OneDrive\\Projects\\RepRap\\HackRF\\REVISITED\\revisited_support.
+stp',
+/* time_stamp */ '2023-04-11T09:54:07+02:00',
+/* author */ ('erwin'),
+/* organization */ (''),
+/* preprocessor_version */ 'ST-DEVELOPER v18.1',
+/* originating_system */ 'Autodesk Inventor 2022',
+/* authorisation */ '');
+
+FILE_SCHEMA (('AUTOMOTIVE_DESIGN { 1 0 10303 214 3 1 1 }'));
+ENDSEC;
+
+DATA;
+#10=MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#13),#883);
+#11=SHAPE_REPRESENTATION_RELATIONSHIP('SRR','None',#890,#12);
+#12=ADVANCED_BREP_SHAPE_REPRESENTATION('',(#14),#882);
+#13=STYLED_ITEM('',(#899),#14);
+#14=MANIFOLD_SOLID_BREP('Solid1',#461);
+#15=FACE_BOUND('',#135,.T.);
+#16=FACE_BOUND('',#136,.T.);
+#17=FACE_BOUND('',#142,.T.);
+#18=FACE_BOUND('',#145,.T.);
+#19=CONICAL_SURFACE('',#515,1.50402,0.785398163397446);
+#20=CONICAL_SURFACE('',#525,1.50402,0.785398163397446);
+#21=CONICAL_SURFACE('',#530,1.50402,0.785398163397446);
+#22=CONICAL_SURFACE('',#533,1.50402,0.785398163397446);
+#23=PLANE('',#491);
+#24=PLANE('',#500);
+#25=PLANE('',#501);
+#26=PLANE('',#510);
+#27=PLANE('',#518);
+#28=PLANE('',#532);
+#29=PLANE('',#535);
+#30=LINE('',#735,#56);
+#31=LINE('',#738,#57);
+#32=LINE('',#740,#58);
+#33=LINE('',#787,#59);
+#34=LINE('',#792,#60);
+#35=LINE('',#796,#61);
+#36=LINE('',#799,#62);
+#37=LINE('',#802,#63);
+#38=LINE('',#806,#64);
+#39=LINE('',#807,#65);
+#40=LINE('',#810,#66);
+#41=LINE('',#812,#67);
+#42=LINE('',#813,#68);
+#43=LINE('',#818,#69);
+#44=LINE('',#821,#70);
+#45=LINE('',#826,#71);
+#46=LINE('',#829,#72);
+#47=LINE('',#833,#73);
+#48=LINE('',#834,#74);
+#49=LINE('',#843,#75);
+#50=LINE('',#855,#76);
+#51=LINE('',#859,#77);
+#52=LINE('',#865,#78);
+#53=LINE('',#870,#79);
+#54=LINE('',#875,#80);
+#55=LINE('',#878,#81);
+#56=VECTOR('',#550,3.00804);
+#57=VECTOR('',#553,10.);
+#58=VECTOR('',#554,10.);
+#59=VECTOR('',#567,10.);
+#60=VECTOR('',#572,10.);
+#61=VECTOR('',#577,8.02144);
+#62=VECTOR('',#580,10.);
+#63=VECTOR('',#583,10.0268);
+#64=VECTOR('',#588,7.01876);
+#65=VECTOR('',#589,10.0268);
+#66=VECTOR('',#592,10.);
+#67=VECTOR('',#593,10.0268);
+#68=VECTOR('',#594,10.);
+#69=VECTOR('',#599,3.00804);
+#70=VECTOR('',#602,10.);
+#71=VECTOR('',#609,10.);
+#72=VECTOR('',#612,10.);
+#73=VECTOR('',#617,10.);
+#74=VECTOR('',#618,10.0268);
+#75=VECTOR('',#631,1.50402);
+#76=VECTOR('',#646,1.25335);
+#77=VECTOR('',#651,1.50402);
+#78=VECTOR('',#658,1.25335);
+#79=VECTOR('',#665,1.50402);
+#80=VECTOR('',#672,1.50402);
+#81=VECTOR('',#677,10.);
+#82=CYLINDRICAL_SURFACE('',#484,3.00804);
+#83=CYLINDRICAL_SURFACE('',#496,8.02144);
+#84=CYLINDRICAL_SURFACE('',#498,7.01876);
+#85=CYLINDRICAL_SURFACE('',#502,3.00804);
+#86=CYLINDRICAL_SURFACE('',#506,8.02144);
+#87=CYLINDRICAL_SURFACE('',#508,8.02144);
+#88=CYLINDRICAL_SURFACE('',#511,7.01876);
+#89=CYLINDRICAL_SURFACE('',#513,7.01876);
+#90=CYLINDRICAL_SURFACE('',#522,1.15335);
+#91=CYLINDRICAL_SURFACE('',#527,1.15335);
+#92=CYLINDRICAL_SURFACE('',#536,7.01876);
+#93=CYLINDRICAL_SURFACE('',#537,8.02144);
+#94=FACE_OUTER_BOUND('',#119,.T.);
+#95=FACE_OUTER_BOUND('',#120,.T.);
+#96=FACE_OUTER_BOUND('',#121,.T.);
+#97=FACE_OUTER_BOUND('',#122,.T.);
+#98=FACE_OUTER_BOUND('',#123,.T.);
+#99=FACE_OUTER_BOUND('',#124,.T.);
+#100=FACE_OUTER_BOUND('',#125,.T.);
+#101=FACE_OUTER_BOUND('',#126,.T.);
+#102=FACE_OUTER_BOUND('',#127,.T.);
+#103=FACE_OUTER_BOUND('',#128,.T.);
+#104=FACE_OUTER_BOUND('',#129,.T.);
+#105=FACE_OUTER_BOUND('',#130,.T.);
+#106=FACE_OUTER_BOUND('',#131,.T.);
+#107=FACE_OUTER_BOUND('',#132,.T.);
+#108=FACE_OUTER_BOUND('',#133,.T.);
+#109=FACE_OUTER_BOUND('',#134,.T.);
+#110=FACE_OUTER_BOUND('',#137,.T.);
+#111=FACE_OUTER_BOUND('',#138,.T.);
+#112=FACE_OUTER_BOUND('',#139,.T.);
+#113=FACE_OUTER_BOUND('',#140,.T.);
+#114=FACE_OUTER_BOUND('',#141,.T.);
+#115=FACE_OUTER_BOUND('',#143,.T.);
+#116=FACE_OUTER_BOUND('',#144,.T.);
+#117=FACE_OUTER_BOUND('',#146,.T.);
+#118=FACE_OUTER_BOUND('',#147,.T.);
+#119=EDGE_LOOP('',(#300,#301,#302,#303,#304,#305,#306));
+#120=EDGE_LOOP('',(#307,#308,#309,#310,#311,#312,#313,#314));
+#121=EDGE_LOOP('',(#315,#316,#317,#318,#319,#320));
+#122=EDGE_LOOP('',(#321,#322,#323,#324,#325,#326,#327,#328));
+#123=EDGE_LOOP('',(#329,#330,#331,#332));
+#124=EDGE_LOOP('',(#333,#334,#335,#336,#337));
+#125=EDGE_LOOP('',(#338,#339,#340,#341));
+#126=EDGE_LOOP('',(#342,#343,#344,#345));
+#127=EDGE_LOOP('',(#346,#347,#348,#349,#350,#351,#352,#353));
+#128=EDGE_LOOP('',(#354,#355,#356,#357));
+#129=EDGE_LOOP('',(#358,#359,#360,#361));
+#130=EDGE_LOOP('',(#362,#363,#364,#365));
+#131=EDGE_LOOP('',(#366,#367,#368,#369,#370));
+#132=EDGE_LOOP('',(#371,#372,#373,#374,#375));
+#133=EDGE_LOOP('',(#376,#377,#378,#379));
+#134=EDGE_LOOP('',(#380,#381,#382,#383,#384,#385,#386,#387,#388,#389,#390,
+#391,#392,#393,#394));
+#135=EDGE_LOOP('',(#395));
+#136=EDGE_LOOP('',(#396));
+#137=EDGE_LOOP('',(#397,#398,#399,#400,#401));
+#138=EDGE_LOOP('',(#402,#403,#404,#405));
+#139=EDGE_LOOP('',(#406,#407,#408,#409,#410));
+#140=EDGE_LOOP('',(#411,#412,#413,#414,#415));
+#141=EDGE_LOOP('',(#416));
+#142=EDGE_LOOP('',(#417));
+#143=EDGE_LOOP('',(#418,#419,#420,#421,#422));
+#144=EDGE_LOOP('',(#423));
+#145=EDGE_LOOP('',(#424));
+#146=EDGE_LOOP('',(#425,#426,#427,#428,#429));
+#147=EDGE_LOOP('',(#430,#431,#432,#433));
+#148=CIRCLE('',#482,7.00804);
+#149=CIRCLE('',#483,3.00804);
+#150=CIRCLE('',#485,3.00804);
+#151=CIRCLE('',#486,3.00804);
+#152=CIRCLE('',#487,3.00804);
+#153=CIRCLE('',#489,3.00804);
+#154=CIRCLE('',#490,7.00804);
+#155=CIRCLE('',#492,7.01876);
+#156=CIRCLE('',#493,7.01876);
+#157=CIRCLE('',#494,7.01876);
+#158=CIRCLE('',#495,7.01876);
+#159=CIRCLE('',#497,8.02144);
+#160=CIRCLE('',#499,7.01876);
+#161=CIRCLE('',#503,3.00804);
+#162=CIRCLE('',#504,3.00804);
+#163=CIRCLE('',#505,3.00804);
+#164=CIRCLE('',#507,8.02144);
+#165=CIRCLE('',#509,8.02144);
+#166=CIRCLE('',#512,7.01876);
+#167=CIRCLE('',#514,7.01876);
+#168=CIRCLE('',#516,1.75469);
+#169=CIRCLE('',#517,1.15335);
+#170=CIRCLE('',#519,7.01876);
+#171=CIRCLE('',#520,8.02144);
+#172=CIRCLE('',#521,1.75469);
+#173=CIRCLE('',#523,1.15335);
+#174=CIRCLE('',#524,1.15335);
+#175=CIRCLE('',#526,1.15335);
+#176=CIRCLE('',#528,1.15335);
+#177=CIRCLE('',#529,1.15335);
+#178=CIRCLE('',#531,1.75469);
+#179=CIRCLE('',#534,1.75469);
+#180=B_SPLINE_CURVE_WITH_KNOTS('',3,(#684,#685,#686,#687,#688,#689),
+ .UNSPECIFIED.,.F.,.F.,(4,2,4),(1.84958971453185,1.88077149669059,1.89236508906971),
+ .UNSPECIFIED.);
+#181=B_SPLINE_CURVE_WITH_KNOTS('',3,(#693,#694,#695,#696,#697,#698),
+ .UNSPECIFIED.,.F.,.F.,(4,2,4),(0.677497757408314,0.788403142650085,0.821392408392587),
+ .UNSPECIFIED.);
+#182=B_SPLINE_CURVE_WITH_KNOTS('',3,(#700,#701,#702,#703,#704,#705),
+ .UNSPECIFIED.,.F.,.F.,(4,2,4),(0.718120459763341,0.755157597858511,0.76176835105742),
+ .UNSPECIFIED.);
+#183=B_SPLINE_CURVE_WITH_KNOTS('',3,(#707,#708,#709,#710,#711,#712,#713,
+#714,#715,#716),.UNSPECIFIED.,.F.,.F.,(4,2,2,2,4),(1.8094458082449,1.88790790479797,
+2.05305157993795,2.26943298100183,2.27022614805197),.UNSPECIFIED.);
+#184=B_SPLINE_CURVE_WITH_KNOTS('',3,(#719,#720,#721,#722,#723,#724,#725,
+#726,#727,#728,#729,#730),.UNSPECIFIED.,.F.,.F.,(4,2,2,2,2,4),(-0.000793167050811743,
+0.,0.216381428611185,0.381525135470128,0.509883396641204,0.567800192420913),
+ .UNSPECIFIED.);
+#185=B_SPLINE_CURVE_WITH_KNOTS('',3,(#745,#746,#747,#748,#749,#750,#751,
+#752,#753,#754,#755,#756),.UNSPECIFIED.,.F.,.F.,(4,2,2,2,2,4),(1.71827230670034,
+1.75955118014646,1.88790953171987,2.05305335488903,2.26943488454831,2.27022805161283),
+ .UNSPECIFIED.);
+#186=B_SPLINE_CURVE_WITH_KNOTS('',3,(#760,#761,#762,#763,#764,#765,#766,
+#767),.UNSPECIFIED.,.F.,.F.,(4,2,2,4),(-0.000793167053338841,0.,0.216381446124703,
+0.281282906842762),.UNSPECIFIED.);
+#187=B_SPLINE_CURVE_WITH_KNOTS('',3,(#769,#770,#771,#772,#773,#774,#775,
+#776),.UNSPECIFIED.,.F.,.F.,(4,2,2,4),(4.43658033669356,4.60723589928881,
+4.776503081225,4.8535852884345),.UNSPECIFIED.);
+#188=B_SPLINE_CURVE_WITH_KNOTS('',3,(#779,#780,#781,#782),.UNSPECIFIED.,
+ .F.,.F.,(4,4),(0.661852334486626,0.723354146244754),.UNSPECIFIED.);
+#189=VERTEX_POINT('',#682);
+#190=VERTEX_POINT('',#683);
+#191=VERTEX_POINT('',#690);
+#192=VERTEX_POINT('',#692);
+#193=VERTEX_POINT('',#699);
+#194=VERTEX_POINT('',#706);
+#195=VERTEX_POINT('',#717);
+#196=VERTEX_POINT('',#732);
+#197=VERTEX_POINT('',#734);
+#198=VERTEX_POINT('',#736);
+#199=VERTEX_POINT('',#739);
+#200=VERTEX_POINT('',#743);
+#201=VERTEX_POINT('',#744);
+#202=VERTEX_POINT('',#757);
+#203=VERTEX_POINT('',#759);
+#204=VERTEX_POINT('',#768);
+#205=VERTEX_POINT('',#777);
+#206=VERTEX_POINT('',#784);
+#207=VERTEX_POINT('',#786);
+#208=VERTEX_POINT('',#789);
+#209=VERTEX_POINT('',#791);
+#210=VERTEX_POINT('',#795);
+#211=VERTEX_POINT('',#797);
+#212=VERTEX_POINT('',#801);
+#213=VERTEX_POINT('',#805);
+#214=VERTEX_POINT('',#809);
+#215=VERTEX_POINT('',#811);
+#216=VERTEX_POINT('',#815);
+#217=VERTEX_POINT('',#817);
+#218=VERTEX_POINT('',#819);
+#219=VERTEX_POINT('',#824);
+#220=VERTEX_POINT('',#828);
+#221=VERTEX_POINT('',#832);
+#222=VERTEX_POINT('',#840);
+#223=VERTEX_POINT('',#842);
+#224=VERTEX_POINT('',#846);
+#225=VERTEX_POINT('',#849);
+#226=VERTEX_POINT('',#852);
+#227=VERTEX_POINT('',#853);
+#228=VERTEX_POINT('',#858);
+#229=VERTEX_POINT('',#862);
+#230=VERTEX_POINT('',#863);
+#231=VERTEX_POINT('',#868);
+#232=VERTEX_POINT('',#873);
+#233=EDGE_CURVE('',#189,#190,#180,.T.);
+#234=EDGE_CURVE('',#190,#191,#148,.T.);
+#235=EDGE_CURVE('',#191,#192,#181,.T.);
+#236=EDGE_CURVE('',#193,#192,#182,.F.);
+#237=EDGE_CURVE('',#194,#193,#183,.F.);
+#238=EDGE_CURVE('',#194,#195,#149,.T.);
+#239=EDGE_CURVE('',#195,#189,#184,.T.);
+#240=EDGE_CURVE('',#196,#196,#150,.T.);
+#241=EDGE_CURVE('',#196,#197,#30,.T.);
+#242=EDGE_CURVE('',#198,#197,#151,.T.);
+#243=EDGE_CURVE('',#198,#195,#31,.T.);
+#244=EDGE_CURVE('',#194,#199,#32,.T.);
+#245=EDGE_CURVE('',#197,#199,#152,.T.);
+#246=EDGE_CURVE('',#200,#201,#185,.F.);
+#247=EDGE_CURVE('',#200,#202,#153,.T.);
+#248=EDGE_CURVE('',#202,#203,#186,.T.);
+#249=EDGE_CURVE('',#204,#203,#187,.F.);
+#250=EDGE_CURVE('',#204,#205,#154,.T.);
+#251=EDGE_CURVE('',#201,#205,#188,.F.);
+#252=EDGE_CURVE('',#206,#190,#155,.F.);
+#253=EDGE_CURVE('',#206,#207,#33,.T.);
+#254=EDGE_CURVE('',#207,#205,#156,.T.);
+#255=EDGE_CURVE('',#208,#204,#157,.F.);
+#256=EDGE_CURVE('',#208,#209,#34,.T.);
+#257=EDGE_CURVE('',#191,#209,#158,.F.);
+#258=EDGE_CURVE('',#201,#210,#35,.T.);
+#259=EDGE_CURVE('',#210,#211,#159,.T.);
+#260=EDGE_CURVE('',#211,#200,#36,.T.);
+#261=EDGE_CURVE('',#207,#212,#37,.T.);
+#262=EDGE_CURVE('',#212,#210,#160,.T.);
+#263=EDGE_CURVE('',#213,#206,#38,.T.);
+#264=EDGE_CURVE('',#213,#212,#39,.T.);
+#265=EDGE_CURVE('',#208,#214,#40,.T.);
+#266=EDGE_CURVE('',#214,#215,#41,.F.);
+#267=EDGE_CURVE('',#215,#209,#42,.F.);
+#268=EDGE_CURVE('',#216,#216,#161,.T.);
+#269=EDGE_CURVE('',#216,#217,#43,.T.);
+#270=EDGE_CURVE('',#217,#218,#162,.T.);
+#271=EDGE_CURVE('',#218,#202,#44,.T.);
+#272=EDGE_CURVE('',#211,#217,#163,.T.);
+#273=EDGE_CURVE('',#198,#219,#164,.T.);
+#274=EDGE_CURVE('',#189,#219,#45,.T.);
+#275=EDGE_CURVE('',#193,#220,#46,.F.);
+#276=EDGE_CURVE('',#220,#199,#165,.T.);
+#277=EDGE_CURVE('',#192,#221,#47,.T.);
+#278=EDGE_CURVE('',#221,#220,#48,.F.);
+#279=EDGE_CURVE('',#215,#221,#166,.T.);
+#280=EDGE_CURVE('',#219,#213,#167,.T.);
+#281=EDGE_CURVE('',#222,#222,#168,.T.);
+#282=EDGE_CURVE('',#222,#223,#49,.T.);
+#283=EDGE_CURVE('',#223,#223,#169,.F.);
+#284=EDGE_CURVE('',#214,#224,#170,.F.);
+#285=EDGE_CURVE('',#218,#224,#171,.T.);
+#286=EDGE_CURVE('',#225,#225,#172,.T.);
+#287=EDGE_CURVE('',#226,#227,#173,.F.);
+#288=EDGE_CURVE('',#226,#223,#50,.T.);
+#289=EDGE_CURVE('',#227,#226,#174,.F.);
+#290=EDGE_CURVE('',#225,#228,#51,.T.);
+#291=EDGE_CURVE('',#228,#228,#175,.F.);
+#292=EDGE_CURVE('',#229,#230,#176,.F.);
+#293=EDGE_CURVE('',#229,#228,#52,.T.);
+#294=EDGE_CURVE('',#230,#229,#177,.F.);
+#295=EDGE_CURVE('',#231,#231,#178,.T.);
+#296=EDGE_CURVE('',#231,#230,#53,.T.);
+#297=EDGE_CURVE('',#232,#232,#179,.T.);
+#298=EDGE_CURVE('',#232,#227,#54,.T.);
+#299=EDGE_CURVE('',#203,#224,#55,.F.);
+#300=ORIENTED_EDGE('',*,*,#233,.T.);
+#301=ORIENTED_EDGE('',*,*,#234,.T.);
+#302=ORIENTED_EDGE('',*,*,#235,.T.);
+#303=ORIENTED_EDGE('',*,*,#236,.F.);
+#304=ORIENTED_EDGE('',*,*,#237,.F.);
+#305=ORIENTED_EDGE('',*,*,#238,.T.);
+#306=ORIENTED_EDGE('',*,*,#239,.T.);
+#307=ORIENTED_EDGE('',*,*,#240,.T.);
+#308=ORIENTED_EDGE('',*,*,#241,.T.);
+#309=ORIENTED_EDGE('',*,*,#242,.F.);
+#310=ORIENTED_EDGE('',*,*,#243,.T.);
+#311=ORIENTED_EDGE('',*,*,#238,.F.);
+#312=ORIENTED_EDGE('',*,*,#244,.T.);
+#313=ORIENTED_EDGE('',*,*,#245,.F.);
+#314=ORIENTED_EDGE('',*,*,#241,.F.);
+#315=ORIENTED_EDGE('',*,*,#246,.F.);
+#316=ORIENTED_EDGE('',*,*,#247,.T.);
+#317=ORIENTED_EDGE('',*,*,#248,.T.);
+#318=ORIENTED_EDGE('',*,*,#249,.F.);
+#319=ORIENTED_EDGE('',*,*,#250,.T.);
+#320=ORIENTED_EDGE('',*,*,#251,.F.);
+#321=ORIENTED_EDGE('',*,*,#234,.F.);
+#322=ORIENTED_EDGE('',*,*,#252,.F.);
+#323=ORIENTED_EDGE('',*,*,#253,.T.);
+#324=ORIENTED_EDGE('',*,*,#254,.T.);
+#325=ORIENTED_EDGE('',*,*,#250,.F.);
+#326=ORIENTED_EDGE('',*,*,#255,.F.);
+#327=ORIENTED_EDGE('',*,*,#256,.T.);
+#328=ORIENTED_EDGE('',*,*,#257,.F.);
+#329=ORIENTED_EDGE('',*,*,#258,.T.);
+#330=ORIENTED_EDGE('',*,*,#259,.T.);
+#331=ORIENTED_EDGE('',*,*,#260,.T.);
+#332=ORIENTED_EDGE('',*,*,#246,.T.);
+#333=ORIENTED_EDGE('',*,*,#254,.F.);
+#334=ORIENTED_EDGE('',*,*,#261,.T.);
+#335=ORIENTED_EDGE('',*,*,#262,.T.);
+#336=ORIENTED_EDGE('',*,*,#258,.F.);
+#337=ORIENTED_EDGE('',*,*,#251,.T.);
+#338=ORIENTED_EDGE('',*,*,#253,.F.);
+#339=ORIENTED_EDGE('',*,*,#263,.F.);
+#340=ORIENTED_EDGE('',*,*,#264,.T.);
+#341=ORIENTED_EDGE('',*,*,#261,.F.);
+#342=ORIENTED_EDGE('',*,*,#256,.F.);
+#343=ORIENTED_EDGE('',*,*,#265,.T.);
+#344=ORIENTED_EDGE('',*,*,#266,.T.);
+#345=ORIENTED_EDGE('',*,*,#267,.T.);
+#346=ORIENTED_EDGE('',*,*,#268,.F.);
+#347=ORIENTED_EDGE('',*,*,#269,.T.);
+#348=ORIENTED_EDGE('',*,*,#270,.T.);
+#349=ORIENTED_EDGE('',*,*,#271,.T.);
+#350=ORIENTED_EDGE('',*,*,#247,.F.);
+#351=ORIENTED_EDGE('',*,*,#260,.F.);
+#352=ORIENTED_EDGE('',*,*,#272,.T.);
+#353=ORIENTED_EDGE('',*,*,#269,.F.);
+#354=ORIENTED_EDGE('',*,*,#243,.F.);
+#355=ORIENTED_EDGE('',*,*,#273,.T.);
+#356=ORIENTED_EDGE('',*,*,#274,.F.);
+#357=ORIENTED_EDGE('',*,*,#239,.F.);
+#358=ORIENTED_EDGE('',*,*,#275,.T.);
+#359=ORIENTED_EDGE('',*,*,#276,.T.);
+#360=ORIENTED_EDGE('',*,*,#244,.F.);
+#361=ORIENTED_EDGE('',*,*,#237,.T.);
+#362=ORIENTED_EDGE('',*,*,#277,.T.);
+#363=ORIENTED_EDGE('',*,*,#278,.T.);
+#364=ORIENTED_EDGE('',*,*,#275,.F.);
+#365=ORIENTED_EDGE('',*,*,#236,.T.);
+#366=ORIENTED_EDGE('',*,*,#257,.T.);
+#367=ORIENTED_EDGE('',*,*,#267,.F.);
+#368=ORIENTED_EDGE('',*,*,#279,.T.);
+#369=ORIENTED_EDGE('',*,*,#277,.F.);
+#370=ORIENTED_EDGE('',*,*,#235,.F.);
+#371=ORIENTED_EDGE('',*,*,#252,.T.);
+#372=ORIENTED_EDGE('',*,*,#233,.F.);
+#373=ORIENTED_EDGE('',*,*,#274,.T.);
+#374=ORIENTED_EDGE('',*,*,#280,.T.);
+#375=ORIENTED_EDGE('',*,*,#263,.T.);
+#376=ORIENTED_EDGE('',*,*,#281,.T.);
+#377=ORIENTED_EDGE('',*,*,#282,.T.);
+#378=ORIENTED_EDGE('',*,*,#283,.T.);
+#379=ORIENTED_EDGE('',*,*,#282,.F.);
+#380=ORIENTED_EDGE('',*,*,#259,.F.);
+#381=ORIENTED_EDGE('',*,*,#262,.F.);
+#382=ORIENTED_EDGE('',*,*,#264,.F.);
+#383=ORIENTED_EDGE('',*,*,#280,.F.);
+#384=ORIENTED_EDGE('',*,*,#273,.F.);
+#385=ORIENTED_EDGE('',*,*,#242,.T.);
+#386=ORIENTED_EDGE('',*,*,#245,.T.);
+#387=ORIENTED_EDGE('',*,*,#276,.F.);
+#388=ORIENTED_EDGE('',*,*,#278,.F.);
+#389=ORIENTED_EDGE('',*,*,#279,.F.);
+#390=ORIENTED_EDGE('',*,*,#266,.F.);
+#391=ORIENTED_EDGE('',*,*,#284,.T.);
+#392=ORIENTED_EDGE('',*,*,#285,.F.);
+#393=ORIENTED_EDGE('',*,*,#270,.F.);
+#394=ORIENTED_EDGE('',*,*,#272,.F.);
+#395=ORIENTED_EDGE('',*,*,#281,.F.);
+#396=ORIENTED_EDGE('',*,*,#286,.F.);
+#397=ORIENTED_EDGE('',*,*,#287,.F.);
+#398=ORIENTED_EDGE('',*,*,#288,.T.);
+#399=ORIENTED_EDGE('',*,*,#283,.F.);
+#400=ORIENTED_EDGE('',*,*,#288,.F.);
+#401=ORIENTED_EDGE('',*,*,#289,.F.);
+#402=ORIENTED_EDGE('',*,*,#286,.T.);
+#403=ORIENTED_EDGE('',*,*,#290,.T.);
+#404=ORIENTED_EDGE('',*,*,#291,.T.);
+#405=ORIENTED_EDGE('',*,*,#290,.F.);
+#406=ORIENTED_EDGE('',*,*,#292,.F.);
+#407=ORIENTED_EDGE('',*,*,#293,.T.);
+#408=ORIENTED_EDGE('',*,*,#291,.F.);
+#409=ORIENTED_EDGE('',*,*,#293,.F.);
+#410=ORIENTED_EDGE('',*,*,#294,.F.);
+#411=ORIENTED_EDGE('',*,*,#295,.T.);
+#412=ORIENTED_EDGE('',*,*,#296,.T.);
+#413=ORIENTED_EDGE('',*,*,#294,.T.);
+#414=ORIENTED_EDGE('',*,*,#292,.T.);
+#415=ORIENTED_EDGE('',*,*,#296,.F.);
+#416=ORIENTED_EDGE('',*,*,#240,.F.);
+#417=ORIENTED_EDGE('',*,*,#295,.F.);
+#418=ORIENTED_EDGE('',*,*,#297,.T.);
+#419=ORIENTED_EDGE('',*,*,#298,.T.);
+#420=ORIENTED_EDGE('',*,*,#289,.T.);
+#421=ORIENTED_EDGE('',*,*,#287,.T.);
+#422=ORIENTED_EDGE('',*,*,#298,.F.);
+#423=ORIENTED_EDGE('',*,*,#268,.T.);
+#424=ORIENTED_EDGE('',*,*,#297,.F.);
+#425=ORIENTED_EDGE('',*,*,#255,.T.);
+#426=ORIENTED_EDGE('',*,*,#249,.T.);
+#427=ORIENTED_EDGE('',*,*,#299,.T.);
+#428=ORIENTED_EDGE('',*,*,#284,.F.);
+#429=ORIENTED_EDGE('',*,*,#265,.F.);
+#430=ORIENTED_EDGE('',*,*,#271,.F.);
+#431=ORIENTED_EDGE('',*,*,#285,.T.);
+#432=ORIENTED_EDGE('',*,*,#299,.F.);
+#433=ORIENTED_EDGE('',*,*,#248,.F.);
+#434=TOROIDAL_SURFACE('',#481,7.00804000000001,4.);
+#435=TOROIDAL_SURFACE('',#488,7.00804,4.);
+#436=ADVANCED_FACE('',(#94),#434,.F.);
+#437=ADVANCED_FACE('',(#95),#82,.T.);
+#438=ADVANCED_FACE('',(#96),#435,.F.);
+#439=ADVANCED_FACE('',(#97),#23,.T.);
+#440=ADVANCED_FACE('',(#98),#83,.F.);
+#441=ADVANCED_FACE('',(#99),#84,.T.);
+#442=ADVANCED_FACE('',(#100),#24,.T.);
+#443=ADVANCED_FACE('',(#101),#25,.T.);
+#444=ADVANCED_FACE('',(#102),#85,.T.);
+#445=ADVANCED_FACE('',(#103),#86,.F.);
+#446=ADVANCED_FACE('',(#104),#87,.F.);
+#447=ADVANCED_FACE('',(#105),#26,.T.);
+#448=ADVANCED_FACE('',(#106),#88,.F.);
+#449=ADVANCED_FACE('',(#107),#89,.T.);
+#450=ADVANCED_FACE('',(#108),#19,.F.);
+#451=ADVANCED_FACE('',(#109,#15,#16),#27,.T.);
+#452=ADVANCED_FACE('',(#110),#90,.F.);
+#453=ADVANCED_FACE('',(#111),#20,.F.);
+#454=ADVANCED_FACE('',(#112),#91,.F.);
+#455=ADVANCED_FACE('',(#113),#21,.F.);
+#456=ADVANCED_FACE('',(#114,#17),#28,.T.);
+#457=ADVANCED_FACE('',(#115),#22,.F.);
+#458=ADVANCED_FACE('',(#116,#18),#29,.F.);
+#459=ADVANCED_FACE('',(#117),#92,.F.);
+#460=ADVANCED_FACE('',(#118),#93,.F.);
+#461=CLOSED_SHELL('',(#436,#437,#438,#439,#440,#441,#442,#443,#444,#445,
+#446,#447,#448,#449,#450,#451,#452,#453,#454,#455,#456,#457,#458,#459,#460));
+#462=DERIVED_UNIT_ELEMENT(#464,1.);
+#463=DERIVED_UNIT_ELEMENT(#885,-3.);
+#464=(
+MASS_UNIT()
+NAMED_UNIT(*)
+SI_UNIT($,.GRAM.)
+);
+#465=DERIVED_UNIT((#462,#463));
+#466=MEASURE_REPRESENTATION_ITEM('density measure',
+POSITIVE_RATIO_MEASURE(1.),#465);
+#467=PROPERTY_DEFINITION_REPRESENTATION(#472,#469);
+#468=PROPERTY_DEFINITION_REPRESENTATION(#473,#470);
+#469=REPRESENTATION('material name',(#471),#882);
+#470=REPRESENTATION('density',(#466),#882);
+#471=DESCRIPTIVE_REPRESENTATION_ITEM('Generic','Generic');
+#472=PROPERTY_DEFINITION('material property','material name',#892);
+#473=PROPERTY_DEFINITION('material property','density of part',#892);
+#474=DATE_TIME_ROLE('creation_date');
+#475=APPLIED_DATE_AND_TIME_ASSIGNMENT(#476,#474,(#892));
+#476=DATE_AND_TIME(#477,#478);
+#477=CALENDAR_DATE(2020,5,10);
+#478=LOCAL_TIME(0,0,0.,#479);
+#479=COORDINATED_UNIVERSAL_TIME_OFFSET(0,0,.BEHIND.);
+#480=AXIS2_PLACEMENT_3D('placement',#680,#538,#539);
+#481=AXIS2_PLACEMENT_3D('',#681,#540,#541);
+#482=AXIS2_PLACEMENT_3D('',#691,#542,#543);
+#483=AXIS2_PLACEMENT_3D('',#718,#544,#545);
+#484=AXIS2_PLACEMENT_3D('',#731,#546,#547);
+#485=AXIS2_PLACEMENT_3D('',#733,#548,#549);
+#486=AXIS2_PLACEMENT_3D('',#737,#551,#552);
+#487=AXIS2_PLACEMENT_3D('',#741,#555,#556);
+#488=AXIS2_PLACEMENT_3D('',#742,#557,#558);
+#489=AXIS2_PLACEMENT_3D('',#758,#559,#560);
+#490=AXIS2_PLACEMENT_3D('',#778,#561,#562);
+#491=AXIS2_PLACEMENT_3D('',#783,#563,#564);
+#492=AXIS2_PLACEMENT_3D('',#785,#565,#566);
+#493=AXIS2_PLACEMENT_3D('',#788,#568,#569);
+#494=AXIS2_PLACEMENT_3D('',#790,#570,#571);
+#495=AXIS2_PLACEMENT_3D('',#793,#573,#574);
+#496=AXIS2_PLACEMENT_3D('',#794,#575,#576);
+#497=AXIS2_PLACEMENT_3D('',#798,#578,#579);
+#498=AXIS2_PLACEMENT_3D('',#800,#581,#582);
+#499=AXIS2_PLACEMENT_3D('',#803,#584,#585);
+#500=AXIS2_PLACEMENT_3D('',#804,#586,#587);
+#501=AXIS2_PLACEMENT_3D('',#808,#590,#591);
+#502=AXIS2_PLACEMENT_3D('',#814,#595,#596);
+#503=AXIS2_PLACEMENT_3D('',#816,#597,#598);
+#504=AXIS2_PLACEMENT_3D('',#820,#600,#601);
+#505=AXIS2_PLACEMENT_3D('',#822,#603,#604);
+#506=AXIS2_PLACEMENT_3D('',#823,#605,#606);
+#507=AXIS2_PLACEMENT_3D('',#825,#607,#608);
+#508=AXIS2_PLACEMENT_3D('',#827,#610,#611);
+#509=AXIS2_PLACEMENT_3D('',#830,#613,#614);
+#510=AXIS2_PLACEMENT_3D('',#831,#615,#616);
+#511=AXIS2_PLACEMENT_3D('',#835,#619,#620);
+#512=AXIS2_PLACEMENT_3D('',#836,#621,#622);
+#513=AXIS2_PLACEMENT_3D('',#837,#623,#624);
+#514=AXIS2_PLACEMENT_3D('',#838,#625,#626);
+#515=AXIS2_PLACEMENT_3D('',#839,#627,#628);
+#516=AXIS2_PLACEMENT_3D('',#841,#629,#630);
+#517=AXIS2_PLACEMENT_3D('',#844,#632,#633);
+#518=AXIS2_PLACEMENT_3D('',#845,#634,#635);
+#519=AXIS2_PLACEMENT_3D('',#847,#636,#637);
+#520=AXIS2_PLACEMENT_3D('',#848,#638,#639);
+#521=AXIS2_PLACEMENT_3D('',#850,#640,#641);
+#522=AXIS2_PLACEMENT_3D('',#851,#642,#643);
+#523=AXIS2_PLACEMENT_3D('',#854,#644,#645);
+#524=AXIS2_PLACEMENT_3D('',#856,#647,#648);
+#525=AXIS2_PLACEMENT_3D('',#857,#649,#650);
+#526=AXIS2_PLACEMENT_3D('',#860,#652,#653);
+#527=AXIS2_PLACEMENT_3D('',#861,#654,#655);
+#528=AXIS2_PLACEMENT_3D('',#864,#656,#657);
+#529=AXIS2_PLACEMENT_3D('',#866,#659,#660);
+#530=AXIS2_PLACEMENT_3D('',#867,#661,#662);
+#531=AXIS2_PLACEMENT_3D('',#869,#663,#664);
+#532=AXIS2_PLACEMENT_3D('',#871,#666,#667);
+#533=AXIS2_PLACEMENT_3D('',#872,#668,#669);
+#534=AXIS2_PLACEMENT_3D('',#874,#670,#671);
+#535=AXIS2_PLACEMENT_3D('',#876,#673,#674);
+#536=AXIS2_PLACEMENT_3D('',#877,#675,#676);
+#537=AXIS2_PLACEMENT_3D('',#879,#678,#679);
+#538=DIRECTION('axis',(0.,0.,1.));
+#539=DIRECTION('refdir',(1.,0.,0.));
+#540=DIRECTION('center_axis',(0.,0.,-1.));
+#541=DIRECTION('ref_axis',(-1.,0.,0.));
+#542=DIRECTION('center_axis',(0.,0.,1.));
+#543=DIRECTION('ref_axis',(-0.914718354155798,0.404091985283683,0.));
+#544=DIRECTION('center_axis',(0.,0.,-1.));
+#545=DIRECTION('ref_axis',(-0.914718354155798,0.404091985283683,0.));
+#546=DIRECTION('center_axis',(0.,0.,-1.));
+#547=DIRECTION('ref_axis',(-1.,0.,0.));
+#548=DIRECTION('center_axis',(0.,0.,-1.));
+#549=DIRECTION('ref_axis',(-1.,0.,0.));
+#550=DIRECTION('',(0.,0.,-1.));
+#551=DIRECTION('center_axis',(0.,0.,-1.));
+#552=DIRECTION('ref_axis',(-1.,0.,0.));
+#553=DIRECTION('',(0.,0.,1.));
+#554=DIRECTION('',(0.,0.,-1.));
+#555=DIRECTION('center_axis',(0.,0.,-1.));
+#556=DIRECTION('ref_axis',(-1.,0.,0.));
+#557=DIRECTION('center_axis',(0.,0.,1.));
+#558=DIRECTION('ref_axis',(1.,0.,0.));
+#559=DIRECTION('center_axis',(0.,0.,-1.));
+#560=DIRECTION('ref_axis',(0.902489931377324,0.430710951523817,0.));
+#561=DIRECTION('center_axis',(0.,0.,1.));
+#562=DIRECTION('ref_axis',(0.902489931377324,0.430710951523817,0.));
+#563=DIRECTION('center_axis',(0.,0.,1.));
+#564=DIRECTION('ref_axis',(1.,0.,0.));
+#565=DIRECTION('center_axis',(0.,0.,1.));
+#566=DIRECTION('ref_axis',(0.,-1.,0.));
+#567=DIRECTION('',(-1.,-1.98254111540207E-16,0.));
+#568=DIRECTION('center_axis',(0.,0.,1.));
+#569=DIRECTION('ref_axis',(-0.227318181659297,0.973820540082777,0.));
+#570=DIRECTION('center_axis',(0.,0.,-1.));
+#571=DIRECTION('ref_axis',(0.,-1.,0.));
+#572=DIRECTION('',(1.,0.,0.));
+#573=DIRECTION('center_axis',(0.,0.,-1.));
+#574=DIRECTION('ref_axis',(0.265195148400822,0.964194758990457,0.));
+#575=DIRECTION('center_axis',(0.,0.,1.));
+#576=DIRECTION('ref_axis',(0.166497708562777,0.986041841426288,0.));
+#577=DIRECTION('',(0.,0.,-1.));
+#578=DIRECTION('center_axis',(0.,0.,-1.));
+#579=DIRECTION('ref_axis',(0.166497708562777,0.986041841426288,0.));
+#580=DIRECTION('',(0.,0.,1.));
+#581=DIRECTION('center_axis',(0.,0.,1.));
+#582=DIRECTION('ref_axis',(-0.227318181659297,0.973820540082777,0.));
+#583=DIRECTION('',(0.,0.,-1.));
+#584=DIRECTION('center_axis',(0.,0.,1.));
+#585=DIRECTION('ref_axis',(-0.227318181659297,0.973820540082777,0.));
+#586=DIRECTION('center_axis',(-1.98254111540207E-16,1.,0.));
+#587=DIRECTION('ref_axis',(-1.,-1.98254111540207E-16,0.));
+#588=DIRECTION('',(0.,0.,1.));
+#589=DIRECTION('',(-1.,-1.98254111540207E-16,0.));
+#590=DIRECTION('center_axis',(0.,-1.,0.));
+#591=DIRECTION('ref_axis',(1.,0.,0.));
+#592=DIRECTION('',(0.,0.,-1.));
+#593=DIRECTION('',(-1.,0.,0.));
+#594=DIRECTION('',(0.,0.,-1.));
+#595=DIRECTION('center_axis',(0.,0.,1.));
+#596=DIRECTION('ref_axis',(1.,0.,0.));
+#597=DIRECTION('center_axis',(0.,0.,1.));
+#598=DIRECTION('ref_axis',(1.,0.,0.));
+#599=DIRECTION('',(0.,0.,-1.));
+#600=DIRECTION('center_axis',(0.,0.,1.));
+#601=DIRECTION('ref_axis',(1.,0.,0.));
+#602=DIRECTION('',(0.,0.,1.));
+#603=DIRECTION('center_axis',(0.,0.,1.));
+#604=DIRECTION('ref_axis',(1.,0.,0.));
+#605=DIRECTION('center_axis',(0.,0.,1.));
+#606=DIRECTION('ref_axis',(-0.17448917007188,-0.984659093050801,0.));
+#607=DIRECTION('center_axis',(0.,0.,-1.));
+#608=DIRECTION('ref_axis',(-0.17448917007188,-0.984659093050801,0.));
+#609=DIRECTION('',(0.,0.,-1.));
+#610=DIRECTION('center_axis',(0.,0.,-1.));
+#611=DIRECTION('ref_axis',(0.701436943476595,0.712731516299239,0.));
+#612=DIRECTION('',(0.,0.,1.));
+#613=DIRECTION('center_axis',(0.,0.,-1.));
+#614=DIRECTION('ref_axis',(0.701436943476595,0.712731516299239,0.));
+#615=DIRECTION('center_axis',(-0.511399544395539,-0.859343066529332,0.));
+#616=DIRECTION('ref_axis',(0.859343066529332,-0.511399544395539,0.));
+#617=DIRECTION('',(0.,0.,-1.));
+#618=DIRECTION('',(-0.859343066529332,0.511399544395539,0.));
+#619=DIRECTION('center_axis',(0.,0.,1.));
+#620=DIRECTION('ref_axis',(0.265195148400822,0.964194758990457,0.));
+#621=DIRECTION('center_axis',(0.,0.,-1.));
+#622=DIRECTION('ref_axis',(0.265195148400822,0.964194758990457,0.));
+#623=DIRECTION('center_axis',(0.,0.,-1.));
+#624=DIRECTION('ref_axis',(0.,-1.,0.));
+#625=DIRECTION('center_axis',(0.,0.,1.));
+#626=DIRECTION('ref_axis',(0.,-1.,0.));
+#627=DIRECTION('center_axis',(0.,0.,-1.));
+#628=DIRECTION('ref_axis',(1.,0.,0.));
+#629=DIRECTION('center_axis',(0.,0.,-1.));
+#630=DIRECTION('ref_axis',(1.,0.,0.));
+#631=DIRECTION('',(0.707106781186546,-8.65956056235492E-17,0.707106781186549));
+#632=DIRECTION('center_axis',(0.,0.,-1.));
+#633=DIRECTION('ref_axis',(1.,0.,0.));
+#634=DIRECTION('center_axis',(0.,0.,-1.));
+#635=DIRECTION('ref_axis',(-1.,0.,0.));
+#636=DIRECTION('center_axis',(0.,0.,-1.));
+#637=DIRECTION('ref_axis',(0.,-1.,0.));
+#638=DIRECTION('center_axis',(0.,0.,-1.));
+#639=DIRECTION('ref_axis',(-0.687645856987837,0.726046262553195,0.));
+#640=DIRECTION('center_axis',(0.,0.,-1.));
+#641=DIRECTION('ref_axis',(-1.,0.,0.));
+#642=DIRECTION('center_axis',(0.,0.,1.));
+#643=DIRECTION('ref_axis',(1.,0.,0.));
+#644=DIRECTION('center_axis',(0.,0.,1.));
+#645=DIRECTION('ref_axis',(1.,0.,0.));
+#646=DIRECTION('',(0.,0.,-1.));
+#647=DIRECTION('center_axis',(0.,0.,1.));
+#648=DIRECTION('ref_axis',(1.,0.,0.));
+#649=DIRECTION('center_axis',(0.,0.,-1.));
+#650=DIRECTION('ref_axis',(-1.,0.,0.));
+#651=DIRECTION('',(-0.707106781186546,8.65956056235492E-17,0.707106781186549));
+#652=DIRECTION('center_axis',(0.,0.,-1.));
+#653=DIRECTION('ref_axis',(-1.,0.,0.));
+#654=DIRECTION('center_axis',(0.,0.,-1.));
+#655=DIRECTION('ref_axis',(-1.,0.,0.));
+#656=DIRECTION('center_axis',(0.,0.,1.));
+#657=DIRECTION('ref_axis',(-1.,0.,0.));
+#658=DIRECTION('',(0.,0.,-1.));
+#659=DIRECTION('center_axis',(0.,0.,1.));
+#660=DIRECTION('ref_axis',(-1.,0.,0.));
+#661=DIRECTION('center_axis',(0.,0.,1.));
+#662=DIRECTION('ref_axis',(1.,0.,0.));
+#663=DIRECTION('center_axis',(0.,0.,1.));
+#664=DIRECTION('ref_axis',(1.,0.,0.));
+#665=DIRECTION('',(0.707106781186546,8.65956056235491E-17,-0.707106781186549));
+#666=DIRECTION('center_axis',(0.,0.,1.));
+#667=DIRECTION('ref_axis',(1.,0.,0.));
+#668=DIRECTION('center_axis',(0.,0.,1.));
+#669=DIRECTION('ref_axis',(-1.,0.,0.));
+#670=DIRECTION('center_axis',(0.,0.,1.));
+#671=DIRECTION('ref_axis',(-1.,0.,0.));
+#672=DIRECTION('',(-0.707106781186546,-8.65956056235491E-17,-0.707106781186549));
+#673=DIRECTION('center_axis',(0.,0.,-1.));
+#674=DIRECTION('ref_axis',(-1.,0.,0.));
+#675=DIRECTION('center_axis',(0.,0.,1.));
+#676=DIRECTION('ref_axis',(0.,-1.,0.));
+#677=DIRECTION('',(0.,0.,1.));
+#678=DIRECTION('center_axis',(0.,0.,1.));
+#679=DIRECTION('ref_axis',(-0.687645856987837,0.726046262553195,0.));
+#680=CARTESIAN_POINT('',(0.,0.,0.));
+#681=CARTESIAN_POINT('Origin',(56.15008,33.58978,9.00804));
+#682=CARTESIAN_POINT('',(50.6247958150228,37.2041966558329,5.02865273728351));
+#683=CARTESIAN_POINT('',(50.2500667968349,37.371640500346,5.00804));
+#684=CARTESIAN_POINT('Ctrl Pts',(50.6247958150228,37.2041966558329,5.02865273728351));
+#685=CARTESIAN_POINT('Ctrl Pts',(50.5357227502342,37.2471651591677,5.01865867292698));
+#686=CARTESIAN_POINT('Ctrl Pts',(50.4451021174361,37.2885580963717,5.01227776512809));
+#687=CARTESIAN_POINT('Ctrl Pts',(50.3188228412002,37.3429786608689,5.00854341432407));
+#688=CARTESIAN_POINT('Ctrl Pts',(50.2844922321955,37.3574503025008,5.00804000000001));
+#689=CARTESIAN_POINT('Ctrl Pts',(50.2500667968359,37.3716405003456,5.00804));
+#690=CARTESIAN_POINT('',(49.3915707992385,35.4432033258548,5.00804));
+#691=CARTESIAN_POINT('Origin',(56.15008,33.58978,5.00804));
+#692=CARTESIAN_POINT('',(50.5009650642326,34.9087067416334,5.19449159161523));
+#693=CARTESIAN_POINT('Ctrl Pts',(49.3915707992386,35.4432033258547,5.00804));
+#694=CARTESIAN_POINT('Ctrl Pts',(49.6951751671788,35.328531451996,5.00804000000001));
+#695=CARTESIAN_POINT('Ctrl Pts',(49.9860105158439,35.1945427153753,5.04710404861977));
+#696=CARTESIAN_POINT('Ctrl Pts',(50.3432741314213,35.0005095939757,5.14244590473823));
+#697=CARTESIAN_POINT('Ctrl Pts',(50.4231029442769,34.9550428956352,5.16715902818914));
+#698=CARTESIAN_POINT('Ctrl Pts',(50.5009650642326,34.9087067416334,5.19449159161523));
+#699=CARTESIAN_POINT('',(50.865434714585,34.6918089502903,5.34623350576054));
+#700=CARTESIAN_POINT('Ctrl Pts',(50.5009650642326,34.9087067416334,5.19449159161523));
+#701=CARTESIAN_POINT('Ctrl Pts',(50.6092970149861,34.8442378322808,5.2325202237245));
+#702=CARTESIAN_POINT('Ctrl Pts',(50.713867355334,34.7820074769152,5.27543332367862));
+#703=CARTESIAN_POINT('Ctrl Pts',(50.8300172908763,34.7128860440073,5.32928148605159));
+#704=CARTESIAN_POINT('Ctrl Pts',(50.8476922638109,34.702367575356,5.33765072778525));
+#705=CARTESIAN_POINT('Ctrl Pts',(50.865434714585,34.6918089502903,5.34623350576053));
+#706=CARTESIAN_POINT('',(53.5900419872343,32.0103782098292,9.00804));
+#707=CARTESIAN_POINT('Ctrl Pts',(50.865434714585,34.6918089502903,5.34623350576054));
+#708=CARTESIAN_POINT('Ctrl Pts',(51.1121207963903,34.5450047753834,5.46556605438542));
+#709=CARTESIAN_POINT('Ctrl Pts',(51.3409384813757,34.3909239972629,5.61283853761381));
+#710=CARTESIAN_POINT('Ctrl Pts',(51.9985611380572,33.901436736254,6.14034807784202));
+#711=CARTESIAN_POINT('Ctrl Pts',(52.36002697223,33.5624215607093,6.59035964936713));
+#712=CARTESIAN_POINT('Ctrl Pts',(53.0622110060386,32.7998916705579,7.71732122046303));
+#713=CARTESIAN_POINT('Ctrl Pts',(53.3621670790386,32.3792556992102,8.42174702507106));
+#714=CARTESIAN_POINT('Ctrl Pts',(53.5883907362628,32.0130538273486,9.00378851990973));
+#715=CARTESIAN_POINT('Ctrl Pts',(53.5892165587142,32.0117161394183,9.00591426074358));
+#716=CARTESIAN_POINT('Ctrl Pts',(53.5900419872343,32.0103782098292,9.00804));
+#717=CARTESIAN_POINT('',(55.5936905952374,36.545915225572,9.00804));
+#718=CARTESIAN_POINT('Origin',(56.15008,33.58978,9.00804));
+#719=CARTESIAN_POINT('Ctrl Pts',(55.5936905952374,36.545915225572,9.00804));
+#720=CARTESIAN_POINT('Ctrl Pts',(55.592145656931,36.5456244447927,9.00591426074139));
+#721=CARTESIAN_POINT('Ctrl Pts',(55.5906006319998,36.5453341179705,9.003788519914));
+#722=CARTESIAN_POINT('Ctrl Pts',(55.1675385371182,36.4659649486835,8.42174695117465));
+#723=CARTESIAN_POINT('Ctrl Pts',(54.6545826862427,36.4044463028556,7.71732117907136));
+#724=CARTESIAN_POINT('Ctrl Pts',(53.6180100302521,36.4100409995902,6.59035964936721));
+#725=CARTESIAN_POINT('Ctrl Pts',(53.1239713487764,36.4489591152896,6.14034807784204));
+#726=CARTESIAN_POINT('Ctrl Pts',(52.1544325475448,36.6375433694353,5.50479228867297));
+#727=CARTESIAN_POINT('Ctrl Pts',(51.706839390841,36.7599974653572,5.28734773854807));
+#728=CARTESIAN_POINT('Ctrl Pts',(51.0368192247517,37.0161904928946,5.09359272486355));
+#729=CARTESIAN_POINT('Ctrl Pts',(50.8294613797647,37.1054667718539,5.05161636663702));
+#730=CARTESIAN_POINT('Ctrl Pts',(50.6247958150228,37.2041966558329,5.02865273728351));
+#731=CARTESIAN_POINT('Origin',(56.15008,33.58978,8.34898816748364E-16));
+#732=CARTESIAN_POINT('',(59.15812,33.58978,11.02948));
+#733=CARTESIAN_POINT('Origin',(56.15008,33.58978,11.02948));
+#734=CARTESIAN_POINT('',(59.15812,33.58978,8.34898816748364E-16));
+#735=CARTESIAN_POINT('',(59.15812,33.58978,8.34898816748364E-16));
+#736=CARTESIAN_POINT('',(55.5936905952374,36.545915225572,8.34898816748364E-16));
+#737=CARTESIAN_POINT('Origin',(56.15008,33.58978,8.34898816748364E-16));
+#738=CARTESIAN_POINT('',(55.5936905952374,36.545915225572,8.34898816748364E-16));
+#739=CARTESIAN_POINT('',(53.5900419872343,32.0103782098292,8.34898816748364E-16));
+#740=CARTESIAN_POINT('',(53.5900419872343,32.0103782098292,8.34898816748364E-16));
+#741=CARTESIAN_POINT('Origin',(56.15008,33.58978,8.34898816748364E-16));
+#742=CARTESIAN_POINT('Origin',(-56.15008,33.58978,9.00804));
+#743=CARTESIAN_POINT('',(-55.6492482327348,36.5558333006839,9.00804));
+#744=CARTESIAN_POINT('',(-50.8690026990792,37.2211675600968,5.05313309133144));
+#745=CARTESIAN_POINT('Ctrl Pts',(-50.8690026990792,37.2211675600968,5.05313309133144));
+#746=CARTESIAN_POINT('Ctrl Pts',(-51.0145997406747,37.1519340562777,5.07724190703958));
+#747=CARTESIAN_POINT('Ctrl Pts',(-51.1614075276573,37.0875150337691,5.11089878051668));
+#748=CARTESIAN_POINT('Ctrl Pts',(-51.7670974898426,36.8427986295485,5.28734773854807));
+#749=CARTESIAN_POINT('Ctrl Pts',(-52.2123145225646,36.7119688419987,5.50479228867298));
+#750=CARTESIAN_POINT('Ctrl Pts',(-53.1781446766363,36.5052283730743,6.14034807784203));
+#751=CARTESIAN_POINT('Ctrl Pts',(-53.6713662685796,36.4570485041999,6.59035964936717));
+#752=CARTESIAN_POINT('Ctrl Pts',(-54.7076513859303,36.4320077753044,7.71732102739605));
+#753=CARTESIAN_POINT('Ctrl Pts',(-55.2216710420583,36.4838920515183,8.42174668038323));
+#754=CARTESIAN_POINT('Ctrl Pts',(-55.6461479112677,36.5553102658067,9.00378851994531));
+#755=CARTESIAN_POINT('Ctrl Pts',(-55.6476981110072,36.5555715554873,9.00591426070426));
+#756=CARTESIAN_POINT('Ctrl Pts',(-55.6492482327348,36.5558333006839,9.00804));
+#757=CARTESIAN_POINT('',(-53.5291859784223,32.1135621403131,9.00804));
+#758=CARTESIAN_POINT('Origin',(-56.15008,33.58978,9.00804));
+#759=CARTESIAN_POINT('',(-52.2816789701062,33.7786037525209,6.52377627814055));
+#760=CARTESIAN_POINT('Ctrl Pts',(-53.5291859784223,32.1135621403131,9.00804));
+#761=CARTESIAN_POINT('Ctrl Pts',(-53.5284144759865,32.1149318745353,9.00591426073462));
+#762=CARTESIAN_POINT('Ctrl Pts',(-53.5276425703196,32.1163013829575,9.00378851991685));
+#763=CARTESIAN_POINT('Ctrl Pts',(-53.3161791000315,32.4912203499456,8.421746904257));
+#764=CARTESIAN_POINT('Ctrl Pts',(-53.0332091000439,32.923465901452,7.71732115279223));
+#765=CARTESIAN_POINT('Ctrl Pts',(-52.5383121465054,33.5058147781869,6.88645852589308));
+#766=CARTESIAN_POINT('Ctrl Pts',(-52.4152132167845,33.641733996463,6.70051126035222));
+#767=CARTESIAN_POINT('Ctrl Pts',(-52.2816789701062,33.7786037525209,6.52377627814055));
+#768=CARTESIAN_POINT('',(-49.4228448227586,35.5536872054672,5.00804));
+#769=CARTESIAN_POINT('Ctrl Pts',(-52.2816789701062,33.7786037525209,6.52377627814055));
+#770=CARTESIAN_POINT('Ctrl Pts',(-52.0283995813855,34.0382097260861,6.188556442245));
+#771=CARTESIAN_POINT('Ctrl Pts',(-51.7254354644008,34.3097161939923,5.87034180686871));
+#772=CARTESIAN_POINT('Ctrl Pts',(-50.9861359604753,34.8410968297498,5.35362337513694));
+#773=CARTESIAN_POINT('Ctrl Pts',(-50.5662347209846,35.0890773541913,5.16508026972491));
+#774=CARTESIAN_POINT('Ctrl Pts',(-49.8740938940358,35.3944054481485,5.02954756629323));
+#775=CARTESIAN_POINT('Ctrl Pts',(-49.6508407134816,35.4797540591315,5.00804));
+#776=CARTESIAN_POINT('Ctrl Pts',(-49.4228448227586,35.5536872054672,5.00804));
+#777=CARTESIAN_POINT('',(-50.3070040221276,37.4590289915242,5.00804));
+#778=CARTESIAN_POINT('Origin',(-56.15008,33.58978,5.00804));
+#779=CARTESIAN_POINT('Ctrl Pts',(-50.3070040221276,37.4590289915242,5.00804));
+#780=CARTESIAN_POINT('Ctrl Pts',(-50.4981604245898,37.3877544004905,5.00804));
+#781=CARTESIAN_POINT('Ctrl Pts',(-50.685995630357,37.3081900739412,5.02282970300183));
+#782=CARTESIAN_POINT('Ctrl Pts',(-50.8690026990792,37.2211675600968,5.05313309133144));
+#783=CARTESIAN_POINT('Origin',(-0.143365748922946,36.1667324932162,5.00804));
+#784=CARTESIAN_POINT('',(47.5752549255443,37.901304,5.00804));
+#785=CARTESIAN_POINT('Origin',(47.5752549255443,30.882544,5.00804));
+#786=CARTESIAN_POINT('',(-47.8548953186122,37.901304,5.00804));
+#787=CARTESIAN_POINT('',(24.625115448216,37.901304,5.00804));
+#788=CARTESIAN_POINT('Origin',(-47.8548953186122,30.882544,5.00804));
+#789=CARTESIAN_POINT('',(-47.2578282212087,35.895944,5.00804));
+#790=CARTESIAN_POINT('Origin',(-47.2578282212087,28.877184,5.00804));
+#791=CARTESIAN_POINT('',(46.911574398011,35.895944,5.00804));
+#792=CARTESIAN_POINT('',(-24.7012950035171,35.895944,5.00804));
+#793=CARTESIAN_POINT('Origin',(46.911574398011,28.877184,5.00804));
+#794=CARTESIAN_POINT('Origin',(-54.313696853361,44.4653087691744,8.34898816748364E-16));
+#795=CARTESIAN_POINT('',(-50.8690027014949,37.2211675589481,8.34898816748364E-16));
+#796=CARTESIAN_POINT('',(-50.8690027014949,37.2211675589481,8.34898816748364E-16));
+#797=CARTESIAN_POINT('',(-55.6492482327348,36.5558333006839,8.34898816748364E-16));
+#798=CARTESIAN_POINT('Origin',(-54.313696853361,44.4653087691744,8.34898816748364E-16));
+#799=CARTESIAN_POINT('',(-55.6492482327348,36.5558333006839,8.34898816748364E-16));
+#800=CARTESIAN_POINT('Origin',(-47.8548953186122,30.882544,8.34898816748364E-16));
+#801=CARTESIAN_POINT('',(-47.8548953186122,37.901304,8.34898816748364E-16));
+#802=CARTESIAN_POINT('',(-47.8548953186122,37.901304,8.34898816748364E-16));
+#803=CARTESIAN_POINT('Origin',(-47.8548953186122,30.882544,8.34898816748364E-16));
+#804=CARTESIAN_POINT('Origin',(49.393596645355,37.901304,8.34898816748364E-16));
+#805=CARTESIAN_POINT('',(47.5752549255443,37.901304,8.34898816748364E-16));
+#806=CARTESIAN_POINT('',(47.5752549255443,37.901304,8.34898816748364E-16));
+#807=CARTESIAN_POINT('',(56.15008,37.901304,8.34898816748364E-16));
+#808=CARTESIAN_POINT('Origin',(-49.2592242581112,35.895944,8.34898816748364E-16));
+#809=CARTESIAN_POINT('',(-47.2578282212087,35.895944,8.34898816748364E-16));
+#810=CARTESIAN_POINT('',(-47.2578282212087,35.895944,8.34898816748364E-16));
+#811=CARTESIAN_POINT('',(46.911574398011,35.895944,8.34898816748364E-16));
+#812=CARTESIAN_POINT('',(3.44542787094439,35.895944,8.34898816748364E-16));
+#813=CARTESIAN_POINT('',(46.911574398011,35.895944,8.34898816748364E-16));
+#814=CARTESIAN_POINT('Origin',(-56.15008,33.58978,8.34898816748364E-16));
+#815=CARTESIAN_POINT('',(-59.15812,33.58978,11.02948));
+#816=CARTESIAN_POINT('Origin',(-56.15008,33.58978,11.02948));
+#817=CARTESIAN_POINT('',(-59.15812,33.58978,8.34898816748364E-16));
+#818=CARTESIAN_POINT('',(-59.15812,33.58978,8.34898816748364E-16));
+#819=CARTESIAN_POINT('',(-53.5291859784223,32.1135621403131,8.34898816748364E-16));
+#820=CARTESIAN_POINT('Origin',(-56.15008,33.58978,8.34898816748364E-16));
+#821=CARTESIAN_POINT('',(-53.5291859784223,32.1135621403131,8.34898816748364E-16));
+#822=CARTESIAN_POINT('Origin',(-56.15008,33.58978,8.34898816748364E-16));
+#823=CARTESIAN_POINT('Origin',(54.1099855158704,44.4289424937642,8.34898816748364E-16));
+#824=CARTESIAN_POINT('',(50.6247958676965,37.2041966304233,8.34898816748364E-16));
+#825=CARTESIAN_POINT('Origin',(54.1099855158704,44.4289424937642,8.34898816748364E-16));
+#826=CARTESIAN_POINT('',(50.6247958676965,37.2041966304233,8.34898816748364E-16));
+#827=CARTESIAN_POINT('Origin',(46.7632739531924,27.7986401027071,8.34898816748364E-16));
+#828=CARTESIAN_POINT('',(50.8654347145886,34.6918089502882,8.34898816748364E-16));
+#829=CARTESIAN_POINT('',(50.8654347145886,34.6918089502882,8.34898816748364E-16));
+#830=CARTESIAN_POINT('Origin',(46.7632739531924,27.7986401027071,8.34898816748364E-16));
+#831=CARTESIAN_POINT('Origin',(48.6050463004756,36.0369778940524,8.34898816748364E-16));
+#832=CARTESIAN_POINT('',(50.5009650642326,34.9087067416334,8.34898816748364E-16));
+#833=CARTESIAN_POINT('',(50.5009650642326,34.9087067416334,8.34898816748364E-16));
+#834=CARTESIAN_POINT('',(51.9286708844819,34.0590715558221,8.34898816748364E-16));
+#835=CARTESIAN_POINT('Origin',(46.911574398011,28.877184,8.34898816748364E-16));
+#836=CARTESIAN_POINT('Origin',(46.911574398011,28.877184,8.34898816748364E-16));
+#837=CARTESIAN_POINT('Origin',(47.5752549255443,30.882544,8.34898816748364E-16));
+#838=CARTESIAN_POINT('Origin',(47.5752549255443,30.882544,8.34898816748364E-16));
+#839=CARTESIAN_POINT('Origin',(-56.15008,33.58978,0.250670000000001));
+#840=CARTESIAN_POINT('',(-57.90477,33.58978,8.34898816748364E-16));
+#841=CARTESIAN_POINT('Origin',(-56.15008,33.58978,8.34898816748364E-16));
+#842=CARTESIAN_POINT('',(-57.30343,33.58978,0.601340000000002));
+#843=CARTESIAN_POINT('',(-57.6541,33.58978,0.250670000000001));
+#844=CARTESIAN_POINT('Origin',(-56.15008,33.58978,0.601340000000002));
+#845=CARTESIAN_POINT('Origin',(56.15008,33.58978,8.34898816748364E-16));
+#846=CARTESIAN_POINT('',(-52.2816789901629,33.7786037319632,8.34898816748364E-16));
+#847=CARTESIAN_POINT('Origin',(-47.2578282212087,28.877184,8.34898816748364E-16));
+#848=CARTESIAN_POINT('Origin',(-46.5401352542153,28.1769811811481,8.34898816748364E-16));
+#849=CARTESIAN_POINT('',(57.90477,33.58978,8.34898816748364E-16));
+#850=CARTESIAN_POINT('Origin',(56.15008,33.58978,8.34898816748364E-16));
+#851=CARTESIAN_POINT('Origin',(-56.15008,33.58978,-2.83875875713276));
+#852=CARTESIAN_POINT('',(-57.30343,33.58978,10.42814));
+#853=CARTESIAN_POINT('',(-54.99673,33.58978,10.42814));
+#854=CARTESIAN_POINT('Origin',(-56.15008,33.58978,10.42814));
+#855=CARTESIAN_POINT('',(-57.30343,33.58978,-2.83875875713276));
+#856=CARTESIAN_POINT('Origin',(-56.15008,33.58978,10.42814));
+#857=CARTESIAN_POINT('Origin',(56.15008,33.58978,0.250670000000001));
+#858=CARTESIAN_POINT('',(57.30343,33.58978,0.601340000000002));
+#859=CARTESIAN_POINT('',(57.6541,33.58978,0.250670000000001));
+#860=CARTESIAN_POINT('Origin',(56.15008,33.58978,0.601340000000002));
+#861=CARTESIAN_POINT('Origin',(56.15008,33.58978,-2.83875875713276));
+#862=CARTESIAN_POINT('',(57.30343,33.58978,10.42814));
+#863=CARTESIAN_POINT('',(54.99673,33.58978,10.42814));
+#864=CARTESIAN_POINT('Origin',(56.15008,33.58978,10.42814));
+#865=CARTESIAN_POINT('',(57.30343,33.58978,-2.83875875713276));
+#866=CARTESIAN_POINT('Origin',(56.15008,33.58978,10.42814));
+#867=CARTESIAN_POINT('Origin',(56.15008,33.58978,10.77881));
+#868=CARTESIAN_POINT('',(54.39539,33.58978,11.02948));
+#869=CARTESIAN_POINT('Origin',(56.15008,33.58978,11.02948));
+#870=CARTESIAN_POINT('',(54.64606,33.58978,10.77881));
+#871=CARTESIAN_POINT('Origin',(56.15008,33.58978,11.02948));
+#872=CARTESIAN_POINT('Origin',(-56.15008,33.58978,10.77881));
+#873=CARTESIAN_POINT('',(-54.39539,33.58978,11.02948));
+#874=CARTESIAN_POINT('Origin',(-56.15008,33.58978,11.02948));
+#875=CARTESIAN_POINT('',(-54.64606,33.58978,10.77881));
+#876=CARTESIAN_POINT('Origin',(-56.15008,33.58978,11.02948));
+#877=CARTESIAN_POINT('Origin',(-47.2578282212087,28.877184,8.34898816748364E-16));
+#878=CARTESIAN_POINT('',(-52.2816789901629,33.7786037319632,8.34898816748364E-16));
+#879=CARTESIAN_POINT('Origin',(-46.5401352542153,28.1769811811481,8.34898816748364E-16));
+#880=UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(0.01),#884,
+'DISTANCE_ACCURACY_VALUE',
+'Maximum model space distance between geometric entities at asserted c
+onnectivities');
+#881=UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(0.01),#884,
+'DISTANCE_ACCURACY_VALUE',
+'Maximum model space distance between geometric entities at asserted c
+onnectivities');
+#882=(
+GEOMETRIC_REPRESENTATION_CONTEXT(3)
+GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#880))
+GLOBAL_UNIT_ASSIGNED_CONTEXT((#884,#886,#887))
+REPRESENTATION_CONTEXT('','3D')
+);
+#883=(
+GEOMETRIC_REPRESENTATION_CONTEXT(3)
+GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#881))
+GLOBAL_UNIT_ASSIGNED_CONTEXT((#884,#886,#887))
+REPRESENTATION_CONTEXT('','3D')
+);
+#884=(
+LENGTH_UNIT()
+NAMED_UNIT(*)
+SI_UNIT(.MILLI.,.METRE.)
+);
+#885=(
+LENGTH_UNIT()
+NAMED_UNIT(*)
+SI_UNIT(.CENTI.,.METRE.)
+);
+#886=(
+NAMED_UNIT(*)
+PLANE_ANGLE_UNIT()
+SI_UNIT($,.RADIAN.)
+);
+#887=(
+NAMED_UNIT(*)
+SI_UNIT($,.STERADIAN.)
+SOLID_ANGLE_UNIT()
+);
+#888=SHAPE_DEFINITION_REPRESENTATION(#889,#890);
+#889=PRODUCT_DEFINITION_SHAPE('',$,#892);
+#890=SHAPE_REPRESENTATION('',(#480),#882);
+#891=PRODUCT_DEFINITION_CONTEXT('part definition',#896,'design');
+#892=PRODUCT_DEFINITION('revisited_support','revisited_support',#893,#891);
+#893=PRODUCT_DEFINITION_FORMATION('',$,#898);
+#894=PRODUCT_RELATED_PRODUCT_CATEGORY('revisited_support',
+'revisited_support',(#898));
+#895=APPLICATION_PROTOCOL_DEFINITION('international standard',
+'automotive_design',2009,#896);
+#896=APPLICATION_CONTEXT(
+'Core Data for Automotive Mechanical Design Process');
+#897=PRODUCT_CONTEXT('part definition',#896,'mechanical');
+#898=PRODUCT('revisited_support','revisited_support',$,(#897));
+#899=PRESENTATION_STYLE_ASSIGNMENT((#900));
+#900=SURFACE_STYLE_USAGE(.BOTH.,#903);
+#901=SURFACE_STYLE_RENDERING_WITH_PROPERTIES($,#907,(#902));
+#902=SURFACE_STYLE_TRANSPARENT(0.);
+#903=SURFACE_SIDE_STYLE('',(#904,#901));
+#904=SURFACE_STYLE_FILL_AREA(#905);
+#905=FILL_AREA_STYLE('',(#906));
+#906=FILL_AREA_STYLE_COLOUR('',#907);
+#907=COLOUR_RGB('',0.749019607843137,0.749019607843137,0.749019607843137);
+ENDSEC;
+END-ISO-10303-21;