Github actions update

Type error corrected

.github/workflows/main.yml

@@ -0,0 +1,49 @@
+on:
+  push:
+
+jobs:
+  build:
+    runs-on: ubuntu-22.04
+    container:
+      image: archlinux:latest
+    steps:
+      - name: base-devel
+        run:  pacman -Syyu base-devel --noconfirm
+      - name: arm-none-eabi-gcc
+        run:  pacman -Syyu arm-none-eabi-gcc --noconfirm
+      - name: arm-none-eabi-newlib
+        run:  pacman -Syyu arm-none-eabi-newlib --noconfirm
+      - name: git
+        run:  pacman -Syyu git --noconfirm
+      - name: python-pip
+        run:  pacman -Syyu python-pip --noconfirm
+      - name: python-crcmod
+        run:  pacman -Syyu python-crcmod --noconfirm      
+
+      - name: Checkout
+        uses: actions/checkout@v3
+        
+      - name: safe.directory
+        run:  git config --global --add safe.directory /__w/uv-k5-firmware-custom/uv-k5-firmware-custom        
+      - name: Make
+        run:  make
+      - name: size
+        run:  arm-none-eabi-size firmware
+
+      - name: 'Upload Artifact'
+        uses: actions/upload-artifact@v3
+        with:
+          name: firmware
+          path: firmware*.bin
+
+      - name: Upload binaries to release
+        if: ${{ startsWith(github.ref, 'refs/tags/v') }}
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: firmware.packed.bin
+          asset_name: egzumer_$tag.packed.bin
+          tag: ${{ github.ref }}
+          overwrite: true
+          release_name: release ${{ github.ref_name }}     
+   

Makefile

@@ -26,7 +26,7 @@ ENABLE_CTCSS_TAIL_PHASE_SHIFT := 0
 ENABLE_BOOT_BEEPS             := 0
 ENABLE_SHOW_CHARGE_LEVEL      := 1
 ENABLE_REVERSE_BAT_SYMBOL     := 0
-ENABLE_CODE_SCAN_TIMEOUT      := 0
+ENABLE_NO_CODE_SCAN_TIMEOUT   := 1
 ENABLE_AM_FIX                 := 1
 ENABLE_AM_FIX_SHOW_DATA       := 0
 ENABLE_SQUELCH_MORE_SENSITIVE := 1
@@ -37,7 +37,9 @@ ENABLE_COPY_CHAN_TO_VFO       := 1
 ENABLE_SPECTRUM               := 1
 ENABLE_REDUCE_LOW_MID_TX_POWER:= 0
 ENABLE_BYP_RAW_DEMODULATORS   := 0
-
+ENABLE_BLMIN_TMP_OFF          := 0
+ENABLE_SCAN_RANGES            := 1
+ENABLE_DTMF_CALLING           := 1
 #############################################################
 
 TARGET = firmware
@@ -99,12 +101,13 @@ ifeq ($(ENABLE_AIRCOPY),1)
 	OBJS += app/aircopy.o
 endif
 OBJS += app/app.o
+OBJS += app/chFrScanner.o
+OBJS += app/common.o
 OBJS += app/dtmf.o
 ifeq ($(ENABLE_FMRADIO),1)
 	OBJS += app/fm.o
 endif
 OBJS += app/generic.o
-OBJS += app/common.o
 OBJS += app/main.o
 OBJS += app/menu.o
 ifeq ($(ENABLE_SPECTRUM), 1)
@@ -157,6 +160,20 @@ else
 	TOP := $(shell pwd)
 endif
 
+ifdef OS # windows
+   RM = del /Q
+   FixPath = $(subst /,\,$1)
+   WHERE = where
+   NULL_OUTPUT = nul
+else # unix
+   ifeq ($(shell uname), Linux)
+      RM = rm -f
+      FixPath = $1
+	  WHERE = which
+	  NULL_OUTPUT = /dev/null
+   endif
+endif
+
 AS = arm-none-eabi-gcc
 
 CC =
@@ -176,12 +193,17 @@ endif
 OBJCOPY = arm-none-eabi-objcopy
 SIZE = arm-none-eabi-size
 
+AUTHOR_STRING := EGZUMER
 # the user might not have/want git installed
 # can set own version string here (max 7 chars)
-GIT_HASH := $(shell git rev-parse --short HEAD)
+ifneq (, $(shell $(WHERE) git))
-#GIT_HASH := 230930b
+	VERSION_STRING := $(shell git describe --tags --exact-match 2>$(NULL_OUTPUT))
+	ifeq (, $(VERSION_STRING))
+    	VERSION_STRING := $(shell git rev-parse --short HEAD)
+	endif
+endif
+#VERSION_STRING := 230930b
 
-$(info GIT_HASH = $(GIT_HASH))
 
 ASFLAGS = -c -mcpu=cortex-m0
 ifeq ($(ENABLE_OVERLAY),1)
@@ -214,7 +236,7 @@ CFLAGS += -Wextra
 #CFLAGS += -Wpedantic
 
 CFLAGS += -DPRINTF_INCLUDE_CONFIG_H
-CFLAGS += -DGIT_HASH=\"$(GIT_HASH)\"
+CFLAGS += -DAUTHOR_STRING=\"$(AUTHOR_STRING)\" -DVERSION_STRING=\"$(VERSION_STRING)\"
 
 ifeq ($(ENABLE_SPECTRUM),1)
 CFLAGS += -DENABLE_SPECTRUM
@@ -282,7 +304,7 @@ endif
 ifeq ($(ENABLE_REVERSE_BAT_SYMBOL),1)
 	CFLAGS  += -DENABLE_REVERSE_BAT_SYMBOL
 endif
-ifeq ($(ENABLE_CODE_SCAN_TIMEOUT),1)
+ifeq ($(ENABLE_NO_CODE_SCAN_TIMEOUT),1)
 	CFLAGS  += -DENABLE_CODE_SCAN_TIMEOUT
 endif
 ifeq ($(ENABLE_AM_FIX),1)
@@ -324,6 +346,15 @@ endif
 ifeq ($(ENABLE_BYP_RAW_DEMODULATORS),1)
 	CFLAGS  += -DENABLE_BYP_RAW_DEMODULATORS
 endif
+ifeq ($(ENABLE_BLMIN_TMP_OFF),1)
+	CFLAGS  += -DENABLE_BLMIN_TMP_OFF
+endif
+ifeq ($(ENABLE_SCAN_RANGES),1)
+	CFLAGS  += -DENABLE_SCAN_RANGES
+endif
+ifeq ($(ENABLE_DTMF_CALLING),1)
+	CFLAGS  += -DENABLE_DTMF_CALLING
+endif
 
 LDFLAGS =
 ifeq ($(ENABLE_CLANG),0)
@@ -356,17 +387,7 @@ LIBS =
 
 DEPS = $(OBJS:.o=.d)
 
-ifdef OS
+
-   RM = del /Q
-   FixPath = $(subst /,\,$1)
-   WHERE = where
-else
-   ifeq ($(shell uname), Linux)
-      RM = rm -f
-      FixPath = $1
-	  WHERE = which
-   endif
-endif
 
 ifneq (, $(shell $(WHERE) python))
     MY_PYTHON := python
@@ -391,7 +412,7 @@ else ifneq (,$(HAS_CRCMOD))
 	$(info !!!!!!!! run: pip install crcmod)
 	$(info )
 else
-	-$(MY_PYTHON) fw-pack.py $<.bin $(GIT_HASH) $<.packed.bin
+	-$(MY_PYTHON) fw-pack.py $<.bin $(AUTHOR_STRING) $(VERSION_STRING) $<.packed.bin
 endif
 
 	$(SIZE) $<

README.md

@@ -1,7 +1,32 @@
 # Main features:
- - many of OneOfEleven mods, including AM fix
+* many of OneOfEleven mods:
- - fagci spectrum analyzer (**F+5** to turn on)
+   * AM fix, huge improvement in reception quality
- - some other mods introduced by me
+   * longpress buttons functions replicating F+ action
+   * fast scanning
+   * channel name editing in the menu
+   * channel name + frequency display option
+   * shortcut for scannlist assignment (longpress `5 NOAA`)
+   * scannlist toggle (longpress `* Scan` while scanning)
+   * configurable button function selectable from menu
+   * battery percentage/voltage on status bar, selectable from menu
+   * longer backlight times
+   * mic bar
+   * RSSI s-meter
+   * more frequency steps
+   * squelch more sensitive
+* fagci spectrum analyzer (**F+5** to turn on)
+* some other mods introduced by me:
+   * SSB demodulation (adopted from fagci)
+   * backlight dimming
+   * battery voltage callibration from menu
+   * better battery percentage calculation, selectable for 1600mAh or 2200mAh
+   * more configurable button functions
+   * longpress MENU as another configurable button
+   * better DCS/CTCSS scanning in the menu (`* SCAN` while in RX DCS/CTCSS menu item)
+   * Piotr022 s-meter style
+   * restore initial freq/channel when scanning stopped with EXIT, remember last found transmission with MENU button
+   * reordered and renamed menu entries
+   * LCD interference crash fix
 
  # Manual
 
@@ -73,45 +98,25 @@ ENABLE_SMALL_BOLD             := 1       bold channel name/no. (when name + freq
 ENABLE_KEEP_MEM_NAME          := 1       maintain channel name when (re)saving memory channel
 ENABLE_WIDE_RX                := 1       full 18MHz to 1300MHz RX (though front-end/PA not designed for full range)
 ENABLE_TX_WHEN_AM             := 0       allow TX (always FM) when RX is set to AM
-ENABLE_F_CAL_MENU             := 0       enable/disable the radios hidden frequency calibration menu
+ENABLE_F_CAL_MENU             := 0       enable the radios hidden frequency calibration menu
 ENABLE_CTCSS_TAIL_PHASE_SHIFT := 1       standard CTCSS tail phase shift rather than QS's own 55Hz tone method
 ENABLE_BOOT_BEEPS             := 0       gives user audio feedback on volume knob position at boot-up
 ENABLE_SHOW_CHARGE_LEVEL      := 0       show the charge level when the radio is on charge
 ENABLE_REVERSE_BAT_SYMBOL     := 1       mirror the battery symbol on the status bar (+ pole on the right)
-ENABLE_CODE_SCAN_TIMEOUT      := 0       enable/disable 32-sec CTCSS/DCS scan timeout (press exit butt instead of time-out to end scan)
+ENABLE_NO_CODE_SCAN_TIMEOUT   := 1       disable 32-sec CTCSS/DCS scan timeout (press exit butt instead of time-out to end scan)
 ENABLE_AM_FIX                 := 1       dynamically adjust the front end gains when in AM mode to helo prevent AM demodulator saturation, ignore the on-screen RSSI level (for now)
 ENABLE_AM_FIX_SHOW_DATA       := 1       show debug data for the AM fix (still tweaking it)
 ENABLE_SQUELCH_MORE_SENSITIVE := 0       make squelch levels a little bit more sensitive - I plan to let user adjust the values themselves
 ENABLE_FASTER_CHANNEL_SCAN    := 0       increases the channel scan speed, but the squelch is also made more twitchy
 ENABLE_RSSI_BAR               := 1       enable a dBm/Sn RSSI bar graph level inplace of the little antenna symbols
-ENABLE_AUDIO_BAR              := 0       experimental, display an audo bar level when TX'ing
+ENABLE_AUDIO_BAR              := 0       experimental, display an audio bar level when TX'ing
-ENABLE_COPY_CHAN_TO_VFO       := 1       copy current channel into the other VFO. Long press Menu key ('M')
+ENABLE_COPY_CHAN_TO_VFO       := 1       copy current channel into the other VFO. Long press `1 BAND` when in channel mode
-#ENABLE_SINGLE_VFO_CHAN       := 1       not yet implemented - single VFO on display when possible
+ENABLE_SPECTRUM               := 1       fagci spectrum analizer, activated with `F` + `5 NOAA`
-#ENABLE_BAND_SCOPE            := 1       not yet implemented - spectrum/pan-adapter
+ENABLE_REDUCE_LOW_MID_TX_POWER:= 0       makes medium and low power settings even lower
+ENABLE_BYP_RAW_DEMODULATORS   := 0       additional BYP (bypass?) and RAW demodulation options, prooved not to be very usefull, but it is there if you want to experiment
+ENABLE_BLMIN_TMP_OFF          := 0       additional function for configurable buttons that toggles `BLMin` on and off wihout saving it to the EEPROM
 ```
 
-# New/modified function keys
-
-* Long-press 'M' .. Copy selected channel into same VFO, then switch VFO to frequency mode
-*
-* Long-press '7' .. Toggle selected channel scanlist setting .. if VOX  is disabled in Makefile
-* or
-* Long-press '5' .. Toggle selected channel scanlist setting .. if NOAA is disabled in Makefile
-*
-* Long-press '*' .. Start scanning, then toggles the scanning between scanlists 1, 2 or ALL channels
-
-# Some changes made from the Quansheng firmware
-
-* Various Quansheng firmware bugs fixed
-* Added new bugs
-* Mic menu includes max gain possible
-* AM RX everywhere (left the TX as is)
-* An attempt to improve the AM RX audio (demodulator getting saturated/overloaded in Quansheng firmware)
-* keypad-5/NOAA button now toggles scanlist-1 on/off for current channel when held down - IF NOAA not used
-* Better backlight times (inc always on)
-* Live DTMF decoder option, though the decoder needs some coeff tuning changes to decode other radios it seems
-* Various menu re-wordings (trying to reduce 'WTH does that mean ?')
-* ..
 
 # Compiler
 

app/action.c

@@ -18,6 +18,7 @@
 
 #include "app/action.h"
 #include "app/app.h"
+#include "app/chFrScanner.h"
 #include "app/common.h"
 #include "app/dtmf.h"
 #ifdef ENABLE_FMRADIO
@@ -31,6 +32,7 @@
 #endif
 #include "driver/bk4819.h"
 #include "driver/gpio.h"
+#include "driver/backlight.h"
 #include "functions.h"
 #include "misc.h"
 #include "settings.h"
@@ -61,24 +63,22 @@ void ACTION_Power(void)
 		gTxVfo->OUTPUT_POWER = OUTPUT_POWER_LOW;
 
 	gRequestSaveChannel = 1;
-	//gRequestSaveChannel = 2;   // auto save the channel
 
-	#ifdef ENABLE_VOICE
+#ifdef ENABLE_VOICE
-		gAnotherVoiceID   = VOICE_ID_POWER;
+	gAnotherVoiceID   = VOICE_ID_POWER;
-	#endif
+#endif
 
 	gRequestDisplayScreen = gScreenToDisplay;
 }
 
 void ACTION_Monitor(void)
 {
-	if (gCurrentFunction != FUNCTION_MONITOR)
+	if (gCurrentFunction != FUNCTION_MONITOR) { // enable the monitor
-	{	// enable the monitor
 		RADIO_SelectVfos();
-		#ifdef ENABLE_NOAA
+#ifdef ENABLE_NOAA
-			if (gRxVfo->CHANNEL_SAVE >= NOAA_CHANNEL_FIRST && gIsNoaaMode)
+		if (gRxVfo->CHANNEL_SAVE >= NOAA_CHANNEL_FIRST && gIsNoaaMode)
-				gNoaaChannel = gRxVfo->CHANNEL_SAVE - NOAA_CHANNEL_FIRST;
+			gNoaaChannel = gRxVfo->CHANNEL_SAVE - NOAA_CHANNEL_FIRST;
-		#endif
+#endif
 		RADIO_SetupRegisters(true);
 		APP_StartListening(FUNCTION_MONITOR, false);
 		return;
@@ -86,36 +86,34 @@ void ACTION_Monitor(void)
 
 	gMonitor = false;
 	
-	if (gScanStateDir != SCAN_OFF)
+	if (gScanStateDir != SCAN_OFF) {
-	{
 		gScanPauseDelayIn_10ms = scan_pause_delay_in_1_10ms;
 		gScheduleScanListen    = false;
 		gScanPauseMode         = true;
 	}
 
-	#ifdef ENABLE_NOAA
+#ifdef ENABLE_NOAA
-		if (gEeprom.DUAL_WATCH == DUAL_WATCH_OFF && gIsNoaaMode)
+	if (gEeprom.DUAL_WATCH == DUAL_WATCH_OFF && gIsNoaaMode) {
-		{
+		gNOAA_Countdown_10ms = NOAA_countdown_10ms;
-			gNOAA_Countdown_10ms = NOAA_countdown_10ms;
+		gScheduleNOAA        = false;
-			gScheduleNOAA        = false;
+	}
-		}
+#endif
-	#endif
 
 	RADIO_SetupRegisters(true);
 
-	#ifdef ENABLE_FMRADIO
+#ifdef ENABLE_FMRADIO
-		if (gFmRadioMode)
+	if (gFmRadioMode) {
-		{
+		FM_Start();
-			FM_Start();
+		gRequestDisplayScreen = DISPLAY_FM;
-			gRequestDisplayScreen = DISPLAY_FM;
+	}
-		}
+	else
-		else
+#endif
-	#endif
+	gRequestDisplayScreen = gScreenToDisplay;
-			gRequestDisplayScreen = gScreenToDisplay;
 }
 
 void ACTION_Scan(bool bRestart)
 {
+	(void)bRestart;
 #ifdef ENABLE_FMRADIO
 	if (gFmRadioMode)
 	{
@@ -164,13 +162,14 @@ void ACTION_Scan(bool bRestart)
 	}
 #endif
 
-	if (gScreenToDisplay != DISPLAY_SCANNER)
+	if (!SCANNER_IsScanning())
 	{	// not scanning
 
 		gMonitor = false;
 
+#ifdef ENABLE_DTMF_CALLING
 		DTMF_clear_RX();
-
+#endif
 		gDTMF_RX_live_timeout = 0;
 		memset(gDTMF_RX_live, 0, sizeof(gDTMF_RX_live));
 
@@ -192,7 +191,7 @@ void ACTION_Scan(bool bRestart)
 					gEeprom.SCAN_LIST_DEFAULT = (gEeprom.SCAN_LIST_DEFAULT + 1) % 3;
 
 					// jump to the next channel
-					SCANNER_ScanChannels(false, gScanStateDir);
+					CHFRSCANNER_Start(false, gScanStateDir);
 					gScanPauseDelayIn_10ms = 1;
 					gScheduleScanListen    = false;
 
@@ -201,7 +200,7 @@ void ACTION_Scan(bool bRestart)
 				else
 				{	// stop scanning
 			
-					SCANNER_Stop();
+					CHFRSCANNER_Stop();
 
 					#ifdef ENABLE_VOICE
 						gAnotherVoiceID = VOICE_ID_SCANNING_STOP;
@@ -211,7 +210,7 @@ void ACTION_Scan(bool bRestart)
 			else
 			{	// start scanning
 	
-				SCANNER_ScanChannels(true, SCAN_FWD);
+				CHFRSCANNER_Start(true, SCAN_FWD);
 
 				#ifdef ENABLE_VOICE
 					AUDIO_SetVoiceID(0, VOICE_ID_SCANNING_BEGIN);
@@ -227,31 +226,6 @@ void ACTION_Scan(bool bRestart)
 			}
 		}
 	}
-	else
-//	if (!bRestart)
-	if (!bRestart && IS_MR_CHANNEL(gNextMrChannel))
-	{	// channel mode, keep scanning but toggle between scan lists
-		gEeprom.SCAN_LIST_DEFAULT = (gEeprom.SCAN_LIST_DEFAULT + 1) % 3;
-
-		// jump to the next channel
-		SCANNER_ScanChannels(false, gScanStateDir);
-		gScanPauseDelayIn_10ms = 1;
-		gScheduleScanListen    = false;
-
-		gUpdateStatus = true;
-	}
-	else
-	{	// stop scanning
-		gMonitor = false;
-	
-		SCANNER_Stop();
-	
-		#ifdef ENABLE_VOICE
-			gAnotherVoiceID = VOICE_ID_SCANNING_STOP;
-		#endif
-	
-		gRequestDisplayScreen = DISPLAY_MAIN;
-	}
 }
 
 #ifdef ENABLE_VOX
@@ -332,6 +306,20 @@ void ACTION_SwitchDemodul(void)
 	gRequestSaveChannel = 1;
 }
 
+#ifdef ENABLE_BLMIN_TMP_OFF
+void ACTION_BlminTmpOff(void)
+{
+	if(++gEeprom.BACKLIGHT_MIN_STAT == BLMIN_STAT_UNKNOWN)
+	{
+		gEeprom.BACKLIGHT_MIN_STAT = BLMIN_STAT_ON;
+		BACKLIGHT_SetBrightness(gEeprom.BACKLIGHT_MIN);
+	} else
+	{
+		BACKLIGHT_SetBrightness(0);
+	}
+}
+#endif
+
 void ACTION_Handle(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 {
 	if (gScreenToDisplay == DISPLAY_MAIN && gDTMF_InputMode) // entering DTMF code
@@ -450,5 +438,10 @@ void ACTION_Handle(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 		case ACTION_OPT_SWITCH_DEMODUL:
 			ACTION_SwitchDemodul();
 			break;
+#ifdef ENABLE_BLMIN_TMP_OFF
+		case ACTION_OPT_BLMIN_TMP_OFF:
+			ACTION_BlminTmpOff();
+			break;
+#endif
 	}
 }

app/action.h

@@ -34,6 +34,10 @@ void ACTION_Scan(bool bRestart);
 #endif
 void ACTION_SwitchDemodul(void);
 
+#ifdef ENABLE_BLMIN_TMP_OFF
+void ACTION_BlminTmpOff(void);
+#endif
+
 void ACTION_Handle(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld);
 
 #endif

app/app.c

@@ -21,6 +21,7 @@
 	#include "app/aircopy.h"
 #endif
 #include "app/app.h"
+#include "app/chFrScanner.h"
 #include "app/dtmf.h"
 #ifdef ENABLE_FMRADIO
 	#include "app/fm.h"
@@ -92,15 +93,6 @@ static void CheckForIncoming(void)
 
 	if (gScanStateDir == SCAN_OFF)
 	{	// not RF scanning
-
-		if (gCssScanMode != CSS_SCAN_MODE_OFF && gRxReceptionMode == RX_MODE_NONE)
-		{	// CTCSS/DTS scanning
-
-			gScanPauseDelayIn_10ms = scan_pause_delay_in_5_10ms;
-			gScheduleScanListen    = false;
-			gRxReceptionMode       = RX_MODE_DETECTED;
-		}
-
 		if (gEeprom.DUAL_WATCH == DUAL_WATCH_OFF)
 		{	// dual watch is disabled
 
@@ -181,14 +173,12 @@ static void HandleIncoming(void)
 {
 	bool bFlag;
 
-	if (!g_SquelchLost)
+	if (!g_SquelchLost) {	// squelch is closed
-	{	// squelch is closed
+#ifdef ENABLE_DTMF_CALLING
-
 		if (gDTMF_RX_index > 0)
 			DTMF_clear_RX();
-
+#endif
-		if (gCurrentFunction != FUNCTION_FOREGROUND)
+		if (gCurrentFunction != FUNCTION_FOREGROUND) {
-		{
 			FUNCTION_Select(FUNCTION_FOREGROUND);
 			gUpdateDisplay = true;
 		}
@@ -197,39 +187,32 @@ static void HandleIncoming(void)
 
 	bFlag = (gScanStateDir == SCAN_OFF && gCurrentCodeType == CODE_TYPE_OFF);
 
-	#ifdef ENABLE_NOAA
+#ifdef ENABLE_NOAA
-		if (IS_NOAA_CHANNEL(gRxVfo->CHANNEL_SAVE) && gNOAACountdown_10ms > 0)
+	if (IS_NOAA_CHANNEL(gRxVfo->CHANNEL_SAVE) && gNOAACountdown_10ms > 0) {
-		{
+		gNOAACountdown_10ms = 0;
-			gNOAACountdown_10ms = 0;
+		bFlag               = true;
-			bFlag               = true;
+	}
-		}
+#endif
-	#endif
 
-	if (g_CTCSS_Lost && gCurrentCodeType == CODE_TYPE_CONTINUOUS_TONE)
+	if (g_CTCSS_Lost && gCurrentCodeType == CODE_TYPE_CONTINUOUS_TONE) {
-	{
 		bFlag       = true;
 		gFoundCTCSS = false;
 	}
 
-	if (g_CDCSS_Lost && gCDCSSCodeType == CDCSS_POSITIVE_CODE && (gCurrentCodeType == CODE_TYPE_DIGITAL || gCurrentCodeType == CODE_TYPE_REVERSE_DIGITAL))
+	if (g_CDCSS_Lost && gCDCSSCodeType == CDCSS_POSITIVE_CODE && (gCurrentCodeType == CODE_TYPE_DIGITAL || gCurrentCodeType == CODE_TYPE_REVERSE_DIGITAL)) {
-	{
 		gFoundCDCSS = false;
 	}
-	else
+	else if (!bFlag)
-	if (!bFlag)
 		return;
 
-	if (gScanStateDir == SCAN_OFF && gCssScanMode == CSS_SCAN_MODE_OFF)
+#ifdef ENABLE_DTMF_CALLING
-	{	// not scanning
+	if (gScanStateDir == SCAN_OFF) { // not scanning
-		if (gRxVfo->DTMF_DECODING_ENABLE || gSetting_KILLED)
+		if (gRxVfo->DTMF_DECODING_ENABLE || gSetting_KILLED) { // DTMF DCD is enabled
-		{	// DTMF DCD is enabled
 
 			DTMF_HandleRequest();
 
-			if (gDTMF_CallState == DTMF_CALL_STATE_NONE)
+			if (gDTMF_CallState == DTMF_CALL_STATE_NONE) {
-			{
+				if (gRxReceptionMode == RX_MODE_DETECTED) {
-				if (gRxReceptionMode == RX_MODE_DETECTED)
-				{
 					gDualWatchCountdown_10ms = dual_watch_count_after_1_10ms;
 					gScheduleDualWatch       = false;
 
@@ -245,6 +228,7 @@ static void HandleIncoming(void)
 			}
 		}
 	}
+#endif
 
 	APP_StartListening(gMonitor ? FUNCTION_MONITOR : FUNCTION_RECEIVE, false);
 }
@@ -407,7 +391,7 @@ Skip:
 						break;
 
 					case SCAN_RESUME_SE:
-						SCANNER_Stop();
+						CHFRSCANNER_Stop();
 						break;
 				}
 			}
@@ -465,8 +449,10 @@ void APP_StartListening(FUNCTION_Type_t Function, const bool reset_am_fix)
 	const unsigned int chan = gEeprom.RX_VFO;
 //	const unsigned int chan = gRxVfo->CHANNEL_SAVE;
 
+#ifdef ENABLE_DTMF_CALLING
 	if (gSetting_KILLED)
 		return;
+#endif
 
 #ifdef ENABLE_FMRADIO
 	if (gFmRadioMode)
@@ -483,7 +469,7 @@ void APP_StartListening(FUNCTION_Type_t Function, const bool reset_am_fix)
 		BACKLIGHT_TurnOn();
 
 	if (gScanStateDir != SCAN_OFF)
-		SCANNER_Found();
+		CHFRSCANNER_Found();
 
 #ifdef ENABLE_NOAA
 	if (IS_NOAA_CHANNEL(gRxVfo->CHANNEL_SAVE) && gIsNoaaMode) {
@@ -497,11 +483,7 @@ void APP_StartListening(FUNCTION_Type_t Function, const bool reset_am_fix)
 	}
 #endif
 
-	if (gCssScanMode != CSS_SCAN_MODE_OFF)
-		gCssScanMode = CSS_SCAN_MODE_FOUND;
-
 	if (gScanStateDir == SCAN_OFF &&
-	    gCssScanMode == CSS_SCAN_MODE_OFF &&
 	    gEeprom.DUAL_WATCH != DUAL_WATCH_OFF)
 	{	// not scanning, dual watch is enabled
 
@@ -574,18 +556,23 @@ void APP_StartListening(FUNCTION_Type_t Function, const bool reset_am_fix)
 	gUpdateStatus = true;
 }
 
-uint32_t APP_SetFrequencyByStep(VFO_Info_t *pInfo, int8_t direction)
+uint32_t APP_SetFreqByStepAndLimits(VFO_Info_t *pInfo, int8_t direction, uint32_t lower, uint32_t upper)
 {
 	uint32_t Frequency = FREQUENCY_RoundToStep(pInfo->freq_config_RX.Frequency + (direction * pInfo->StepFrequency), pInfo->StepFrequency);
 
-	if (Frequency >= frequencyBandTable[pInfo->Band].upper)
+	if (Frequency >= upper)
-		Frequency =  frequencyBandTable[pInfo->Band].lower;
+		Frequency =  lower;
-	else if (Frequency < frequencyBandTable[pInfo->Band].lower)
+	else if (Frequency < lower)
-		Frequency = FREQUENCY_RoundToStep(frequencyBandTable[pInfo->Band].upper - pInfo->StepFrequency, pInfo->StepFrequency);
+		Frequency = FREQUENCY_RoundToStep(upper - pInfo->StepFrequency, pInfo->StepFrequency);
 
 	return Frequency;
 }
 
+uint32_t APP_SetFrequencyByStep(VFO_Info_t *pInfo, int8_t direction)
+{
+	return APP_SetFreqByStepAndLimits(pInfo, direction, frequencyBandTable[pInfo->Band].lower, frequencyBandTable[pInfo->Band].upper);
+}
+
 #ifdef ENABLE_NOAA
 	static void NOAA_IncreaseChannel(void)
 	{
@@ -633,7 +620,7 @@ static void DualwatchAlternate(void)
 
 static void CheckRadioInterrupts(void)
 {
-	if (gScreenToDisplay == DISPLAY_SCANNER)
+	if (SCANNER_IsScanning())
 		return;
 
 	while (BK4819_ReadRegister(BK4819_REG_0C) & 1u)
@@ -676,6 +663,7 @@ static void CheckRadioInterrupts(void)
 						gUpdateDisplay        = true;
 					}
 
+#ifdef ENABLE_DTMF_CALLING
 					if (gRxVfo->DTMF_DECODING_ENABLE || gSetting_KILLED)
 					{
 						if (gDTMF_RX_index >= (sizeof(gDTMF_RX) - 1))
@@ -690,6 +678,7 @@ static void CheckRadioInterrupts(void)
 
 						DTMF_HandleRequest();
 					}
+#endif
 				}
 			}
 		}
@@ -778,13 +767,18 @@ void APP_EndTransmission(void)
 	// send the CTCSS/DCS tail tone - allows the receivers to mute the usual FM squelch tail/crash
 	RADIO_EnableCxCSS();
 	RADIO_SetupRegisters(false);
+
+	if (gMonitor)
+		gFlagReconfigureVfos = true; //turn the monitor back on
 }
 
 #ifdef ENABLE_VOX
 	static void HandleVox(void)
 	{
+#ifdef ENABLE_DTMF_CALLING
 		if (gSetting_KILLED)
 			return;
+#endif
 
 		if (gVoxResumeCountdown == 0)
 		{
@@ -805,7 +799,7 @@ void APP_EndTransmission(void)
 		if (gCurrentFunction == FUNCTION_RECEIVE || gCurrentFunction == FUNCTION_MONITOR)
 			return;
 	
-		if (gScanStateDir != SCAN_OFF || gCssScanMode != CSS_SCAN_MODE_OFF)
+		if (gScanStateDir != SCAN_OFF)
 			return;
 	
 		if (gVOX_NoiseDetected)
@@ -852,7 +846,9 @@ void APP_EndTransmission(void)
 	
 			if (gCurrentFunction != FUNCTION_TRANSMIT && gSerialConfigCountDown_500ms == 0)
 			{
+#ifdef ENABLE_DTMF_CALLING
 				gDTMF_ReplyState = DTMF_REPLY_NONE;
+#endif
 				RADIO_PrepareTX();
 				gUpdateDisplay = true;
 			}
@@ -896,23 +892,12 @@ void APP_Update(void)
 #endif
 
 #ifdef ENABLE_VOICE
-	if (gScreenToDisplay != DISPLAY_SCANNER && gScanStateDir != SCAN_OFF && gScheduleScanListen && !gPttIsPressed && gVoiceWriteIndex == 0)
+	if (!SCANNER_IsScanning() && gScanStateDir != SCAN_OFF && gScheduleScanListen && !gPttIsPressed && gVoiceWriteIndex == 0)
 #else
-	if (gScreenToDisplay != DISPLAY_SCANNER && gScanStateDir != SCAN_OFF && gScheduleScanListen && !gPttIsPressed)
+	if (!SCANNER_IsScanning() && gScanStateDir != SCAN_OFF && gScheduleScanListen && !gPttIsPressed)
 #endif
 	{	// scanning
-		SCANNER_ContinueScanning();
+		CHFRSCANNER_ContinueScanning();
-	}
-
-#ifdef ENABLE_VOICE
-	if (gCssScanMode == CSS_SCAN_MODE_SCANNING && gScheduleScanListen && gVoiceWriteIndex == 0)
-#else
-	if (gCssScanMode == CSS_SCAN_MODE_SCANNING && gScheduleScanListen)
-#endif
-	{
-		MENU_SelectNextCode();
-
-		gScheduleScanListen = false;
 	}
 
 #ifdef ENABLE_NOAA
@@ -931,7 +916,7 @@ void APP_Update(void)
 #endif
 
 	// toggle between the VFO's if dual watch is enabled
-	if (gScreenToDisplay != DISPLAY_SCANNER && gEeprom.DUAL_WATCH != DUAL_WATCH_OFF)
+	if (!SCANNER_IsScanning() && gEeprom.DUAL_WATCH != DUAL_WATCH_OFF)
 	{
 #ifdef ENABLE_VOICE
 		if (gScheduleDualWatch && gVoiceWriteIndex == 0)
@@ -939,13 +924,15 @@ void APP_Update(void)
 		if (gScheduleDualWatch)
 #endif
 		{
-			if (gScanStateDir == SCAN_OFF && gCssScanMode == CSS_SCAN_MODE_OFF)
+			if (gScanStateDir == SCAN_OFF)
 			{
 				if (!gPttIsPressed &&
 #ifdef ENABLE_FMRADIO
 					!gFmRadioMode &&
 #endif
+#ifdef ENABLE_DTMF_CALLING
 				    gDTMF_CallState == DTMF_CALL_STATE_NONE &&
+#endif
 				    gCurrentFunction != FUNCTION_POWER_SAVE)
 				{
 					DualwatchAlternate();    // toggle between the two VFO's
@@ -981,7 +968,6 @@ void APP_Update(void)
 
 	if (gSchedulePowerSave)
 	{
-#ifdef ENABLE_NOAA
 		if (
 #ifdef ENABLE_FMRADIO
 			gFmRadioMode                  ||
@@ -990,42 +976,29 @@ void APP_Update(void)
 		    gKeyBeingHeld                     ||
 			gEeprom.BATTERY_SAVE == 0         ||
 		    gScanStateDir != SCAN_OFF         ||
-		    gCssScanMode != CSS_SCAN_MODE_OFF ||
+		    gCssBackgroundScan                      ||
-		    gScreenToDisplay != DISPLAY_MAIN  ||
+		    gScreenToDisplay != DISPLAY_MAIN  
-		    gDTMF_CallState != DTMF_CALL_STATE_NONE)
+#ifdef ENABLE_DTMF_CALLING			
+			|| gDTMF_CallState != DTMF_CALL_STATE_NONE
+#endif
+			)
 		{
 			gBatterySaveCountdown_10ms   = battery_save_count_10ms;
 		}
-		else if ((!IS_NOAA_CHANNEL(gEeprom.ScreenChannel[0]) && !IS_NOAA_CHANNEL(gEeprom.ScreenChannel[1])) || !gIsNoaaMode)
+		else 
+#ifdef ENABLE_NOAA
+		if ((!IS_NOAA_CHANNEL(gEeprom.ScreenChannel[0]) && !IS_NOAA_CHANNEL(gEeprom.ScreenChannel[1])) || !gIsNoaaMode)
+#endif
 		{
 			//if (gCurrentFunction != FUNCTION_POWER_SAVE)
 				FUNCTION_Select(FUNCTION_POWER_SAVE);
 		}
+#ifdef ENABLE_NOAA
 		else
 		{
 			gBatterySaveCountdown_10ms = battery_save_count_10ms;
 		}
 #else
-		if (
-#ifdef ENABLE_FMRADIO
-				gFmRadioMode                  ||
-#endif
-			gPttIsPressed                     ||
-		    gKeyBeingHeld                     ||
-			gEeprom.BATTERY_SAVE == 0         ||
-		    gScanStateDir != SCAN_OFF         ||
-		    gCssScanMode != CSS_SCAN_MODE_OFF ||
-		    gScreenToDisplay != DISPLAY_MAIN  ||
-		    gDTMF_CallState != DTMF_CALL_STATE_NONE)
-		{
-			gBatterySaveCountdown_10ms = battery_save_count_10ms;
-		}
-		else
-		{
-			//if (gCurrentFunction != FUNCTION_POWER_SAVE)
-				FUNCTION_Select(FUNCTION_POWER_SAVE);
-		}
-
 		gSchedulePowerSave = false;
 #endif
 	}
@@ -1048,7 +1021,7 @@ void APP_Update(void)
 
 			if (gEeprom.DUAL_WATCH != DUAL_WATCH_OFF &&
 			    gScanStateDir == SCAN_OFF &&
-			    gCssScanMode == CSS_SCAN_MODE_OFF)
+			    !gCssBackgroundScan)
 			{	// dual watch mode, toggle between the two VFO's
 				DualwatchAlternate();
 
@@ -1061,7 +1034,7 @@ void APP_Update(void)
 			gRxIdleMode     = false;            // RX is awake
 		}
 		else
-		if (gEeprom.DUAL_WATCH == DUAL_WATCH_OFF || gScanStateDir != SCAN_OFF || gCssScanMode != CSS_SCAN_MODE_OFF || gUpdateRSSI)
+		if (gEeprom.DUAL_WATCH == DUAL_WATCH_OFF || gScanStateDir != SCAN_OFF || gCssBackgroundScan || gUpdateRSSI)
 		{	// dual watch mode off or scanning or rssi update request
 
 			UpdateRSSI(gEeprom.RX_VFO);
@@ -1094,13 +1067,17 @@ void APP_Update(void)
 // called every 10ms
 static void CheckKeys(void)
 {
-#ifdef ENABLE_AIRCOPY
+
-	if (gSetting_KILLED || (gScreenToDisplay == DISPLAY_AIRCOPY && gAircopyState != AIRCOPY_READY))
+	if (0 
-		return;
+#ifdef ENABLE_DTMF_CALLING
-#else
+	|| gSetting_KILLED 
-	if (gSetting_KILLED)
-		return;
 #endif	
+#ifdef ENABLE_AIRCOPY	
+	|| (gScreenToDisplay == DISPLAY_AIRCOPY && gAircopyState != AIRCOPY_READY)
+#endif	
+	)
+		return;
+
 
 // -------------------- PTT ------------------------
 	if (gPttIsPressed)
@@ -1330,153 +1307,33 @@ void APP_TimeSlice10ms(void)
 		}
 	}
 
-	#ifdef ENABLE_FMRADIO
+#ifdef ENABLE_FMRADIO
-		if (gFmRadioMode && gFM_RestoreCountdown_10ms > 0)
+	if (gFmRadioMode && gFM_RestoreCountdown_10ms > 0)
-		{
-			if (--gFM_RestoreCountdown_10ms == 0)
-			{	// switch back to FM radio mode
-				FM_Start();
-				GUI_SelectNextDisplay(DISPLAY_FM);
-			}
-		}
-	#endif
-
-	if (gScreenToDisplay == DISPLAY_SCANNER)
 	{
-		uint32_t               Result;
+		if (--gFM_RestoreCountdown_10ms == 0)
-		int32_t                Delta;
+		{	// switch back to FM radio mode
-		BK4819_CssScanResult_t ScanResult;
+			FM_Start();
-		uint16_t               CtcssFreq;
+			GUI_SelectNextDisplay(DISPLAY_FM);
-
-		if (gScanDelay_10ms > 0)
-		{
-			if (--gScanDelay_10ms > 0)
-			{
-				CheckKeys();
-				return;
-			}
-		}
-
-		if (gScannerEditState != 0)
-		{
-			CheckKeys();
-			return;
-		}
-
-		switch (gScanCssState)
-		{
-			case SCAN_CSS_STATE_OFF:
-
-				// must be RF frequency scanning if we're here ?
-
-				if (!BK4819_GetFrequencyScanResult(&Result))
-					break;
-
-				Delta          = Result - gScanFrequency;
-				gScanFrequency = Result;
-
-				if (Delta < 0)
-					Delta = -Delta;
-				if (Delta < 100)
-					gScanHitCount++;
-				else
-					gScanHitCount = 0;
-
-				BK4819_DisableFrequencyScan();
-
-				if (gScanHitCount < 3)
-				{
-					BK4819_EnableFrequencyScan();
-				}
-				else
-				{
-					BK4819_SetScanFrequency(gScanFrequency);
-					gScanCssResultCode     = 0xFF;
-					gScanCssResultType     = 0xFF;
-					gScanHitCount          = 0;
-					gScanUseCssResult      = false;
-					gScanProgressIndicator = 0;
-					gScanCssState          = SCAN_CSS_STATE_SCANNING;
-
-					GUI_SelectNextDisplay(DISPLAY_SCANNER);
-
-					gUpdateStatus          = true;
-				}
-
-				gScanDelay_10ms = scan_delay_10ms;
-				//gScanDelay_10ms = 1;   // 10ms
-				break;
-
-			case SCAN_CSS_STATE_SCANNING:
-				ScanResult = BK4819_GetCxCSSScanResult(&Result, &CtcssFreq);
-				if (ScanResult == BK4819_CSS_RESULT_NOT_FOUND)
-					break;
-
-				BK4819_Disable();
-
-				if (ScanResult == BK4819_CSS_RESULT_CDCSS)
-				{
-					const uint8_t Code = DCS_GetCdcssCode(Result);
-					if (Code != 0xFF)
-					{
-						gScanCssResultCode = Code;
-						gScanCssResultType = CODE_TYPE_DIGITAL;
-						gScanCssState      = SCAN_CSS_STATE_FOUND;
-						gScanUseCssResult  = true;
-						gUpdateStatus      = true;
-					}
-				}
-				else
-				if (ScanResult == BK4819_CSS_RESULT_CTCSS)
-				{
-					const uint8_t Code = DCS_GetCtcssCode(CtcssFreq);
-					if (Code != 0xFF)
-					{
-						if (Code == gScanCssResultCode && gScanCssResultType == CODE_TYPE_CONTINUOUS_TONE)
-						{
-							if (++gScanHitCount >= 2)
-							{
-								gScanCssState     = SCAN_CSS_STATE_FOUND;
-								gScanUseCssResult = true;
-								gUpdateStatus     = true;
-							}
-						}
-						else
-							gScanHitCount = 0;
-
-						gScanCssResultType = CODE_TYPE_CONTINUOUS_TONE;
-						gScanCssResultCode = Code;
-					}
-				}
-
-				if (gScanCssState < SCAN_CSS_STATE_FOUND)
-				{
-					BK4819_SetScanFrequency(gScanFrequency);
-					gScanDelay_10ms = scan_delay_10ms;
-					break;
-				}
-
-				GUI_SelectNextDisplay(DISPLAY_SCANNER);
-				break;
-
-			default:
-				break;
 		}
 	}
+#endif
 
-	#ifdef ENABLE_AIRCOPY
+	
-		if (gScreenToDisplay == DISPLAY_AIRCOPY && gAircopyState == AIRCOPY_TRANSFER && gAirCopyIsSendMode == 1)
+	SCANNER_TimeSlice10ms();
+	
+#ifdef ENABLE_AIRCOPY
+	if (gScreenToDisplay == DISPLAY_AIRCOPY && gAircopyState == AIRCOPY_TRANSFER && gAirCopyIsSendMode == 1)
+	{
+		if (gAircopySendCountdown > 0)
 		{
-			if (gAircopySendCountdown > 0)
+			if (--gAircopySendCountdown == 0)
 			{
-				if (--gAircopySendCountdown == 0)
+				AIRCOPY_SendMessage();
-				{
+				GUI_DisplayScreen();
-					AIRCOPY_SendMessage();
-					GUI_DisplayScreen();
-				}
 			}
 		}
-	#endif
+	}
+#endif
 
 	CheckKeys();
 }
@@ -1549,9 +1406,11 @@ void APP_TimeSlice500ms(void)
 		if (--gMenuCountdown == 0)
 			exit_menu = (gScreenToDisplay == DISPLAY_MENU);	// exit menu mode
 
+#ifdef ENABLE_DTMF_CALLING
 	if (gDTMF_RX_timeout > 0)
 		if (--gDTMF_RX_timeout == 0)
 			DTMF_clear_RX();
+#endif
 
 	// Skipped authentic device check
 
@@ -1566,9 +1425,9 @@ void APP_TimeSlice500ms(void)
 
 	if (gBacklightCountdown > 0 && 
 		!gAskToSave && 
-		gCssScanMode == CSS_SCAN_MODE_OFF &&
+		!gCssBackgroundScan &&
 		// don't turn off backlight if user is in backlight menu option
-		!(gScreenToDisplay == DISPLAY_MENU && (GetCurrentMenuId() == MENU_ABR || GetCurrentMenuId() == MENU_ABR_MAX)) 
+		!(gScreenToDisplay == DISPLAY_MENU && (UI_MENU_GetCurrentMenuId() == MENU_ABR || UI_MENU_GetCurrentMenuId() == MENU_ABR_MAX)) 
 		) 
 	{	if (--gBacklightCountdown == 0)
 				if (gEeprom.BACKLIGHT_TIME < (ARRAY_SIZE(gSubMenu_BACKLIGHT) - 1)) // backlight is not set to be always on
@@ -1623,15 +1482,15 @@ void APP_TimeSlice500ms(void)
 	}
 
 	#ifdef ENABLE_FMRADIO
-		if ((gFM_ScanState == FM_SCAN_OFF || gAskToSave) && gCssScanMode == CSS_SCAN_MODE_OFF)
+		if ((gFM_ScanState == FM_SCAN_OFF || gAskToSave) && !gCssBackgroundScan)
 	#else
-		if (gCssScanMode == CSS_SCAN_MODE_OFF)
+		if (!gCssBackgroundScan)
 	#endif
 	{
 		#ifdef ENABLE_AIRCOPY
-			if (gScanStateDir == SCAN_OFF && gScreenToDisplay != DISPLAY_AIRCOPY && (gScreenToDisplay != DISPLAY_SCANNER || gScanCssState >= SCAN_CSS_STATE_FOUND))
+			if (gScanStateDir == SCAN_OFF && gScreenToDisplay != DISPLAY_AIRCOPY && !SCANNER_IsScanning())
 		#else
-			if (gScanStateDir == SCAN_OFF && (gScreenToDisplay != DISPLAY_SCANNER || gScanCssState >= SCAN_CSS_STATE_FOUND))
+			if (gScanStateDir == SCAN_OFF && !SCANNER_IsScanning())
 		#endif
 		{
 			if (gEeprom.AUTO_KEYPAD_LOCK && gKeyLockCountdown > 0 && !gDTMF_InputMode && gScreenToDisplay != DISPLAY_MENU)
@@ -1653,7 +1512,7 @@ void APP_TimeSlice500ms(void)
 				if (gInputBoxIndex > 0 || gDTMF_InputMode)
 					AUDIO_PlayBeep(BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL);
 /*
-				if (gScreenToDisplay == DISPLAY_SCANNER)
+				if (SCANNER_IsScanning())
 				{
 					BK4819_StopScan();
 
@@ -1689,10 +1548,10 @@ void APP_TimeSlice500ms(void)
 
 					if (disp == DISPLAY_INVALID)
 					{
-						#ifndef ENABLE_CODE_SCAN_TIMEOUT
+#ifndef ENABLE_NO_CODE_SCAN_TIMEOUT
-							if (gScreenToDisplay != DISPLAY_SCANNER)
+						if (!SCANNER_IsScanning())
-						#endif
+#endif
-								disp = DISPLAY_MAIN;
+							disp = DISPLAY_MAIN;
 					}
 
 					if (disp != DISPLAY_INVALID)
@@ -1723,28 +1582,10 @@ void APP_TimeSlice500ms(void)
 		}
 	}
 
-
 	BATTERY_TimeSlice500ms();
+	SCANNER_TimeSlice500ms();
 
-	if (gScreenToDisplay == DISPLAY_SCANNER && gScannerEditState == 0 && gScanCssState < SCAN_CSS_STATE_FOUND)
+#ifdef ENABLE_DTMF_CALLING
-	{
-		gScanProgressIndicator++;
-
-		#ifdef ENABLE_CODE_SCAN_TIMEOUT
-			if (gScanProgressIndicator > 32)
-			{
-				if (gScanCssState == SCAN_CSS_STATE_SCANNING && !gScanSingleFrequency)
-					gScanCssState = SCAN_CSS_STATE_FOUND;
-				else
-					gScanCssState = SCAN_CSS_STATE_FAILED;
-
-				gUpdateStatus = true;
-			}
-		#endif
-
-		gUpdateDisplay = true;
-	}
-
 	if (gCurrentFunction != FUNCTION_TRANSMIT)
 	{
 		if (gDTMF_DecodeRingCountdown_500ms > 0)
@@ -1781,6 +1622,7 @@ void APP_TimeSlice500ms(void)
 			gUpdateDisplay = true;
 		}
 	}
+#endif
 }
 
 #if defined(ENABLE_ALARM) || defined(ENABLE_TX1750)
@@ -1865,7 +1707,7 @@ static void ProcessKey(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 	else // key pressed or held
 	{
 		const uint8_t s = gSetting_backlight_on_tx_rx;
-		const int m = GetCurrentMenuId();
+		const int m = UI_MENU_GetCurrentMenuId();
 		if 	(	//not when PTT and the backlight shouldn't turn on on TX
 				!(Key == KEY_PTT && s != BACKLIGHT_ON_TR_TX && s != BACKLIGHT_ON_TR_TXRX) 
 				// not in the backlight menu
@@ -1888,11 +1730,18 @@ static void ProcessKey(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 
 			// cancel user input
 			cancelUserInputModes();
+			
+			if (gMonitor)
+				ACTION_Monitor(); //turn off the monitor
+#ifdef ENABLE_SCAN_RANGES
+			gScanRangeStart = 0;
+#endif
 		}
 
 		if (gScreenToDisplay == DISPLAY_MENU)       // 1of11
 			gMenuCountdown = menu_timeout_500ms;
 
+#ifdef ENABLE_DTMF_CALLING
 		if (gDTMF_DecodeRingCountdown_500ms > 0)
 		{	// cancel the ringing
 			gDTMF_DecodeRingCountdown_500ms = 0;
@@ -1905,6 +1754,7 @@ static void ProcessKey(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 				return;
 			}
 		}
+#endif
 	}
 
 	bool lowBatPopup = gLowBattery && !gLowBatteryConfirmed &&  gScreenToDisplay == DISPLAY_MAIN;
@@ -1954,7 +1804,7 @@ static void ProcessKey(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 
 	if (Key <= KEY_9 || Key == KEY_F)
 	{
-		if (gScanStateDir != SCAN_OFF || gCssScanMode != CSS_SCAN_MODE_OFF)
+		if (gScanStateDir != SCAN_OFF || gCssBackgroundScan)
 		{	// FREQ/CTCSS/DCS scanning
 			if (bKeyPressed && !bKeyHeld)
 				AUDIO_PlayBeep(BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL);
@@ -2073,22 +1923,16 @@ static void ProcessKey(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 				}
 #endif
 		}
-		else if (Key != KEY_SIDE1 && Key != KEY_SIDE2)
+		else if (Key != KEY_SIDE1 && Key != KEY_SIDE2) {
-		{
+			switch (gScreenToDisplay) {
-			switch (gScreenToDisplay)
-			{
 				case DISPLAY_MAIN:
-				
 					MAIN_ProcessKeys(Key, bKeyPressed, bKeyHeld);
-//					bKeyHeld = false;	// allow the channel setting to be saved
 					break;
-
+#ifdef ENABLE_FMRADIO
-				#ifdef ENABLE_FMRADIO
+				case DISPLAY_FM:
-					case DISPLAY_FM:
+					FM_ProcessKeys(Key, bKeyPressed, bKeyHeld);
-						FM_ProcessKeys(Key, bKeyPressed, bKeyHeld);
+					break;
-						break;
+#endif
-				#endif
-
 				case DISPLAY_MENU:
 					MENU_ProcessKeys(Key, bKeyPressed, bKeyHeld);
 					break;
@@ -2097,12 +1941,11 @@ static void ProcessKey(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 					SCANNER_ProcessKeys(Key, bKeyPressed, bKeyHeld);
 					break;
 
-				#ifdef ENABLE_AIRCOPY
+#ifdef ENABLE_AIRCOPY
-					case DISPLAY_AIRCOPY:
+				case DISPLAY_AIRCOPY:
-						AIRCOPY_ProcessKeys(Key, bKeyPressed, bKeyHeld);
+					AIRCOPY_ProcessKeys(Key, bKeyPressed, bKeyHeld);
-						break;
+					break;
-				#endif
+#endif
-
 				case DISPLAY_INVALID:
 				default:
 					break;
@@ -2110,9 +1953,9 @@ static void ProcessKey(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 		}
 		else
 #ifdef ENABLE_AIRCOPY
-		if (gScreenToDisplay != DISPLAY_SCANNER && gScreenToDisplay != DISPLAY_AIRCOPY)
+		if (!SCANNER_IsScanning() && gScreenToDisplay != DISPLAY_AIRCOPY)
 #else
-		if (gScreenToDisplay != DISPLAY_SCANNER)
+		if (!SCANNER_IsScanning())
 #endif
 		{
 			ACTION_Handle(Key, bKeyPressed, bKeyHeld);
@@ -2138,12 +1981,6 @@ Skip:
 		gFlagAcceptSetting  = false;
 	}
 
-	if (gFlagStopScan)
-	{
-		BK4819_StopScan();
-		gFlagStopScan = false;
-	}
-
 	if (gRequestSaveSettings)
 	{
 		if (!bKeyHeld)
@@ -2180,7 +2017,7 @@ Skip:
 		{
 			SETTINGS_SaveChannel(gTxVfo->CHANNEL_SAVE, gEeprom.TX_VFO, gTxVfo, gRequestSaveChannel);
 
-			if (gScreenToDisplay != DISPLAY_SCANNER)
+			if (!SCANNER_IsScanning())
 				if (gVfoConfigureMode == VFO_CONFIGURE_NONE)  // 'if' is so as we don't wipe out previously setting this variable elsewhere
 					gVfoConfigureMode = VFO_CONFIGURE;
 		}
@@ -2217,16 +2054,18 @@ Skip:
 	{
 		RADIO_SelectVfos();
 
-		#ifdef ENABLE_NOAA
+#ifdef ENABLE_NOAA
-			RADIO_ConfigureNOAA();
+		RADIO_ConfigureNOAA();
-		#endif
+#endif
 
 		RADIO_SetupRegisters(true);
 
+#ifdef ENABLE_DTMF_CALLING
 		gDTMF_auto_reset_time_500ms = 0;
 		gDTMF_CallState             = DTMF_CALL_STATE_NONE;
 		gDTMF_TxStopCountdown_500ms = 0;
 		gDTMF_IsTx                  = false;
+#endif
 
 		gVFO_RSSI_bar_level[0]      = 0;
 		gVFO_RSSI_bar_level[1]      = 0;
@@ -2245,22 +2084,6 @@ Skip:
 		MENU_ShowCurrentSetting();
 	}
 
-	if (gFlagStartScan)
-	{
-		gFlagStartScan = false;
-
-		gMonitor = false;
-
-		#ifdef ENABLE_VOICE
-			AUDIO_SetVoiceID(0, VOICE_ID_SCANNING_BEGIN);
-			AUDIO_PlaySingleVoice(true);
-		#endif
-
-		SCANNER_Start();
-
-		gRequestDisplayScreen = DISPLAY_SCANNER;
-	}
-
 	if (gFlagPrepareTX)
 	{
 		RADIO_PrepareTX();

app/app.h

@@ -25,6 +25,7 @@
 
 void     APP_EndTransmission(void);
 void     APP_StartListening(FUNCTION_Type_t Function, const bool reset_am_fix);
+uint32_t APP_SetFreqByStepAndLimits(VFO_Info_t *pInfo, int8_t direction, uint32_t lower, uint32_t upper);
 uint32_t APP_SetFrequencyByStep(VFO_Info_t *pInfo, int8_t direction);
 void     APP_Update(void);
 void     APP_TimeSlice10ms(void);

app/chFrScanner.c

@@ -0,0 +1,274 @@
+
+#include "app/app.h"
+#include "app/chFrScanner.h"
+#include "functions.h"
+#include "misc.h"
+#include "settings.h"
+
+int8_t            gScanStateDir;
+bool              gScanKeepResult;
+bool              gScanPauseMode;
+
+#ifdef ENABLE_SCAN_RANGES
+uint32_t          gScanRangeStart;
+#endif
+
+typedef enum {
+	SCAN_NEXT_CHAN_SCANLIST1 = 0,
+	SCAN_NEXT_CHAN_SCANLIST2,
+	SCAN_NEXT_CHAN_DUAL_WATCH,
+	SCAN_NEXT_CHAN_MR,
+	SCAN_NEXT_NUM
+} scan_next_chan_t;
+
+scan_next_chan_t	currentScanList;
+uint32_t            initialFrqOrChan;
+uint8_t           	initialCROSS_BAND_RX_TX;
+uint32_t            lastFoundFrqOrChan;
+
+static void NextFreqChannel(void);
+static void NextMemChannel(void);
+
+void CHFRSCANNER_Start(const bool storeBackupSettings, const int8_t scan_direction)
+{
+	if (storeBackupSettings) {
+		initialCROSS_BAND_RX_TX = gEeprom.CROSS_BAND_RX_TX;
+		gEeprom.CROSS_BAND_RX_TX = CROSS_BAND_OFF;
+		gScanKeepResult = false;
+	}
+	
+	RADIO_SelectVfos();
+
+	gNextMrChannel   = gRxVfo->CHANNEL_SAVE;
+	currentScanList = SCAN_NEXT_CHAN_SCANLIST1;
+	gScanStateDir    = scan_direction;
+
+	if (IS_MR_CHANNEL(gNextMrChannel))
+	{	// channel mode
+		if (storeBackupSettings) {
+			initialFrqOrChan = gRxVfo->CHANNEL_SAVE;
+			lastFoundFrqOrChan = initialFrqOrChan;
+		}
+		NextMemChannel();
+	}
+	else
+	{	// frequency mode
+		if (storeBackupSettings) {
+			initialFrqOrChan = gRxVfo->freq_config_RX.Frequency;
+			lastFoundFrqOrChan = initialFrqOrChan;
+		}
+		NextFreqChannel();
+	}
+
+	gScanPauseDelayIn_10ms = scan_pause_delay_in_2_10ms;
+	gScheduleScanListen    = false;
+	gRxReceptionMode       = RX_MODE_NONE;
+	gScanPauseMode         = false;
+}
+
+void CHFRSCANNER_ContinueScanning(void)
+{
+	if (IS_FREQ_CHANNEL(gNextMrChannel))
+	{
+		if (gCurrentFunction == FUNCTION_INCOMING)
+			APP_StartListening(gMonitor ? FUNCTION_MONITOR : FUNCTION_RECEIVE, true);
+		else
+			NextFreqChannel();  // switch to next frequency
+	}
+	else
+	{
+		if (gCurrentCodeType == CODE_TYPE_OFF && gCurrentFunction == FUNCTION_INCOMING)
+			APP_StartListening(gMonitor ? FUNCTION_MONITOR : FUNCTION_RECEIVE, true);
+		else
+			NextMemChannel();    // switch to next channel
+	}
+	
+	gScanPauseMode      = false;
+	gRxReceptionMode    = RX_MODE_NONE;
+	gScheduleScanListen = false;
+}
+
+void CHFRSCANNER_Found(void)
+{
+	switch (gEeprom.SCAN_RESUME_MODE)
+	{
+		case SCAN_RESUME_TO:
+			if (!gScanPauseMode)
+			{
+				gScanPauseDelayIn_10ms = scan_pause_delay_in_1_10ms;
+				gScheduleScanListen    = false;
+				gScanPauseMode         = true;
+			}
+			break;
+
+		case SCAN_RESUME_CO:
+		case SCAN_RESUME_SE:
+			gScanPauseDelayIn_10ms = 0;
+			gScheduleScanListen    = false;
+			break;
+	}
+
+	if (IS_MR_CHANNEL(gRxVfo->CHANNEL_SAVE)) { //memory scan
+		lastFoundFrqOrChan = gRxVfo->CHANNEL_SAVE;
+	}
+	else { // frequency scan
+		lastFoundFrqOrChan = gRxVfo->freq_config_RX.Frequency;
+	}
+
+
+	gScanKeepResult = true;
+}
+
+void CHFRSCANNER_Stop(void)
+{
+	if(initialCROSS_BAND_RX_TX != CROSS_BAND_OFF) {
+		gEeprom.CROSS_BAND_RX_TX = initialCROSS_BAND_RX_TX;
+		initialCROSS_BAND_RX_TX = CROSS_BAND_OFF;
+	}
+	
+	gScanStateDir = SCAN_OFF;
+
+	const uint32_t chFr = gScanKeepResult ? lastFoundFrqOrChan : initialFrqOrChan;
+	const bool channelChanged = chFr != initialFrqOrChan;
+	if (IS_MR_CHANNEL(gNextMrChannel)) {
+		gEeprom.MrChannel[gEeprom.RX_VFO]     = chFr;
+		gEeprom.ScreenChannel[gEeprom.RX_VFO] = chFr;
+		RADIO_ConfigureChannel(gEeprom.RX_VFO, VFO_CONFIGURE_RELOAD);
+
+		if(channelChanged) {
+			SETTINGS_SaveVfoIndices();
+			gUpdateStatus = true;
+		}
+	}
+	else {
+		gRxVfo->freq_config_RX.Frequency = chFr;
+		RADIO_ApplyOffset(gRxVfo);
+		RADIO_ConfigureSquelchAndOutputPower(gRxVfo);
+		if(channelChanged) {
+			SETTINGS_SaveChannel(gRxVfo->CHANNEL_SAVE, gEeprom.RX_VFO, gRxVfo, 1);
+		}
+	}
+
+	RADIO_SetupRegisters(true);
+	gUpdateDisplay = true;
+}
+
+static void NextFreqChannel(void)
+{
+#ifdef ENABLE_SCAN_RANGES
+	if(gScanRangeStart) {
+		uint32_t start = gScanRangeStart;
+		uint32_t end = gEeprom.VfoInfo[(gEeprom.TX_VFO+1)%2].freq_config_RX.Frequency;
+		gRxVfo->freq_config_RX.Frequency = APP_SetFreqByStepAndLimits(gRxVfo, gScanStateDir, MIN(start, end), MAX(start, end));
+	}
+	else
+#endif
+		gRxVfo->freq_config_RX.Frequency = APP_SetFrequencyByStep(gRxVfo, gScanStateDir);
+
+	RADIO_ApplyOffset(gRxVfo);
+	RADIO_ConfigureSquelchAndOutputPower(gRxVfo);
+	RADIO_SetupRegisters(true);
+
+#ifdef ENABLE_FASTER_CHANNEL_SCAN
+	gScanPauseDelayIn_10ms = 9;   // 90ms
+#else
+	gScanPauseDelayIn_10ms = scan_pause_delay_in_6_10ms;
+#endif
+
+	gUpdateDisplay     = true;
+}
+
+static void NextMemChannel(void)
+{
+	static unsigned int prev_mr_chan = 0;
+	const bool          enabled      = (gEeprom.SCAN_LIST_DEFAULT < 2) ? gEeprom.SCAN_LIST_ENABLED[gEeprom.SCAN_LIST_DEFAULT] : true;
+	const int           chan1        = (gEeprom.SCAN_LIST_DEFAULT < 2) ? gEeprom.SCANLIST_PRIORITY_CH1[gEeprom.SCAN_LIST_DEFAULT] : -1;
+	const int           chan2        = (gEeprom.SCAN_LIST_DEFAULT < 2) ? gEeprom.SCANLIST_PRIORITY_CH2[gEeprom.SCAN_LIST_DEFAULT] : -1;
+	const unsigned int  prev_chan    = gNextMrChannel;
+	unsigned int        chan         = 0;
+
+	if (enabled)
+	{
+		switch (currentScanList)
+		{
+			case SCAN_NEXT_CHAN_SCANLIST1:
+				prev_mr_chan = gNextMrChannel;
+	
+				if (chan1 >= 0)
+				{
+					if (RADIO_CheckValidChannel(chan1, false, 0))
+					{
+						currentScanList = SCAN_NEXT_CHAN_SCANLIST1;
+						gNextMrChannel   = chan1;
+						break;
+					}
+				}
+				[[fallthrough]];
+			case SCAN_NEXT_CHAN_SCANLIST2:
+				if (chan2 >= 0)
+				{
+					if (RADIO_CheckValidChannel(chan2, false, 0))
+					{
+						currentScanList = SCAN_NEXT_CHAN_SCANLIST2;
+						gNextMrChannel   = chan2;
+						break;
+					}
+				}
+				[[fallthrough]];
+				
+			// this bit doesn't yet work if the other VFO is a frequency
+			case SCAN_NEXT_CHAN_DUAL_WATCH:
+				// dual watch is enabled - include the other VFO in the scan
+//				if (gEeprom.DUAL_WATCH != DUAL_WATCH_OFF)
+//				{
+//					chan = (gEeprom.RX_VFO + 1) & 1u;
+//					chan = gEeprom.ScreenChannel[chan];
+//					if (IS_MR_CHANNEL(chan))
+//					{
+//						currentScanList = SCAN_NEXT_CHAN_DUAL_WATCH;
+//						gNextMrChannel   = chan;
+//						break;
+//					}
+//				}
+
+			default:
+			case SCAN_NEXT_CHAN_MR:
+				currentScanList = SCAN_NEXT_CHAN_MR;
+				gNextMrChannel   = prev_mr_chan;
+				chan             = 0xff;
+				break;
+		}
+	}
+
+	if (!enabled || chan == 0xff)
+	{
+		chan = RADIO_FindNextChannel(gNextMrChannel + gScanStateDir, gScanStateDir, (gEeprom.SCAN_LIST_DEFAULT < 2) ? true : false, gEeprom.SCAN_LIST_DEFAULT);
+		if (chan == 0xFF)
+		{	// no valid channel found
+			chan = MR_CHANNEL_FIRST;
+		}
+		
+		gNextMrChannel = chan;
+	}
+
+	if (gNextMrChannel != prev_chan)
+	{
+		gEeprom.MrChannel[    gEeprom.RX_VFO] = gNextMrChannel;
+		gEeprom.ScreenChannel[gEeprom.RX_VFO] = gNextMrChannel;
+
+		RADIO_ConfigureChannel(gEeprom.RX_VFO, VFO_CONFIGURE_RELOAD);
+		RADIO_SetupRegisters(true);
+
+		gUpdateDisplay = true;
+	}
+
+#ifdef ENABLE_FASTER_CHANNEL_SCAN
+	gScanPauseDelayIn_10ms = 9;  // 90ms .. <= ~60ms it misses signals (squelch response and/or PLL lock time) ?
+#else
+	gScanPauseDelayIn_10ms = scan_pause_delay_in_3_10ms;
+#endif
+
+	if (enabled)
+		if (++currentScanList >= SCAN_NEXT_NUM)
+			currentScanList = SCAN_NEXT_CHAN_SCANLIST1;  // back round we go
+}

app/chFrScanner.h

@@ -0,0 +1,22 @@
+#ifndef APP_CHFRSCANNER_H
+#define APP_CHFRSCANNER_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+// scan direction, if not equal SCAN_OFF indicates 
+// that we are in a process of scanning channels/frequencies
+extern int8_t            gScanStateDir;
+extern bool              gScanKeepResult;
+extern bool              gScanPauseMode;
+
+#ifdef ENABLE_SCAN_RANGES
+extern uint32_t          gScanRangeStart;
+#endif
+
+void CHFRSCANNER_Found(void);
+void CHFRSCANNER_Stop(void);
+void CHFRSCANNER_Start(const bool storeBackupSettings, const int8_t scan_direction);
+void CHFRSCANNER_ContinueScanning(void);
+
+#endif

app/common.c

@@ -1,3 +1,4 @@
+#include "app/chFrScanner.h"
 #include "audio.h"
 #include "functions.h"
 #include "misc.h"
@@ -23,6 +24,9 @@ void COMMON_KeypadLockToggle()
 
 void COMMON_SwitchVFOs()
 {
+#ifdef ENABLE_SCAN_RANGES    
+    gScanRangeStart = 0;
+#endif
     gEeprom.TX_VFO ^= 1;
 
     if (gEeprom.CROSS_BAND_RX_TX != CROSS_BAND_OFF)

app/dtmf.c

@@ -17,6 +17,7 @@
 #include <string.h>
 #include <stdio.h>   // NULL
 
+#include "app/chFrScanner.h"
 #ifdef ENABLE_FMRADIO
 	#include "app/fm.h"
 #endif
@@ -40,14 +41,15 @@ uint8_t           gDTMF_InputBox_Index = 0;
 bool              gDTMF_InputMode      = false;
 uint8_t           gDTMF_PreviousIndex  = 0;
 
+char              gDTMF_RX_live[20];
+uint8_t           gDTMF_RX_live_timeout = 0;
+
+#ifdef ENABLE_DTMF_CALLING
 char              gDTMF_RX[17];
 uint8_t           gDTMF_RX_index   = 0;
 uint8_t           gDTMF_RX_timeout = 0;
 bool              gDTMF_RX_pending = false;
 
-char              gDTMF_RX_live[20];
-uint8_t           gDTMF_RX_live_timeout = 0;
-
 bool              gIsDtmfContactValid;
 char              gDTMF_ID[4];
 char              gDTMF_Caller[4];
@@ -57,12 +59,16 @@ uint8_t           gDTMF_DecodeRingCountdown_500ms;
 uint8_t           gDTMF_chosen_contact;
 uint8_t           gDTMF_auto_reset_time_500ms;
 DTMF_CallState_t  gDTMF_CallState;
-DTMF_ReplyState_t gDTMF_ReplyState;
 DTMF_CallMode_t   gDTMF_CallMode;
+
 bool              gDTMF_IsTx;
+
 uint8_t           gDTMF_TxStopCountdown_500ms;
 bool              gDTMF_IsGroupCall;
+#endif
+DTMF_ReplyState_t gDTMF_ReplyState;
 
+#ifdef ENABLE_DTMF_CALLING
 void DTMF_clear_RX(void)
 {
 	gDTMF_RX_timeout = 0;
@@ -70,6 +76,7 @@ void DTMF_clear_RX(void)
 	gDTMF_RX_pending = false;
 	memset(gDTMF_RX, 0, sizeof(gDTMF_RX));
 }
+#endif
 
 bool DTMF_ValidateCodes(char *pCode, const unsigned int size)
 {
@@ -93,6 +100,7 @@ bool DTMF_ValidateCodes(char *pCode, const unsigned int size)
 	return true;
 }
 
+#ifdef ENABLE_DTMF_CALLING
 bool DTMF_GetContact(const int Index, char *pContact)
 {
 	int i = -1;
@@ -131,6 +139,8 @@ bool DTMF_FindContact(const char *pContact, char *pResult)
 	return false;
 }
 
+#endif
+
 char DTMF_GetCharacter(const unsigned int code)
 {
 	switch (code)
@@ -154,8 +164,8 @@ char DTMF_GetCharacter(const unsigned int code)
 		default:       return 0xff;
 	}
 }
-
+#ifdef ENABLE_DTMF_CALLING
-bool DTMF_CompareMessage(const char *pMsg, const char *pTemplate, const unsigned int size, const bool bCheckGroup)
+static bool CompareMessage(const char *pMsg, const char *pTemplate, const unsigned int size, const bool bCheckGroup)
 {
 	unsigned int i;
 	for (i = 0; i < size; i++)
@@ -180,6 +190,7 @@ DTMF_CallMode_t DTMF_CheckGroupCall(const char *pMsg, const unsigned int size)
 
 	return (i < size) ? DTMF_CALL_MODE_GROUP : DTMF_CALL_MODE_NOT_GROUP;
 }
+#endif
 
 void DTMF_clear_input_box(void)
 {
@@ -200,6 +211,7 @@ void DTMF_Append(const char code)
 		gDTMF_InputBox[gDTMF_InputBox_Index++] = code;
 }
 
+#ifdef ENABLE_DTMF_CALLING
 void DTMF_HandleRequest(void)
 {	// proccess the RX'ed DTMF characters
 
@@ -209,7 +221,7 @@ void DTMF_HandleRequest(void)
 	if (!gDTMF_RX_pending)
 		return;   // nothing new received
 
-	if (gScanStateDir != SCAN_OFF || gCssScanMode != CSS_SCAN_MODE_OFF)
+	if (gScanStateDir != SCAN_OFF || gCssBackgroundScan)
 	{	// we're busy scanning
 		DTMF_clear_RX();
 		return;
@@ -230,7 +242,7 @@ void DTMF_HandleRequest(void)
 
 		Offset = gDTMF_RX_index - strlen(String);
 
-		if (DTMF_CompareMessage(gDTMF_RX + Offset, String, strlen(String), true))
+		if (CompareMessage(gDTMF_RX + Offset, String, strlen(String), true))
 		{	// bugger
 
 			if (gEeprom.PERMIT_REMOTE_KILL)
@@ -271,7 +283,7 @@ void DTMF_HandleRequest(void)
 
 		Offset = gDTMF_RX_index - strlen(String);
 
-		if (DTMF_CompareMessage(gDTMF_RX + Offset, String, strlen(String), true))
+		if (CompareMessage(gDTMF_RX + Offset, String, strlen(String), true))
 		{	// shit, we're back !
 
 			gSetting_KILLED  = false;
@@ -296,7 +308,7 @@ void DTMF_HandleRequest(void)
 
 		Offset = gDTMF_RX_index - strlen(String);
 
-		if (DTMF_CompareMessage(gDTMF_RX + Offset, String, strlen(String), true))
+		if (CompareMessage(gDTMF_RX + Offset, String, strlen(String), true))
 		{	// ends with "AB"
 
 			if (gDTMF_ReplyState != DTMF_REPLY_NONE)          // 1of11
@@ -320,7 +332,7 @@ void DTMF_HandleRequest(void)
 
 		Offset = gDTMF_RX_index - strlen(String);
 
-		if (DTMF_CompareMessage(gDTMF_RX + Offset, String, strlen(String), false))
+		if (CompareMessage(gDTMF_RX + Offset, String, strlen(String), false))
 		{	// we got a response
 			gDTMF_State    = DTMF_STATE_CALL_OUT_RSP;
 			DTMF_clear_RX();
@@ -342,7 +354,7 @@ void DTMF_HandleRequest(void)
 
 		Offset = gDTMF_RX_index - strlen(String) - 3;
 
-		if (DTMF_CompareMessage(gDTMF_RX + Offset, String, strlen(String), true))
+		if (CompareMessage(gDTMF_RX + Offset, String, strlen(String), true))
 		{	// it's for us !
 
 			gDTMF_CallState = DTMF_CALL_STATE_RECEIVED;
@@ -379,27 +391,33 @@ void DTMF_HandleRequest(void)
 		}
 	}
 }
+#endif
 
 void DTMF_Reply(void)
 {
 	uint16_t    Delay;
+#ifdef ENABLE_DTMF_CALLING
 	char        String[23];
+#endif
 	const char *pString = NULL;
 
 	switch (gDTMF_ReplyState)
 	{
 		case DTMF_REPLY_ANI:
-			if (gDTMF_CallMode == DTMF_CALL_MODE_DTMF)
+#ifdef ENABLE_DTMF_CALLING
-			{
+			if (gDTMF_CallMode != DTMF_CALL_MODE_DTMF)
-				pString = gDTMF_String;
-			}
-			else
 			{	// append our ID code onto the end of the DTMF code to send
 				sprintf(String, "%s%c%s", gDTMF_String, gEeprom.DTMF_SEPARATE_CODE, gEeprom.ANI_DTMF_ID);
 				pString = String;
 			}
-			break;
+			else 
+#endif
+			{
+				pString = gDTMF_String;
+			}
 
+			break;
+#ifdef ENABLE_DTMF_CALLING
 		case DTMF_REPLY_AB:
 			pString = "AB";
 			break;
@@ -408,10 +426,13 @@ void DTMF_Reply(void)
 			sprintf(String, "%s%c%s", gEeprom.ANI_DTMF_ID, gEeprom.DTMF_SEPARATE_CODE, "AAAAA");
 			pString = String;
 			break;
-
+#endif
 		default:
 		case DTMF_REPLY_NONE:
-			if (gDTMF_CallState != DTMF_CALL_STATE_NONE           ||
+			if (
+#ifdef ENABLE_DTMF_CALLING
+				gDTMF_CallState != DTMF_CALL_STATE_NONE           ||
+#endif
 			    gCurrentVfo->DTMF_PTT_ID_TX_MODE == PTT_ID_APOLLO ||
 			    gCurrentVfo->DTMF_PTT_ID_TX_MODE == PTT_ID_OFF    ||
 			    gCurrentVfo->DTMF_PTT_ID_TX_MODE == PTT_ID_TX_DOWN)

app/dtmf.h

@@ -75,14 +75,15 @@ extern uint8_t           gDTMF_InputBox_Index;
 extern bool              gDTMF_InputMode;
 extern uint8_t           gDTMF_PreviousIndex;
 
+extern char              gDTMF_RX_live[20];
+extern uint8_t           gDTMF_RX_live_timeout;
+
+#ifdef ENABLE_DTMF_CALLING
 extern char              gDTMF_RX[17];
 extern uint8_t           gDTMF_RX_index;
 extern uint8_t           gDTMF_RX_timeout;
 extern bool              gDTMF_RX_pending;
 
-extern char              gDTMF_RX_live[20];
-extern uint8_t           gDTMF_RX_live_timeout;
-
 extern bool              gIsDtmfContactValid;
 extern char              gDTMF_ID[4];
 extern char              gDTMF_Caller[4];
@@ -92,21 +93,25 @@ extern uint8_t           gDTMF_DecodeRingCountdown_500ms;
 extern uint8_t           gDTMF_chosen_contact;
 extern uint8_t           gDTMF_auto_reset_time_500ms;
 extern DTMF_CallState_t  gDTMF_CallState;
-extern DTMF_ReplyState_t gDTMF_ReplyState;
+
 extern DTMF_CallMode_t   gDTMF_CallMode;
 extern bool              gDTMF_IsTx;
 extern uint8_t           gDTMF_TxStopCountdown_500ms;
+#endif
+extern DTMF_ReplyState_t gDTMF_ReplyState;
 
-void DTMF_clear_RX(void);
 bool DTMF_ValidateCodes(char *pCode, const unsigned int size);
-bool DTMF_GetContact(const int Index, char *pContact);
-bool DTMF_FindContact(const char *pContact, char *pResult);
 char DTMF_GetCharacter(const unsigned int code);
-bool DTMF_CompareMessage(const char *pDTMF, const char *pTemplate, const unsigned int size, const bool bFlag);
-DTMF_CallMode_t DTMF_CheckGroupCall(const char *pDTMF, const unsigned int size);
 void DTMF_clear_input_box(void);
 void DTMF_Append(const char vode);
-void DTMF_HandleRequest(void);
 void DTMF_Reply(void);
 
+#ifdef ENABLE_DTMF_CALLING
+void DTMF_clear_RX(void);
+DTMF_CallMode_t DTMF_CheckGroupCall(const char *pDTMF, const unsigned int size);
+bool DTMF_GetContact(const int Index, char *pContact);
+bool DTMF_FindContact(const char *pContact, char *pResult);
+void DTMF_HandleRequest(void);
+#endif
+
 #endif

app/fm.c

@@ -47,6 +47,19 @@ bool              gFM_FoundFrequency;
 bool              gFM_AutoScan;
 uint16_t          gFM_RestoreCountdown_10ms;
 
+
+
+const uint8_t BUTTON_STATE_PRESSED = 1 << 0;
+const uint8_t BUTTON_STATE_HELD = 1 << 1;
+
+const uint8_t BUTTON_EVENT_PRESSED = BUTTON_STATE_PRESSED;
+const uint8_t BUTTON_EVENT_HELD = BUTTON_STATE_PRESSED | BUTTON_STATE_HELD;
+const uint8_t BUTTON_EVENT_SHORT =  0;
+const uint8_t BUTTON_EVENT_LONG =  BUTTON_STATE_HELD;
+
+
+static void Key_FUNC(KEY_Code_t Key, uint8_t state);
+
 bool FM_CheckValidChannel(uint8_t Channel)
 {
 	return (Channel < ARRAY_SIZE(gFM_Channels) && (gFM_Channels[Channel] >= 760 && gFM_Channels[Channel] < 1080)) ? true : false;
@@ -223,32 +236,23 @@ Bail:
 	return ret;
 }
 
-static void FM_Key_DIGITS(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
+static void Key_DIGITS(KEY_Code_t Key, uint8_t state)
 {
-	#define STATE_FREQ_MODE 0
+	enum { STATE_FREQ_MODE, STATE_MR_MODE, STATE_SAVE };
-	#define STATE_MR_MODE   1
-	#define STATE_SAVE      2
 
-	if (!bKeyHeld && bKeyPressed)
+	if (state == BUTTON_EVENT_SHORT && !gWasFKeyPressed) {
-	{
-		if (!gWasFKeyPressed)
-		{
 			uint8_t State;
 
-			if (gAskToDelete)
+			if (gAskToDelete) {
-			{
 				gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
 				return;
 			}
 
-			if (gAskToSave)
+			if (gAskToSave) {
-			{
 				State = STATE_SAVE;
 			}
-			else
+			else {
-			{
+				if (gFM_ScanState != FM_SCAN_OFF) {
-				if (gFM_ScanState != FM_SCAN_OFF)
-				{
 					gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
 					return;
 				}
@@ -260,59 +264,47 @@ static void FM_Key_DIGITS(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 
 			gRequestDisplayScreen = DISPLAY_FM;
 
-			if (State == STATE_FREQ_MODE)
+			if (State == STATE_FREQ_MODE) {
-			{
+				if (gInputBoxIndex == 1) {
-				if (gInputBoxIndex == 1)
+					if (gInputBox[0] > 1) {
-				{
-					if (gInputBox[0] > 1)
-					{
 						gInputBox[1] = gInputBox[0];
 						gInputBox[0] = 0;
 						gInputBoxIndex = 2;
 					}
 				}
-				else
+				else if (gInputBoxIndex > 3) {
-				if (gInputBoxIndex > 3)
-				{
 					uint32_t Frequency;
 
 					gInputBoxIndex = 0;
 					Frequency = StrToUL(INPUTBOX_GetAscii());
 
-					if (Frequency < gEeprom.FM_LowerLimit || gEeprom.FM_UpperLimit < Frequency)
+					if (Frequency < gEeprom.FM_LowerLimit || gEeprom.FM_UpperLimit < Frequency) {
-					{
 						gBeepToPlay           = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
 						gRequestDisplayScreen = DISPLAY_FM;
 						return;
 					}
 
 					gEeprom.FM_SelectedFrequency = (uint16_t)Frequency;
-
+#ifdef ENABLE_VOICE
-					#ifdef ENABLE_VOICE
+					gAnotherVoiceID = (VOICE_ID_t)Key;
-						gAnotherVoiceID = (VOICE_ID_t)Key;
+#endif
-					#endif
-
 					gEeprom.FM_FrequencyPlaying = gEeprom.FM_SelectedFrequency;
 					BK1080_SetFrequency(gEeprom.FM_FrequencyPlaying);
 					gRequestSaveFM = true;
 					return;
 				}
 			}
-			else
+			else if (gInputBoxIndex == 2) {
-			if (gInputBoxIndex == 2)
-			{
 				uint8_t Channel;
 
 				gInputBoxIndex = 0;
 				Channel = ((gInputBox[0] * 10) + gInputBox[1]) - 1;
 
-				if (State == STATE_MR_MODE)
+				if (State == STATE_MR_MODE) {
-				{
+					if (FM_CheckValidChannel(Channel)) {
-					if (FM_CheckValidChannel(Channel))
+#ifdef ENABLE_VOICE
-					{
+						gAnotherVoiceID = (VOICE_ID_t)Key;
-						#ifdef ENABLE_VOICE
+#endif
-							gAnotherVoiceID = (VOICE_ID_t)Key;
-						#endif
 						gEeprom.FM_SelectedChannel = Channel;
 						gEeprom.FM_FrequencyPlaying = gFM_Channels[Channel];
 						BK1080_SetFrequency(gEeprom.FM_FrequencyPlaying);
@@ -320,12 +312,10 @@ static void FM_Key_DIGITS(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 						return;
 					}
 				}
-				else
+				else if (Channel < 20) {
-				if (Channel < 20)
+#ifdef ENABLE_VOICE
-				{
+					gAnotherVoiceID = (VOICE_ID_t)Key;
-					#ifdef ENABLE_VOICE
+#endif
-						gAnotherVoiceID = (VOICE_ID_t)Key;
-					#endif
 					gRequestDisplayScreen = DISPLAY_FM;
 					gInputBoxIndex = 0;
 					gFM_ChannelPosition = Channel;
@@ -336,25 +326,31 @@ static void FM_Key_DIGITS(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 				return;
 			}
 
-			#ifdef ENABLE_VOICE
+#ifdef ENABLE_VOICE
-				gAnotherVoiceID = (VOICE_ID_t)Key;
+			gAnotherVoiceID = (VOICE_ID_t)Key;
-			#endif
+#endif
+	}
+	else
+		Key_FUNC(Key, state);
+}
 
-			return;
+static void Key_FUNC(KEY_Code_t Key, uint8_t state)
-		}
+{
+	if (state == BUTTON_EVENT_SHORT || state == BUTTON_EVENT_HELD) 
+	{
+		bool autoScan = gWasFKeyPressed || (state == BUTTON_EVENT_HELD);
 
 		gBeepToPlay           = BEEP_1KHZ_60MS_OPTIONAL;
 		gWasFKeyPressed       = false;
 		gUpdateStatus         = true;
 		gRequestDisplayScreen = DISPLAY_FM;
 
-		switch (Key)
+		switch (Key) {
-		{
 			case KEY_0:
 				ACTION_FM();
 				break;
 
-			case KEY_1:
+			case KEY_3:
 				gEeprom.FM_IsMrMode = !gEeprom.FM_IsMrMode;
 
 				if (!FM_ConfigureChannelState())
@@ -366,12 +362,8 @@ static void FM_Key_DIGITS(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 					gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
 				break;
 
-			case KEY_2:
+			case KEY_STAR:
-				ACTION_Scan(true);
+				ACTION_Scan(autoScan);
-				break;
-
-			case KEY_3:
-				ACTION_Scan(false);
 				break;
 
 			default:
@@ -381,12 +373,9 @@ static void FM_Key_DIGITS(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 	}
 }
 
-static void FM_Key_EXIT(bool bKeyPressed, bool bKeyHeld)
+static void Key_EXIT(uint8_t state)
 {
-	if (bKeyHeld)
+	if (state != BUTTON_EVENT_SHORT)
-		return;
-
-	if (!bKeyPressed)
 		return;
 
 	gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
@@ -441,13 +430,11 @@ static void FM_Key_EXIT(bool bKeyPressed, bool bKeyHeld)
 	gRequestDisplayScreen = DISPLAY_FM;
 }
 
-static void FM_Key_MENU(bool bKeyPressed, bool bKeyHeld)
+static void Key_MENU(uint8_t state)
 {
-	if (bKeyHeld)
+	if (state != BUTTON_EVENT_SHORT)
 		return;
 
-	if (!bKeyPressed)
-		return;
 
 	gRequestDisplayScreen = DISPLAY_FM;
 	gBeepToPlay           = BEEP_1KHZ_60MS_OPTIONAL;
@@ -501,38 +488,29 @@ static void FM_Key_MENU(bool bKeyPressed, bool bKeyHeld)
 	}
 }
 
-static void FM_Key_UP_DOWN(bool bKeyPressed, bool bKeyHeld, int8_t Step)
+static void Key_UP_DOWN(uint8_t state, int8_t Step)
 {
-	if (bKeyHeld || !bKeyPressed)
+	if (state == BUTTON_EVENT_PRESSED) {		
-	{
+		if (gInputBoxIndex) {
-		if (gInputBoxIndex)
-			return;
-
-		if (!bKeyPressed)
-			return;
-	}
-	else
-	{
-		if (gInputBoxIndex)
-		{
 			gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
 			return;
 		}
 
 		gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
 	}
+	else {
+		if (gInputBoxIndex || state!=BUTTON_EVENT_HELD)
+			return;
+	}
 
-	if (gAskToSave)
+	if (gAskToSave) {
-	{
 		gRequestDisplayScreen = DISPLAY_FM;
 		gFM_ChannelPosition   = NUMBER_AddWithWraparound(gFM_ChannelPosition, Step, 0, 19);
 		return;
 	}
 
-	if (gFM_ScanState != FM_SCAN_OFF)
+	if (gFM_ScanState != FM_SCAN_OFF) {
-	{
+		if (gFM_AutoScan) {
-		if (gFM_AutoScan)
-		{
 			gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
 			return;
 		}
@@ -542,8 +520,7 @@ static void FM_Key_UP_DOWN(bool bKeyPressed, bool bKeyHeld, int8_t Step)
 		return;
 	}
 
-	if (gEeprom.FM_IsMrMode)
+	if (gEeprom.FM_IsMrMode) {
-	{
 		const uint8_t Channel = FM_FindNextChannel(gEeprom.FM_SelectedChannel + Step, Step);
 		if (Channel == 0xFF || gEeprom.FM_SelectedChannel == Channel)
 			goto Bail;
@@ -551,8 +528,7 @@ static void FM_Key_UP_DOWN(bool bKeyPressed, bool bKeyHeld, int8_t Step)
 		gEeprom.FM_SelectedChannel  = Channel;
 		gEeprom.FM_FrequencyPlaying = gFM_Channels[Channel];
 	}
-	else
+	else {
-	{
 		uint16_t Frequency = gEeprom.FM_SelectedFrequency + Step;
 		if (Frequency < gEeprom.FM_LowerLimit)
 			Frequency = gEeprom.FM_UpperLimit;
@@ -574,6 +550,10 @@ Bail:
 
 void FM_ProcessKeys(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 {
+	uint8_t state = bKeyPressed + 2 * bKeyHeld;
+
+
+	
 	switch (Key)
 	{
 		case KEY_0:
@@ -586,19 +566,22 @@ void FM_ProcessKeys(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 		case KEY_7:
 		case KEY_8:
 		case KEY_9:
-			FM_Key_DIGITS(Key, bKeyPressed, bKeyHeld);
+			Key_DIGITS(Key, state);
+			break;
+		case KEY_STAR:
+			Key_FUNC(Key, state);
 			break;		
 		case KEY_MENU:
-			FM_Key_MENU(bKeyPressed, bKeyHeld);
+			Key_MENU(state);
 			return;
 		case KEY_UP:
-			FM_Key_UP_DOWN(bKeyPressed, bKeyHeld, 1);
+			Key_UP_DOWN(state, 1);
 			break;
 		case KEY_DOWN:
-			FM_Key_UP_DOWN(bKeyPressed, bKeyHeld, -1);
+			Key_UP_DOWN(state, -1);
 			break;;
 		case KEY_EXIT:
-			FM_Key_EXIT(bKeyPressed, bKeyHeld);
+			Key_EXIT(state);
 			break;
 		case KEY_F:
 			GENERIC_Key_F(bKeyPressed, bKeyHeld);

app/generic.c

@@ -17,6 +17,7 @@
 #include <string.h>
 
 #include "app/app.h"
+#include "app/chFrScanner.h"
 #include "app/common.h"
 
 #ifdef ENABLE_FMRADIO
@@ -142,36 +143,21 @@ void GENERIC_Key_PTT(bool bKeyPressed)
 
 	// PTT pressed
 
-	if (gScanStateDir != SCAN_OFF ||             // frequency/channel scanning
-	    gScreenToDisplay == DISPLAY_SCANNER ||   // CTCSS/CDCSS scanning
-	    gCssScanMode != CSS_SCAN_MODE_OFF)       //   "     "
-	{	// we're scanning .. stop
-
-		if (gScreenToDisplay == DISPLAY_SCANNER)
-		{	// CTCSS/CDCSS scanning .. stop
-			gEeprom.CROSS_BAND_RX_TX = gBackup_CROSS_BAND_RX_TX;
-			gFlagStopScan            = true;
-			gVfoConfigureMode        = VFO_CONFIGURE_RELOAD;
-			gFlagResetVfos           = true;
-		}
-		else
-		if (gScanStateDir != SCAN_OFF)
-		{	// frequency/channel scanning . .stop
-			SCANNER_Stop();
-		}
-		else
-		if (gCssScanMode != CSS_SCAN_MODE_OFF)
-		{	// CTCSS/CDCSS scanning .. stop
-			MENU_StopCssScan();
-
-			#ifdef ENABLE_VOICE
-				gAnotherVoiceID = VOICE_ID_SCANNING_STOP;
-			#endif
-		}
 
+	if (SCANNER_IsScanning())
+	{	// CTCSS/CDCSS scanning .. stop
+		SCANNER_Stop();
 		goto cancel_tx;
 	}
 
+	if (gScanStateDir != SCAN_OFF)
+	{	// frequency/channel scanning . .stop
+		CHFRSCANNER_Stop();
+		goto cancel_tx;
+	}
+
+
+
 #ifdef ENABLE_FMRADIO
 	if (gFM_ScanState != FM_SCAN_OFF)
 	{	// FM radio is scanning .. stop
@@ -198,6 +184,7 @@ void GENERIC_Key_PTT(bool bKeyPressed)
 	if (gScreenToDisplay != DISPLAY_MENU)     // 1of11 .. don't close the menu
 		gRequestDisplayScreen = DISPLAY_MAIN;
 
+
 	if (!gDTMF_InputMode && gDTMF_InputBox_Index == 0)
 		goto start_tx;	// wasn't entering a DTMF code .. start TX'ing (maybe)
 
@@ -212,6 +199,7 @@ void GENERIC_Key_PTT(bool bKeyPressed)
 		if (gDTMF_InputBox_Index < sizeof(gDTMF_InputBox))
 			gDTMF_InputBox[gDTMF_InputBox_Index] = 0;             // NULL term the string
 
+#ifdef ENABLE_DTMF_CALLING
 		// append our DTMF ID to the inputted DTMF code -
 		//  IF the user inputted code is exactly 3 digits long and D-DCD is enabled
 		if (gDTMF_InputBox_Index == 3 && gTxVfo->DTMF_DECODING_ENABLE > 0)
@@ -219,12 +207,12 @@ void GENERIC_Key_PTT(bool bKeyPressed)
 		else
 			gDTMF_CallMode = DTMF_CALL_MODE_DTMF;
 
+		gDTMF_State      = DTMF_STATE_0;
+#endif
 		// remember the DTMF string
 		gDTMF_PreviousIndex = gDTMF_InputBox_Index;
 		strcpy(gDTMF_String, gDTMF_InputBox);
-
 		gDTMF_ReplyState = DTMF_REPLY_ANI;
-		gDTMF_State      = DTMF_STATE_0;
 	}
 
 	DTMF_clear_input_box();

app/main.c

@@ -18,6 +18,7 @@
 
 #include "app/action.h"
 #include "app/app.h"
+#include "app/chFrScanner.h"
 #include "app/common.h"
 #ifdef ENABLE_FMRADIO
 	#include "app/fm.h"
@@ -45,9 +46,16 @@
 void toggle_chan_scanlist(void)
 {	// toggle the selected channels scanlist setting
 
-	if (gScreenToDisplay == DISPLAY_SCANNER || !IS_MR_CHANNEL(gTxVfo->CHANNEL_SAVE))
+	if ( SCANNER_IsScanning())
 		return;
 
+	if(!IS_MR_CHANNEL(gTxVfo->CHANNEL_SAVE)) {
+#ifdef ENABLE_SCAN_RANGES
+		gScanRangeStart = gScanRangeStart ? 0 : gTxVfo->pRX->Frequency;
+#endif
+		return;
+	}
+
 	if (gTxVfo->SCANLIST1_PARTICIPATION)
 	{
 		if (gTxVfo->SCANLIST2_PARTICIPATION)
@@ -105,7 +113,7 @@ static void processFKeyFunction(const KEY_Code_t Key, const bool beep)
 				gBeepToPlay     = BEEP_1KHZ_60MS_OPTIONAL;
 
 #ifdef ENABLE_COPY_CHAN_TO_VFO
-				if (gEeprom.VFO_OPEN && gCssScanMode == CSS_SCAN_MODE_OFF)
+				if (gEeprom.VFO_OPEN && !gCssBackgroundScan)
 				{
 
 					if (gScanStateDir != SCAN_OFF)
@@ -192,15 +200,15 @@ static void processFKeyFunction(const KEY_Code_t Key, const bool beep)
 
 		case KEY_4:
 			gWasFKeyPressed          = false;
-			gFlagStartScan           = true;
+
-			gScanSingleFrequency     = false;
 			gBackup_CROSS_BAND_RX_TX  = gEeprom.CROSS_BAND_RX_TX;
 			gEeprom.CROSS_BAND_RX_TX = CROSS_BAND_OFF;
 			gUpdateStatus            = true;		
-
 			if (beep)
 				gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
 
+			SCANNER_Start(false);
+			gRequestDisplayScreen = DISPLAY_SCANNER;
 			break;
 
 		case KEY_5:
@@ -479,12 +487,14 @@ static void MAIN_Key_EXIT(bool bKeyPressed, bool bKeyHeld)
 
 		gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
 
+#ifdef ENABLE_DTMF_CALLING
 		if (gDTMF_CallState != DTMF_CALL_STATE_NONE && gCurrentFunction != FUNCTION_TRANSMIT)
 		{	// clear CALL mode being displayed
 			gDTMF_CallState = DTMF_CALL_STATE_NONE;
 			gUpdateDisplay  = true;
 			return;
 		}
+#endif
 
 		#ifdef ENABLE_FMRADIO
 			if (!gFmRadioMode)
@@ -506,7 +516,7 @@ static void MAIN_Key_EXIT(bool bKeyPressed, bool bKeyHeld)
 			else
 			{
 				gScanKeepResult = false;
-				SCANNER_Stop();
+				CHFRSCANNER_Stop();
 
 				#ifdef ENABLE_VOICE
 					gAnotherVoiceID = VOICE_ID_SCANNING_STOP;
@@ -579,7 +589,7 @@ static void MAIN_Key_MENU(const bool bKeyPressed, const bool bKeyHeld)
 		if (bFlag)
 		{
 			if (gScanStateDir != SCAN_OFF) {
-				SCANNER_Stop();
+				CHFRSCANNER_Stop();
 				return;
 			}
 
@@ -651,19 +661,18 @@ static void MAIN_Key_STAR(bool bKeyPressed, bool bKeyHeld)
 	{	// with the F-key
 		gWasFKeyPressed = false;
 
-		#ifdef ENABLE_NOAA
+#ifdef ENABLE_NOAA
-			if (IS_NOAA_CHANNEL(gTxVfo->CHANNEL_SAVE))
+		if (IS_NOAA_CHANNEL(gTxVfo->CHANNEL_SAVE)) {
-			{
+			gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
-				gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
+			return;
-				return;
+		}				
-			}				
+#endif
-		#endif
 
 		// scan the CTCSS/DCS code
-		gFlagStartScan           = true;
-		gScanSingleFrequency     = true;
 		gBackup_CROSS_BAND_RX_TX  = gEeprom.CROSS_BAND_RX_TX;
 		gEeprom.CROSS_BAND_RX_TX = CROSS_BAND_OFF;
+		SCANNER_Start(true);
+		gRequestDisplayScreen = DISPLAY_SCANNER;
 	}
 	
 	gPttWasReleased = true;
@@ -764,7 +773,7 @@ static void MAIN_Key_UP_DOWN(bool bKeyPressed, bool bKeyHeld, int8_t Direction)
 	}
 
 	// jump to the next channel
-	SCANNER_ScanChannels(false, Direction);
+	CHFRSCANNER_Start(false, Direction);
 	gScanPauseDelayIn_10ms = 1;
 	gScheduleScanListen    = false;
 

app/menu.c

@@ -47,6 +47,8 @@
 	#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
 #endif
 
+uint8_t gUnlockAllTxConfCnt;
+
 #ifdef ENABLE_F_CAL_MENU
 	void writeXtalFreqCal(const int32_t value, const bool update_eeprom)
 	{
@@ -75,27 +77,39 @@
 	}
 #endif
 
-void MENU_StartCssScan(int8_t Direction)
+void MENU_StartCssScan(void)
 {
-	gCssScanMode  = CSS_SCAN_MODE_SCANNING;
+	SCANNER_Start(true);
 	gUpdateStatus = true;
+	gCssBackgroundScan = true;
 
-	gMenuScrollDirection = Direction;
+	gRequestDisplayScreen = DISPLAY_MENU;
+}
 
-	RADIO_SelectVfos();
+void MENU_CssScanFound(void)
+{
+	if(gScanCssResultType == CODE_TYPE_DIGITAL || gScanCssResultType == CODE_TYPE_REVERSE_DIGITAL) {
+		gMenuCursor = UI_MENU_GetMenuIdx(MENU_R_DCS);
+	}
+	else if(gScanCssResultType == CODE_TYPE_CONTINUOUS_TONE) {
+		gMenuCursor = UI_MENU_GetMenuIdx(MENU_R_CTCS);
+	}
 
-	MENU_SelectNextCode();
+	MENU_ShowCurrentSetting();
 
-	gScanPauseDelayIn_10ms = scan_pause_delay_in_2_10ms;
+	gUpdateStatus = true;
-	gScheduleScanListen    = false;
+	gUpdateDisplay = true;
 }
 
 void MENU_StopCssScan(void)
 {
-	gCssScanMode  = CSS_SCAN_MODE_OFF;
+	gCssBackgroundScan = false;
-	gUpdateStatus = true;
 	
-	RADIO_SetupRegisters(true);
+#ifdef ENABLE_VOICE
+	gAnotherVoiceID       = VOICE_ID_SCANNING_STOP;
+#endif
+	gUpdateDisplay = true;
+	gUpdateStatus = true;
 }
 
 int MENU_GetLimits(uint8_t menu_id, int32_t *pMin, int32_t *pMax)
@@ -230,7 +244,9 @@ int MENU_GetLimits(uint8_t menu_id, int32_t *pMin, int32_t *pMax)
 		case MENU_S_ADD2:
 		case MENU_STE:
 		case MENU_D_ST:
+#ifdef ENABLE_DTMF_CALLING
 		case MENU_D_DCD:
+#endif
 		case MENU_D_LIVE_DEC:
 		#ifdef ENABLE_NOAA
 			case MENU_NOAA_S:
@@ -240,7 +256,6 @@ int MENU_GetLimits(uint8_t menu_id, int32_t *pMin, int32_t *pMax)
 		case MENU_500TX:
 		case MENU_350EN:
 		case MENU_SCREN:
-		case MENU_TX_EN:
 			*pMin = 0;
 			*pMax = ARRAY_SIZE(gSubMenu_OFF_ON) - 1;
 			break;
@@ -297,11 +312,12 @@ int MENU_GetLimits(uint8_t menu_id, int32_t *pMin, int32_t *pMax)
 			*pMax = 2;
 			break;
 			
+#ifdef ENABLE_DTMF_CALLING
 		case MENU_D_RSP:
 			*pMin = 0;
 			*pMax = ARRAY_SIZE(gSubMenu_D_RSP) - 1;
 			break;
-
+#endif
 		case MENU_PTT_ID:
 			*pMin = 0;
 			*pMax = ARRAY_SIZE(gSubMenu_PTT_ID) - 1;
@@ -312,21 +328,23 @@ int MENU_GetLimits(uint8_t menu_id, int32_t *pMin, int32_t *pMax)
 			*pMax = ARRAY_SIZE(gSubMenu_BAT_TXT) - 1;
 			break;
 
+#ifdef ENABLE_DTMF_CALLING
 		case MENU_D_HOLD:
 			*pMin = 5;
 			*pMax = 60;
 			break;
-
+#endif
 		case MENU_D_PRE:
 			*pMin = 3;
 			*pMax = 99;
 			break;
 
+#ifdef ENABLE_DTMF_CALLING
 		case MENU_D_LIST:
 			*pMin = 1;
 			*pMax = 16;
 			break;
-
+#endif
 		#ifdef ENABLE_F_CAL_MENU
 			case MENU_F_CALI:
 				*pMin = -50;
@@ -367,14 +385,14 @@ void MENU_AcceptSetting(void)
 	uint8_t        Code;
 	FREQ_Config_t *pConfig = &gTxVfo->freq_config_RX;
 
-	if (!MENU_GetLimits(GetCurrentMenuId(), &Min, &Max))
+	if (!MENU_GetLimits(UI_MENU_GetCurrentMenuId(), &Min, &Max))
 	{
 		if (gSubMenuSelection < Min) gSubMenuSelection = Min;
 		else
 		if (gSubMenuSelection > Max) gSubMenuSelection = Max;
 	}
 
-	switch (GetCurrentMenuId())
+	switch (UI_MENU_GetCurrentMenuId())
 	{
 		default:
 			return;
@@ -648,6 +666,7 @@ void MENU_AcceptSetting(void)
 			gEeprom.DTMF_SIDE_TONE = gSubMenuSelection;
 			break;
 
+#ifdef ENABLE_DTMF_CALLING
 		case MENU_D_RSP:
 			gEeprom.DTMF_DECODE_RESPONSE = gSubMenuSelection;
 			break;
@@ -655,7 +674,7 @@ void MENU_AcceptSetting(void)
 		case MENU_D_HOLD:
 			gEeprom.DTMF_auto_reset_time = gSubMenuSelection;
 			break;
-
+#endif
 		case MENU_D_PRE:
 			gEeprom.DTMF_PRELOAD_TIME = gSubMenuSelection * 10;
 			break;
@@ -669,11 +688,13 @@ void MENU_AcceptSetting(void)
 			gSetting_battery_text = gSubMenuSelection;
 			break;
 
+#ifdef ENABLE_DTMF_CALLING
 		case MENU_D_DCD:
 			gTxVfo->DTMF_DECODING_ENABLE = gSubMenuSelection;
 			DTMF_clear_RX();
 			gRequestSaveChannel = 1;
 			return;
+#endif
 
 		case MENU_D_LIVE_DEC:
 			gSetting_live_DTMF_decoder = gSubMenuSelection;
@@ -685,6 +706,7 @@ void MENU_AcceptSetting(void)
 			gUpdateStatus            = true;
 			break;
 
+#ifdef ENABLE_DTMF_CALLING
 		case MENU_D_LIST:
 			gDTMF_chosen_contact = gSubMenuSelection - 1;
 			if (gIsDtmfContactValid)
@@ -696,7 +718,7 @@ void MENU_AcceptSetting(void)
 				gRequestDisplayScreen = DISPLAY_INVALID;
 			}
 			return;
-
+#endif
 		case MENU_PONMSG:
 			gEeprom.POWER_ON_DISPLAY_MODE = gSubMenuSelection;
 			break;
@@ -747,10 +769,18 @@ void MENU_AcceptSetting(void)
 			gSetting_350TX = gSubMenuSelection;
 			break;
 
-		case MENU_F_LOCK:
+		case MENU_F_LOCK: {
+			if(gSubMenuSelection == F_LOCK_NONE) { // select 10 times to enable
+				gUnlockAllTxConfCnt++;
+				if(gUnlockAllTxConfCnt < 10)
+					return;
+			}
+			else
+				gUnlockAllTxConfCnt = 0;
+
 			gSetting_F_LOCK = gSubMenuSelection;
 			break;
-
+		}
 		case MENU_200TX:
 			gSetting_200TX = gSubMenuSelection;
 			break;
@@ -770,10 +800,6 @@ void MENU_AcceptSetting(void)
 			gFlagReconfigureVfos    = true;
 			break;
 
-		case MENU_TX_EN:
-			gSetting_TX_EN = gSubMenuSelection;
-			break;
-
 		#ifdef ENABLE_F_CAL_MENU
 			case MENU_F_CALI:
 				writeXtalFreqCal(gSubMenuSelection, true);
@@ -808,7 +834,7 @@ void MENU_AcceptSetting(void)
 					&gEeprom.KEY_2_SHORT_PRESS_ACTION,
 					&gEeprom.KEY_2_LONG_PRESS_ACTION,
 					&gEeprom.KEY_M_LONG_PRESS_ACTION};
-				*fun[GetCurrentMenuId()-MENU_F1SHRT] = gSubMenu_SIDEFUNCTIONS[gSubMenuSelection].id;
+				*fun[UI_MENU_GetCurrentMenuId()-MENU_F1SHRT] = gSubMenu_SIDEFUNCTIONS[gSubMenuSelection].id;
 			}
 			break;
 
@@ -817,53 +843,12 @@ void MENU_AcceptSetting(void)
 	gRequestSaveSettings = true;
 }
 
-void MENU_SelectNextCode(void)
-{
-	int32_t UpperLimit;
-
-	if (GetCurrentMenuId() == MENU_R_DCS)
-		UpperLimit = 208;
-		//UpperLimit = ARRAY_SIZE(DCS_Options);
-	else if (GetCurrentMenuId() == MENU_R_CTCS)
-		UpperLimit = ARRAY_SIZE(CTCSS_Options) - 1;
-	else
-		return;
-
-	gSubMenuSelection = NUMBER_AddWithWraparound(gSubMenuSelection, gMenuScrollDirection, 1, UpperLimit);
-
-	if (GetCurrentMenuId() == MENU_R_DCS)
-	{
-		if (gSubMenuSelection > 104)
-		{
-			gSelectedCodeType = CODE_TYPE_REVERSE_DIGITAL;
-			gSelectedCode     = gSubMenuSelection - 105;
-		}
-		else
-		{
-			gSelectedCodeType = CODE_TYPE_DIGITAL;
-			gSelectedCode     = gSubMenuSelection - 1;
-		}
-
-	}
-	else
-	{
-		gSelectedCodeType = CODE_TYPE_CONTINUOUS_TONE;
-		gSelectedCode     = gSubMenuSelection - 1;
-	}
-
-	RADIO_SetupRegisters(true);
-
-	gScanPauseDelayIn_10ms = (gSelectedCodeType == CODE_TYPE_CONTINUOUS_TONE) ? scan_pause_delay_in_3_10ms : scan_pause_delay_in_4_10ms;
-
-	gUpdateDisplay = true;
-}
-
 static void MENU_ClampSelection(int8_t Direction)
 {
 	int32_t Min;
 	int32_t Max;
 
-	if (!MENU_GetLimits(GetCurrentMenuId(), &Min, &Max))
+	if (!MENU_GetLimits(UI_MENU_GetCurrentMenuId(), &Min, &Max))
 	{
 		int32_t Selection = gSubMenuSelection;
 		if (Selection < Min) Selection = Min;
@@ -875,7 +860,7 @@ static void MENU_ClampSelection(int8_t Direction)
 
 void MENU_ShowCurrentSetting(void)
 {
-	switch (GetCurrentMenuId())
+	switch (UI_MENU_GetCurrentMenuId())
 	{
 		case MENU_SQL:
 			gSubMenuSelection = gEeprom.SQUELCH_LEVEL;
@@ -889,28 +874,41 @@ void MENU_ShowCurrentSetting(void)
 			gSubMenuSelection = gTxVfo->OUTPUT_POWER;
 			break;
 
+		case MENU_RESET:
+			gSubMenuSelection = 0;
+			break;			
+
 		case MENU_R_DCS: 
-			switch (gTxVfo->freq_config_RX.CodeType)
+		case MENU_R_CTCS:
-			{
+		{
+			DCS_CodeType_t type = gTxVfo->freq_config_RX.CodeType;
+			uint8_t code = gTxVfo->freq_config_RX.Code;
+			int menuid = UI_MENU_GetCurrentMenuId();
+
+			if(gScanUseCssResult) {
+				gScanUseCssResult = false;
+				type = gScanCssResultType;
+				code = gScanCssResultCode;
+			}
+			if((menuid==MENU_R_CTCS) ^ (type==CODE_TYPE_CONTINUOUS_TONE)) { //not the same type
+				gSubMenuSelection = 0;
+				break;
+			}
+
+			switch (type) {
+				case CODE_TYPE_CONTINUOUS_TONE:
 				case CODE_TYPE_DIGITAL:
-					gSubMenuSelection = gTxVfo->freq_config_RX.Code + 1;
+					gSubMenuSelection = code + 1;
 					break;
 				case CODE_TYPE_REVERSE_DIGITAL:
-					gSubMenuSelection = gTxVfo->freq_config_RX.Code + 105;
+					gSubMenuSelection = code + 105;
 					break;
 				default:
 					gSubMenuSelection = 0;
 					break;
 			}
-			break;
+		break;
-
+		}
-		case MENU_RESET:
-			gSubMenuSelection = 0;
-			break;
-
-		case MENU_R_CTCS:
-			gSubMenuSelection = (gTxVfo->freq_config_RX.CodeType == CODE_TYPE_CONTINUOUS_TONE) ? gTxVfo->freq_config_RX.Code + 1 : 0;
-			break;
 
 		case MENU_T_DCS:
 			switch (gTxVfo->freq_config_TX.CodeType)
@@ -1075,6 +1073,7 @@ void MENU_ShowCurrentSetting(void)
 			gSubMenuSelection = gEeprom.DTMF_SIDE_TONE;
 			break;
 
+#ifdef ENABLE_DTMF_CALLING
 		case MENU_D_RSP:
 			gSubMenuSelection = gEeprom.DTMF_DECODE_RESPONSE;
 			break;
@@ -1082,7 +1081,7 @@ void MENU_ShowCurrentSetting(void)
 		case MENU_D_HOLD:
 			gSubMenuSelection = gEeprom.DTMF_auto_reset_time;
 			break;
-
+#endif
 		case MENU_D_PRE:
 			gSubMenuSelection = gEeprom.DTMF_PRELOAD_TIME / 10;
 			break;
@@ -1095,6 +1094,7 @@ void MENU_ShowCurrentSetting(void)
 			gSubMenuSelection = gSetting_battery_text;
 			return;
 
+#ifdef ENABLE_DTMF_CALLING
 		case MENU_D_DCD:
 			gSubMenuSelection = gTxVfo->DTMF_DECODING_ENABLE;
 			break;
@@ -1102,7 +1102,7 @@ void MENU_ShowCurrentSetting(void)
 		case MENU_D_LIST:
 			gSubMenuSelection = gDTMF_chosen_contact + 1;
 			break;
-
+#endif
 		case MENU_D_LIVE_DEC:
 			gSubMenuSelection = gSetting_live_DTMF_decoder;
 			break;
@@ -1169,10 +1169,6 @@ void MENU_ShowCurrentSetting(void)
 			gSubMenuSelection = gSetting_ScrambleEnable;
 			break;
 
-		case MENU_TX_EN:
-			gSubMenuSelection = gSetting_TX_EN;
-			break;
-
 		#ifdef ENABLE_F_CAL_MENU
 			case MENU_F_CALI:
 				gSubMenuSelection = gEeprom.BK4819_XTAL_FREQ_LOW;
@@ -1199,7 +1195,7 @@ void MENU_ShowCurrentSetting(void)
 				&gEeprom.KEY_2_SHORT_PRESS_ACTION,
 				&gEeprom.KEY_2_LONG_PRESS_ACTION,
 				&gEeprom.KEY_M_LONG_PRESS_ACTION};
-			uint8_t id = *fun[GetCurrentMenuId()-MENU_F1SHRT];
+			uint8_t id = *fun[UI_MENU_GetCurrentMenuId()-MENU_F1SHRT];
 
 			for(int i = 0; i < gSubMenu_SIDEFUNCTIONS_size; i++) {
 				if(gSubMenu_SIDEFUNCTIONS[i].id==id) {
@@ -1228,7 +1224,7 @@ static void MENU_Key_0_to_9(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 
 	gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
 
-	if (GetCurrentMenuId() == MENU_MEM_NAME && edit_index >= 0)
+	if (UI_MENU_GetCurrentMenuId() == MENU_MEM_NAME && edit_index >= 0)
 	{	// currently editing the channel name
 
 		if (edit_index < 10)
@@ -1293,7 +1289,7 @@ static void MENU_Key_0_to_9(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 		return;
 	}
 
-	if (GetCurrentMenuId() == MENU_OFFSET)
+	if (UI_MENU_GetCurrentMenuId() == MENU_OFFSET)
 	{
 		uint32_t Frequency;
 
@@ -1316,10 +1312,10 @@ static void MENU_Key_0_to_9(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 		return;
 	}
 	
-	if (GetCurrentMenuId() == MENU_MEM_CH || 
+	if (UI_MENU_GetCurrentMenuId() == MENU_MEM_CH || 
-		GetCurrentMenuId() == MENU_DEL_CH || 
+		UI_MENU_GetCurrentMenuId() == MENU_DEL_CH || 
-		GetCurrentMenuId() == MENU_1_CALL || 
+		UI_MENU_GetCurrentMenuId() == MENU_1_CALL || 
-		GetCurrentMenuId() == MENU_MEM_NAME)
+		UI_MENU_GetCurrentMenuId() == MENU_MEM_NAME)
 	{	// enter 3-digit channel number
 
 		if (gInputBoxIndex < 3)
@@ -1348,7 +1344,7 @@ static void MENU_Key_0_to_9(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 		return;
 	}
 
-	if (MENU_GetLimits(GetCurrentMenuId(), &Min, &Max))
+	if (MENU_GetLimits(UI_MENU_GetCurrentMenuId(), &Min, &Max))
 	{
 		gInputBoxIndex = 0;
 		gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
@@ -1389,11 +1385,11 @@ static void MENU_Key_EXIT(bool bKeyPressed, bool bKeyHeld)
 
 	gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
 
-	if (gCssScanMode == CSS_SCAN_MODE_OFF)
+	if (!gCssBackgroundScan)
 	{
 		if (gIsInSubMenu)
 		{
-			if (gInputBoxIndex == 0 || GetCurrentMenuId() != MENU_OFFSET)
+			if (gInputBoxIndex == 0 || UI_MENU_GetCurrentMenuId() != MENU_OFFSET)
 			{
 				gAskForConfirmation = 0;
 				gIsInSubMenu        = false;
@@ -1449,12 +1445,12 @@ static void MENU_Key_MENU(const bool bKeyPressed, const bool bKeyHeld)
 	if (!gIsInSubMenu)
 	{
 		#ifdef ENABLE_VOICE
-			if (GetCurrentMenuId() != MENU_SCR)
+			if (UI_MENU_GetCurrentMenuId() != MENU_SCR)
 				gAnotherVoiceID = MenuList[gMenuCursor].voice_id;
 		#endif
 
 		#if 1
-			if (GetCurrentMenuId() == MENU_DEL_CH || GetCurrentMenuId() == MENU_MEM_NAME)
+			if (UI_MENU_GetCurrentMenuId() == MENU_DEL_CH || UI_MENU_GetCurrentMenuId() == MENU_MEM_NAME)
 				if (!RADIO_CheckValidChannel(gSubMenuSelection, false, 0))
 					return;  // invalid channel
 		#endif
@@ -1462,7 +1458,7 @@ static void MENU_Key_MENU(const bool bKeyPressed, const bool bKeyHeld)
 		gAskForConfirmation = 0;
 		gIsInSubMenu        = true;
 
-//		if (GetCurrentMenuId() != MENU_D_LIST)
+//		if (UI_MENU_GetCurrentMenuId() != MENU_D_LIST)
 		{
 			gInputBoxIndex      = 0;
 			edit_index          = -1;
@@ -1471,7 +1467,7 @@ static void MENU_Key_MENU(const bool bKeyPressed, const bool bKeyHeld)
 		return;
 	}
 
-	if (GetCurrentMenuId() == MENU_MEM_NAME)
+	if (UI_MENU_GetCurrentMenuId() == MENU_MEM_NAME)
 	{
 		if (edit_index < 0)
 		{	// enter channel name edit mode
@@ -1518,10 +1514,10 @@ static void MENU_Key_MENU(const bool bKeyPressed, const bool bKeyHeld)
 
 	if (gIsInSubMenu)
 	{
-		if (GetCurrentMenuId() == MENU_RESET  ||
+		if (UI_MENU_GetCurrentMenuId() == MENU_RESET  ||
-			GetCurrentMenuId() == MENU_MEM_CH ||
+			UI_MENU_GetCurrentMenuId() == MENU_MEM_CH ||
-			GetCurrentMenuId() == MENU_DEL_CH ||
+			UI_MENU_GetCurrentMenuId() == MENU_DEL_CH ||
-			GetCurrentMenuId() == MENU_MEM_NAME)
+			UI_MENU_GetCurrentMenuId() == MENU_MEM_NAME)
 		{
 			switch (gAskForConfirmation)
 			{
@@ -1534,7 +1530,7 @@ static void MENU_Key_MENU(const bool bKeyPressed, const bool bKeyHeld)
 
 					UI_DisplayMenu();
 
-					if (GetCurrentMenuId() == MENU_RESET)
+					if (UI_MENU_GetCurrentMenuId() == MENU_RESET)
 					{
 						#ifdef ENABLE_VOICE
 							AUDIO_SetVoiceID(0, VOICE_ID_CONFIRM);
@@ -1562,14 +1558,10 @@ static void MENU_Key_MENU(const bool bKeyPressed, const bool bKeyHeld)
 		}
 	}
 
-	if (gCssScanMode != CSS_SCAN_MODE_OFF)
+	SCANNER_Stop();
-	{
-		gCssScanMode  = CSS_SCAN_MODE_OFF;
-		gUpdateStatus = true;
-	}
 
 	#ifdef ENABLE_VOICE
-		if (GetCurrentMenuId() == MENU_SCR)
+		if (UI_MENU_GetCurrentMenuId() == MENU_SCR)
 			gAnotherVoiceID = (gSubMenuSelection == 0) ? VOICE_ID_SCRAMBLER_OFF : VOICE_ID_SCRAMBLER_ON;
 		else
 			gAnotherVoiceID = VOICE_ID_CONFIRM;
@@ -1585,7 +1577,7 @@ static void MENU_Key_STAR(const bool bKeyPressed, const bool bKeyHeld)
 
 	gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
 
-	if (GetCurrentMenuId() == MENU_MEM_NAME && edit_index >= 0)
+	if (UI_MENU_GetCurrentMenuId() == MENU_MEM_NAME && edit_index >= 0)
 	{	// currently editing the channel name
 
 		if (edit_index < 10)
@@ -1612,26 +1604,12 @@ static void MENU_Key_STAR(const bool bKeyPressed, const bool bKeyHeld)
 		if (gRxVfo->Modulation ==  MODULATION_FM)
 	#endif
 	{
-		if (GetCurrentMenuId() == MENU_R_CTCS || GetCurrentMenuId() == MENU_R_DCS)
+		if ((UI_MENU_GetCurrentMenuId() == MENU_R_CTCS || UI_MENU_GetCurrentMenuId() == MENU_R_DCS) && gIsInSubMenu)
 		{	// scan CTCSS or DCS to find the tone/code of the incoming signal
-
+			if (!SCANNER_IsScanning())
-			if (gCssScanMode == CSS_SCAN_MODE_OFF)
+				MENU_StartCssScan();
-			{
-				MENU_StartCssScan(1);
-				gRequestDisplayScreen = DISPLAY_MENU;
-				#ifdef ENABLE_VOICE
-					AUDIO_SetVoiceID(0, VOICE_ID_SCANNING_BEGIN);
-					AUDIO_PlaySingleVoice(1);
-				#endif
-			}
 			else
-			{
 				MENU_StopCssScan();
-				gRequestDisplayScreen = DISPLAY_MENU;
-				#ifdef ENABLE_VOICE
-					gAnotherVoiceID       = VOICE_ID_SCANNING_STOP;
-				#endif
-			}
 		}
 
 		gPttWasReleased = true;
@@ -1647,7 +1625,7 @@ static void MENU_Key_UP_DOWN(bool bKeyPressed, bool bKeyHeld, int8_t Direction)
 	uint8_t Channel;
 	bool    bCheckScanList;
 
-	if (GetCurrentMenuId() == MENU_MEM_NAME && gIsInSubMenu && edit_index >= 0)
+	if (UI_MENU_GetCurrentMenuId() == MENU_MEM_NAME && gIsInSubMenu && edit_index >= 0)
 	{	// change the character
 		if (bKeyPressed && edit_index < 10 && Direction != 0)
 		{
@@ -1682,12 +1660,7 @@ static void MENU_Key_UP_DOWN(bool bKeyPressed, bool bKeyHeld, int8_t Direction)
 	if (!bKeyPressed)
 		return;
 
-	if (gCssScanMode != CSS_SCAN_MODE_OFF)
+	if (SCANNER_IsScanning()) {
-	{
-		MENU_StartCssScan(Direction);
-
-		gPttWasReleased       = true;
-		gRequestDisplayScreen = DISPLAY_MENU;
 		return;
 	}
 
@@ -1699,7 +1672,7 @@ static void MENU_Key_UP_DOWN(bool bKeyPressed, bool bKeyHeld, int8_t Direction)
 
 		gRequestDisplayScreen = DISPLAY_MENU;
 
-		if (GetCurrentMenuId() != MENU_ABR && gEeprom.BACKLIGHT_TIME == 0) // backlight always off and not in the backlight menu
+		if (UI_MENU_GetCurrentMenuId() != MENU_ABR && gEeprom.BACKLIGHT_TIME == 0) // backlight always off and not in the backlight menu
 		{
 			BACKLIGHT_TurnOff();
 		}
@@ -1707,7 +1680,7 @@ static void MENU_Key_UP_DOWN(bool bKeyPressed, bool bKeyHeld, int8_t Direction)
 		return;
 	}
 
-	if (GetCurrentMenuId() == MENU_OFFSET)
+	if (UI_MENU_GetCurrentMenuId() == MENU_OFFSET)
 	{
 		int32_t Offset = (Direction * gTxVfo->StepFrequency) + gSubMenuSelection;
 		if (Offset < 99999990)
@@ -1725,7 +1698,7 @@ static void MENU_Key_UP_DOWN(bool bKeyPressed, bool bKeyHeld, int8_t Direction)
 
 	VFO = 0;
 
-	switch (GetCurrentMenuId())
+	switch (UI_MENU_GetCurrentMenuId())
 	{
 		case MENU_DEL_CH:
 		case MENU_1_CALL:
@@ -1785,7 +1758,7 @@ void MENU_ProcessKeys(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 			MENU_Key_STAR(bKeyPressed, bKeyHeld);
 			break;
 		case KEY_F:
-			if (GetCurrentMenuId() == MENU_MEM_NAME && edit_index >= 0)
+			if (UI_MENU_GetCurrentMenuId() == MENU_MEM_NAME && edit_index >= 0)
 			{	// currently editing the channel name
 				if (!bKeyHeld && bKeyPressed)
 				{
@@ -1817,11 +1790,11 @@ void MENU_ProcessKeys(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 
 	if (gScreenToDisplay == DISPLAY_MENU)
 	{
-		if (GetCurrentMenuId() == MENU_VOL ||
+		if (UI_MENU_GetCurrentMenuId() == MENU_VOL ||
 			#ifdef ENABLE_F_CAL_MENU
-				GetCurrentMenuId() == MENU_F_CALI ||
+				UI_MENU_GetCurrentMenuId() == MENU_F_CALI ||
 		    #endif
-			GetCurrentMenuId() == MENU_BATCAL)
+			UI_MENU_GetCurrentMenuId() == MENU_BATCAL)
 		{
 			gMenuCountdown = menu_timeout_long_500ms;
 		}

app/menu.h

@@ -23,11 +23,13 @@
 	void writeXtalFreqCal(const int32_t value, const bool update_eeprom);
 #endif
 
+extern uint8_t gUnlockAllTxConfCnt;
+
 int MENU_GetLimits(uint8_t menu_id, int32_t *pMin, int32_t *pMax);
 void MENU_AcceptSetting(void);
-void MENU_SelectNextCode(void);
 void MENU_ShowCurrentSetting(void);
-void MENU_StartCssScan(int8_t Direction);
+void MENU_StartCssScan(void);
+void MENU_CssScanFound(void);
 void MENU_StopCssScan(void);
 
 void MENU_ProcessKeys(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld);

app/scanner.c

@@ -17,6 +17,7 @@
 #include "app/app.h"
 #include "app/dtmf.h"
 #include "app/generic.h"
+#include "app/menu.h"
 #include "app/scanner.h"
 #include "audio.h"
 #include "driver/bk4819.h"
@@ -29,68 +30,45 @@
 
 DCS_CodeType_t    gScanCssResultType;
 uint8_t           gScanCssResultCode;
-bool              gFlagStartScan;
+bool              gScanSingleFrequency; // scan CTCSS/DCS codes for current frequency
-bool              gFlagStopScan;
+SCAN_SaveState_t  gScannerSaveState;
-bool              gScanSingleFrequency;
-uint8_t           gScannerEditState;
 uint8_t           gScanChannel;
 uint32_t          gScanFrequency;
-bool              gScanPauseMode;
 SCAN_CssState_t   gScanCssState;
-volatile bool     gScheduleScanListen = true;
-volatile uint16_t gScanPauseDelayIn_10ms;
 uint8_t           gScanProgressIndicator;
-uint8_t           gScanHitCount;
 bool              gScanUseCssResult;
-int8_t            gScanStateDir;
-bool              gScanKeepResult;
 
-typedef enum {
+STEP_Setting_t    stepSetting;
-	SCAN_NEXT_CHAN_SCANLIST1 = 0,
+uint8_t           scanHitCount;
-	SCAN_NEXT_CHAN_SCANLIST2,
-	SCAN_NEXT_CHAN_DUAL_WATCH,
-	SCAN_NEXT_CHAN_MR,
-	SCAN_NEXT_NUM
-} scan_next_chan_t;
 
 
-scan_next_chan_t	currentScanList;
-uint32_t            initialFrqOrChan;
-uint8_t           	initialCROSS_BAND_RX_TX;
-uint32_t            lastFoundFrqOrChan;
-
 static void SCANNER_Key_DIGITS(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 {
 	if (!bKeyHeld && bKeyPressed)
 	{
-		if (gScannerEditState == 1)
+		if (gScannerSaveState == SCAN_SAVE_CHAN_SEL) {
-		{
-			uint16_t Channel;
-
 			gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
 
 			INPUTBOX_Append(Key);
 
 			gRequestDisplayScreen = DISPLAY_SCANNER;
 
-			if (gInputBoxIndex < 3)
+			if (gInputBoxIndex < 3) {
-			{
+#ifdef ENABLE_VOICE
-				#ifdef ENABLE_VOICE
+				gAnotherVoiceID = (VOICE_ID_t)Key;
-					gAnotherVoiceID = (VOICE_ID_t)Key;
+#endif
-				#endif
 				return;
 			}
 
 			gInputBoxIndex = 0;
 
-			Channel = ((gInputBox[0] * 100) + (gInputBox[1] * 10) + gInputBox[2]) - 1;
+			uint16_t chan = ((gInputBox[0] * 100) + (gInputBox[1] * 10) + gInputBox[2]) - 1;
-			if (IS_MR_CHANNEL(Channel))
+			if (IS_MR_CHANNEL(chan)) {
-			{
+#ifdef ENABLE_VOICE
-				#ifdef ENABLE_VOICE
+				gAnotherVoiceID = (VOICE_ID_t)Key;
-					gAnotherVoiceID = (VOICE_ID_t)Key;
+#endif
-				#endif
+				gShowChPrefix = RADIO_CheckValidChannel(chan, false, 0);
-				gShowChPrefix = RADIO_CheckValidChannel(Channel, false, 0);
+				gScanChannel  = (uint8_t)chan;
-				gScanChannel  = (uint8_t)Channel;
 				return;
 			}
 		}
@@ -101,28 +79,17 @@ static void SCANNER_Key_DIGITS(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 
 static void SCANNER_Key_EXIT(bool bKeyPressed, bool bKeyHeld)
 {
-	if (!bKeyHeld && bKeyPressed)
+	if (!bKeyHeld && bKeyPressed) { // short pressed
-	{
 		gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
 
-		switch (gScannerEditState)
+		switch (gScannerSaveState) {
-		{
+			case SCAN_SAVE_NO_PROMPT:
-			case 0:
+				SCANNER_Stop();
 				gRequestDisplayScreen    = DISPLAY_MAIN;
-				
-				gEeprom.CROSS_BAND_RX_TX = gBackup_CROSS_BAND_RX_TX;
-				gUpdateStatus            = true;
-				gFlagStopScan            = true;
-				gVfoConfigureMode        = VFO_CONFIGURE_RELOAD;
-				gFlagResetVfos           = true;
-				#ifdef ENABLE_VOICE
-					gAnotherVoiceID      = VOICE_ID_CANCEL;
-				#endif
 				break;
 
-			case 1:
+			case SCAN_SAVE_CHAN_SEL:
-				if (gInputBoxIndex > 0)
+				if (gInputBoxIndex > 0) {
-				{
 					gInputBox[--gInputBoxIndex] = 10;
 					gRequestDisplayScreen       = DISPLAY_SCANNER;
 					break;
@@ -130,11 +97,11 @@ static void SCANNER_Key_EXIT(bool bKeyPressed, bool bKeyHeld)
 
 				// Fallthrough
 
-			case 2:
+			case SCAN_SAVE_CHANNEL:
-				gScannerEditState     = 0;
+				gScannerSaveState     = SCAN_SAVE_NO_PROMPT;
-				#ifdef ENABLE_VOICE
+#ifdef ENABLE_VOICE
-					gAnotherVoiceID   = VOICE_ID_CANCEL;
+				gAnotherVoiceID   = VOICE_ID_CANCEL;
-				#endif
+#endif
 				gRequestDisplayScreen = DISPLAY_SCANNER;
 				break;
 		}
@@ -143,40 +110,28 @@ static void SCANNER_Key_EXIT(bool bKeyPressed, bool bKeyHeld)
 
 static void SCANNER_Key_MENU(bool bKeyPressed, bool bKeyHeld)
 {
-	uint8_t Channel;
+	if (bKeyHeld || !bKeyPressed) // ignore long press or release button events
-
-	if (bKeyHeld)
 		return;
 
-	if (!bKeyPressed)
+	if (gScanCssState == SCAN_CSS_STATE_OFF && !gScanSingleFrequency) {
-		return;
-
-	if (gScanCssState == SCAN_CSS_STATE_OFF && !gScanSingleFrequency)
-	{
 		gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
 		return;
 	}
 
-	if (gScanCssState == SCAN_CSS_STATE_SCANNING)
+	if (gScanCssState == SCAN_CSS_STATE_SCANNING && gScanSingleFrequency) {
-	{
+		gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
-		if (gScanSingleFrequency)
+		return;
-		{
-			gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
-			return;
-		}
 	}
 
-	if (gScanCssState == SCAN_CSS_STATE_FAILED)
+	if (gScanCssState == SCAN_CSS_STATE_FAILED) {
-	{
 		gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
 		return;
 	}
 
 	gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
 
-	switch (gScannerEditState)
+	switch (gScannerSaveState) {
-	{
+		case SCAN_SAVE_NO_PROMPT:
-		case 0:
 			if (!gScanSingleFrequency)
 			{
 				uint32_t freq250  = FREQUENCY_RoundToStep(gScanFrequency, 250);
@@ -186,60 +141,54 @@ static void SCANNER_Key_MENU(bool bKeyPressed, bool bKeyHeld)
 				uint32_t diff625 = gScanFrequency > freq625 ? gScanFrequency - freq625 : freq625 - gScanFrequency;
 
 				if(diff250 > diff625) {
-					gStepSetting   = STEP_6_25kHz;
+					stepSetting   = STEP_6_25kHz;
 					gScanFrequency = freq625;
 				}
 				else {
-					gStepSetting   = STEP_2_5kHz;
+					stepSetting   = STEP_2_5kHz;
 					gScanFrequency = freq250;
 				}
 			}
 
-			if (IS_MR_CHANNEL(gTxVfo->CHANNEL_SAVE))
+			if (IS_MR_CHANNEL(gTxVfo->CHANNEL_SAVE)) {
-			{
+				gScannerSaveState = SCAN_SAVE_CHAN_SEL;
-				gScannerEditState = 1;
 				gScanChannel      = gTxVfo->CHANNEL_SAVE;
 				gShowChPrefix     = RADIO_CheckValidChannel(gTxVfo->CHANNEL_SAVE, false, 0);
 			}
-			else
+			else {
-			{
+				gScannerSaveState = SCAN_SAVE_CHANNEL;
-				gScannerEditState = 2;
 			}
 
 			gScanCssState         = SCAN_CSS_STATE_FOUND;
-			#ifdef ENABLE_VOICE
+#ifdef ENABLE_VOICE
-				gAnotherVoiceID   = VOICE_ID_MEMORY_CHANNEL;
+			gAnotherVoiceID   = VOICE_ID_MEMORY_CHANNEL;
-			#endif
+#endif
 			gRequestDisplayScreen = DISPLAY_SCANNER;
 			
 			gUpdateStatus = true;
 			break;
 
-		case 1:
+		case SCAN_SAVE_CHAN_SEL:
-			if (gInputBoxIndex == 0)
+			if (gInputBoxIndex == 0) {
-			{
 				gBeepToPlay           = BEEP_1KHZ_60MS_OPTIONAL;
 				gRequestDisplayScreen = DISPLAY_SCANNER;
-				gScannerEditState     = 2;
+				gScannerSaveState     = SCAN_SAVE_CHANNEL;
 			}
 			break;
 
-		case 2:
+		case SCAN_SAVE_CHANNEL:
-			if (!gScanSingleFrequency)
+			if (!gScanSingleFrequency) {
-			{
 				RADIO_InitInfo(gTxVfo, gTxVfo->CHANNEL_SAVE, gScanFrequency);
 
-				if (gScanUseCssResult)
+				if (gScanUseCssResult) {
-				{
 					gTxVfo->freq_config_RX.CodeType = gScanCssResultType;
 					gTxVfo->freq_config_RX.Code     = gScanCssResultCode;
 				}
 
 				gTxVfo->freq_config_TX     = gTxVfo->freq_config_RX;
-				gTxVfo->STEP_SETTING = gStepSetting;
+				gTxVfo->STEP_SETTING = stepSetting;
 			}
-			else
+			else {
-			{
 				RADIO_ConfigureChannel(0, VFO_CONFIGURE_RELOAD);
 				RADIO_ConfigureChannel(1, VFO_CONFIGURE_RELOAD);
 
@@ -249,25 +198,24 @@ static void SCANNER_Key_MENU(bool bKeyPressed, bool bKeyHeld)
 				gTxVfo->freq_config_TX.Code     = gScanCssResultCode;
 			}
 
-			if (IS_MR_CHANNEL(gTxVfo->CHANNEL_SAVE))
+			uint8_t chan;
-			{
+			if (IS_MR_CHANNEL(gTxVfo->CHANNEL_SAVE)) {
-				Channel                               = gScanChannel;
+				chan = gScanChannel;
-				gEeprom.MrChannel[gEeprom.TX_VFO] = Channel;
+				gEeprom.MrChannel[gEeprom.TX_VFO] = chan;
 			}
-			else
+			else {
-			{
+				chan = gTxVfo->Band + FREQ_CHANNEL_FIRST;
-				Channel                                 = gTxVfo->Band + FREQ_CHANNEL_FIRST;
+				gEeprom.FreqChannel[gEeprom.TX_VFO] = chan;
-				gEeprom.FreqChannel[gEeprom.TX_VFO] = Channel;
 			}
 
-			gTxVfo->CHANNEL_SAVE                      = Channel;
+			gTxVfo->CHANNEL_SAVE = chan;
-			gEeprom.ScreenChannel[gEeprom.TX_VFO] = Channel;
+			gEeprom.ScreenChannel[gEeprom.TX_VFO] = chan;
-			#ifdef ENABLE_VOICE
+#ifdef ENABLE_VOICE	
-				gAnotherVoiceID                       = VOICE_ID_CONFIRM;
+			gAnotherVoiceID = VOICE_ID_CONFIRM;
-			#endif
+#endif
-			gRequestDisplayScreen                     = DISPLAY_SCANNER;
+			gRequestDisplayScreen = DISPLAY_SCANNER;
-			gRequestSaveChannel                       = 2;
+			gRequestSaveChannel = 2;
-			gScannerEditState                         = 0;
+			gScannerSaveState = SCAN_SAVE_NO_PROMPT;
 			break;
 
 		default:
@@ -278,23 +226,20 @@ static void SCANNER_Key_MENU(bool bKeyPressed, bool bKeyHeld)
 
 static void SCANNER_Key_STAR(bool bKeyPressed, bool bKeyHeld)
 {
-	if (!bKeyHeld && bKeyPressed)
+	if (!bKeyHeld && bKeyPressed) {
-	{
 		gBeepToPlay    = BEEP_1KHZ_60MS_OPTIONAL;
-		gFlagStartScan = true;
+		SCANNER_Start(gScanSingleFrequency);
 	}
 	return;
 }
 
 static void SCANNER_Key_UP_DOWN(bool bKeyPressed, bool pKeyHeld, int8_t Direction)
 {
-	if (pKeyHeld)
+	if (pKeyHeld) {
-	{
 		if (!bKeyPressed)
 			return;
 	}
-	else
+	else {
-	{
 		if (!bKeyPressed)
 			return;
 
@@ -302,8 +247,7 @@ static void SCANNER_Key_UP_DOWN(bool bKeyPressed, bool pKeyHeld, int8_t Directio
 		gBeepToPlay    = BEEP_1KHZ_60MS_OPTIONAL;
 	}
 
-	if (gScannerEditState == 1)
+	if (gScannerSaveState == SCAN_SAVE_CHAN_SEL) {
-	{
 		gScanChannel          = NUMBER_AddWithWraparound(gScanChannel, Direction, 0, MR_CHANNEL_LAST);
 		gShowChPrefix         = RADIO_CheckValidChannel(gScanChannel, false, 0);
 		gRequestDisplayScreen = DISPLAY_SCANNER;
@@ -314,8 +258,7 @@ static void SCANNER_Key_UP_DOWN(bool bKeyPressed, bool pKeyHeld, int8_t Directio
 
 void SCANNER_ProcessKeys(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 {
-	switch (Key)
+	switch (Key) {
-	{
 		case KEY_0:
 		case KEY_1:
 		case KEY_2:
@@ -353,13 +296,16 @@ void SCANNER_ProcessKeys(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
 	}
 }
 
-void SCANNER_Start(void)
+void SCANNER_Start(bool singleFreq)
 {
-	uint8_t  BackupStep;
+	gScanSingleFrequency = singleFreq;
-	uint16_t BackupFrequency;
+	gMonitor = false;
+
+#ifdef ENABLE_VOICE
+	gAnotherVoiceID = VOICE_ID_SCANNING_BEGIN;
+#endif
 
 	BK4819_StopScan();
-
 	RADIO_SelectVfos();
 
 #ifdef ENABLE_NOAA
@@ -367,13 +313,13 @@ void SCANNER_Start(void)
 		gRxVfo->CHANNEL_SAVE = FREQ_CHANNEL_FIRST + BAND6_400MHz;
 #endif
 
-	BackupStep      = gRxVfo->STEP_SETTING;
+	uint8_t  backupStep      = gRxVfo->STEP_SETTING;
-	BackupFrequency = gRxVfo->StepFrequency;
+	uint16_t backupFrequency = gRxVfo->StepFrequency;
 
 	RADIO_InitInfo(gRxVfo, gRxVfo->CHANNEL_SAVE, gRxVfo->pRX->Frequency);
 
-	gRxVfo->STEP_SETTING  = BackupStep;
+	gRxVfo->STEP_SETTING  = backupStep;
-	gRxVfo->StepFrequency = BackupFrequency;
+	gRxVfo->StepFrequency = backupFrequency;
 
 	RADIO_SetupRegisters(true);
 
@@ -381,34 +327,34 @@ void SCANNER_Start(void)
 	gIsNoaaMode = false;
 #endif
 
-	if (gScanSingleFrequency)
+	if (gScanSingleFrequency) {
-	{
 		gScanCssState  = SCAN_CSS_STATE_SCANNING;
 		gScanFrequency = gRxVfo->pRX->Frequency;
-		gStepSetting   = gRxVfo->STEP_SETTING;
+		stepSetting   = gRxVfo->STEP_SETTING;
 
 		BK4819_PickRXFilterPathBasedOnFrequency(gScanFrequency);
 		BK4819_SetScanFrequency(gScanFrequency);
 
 		gUpdateStatus = true;
 	}
-	else
+	else {
-	{
 		gScanCssState  = SCAN_CSS_STATE_OFF;
 		gScanFrequency = 0xFFFFFFFF;
 
-		BK4819_PickRXFilterPathBasedOnFrequency(0xFFFFFFFF);
+		BK4819_PickRXFilterPathBasedOnFrequency(gScanFrequency);
 		BK4819_EnableFrequencyScan();
 
 		gUpdateStatus = true;
 	}
 
+#ifdef ENABLE_DTMF_CALLING
 	DTMF_clear_RX();
+#endif
 
 	gScanDelay_10ms        = scan_delay_10ms;
 	gScanCssResultCode     = 0xFF;
 	gScanCssResultType     = 0xFF;
-	gScanHitCount          = 0;
+	scanHitCount          = 0;
 	gScanUseCssResult      = false;
 	g_CxCSS_TAIL_Found     = false;
 	g_CDCSS_Lost           = false;
@@ -418,242 +364,165 @@ void SCANNER_Start(void)
 	g_VOX_Lost         = false;
 #endif
 	g_SquelchLost          = false;
-	gScannerEditState      = 0;
+	gScannerSaveState      = SCAN_SAVE_NO_PROMPT;
 	gScanProgressIndicator = 0;
 }
 
-void SCANNER_Found()
-{
-	switch (gEeprom.SCAN_RESUME_MODE)
-	{
-		case SCAN_RESUME_TO:
-			if (!gScanPauseMode)
-			{
-				gScanPauseDelayIn_10ms = scan_pause_delay_in_1_10ms;
-				gScheduleScanListen    = false;
-				gScanPauseMode         = true;
-			}
-			break;
-
-		case SCAN_RESUME_CO:
-		case SCAN_RESUME_SE:
-			gScanPauseDelayIn_10ms = 0;
-			gScheduleScanListen    = false;
-			break;
-	}
-
-	if (IS_MR_CHANNEL(gRxVfo->CHANNEL_SAVE)) { //memory scan
-		lastFoundFrqOrChan = gRxVfo->CHANNEL_SAVE;
-	}
-	else { // frequency scan
-		lastFoundFrqOrChan = gRxVfo->freq_config_RX.Frequency;
-	}
-
-
-	gScanKeepResult = true;
-}
-
 void SCANNER_Stop(void)
 {
-	if(initialCROSS_BAND_RX_TX != CROSS_BAND_OFF) {
+	if(SCANNER_IsScanning()) {
-		gEeprom.CROSS_BAND_RX_TX = initialCROSS_BAND_RX_TX;
+		gEeprom.CROSS_BAND_RX_TX = gBackup_CROSS_BAND_RX_TX;
-		initialCROSS_BAND_RX_TX = CROSS_BAND_OFF;
+		gVfoConfigureMode        = VFO_CONFIGURE_RELOAD;
+		gFlagResetVfos           = true;
+		gUpdateStatus            = true;
+		gCssBackgroundScan 			 = false;
+		gScanUseCssResult = false;
+#ifdef ENABLE_VOICE
+		gAnotherVoiceID          = VOICE_ID_CANCEL;
+#endif
+		BK4819_StopScan();
+	}
+}
+
+void SCANNER_TimeSlice10ms(void)
+{
+	if (!SCANNER_IsScanning())
+		return;
+
+	if (gScanDelay_10ms > 0) {
+		gScanDelay_10ms--;
+		return;
 	}
 
-	gScanStateDir = SCAN_OFF;
+	if (gScannerSaveState != SCAN_SAVE_NO_PROMPT) {
+		return;
+	}
 
-	const uint32_t chFr = gScanKeepResult ? lastFoundFrqOrChan : initialFrqOrChan;
+	switch (gScanCssState) {
-	const bool channelChanged = chFr != initialFrqOrChan;
+		case SCAN_CSS_STATE_OFF: {
-	if (IS_MR_CHANNEL(gNextMrChannel)) {
+			// must be RF frequency scanning if we're here ?
-		gEeprom.MrChannel[gEeprom.RX_VFO]     = chFr;
+			uint32_t result;
-		gEeprom.ScreenChannel[gEeprom.RX_VFO] = chFr;
+			if (!BK4819_GetFrequencyScanResult(&result))
-		RADIO_ConfigureChannel(gEeprom.RX_VFO, VFO_CONFIGURE_RELOAD);
+				break;
+
+			int32_t delta = result - gScanFrequency;
+			gScanFrequency = result;
+
+			if (delta < 0)
+				delta = -delta;
+			if (delta < 100)
+				scanHitCount++;
+			else
+				scanHitCount = 0;
+
+			BK4819_DisableFrequencyScan();
+
+			if (scanHitCount < 3) {
+				BK4819_EnableFrequencyScan();
+			}
+			else {
+				BK4819_SetScanFrequency(gScanFrequency);
+				gScanCssResultCode     = 0xFF;
+				gScanCssResultType     = 0xFF;
+				scanHitCount          = 0;
+				gScanUseCssResult      = false;
+				gScanProgressIndicator = 0;
+				gScanCssState          = SCAN_CSS_STATE_SCANNING;
+
+				if(!gCssBackgroundScan)
+					GUI_SelectNextDisplay(DISPLAY_SCANNER);
+
+				gUpdateStatus          = true;
+			}
+
+			gScanDelay_10ms = scan_delay_10ms;
+			//gScanDelay_10ms = 1;   // 10ms
+			break;
+		}
+		case SCAN_CSS_STATE_SCANNING: {
+			uint32_t cdcssFreq;
+			uint16_t ctcssFreq;
+			BK4819_CssScanResult_t scanResult = BK4819_GetCxCSSScanResult(&cdcssFreq, &ctcssFreq);
+			if (scanResult == BK4819_CSS_RESULT_NOT_FOUND)
+				break;
+
+			BK4819_Disable();
+
+			if (scanResult == BK4819_CSS_RESULT_CDCSS) {
+				const uint8_t Code = DCS_GetCdcssCode(cdcssFreq);
+				if (Code != 0xFF)
+				{
+					gScanCssResultCode = Code;
+					gScanCssResultType = CODE_TYPE_DIGITAL;
+					gScanCssState      = SCAN_CSS_STATE_FOUND;
+					gScanUseCssResult  = true;
+					gUpdateStatus      = true;
+				}
+			}
+			else if (scanResult == BK4819_CSS_RESULT_CTCSS) {
+				const uint8_t Code = DCS_GetCtcssCode(ctcssFreq);
+				if (Code != 0xFF) {
+					if (Code == gScanCssResultCode && gScanCssResultType == CODE_TYPE_CONTINUOUS_TONE) {
+						if (++scanHitCount >= 2) {
+							gScanCssState     = SCAN_CSS_STATE_FOUND;
+							gScanUseCssResult = true;
+							gUpdateStatus     = true;
+						}
+					}
+					else
+						scanHitCount = 0;
+
+					gScanCssResultType = CODE_TYPE_CONTINUOUS_TONE;
+					gScanCssResultCode = Code;
+				}
+			}
+
+			if (gScanCssState < SCAN_CSS_STATE_FOUND) { // scanning or off
+				BK4819_SetScanFrequency(gScanFrequency);
+				gScanDelay_10ms = scan_delay_10ms;
+				break;
+			}
+
+			if(gCssBackgroundScan) {
+				gCssBackgroundScan = false;
+				if(gScanUseCssResult)
+					MENU_CssScanFound();
+			}
+			else
+				GUI_SelectNextDisplay(DISPLAY_SCANNER);
+
+
+			break;
+		}
+		default:
+			gCssBackgroundScan = false;
+			break;
+	}
+
+}
+
+void SCANNER_TimeSlice500ms(void)
+{
+	if (SCANNER_IsScanning() && gScannerSaveState == SCAN_SAVE_NO_PROMPT && gScanCssState < SCAN_CSS_STATE_FOUND) {
+		gScanProgressIndicator++;
+#ifdef ENABLE_NO_CODE_SCAN_TIMEOUT
+		if (gScanProgressIndicator > 32) {
+			if (gScanCssState == SCAN_CSS_STATE_SCANNING && !gScanSingleFrequency)
+				gScanCssState = SCAN_CSS_STATE_FOUND;
+			else
+				gScanCssState = SCAN_CSS_STATE_FAILED;
 
-		if(channelChanged) {
-			SETTINGS_SaveVfoIndices();
 			gUpdateStatus = true;
 		}
-	}
-	else {
-		gRxVfo->freq_config_RX.Frequency = chFr;
-		RADIO_ApplyOffset(gRxVfo);
-		RADIO_ConfigureSquelchAndOutputPower(gRxVfo);
-		if(channelChanged) {
-			SETTINGS_SaveChannel(gRxVfo->CHANNEL_SAVE, gEeprom.RX_VFO, gRxVfo, 1);
-		}
-	}
-
-	RADIO_SetupRegisters(true);
-	gUpdateDisplay = true;
-}
-
-static void NextFreqChannel(void)
-{
-	gRxVfo->freq_config_RX.Frequency = APP_SetFrequencyByStep(gRxVfo, gScanStateDir);
-
-	RADIO_ApplyOffset(gRxVfo);
-	RADIO_ConfigureSquelchAndOutputPower(gRxVfo);
-	RADIO_SetupRegisters(true);
-
-#ifdef ENABLE_FASTER_CHANNEL_SCAN
-	gScanPauseDelayIn_10ms = 9;   // 90ms
-#else
-	gScanPauseDelayIn_10ms = scan_pause_delay_in_6_10ms;
 #endif
-
-	gUpdateDisplay     = true;
-}
-
-static void NextMemChannel(void)
-{
-	static unsigned int prev_mr_chan = 0;
-	const bool          enabled      = (gEeprom.SCAN_LIST_DEFAULT < 2) ? gEeprom.SCAN_LIST_ENABLED[gEeprom.SCAN_LIST_DEFAULT] : true;
-	const int           chan1        = (gEeprom.SCAN_LIST_DEFAULT < 2) ? gEeprom.SCANLIST_PRIORITY_CH1[gEeprom.SCAN_LIST_DEFAULT] : -1;
-	const int           chan2        = (gEeprom.SCAN_LIST_DEFAULT < 2) ? gEeprom.SCANLIST_PRIORITY_CH2[gEeprom.SCAN_LIST_DEFAULT] : -1;
-	const unsigned int  prev_chan    = gNextMrChannel;
-	unsigned int        chan         = 0;
-
-	if (enabled)
-	{
-		switch (currentScanList)
-		{
-			case SCAN_NEXT_CHAN_SCANLIST1:
-				prev_mr_chan = gNextMrChannel;
-	
-				if (chan1 >= 0)
-				{
-					if (RADIO_CheckValidChannel(chan1, false, 0))
-					{
-						currentScanList = SCAN_NEXT_CHAN_SCANLIST1;
-						gNextMrChannel   = chan1;
-						break;
-					}
-				}
-				[[fallthrough]];
-			case SCAN_NEXT_CHAN_SCANLIST2:
-				if (chan2 >= 0)
-				{
-					if (RADIO_CheckValidChannel(chan2, false, 0))
-					{
-						currentScanList = SCAN_NEXT_CHAN_SCANLIST2;
-						gNextMrChannel   = chan2;
-						break;
-					}
-				}
-				[[fallthrough]];
-				
-			// this bit doesn't yet work if the other VFO is a frequency
-			case SCAN_NEXT_CHAN_DUAL_WATCH:
-				// dual watch is enabled - include the other VFO in the scan
-//				if (gEeprom.DUAL_WATCH != DUAL_WATCH_OFF)
-//				{
-//					chan = (gEeprom.RX_VFO + 1) & 1u;
-//					chan = gEeprom.ScreenChannel[chan];
-//					if (IS_MR_CHANNEL(chan))
-//					{
-//						currentScanList = SCAN_NEXT_CHAN_DUAL_WATCH;
-//						gNextMrChannel   = chan;
-//						break;
-//					}
-//				}
-
-			default:
-			case SCAN_NEXT_CHAN_MR:
-				currentScanList = SCAN_NEXT_CHAN_MR;
-				gNextMrChannel   = prev_mr_chan;
-				chan             = 0xff;
-				break;
-		}
-	}
-
-	if (!enabled || chan == 0xff)
-	{
-		chan = RADIO_FindNextChannel(gNextMrChannel + gScanStateDir, gScanStateDir, (gEeprom.SCAN_LIST_DEFAULT < 2) ? true : false, gEeprom.SCAN_LIST_DEFAULT);
-		if (chan == 0xFF)
-		{	// no valid channel found
-			chan = MR_CHANNEL_FIRST;
-		}
-		
-		gNextMrChannel = chan;
-	}
-
-	if (gNextMrChannel != prev_chan)
-	{
-		gEeprom.MrChannel[    gEeprom.RX_VFO] = gNextMrChannel;
-		gEeprom.ScreenChannel[gEeprom.RX_VFO] = gNextMrChannel;
-
-		RADIO_ConfigureChannel(gEeprom.RX_VFO, VFO_CONFIGURE_RELOAD);
-		RADIO_SetupRegisters(true);
-
 		gUpdateDisplay = true;
 	}
-
+	else if(gCssBackgroundScan) {
-#ifdef ENABLE_FASTER_CHANNEL_SCAN
+		gUpdateDisplay = true;
-	gScanPauseDelayIn_10ms = 9;  // 90ms .. <= ~60ms it misses signals (squelch response and/or PLL lock time) ?
+	}
-#else
-	gScanPauseDelayIn_10ms = scan_pause_delay_in_3_10ms;
-#endif
-
-	if (enabled)
-		if (++currentScanList >= SCAN_NEXT_NUM)
-			currentScanList = SCAN_NEXT_CHAN_SCANLIST1;  // back round we go
 }
 
-void SCANNER_ScanChannels(const bool storeBackupSettings, const int8_t scan_direction)
+bool SCANNER_IsScanning(void)
 {
-	if (storeBackupSettings) {
+	return gCssBackgroundScan || (gScreenToDisplay == DISPLAY_SCANNER);
-		initialCROSS_BAND_RX_TX = gEeprom.CROSS_BAND_RX_TX;
-		gEeprom.CROSS_BAND_RX_TX = CROSS_BAND_OFF;
-		gScanKeepResult = false;
-	}
-	
-	RADIO_SelectVfos();
-
-	gNextMrChannel   = gRxVfo->CHANNEL_SAVE;
-	currentScanList = SCAN_NEXT_CHAN_SCANLIST1;
-	gScanStateDir    = scan_direction;
-
-	if (IS_MR_CHANNEL(gNextMrChannel))
-	{	// channel mode
-		if (storeBackupSettings) {
-			initialFrqOrChan = gRxVfo->CHANNEL_SAVE;
-			lastFoundFrqOrChan = initialFrqOrChan;
-		}
-		NextMemChannel();
-	}
-	else
-	{	// frequency mode
-		if (storeBackupSettings) {
-			initialFrqOrChan = gRxVfo->freq_config_RX.Frequency;
-			lastFoundFrqOrChan = initialFrqOrChan;
-		}
-		NextFreqChannel();
-	}
-
-	gScanPauseDelayIn_10ms = scan_pause_delay_in_2_10ms;
-	gScheduleScanListen    = false;
-	gRxReceptionMode       = RX_MODE_NONE;
-	gScanPauseMode         = false;
-}
-
-void SCANNER_ContinueScanning()
-{
-	if (IS_FREQ_CHANNEL(gNextMrChannel))
-	{
-		if (gCurrentFunction == FUNCTION_INCOMING)
-			APP_StartListening(gMonitor ? FUNCTION_MONITOR : FUNCTION_RECEIVE, true);
-		else
-			NextFreqChannel();  // switch to next frequency
-	}
-	else
-	{
-		if (gCurrentCodeType == CODE_TYPE_OFF && gCurrentFunction == FUNCTION_INCOMING)
-			APP_StartListening(gMonitor ? FUNCTION_MONITOR : FUNCTION_RECEIVE, true);
-		else
-			NextMemChannel();    // switch to next channel
-	}
-	
-	gScanPauseMode      = false;
-	gRxReceptionMode    = RX_MODE_NONE;
-	gScheduleScanListen = false;
 }

app/scanner.h

@@ -20,50 +20,38 @@
 #include "dcs.h"
 #include "driver/keyboard.h"
 
-enum SCAN_CssState_t
+typedef enum 
 {
-	SCAN_CSS_STATE_OFF = 0,
+	SCAN_CSS_STATE_OFF,
 	SCAN_CSS_STATE_SCANNING,
 	SCAN_CSS_STATE_FOUND,
 	SCAN_CSS_STATE_FAILED
-};
+} SCAN_CssState_t;
 
-typedef enum SCAN_CssState_t SCAN_CssState_t;
+typedef enum 
-
-enum
 {
-	SCAN_REV = -1,
+	SCAN_SAVE_NO_PROMPT, // saving process not initiated
-	SCAN_OFF =  0,
+	SCAN_SAVE_CHAN_SEL,  // "SAVE: ", channel select prompt, actives only in channel mode
-	SCAN_FWD = +1
+	SCAN_SAVE_CHANNEL,   // "SAVE?" prompt, waits for confirmation to save settings to channel, or current VFO 
-};
+} SCAN_SaveState_t;
+
 
 extern DCS_CodeType_t    gScanCssResultType;
 extern uint8_t           gScanCssResultCode;
-extern bool              gFlagStartScan;
-extern bool              gFlagStopScan;
 extern bool              gScanSingleFrequency;
-extern uint8_t           gScannerEditState;
+extern SCAN_SaveState_t  gScannerSaveState;
 extern uint8_t           gScanChannel;
 extern uint32_t          gScanFrequency;
-extern bool              gScanPauseMode;
 extern SCAN_CssState_t   gScanCssState;
-extern volatile bool     gScheduleScanListen;
-extern volatile uint16_t gScanPauseDelayIn_10ms;
 extern uint8_t           gScanProgressIndicator;
-extern uint8_t           gScanHitCount;
 extern bool              gScanUseCssResult;
 
-// scan direction, if not equal SCAN_OFF indicates 
-// that we are in a process of scanning channels/frequencies
-extern int8_t            gScanStateDir;
-extern bool              gScanKeepResult;
-
 void SCANNER_ProcessKeys(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld);
-void SCANNER_Start(void);
+void SCANNER_Start(bool singleFreq);
-void SCANNER_Found();
 void SCANNER_Stop(void);
-void SCANNER_ScanChannels(const bool storeBackupSettings, const int8_t scan_direction);
+void SCANNER_TimeSlice10ms(void);
-void SCANNER_ContinueScanning();
+void SCANNER_TimeSlice500ms(void);
+bool SCANNER_IsScanning(void);
 
 #endif
 

app/spectrum.c

@@ -17,6 +17,7 @@
 #include "app/spectrum.h"
 #include "driver/backlight.h"
 #include "audio.h"
+#include "ui/helper.h"
 
 struct FrequencyBandInfo {
     uint32_t lower;
@@ -125,21 +126,13 @@ static void SetRegMenuValue(uint8_t st, bool add) {
 // GUI functions
 
 static void PutPixel(uint8_t x, uint8_t y, bool fill) {
-  if (fill) {
+  UI_DrawPixelBuffer(gFrameBuffer, x, y, fill);
-    gFrameBuffer[y >> 3][x] |= 1 << (y & 7);
-  } else {
-    gFrameBuffer[y >> 3][x] &= ~(1 << (y & 7));
-  }
 }
 static void PutPixelStatus(uint8_t x, uint8_t y, bool fill) {
-  if (fill) {
+  UI_DrawPixelBuffer(&gStatusLine, x, y, fill);
-    gStatusLine[x] |= 1 << y;
-  } else {
-    gStatusLine[x] &= ~(1 << y);
-  }
 }
 
-static void DrawHLine(int sy, int ey, int nx, bool fill) {
+static void DrawVLine(int sy, int ey, int nx, bool fill) {
   for (int i = sy; i <= ey; i++) {
     if (i < 56 && nx < 128) {
       PutPixel(nx, i, fill);
@@ -541,6 +534,8 @@ static void UpdateFreqInput(KEY_Code_t key) {
   }
   if (key == KEY_EXIT) {
     freqInputIndex--;
+    if(freqInputDotIndex==freqInputIndex)
+      freqInputDotIndex = 0;    
   } else {
     freqInputArr[freqInputIndex++] = key;
   }
@@ -606,7 +601,7 @@ static void DrawSpectrum() {
   for (uint8_t x = 0; x < 128; ++x) {
     uint16_t rssi = rssiHistory[x >> settings.stepsCount];
     if (rssi != RSSI_MAX_VALUE) {
-      DrawHLine(Rssi2Y(rssi), DrawingEndY, x, true);
+      DrawVLine(Rssi2Y(rssi), DrawingEndY, x, true);
     }
   }
 }
@@ -620,36 +615,28 @@ static void DrawStatus() {
 #endif
   GUI_DisplaySmallest(String, 0, 1, true, true);
 
-  for (int i = 0; i < 4; i++) {
+  BOARD_ADC_GetBatteryInfo(&gBatteryVoltages[gBatteryCheckCounter++ % 4], &gBatteryCurrent);
-    BOARD_ADC_GetBatteryInfo(&gBatteryVoltages[i], &gBatteryCurrent);
-  }
 
-  uint16_t Voltage;
+  uint16_t voltage = (gBatteryVoltages[0] + gBatteryVoltages[1] + gBatteryVoltages[2] +
-  uint8_t v = 0;
-
-  Voltage = (gBatteryVoltages[0] + gBatteryVoltages[1] + gBatteryVoltages[2] +
              gBatteryVoltages[3]) /
-            4;
+            4 * 760 / gBatteryCalibration[3];
 
-for(uint8_t i = 5; i > 0; i--) {
+  unsigned perc = BATTERY_VoltsToPercent(voltage);
-  if(Voltage > gBatteryCalibration[i - 1]) {
-    v = i;
-    break;
-  }
-}
 
-  gStatusLine[127] = 0b01111110;
+  // sprintf(String, "%d %d", voltage, perc);
-  for (int i = 126; i >= 116; i--) {
+  // GUI_DisplaySmallest(String, 48, 1, true, true);
-    gStatusLine[i] = 0b01000010;
+
+  gStatusLine[116] = 0b00011100;
+  gStatusLine[117] = 0b00111110;
+  for (int i = 118; i <= 126; i++) {
+    gStatusLine[i] = 0b00100010;
   }
-  v <<= 1;
+  
-  for (int i = 125; i >= 116; i--) {
+  for (unsigned i = 127; i >= 118; i--) {
-    if (126 - i <= v) {
+    if (127 - i <= (perc+5)*9/100) {
-      gStatusLine[i + 2] = 0b01111110;
+      gStatusLine[i] = 0b00111110;
     }
   }
-  gStatusLine[117] = 0b01111110;
-  gStatusLine[116] = 0b00011000;
 }
 
 static void DrawF(uint32_t f) {
@@ -712,19 +699,13 @@ static void DrawTicks() {
 
   // center
   if (IsCenterMode()) {
-    gFrameBuffer[5][62] = 0x80;
+    memset(gFrameBuffer[5] + 62, 0x80, 5);
-    gFrameBuffer[5][63] = 0x80;
     gFrameBuffer[5][64] = 0xff;
-    gFrameBuffer[5][65] = 0x80;
-    gFrameBuffer[5][66] = 0x80;
   } else {
+    memset(gFrameBuffer[5] + 1, 0x80, 3);
+    memset(gFrameBuffer[5] + 124, 0x80, 3);
+
     gFrameBuffer[5][0] = 0xff;
-    gFrameBuffer[5][1] = 0x80;
-    gFrameBuffer[5][2] = 0x80;
-    gFrameBuffer[5][3] = 0x80;
-    gFrameBuffer[5][124] = 0x80;
-    gFrameBuffer[5][125] = 0x80;
-    gFrameBuffer[5][126] = 0x80;
     gFrameBuffer[5][127] = 0xff;
   }
 }
@@ -1017,17 +998,18 @@ bool HandleUserInput() {
   kbd.prev = kbd.current;
   kbd.current = GetKey();
 
-  if (kbd.current == KEY_INVALID) {
+  if (kbd.current != KEY_INVALID && kbd.current == kbd.prev) {
-    kbd.counter = 0;
+    if(kbd.counter < 16)
-    return true;
+      kbd.counter++;
-  }
+    else
-
+      kbd.counter-=3;
-  if (kbd.current == kbd.prev && kbd.counter <= 16) {
-    kbd.counter++;
     SYSTEM_DelayMs(20);
   }
+  else {
+    kbd.counter = 0;
+  }
 
-  if (kbd.counter == 3 || kbd.counter > 16) {
+  if (kbd.counter == 3 || kbd.counter == 16) {
     switch (currentState) {
     case SPECTRUM:
       OnKeyDown(kbd.current);

app/uart.c

@@ -400,7 +400,9 @@ static void CMD_052F(const uint8_t *pBuffer)
 	gEeprom.VfoInfo[0].pTX                           = &gEeprom.VfoInfo[0].freq_config_TX;
 	gEeprom.VfoInfo[0].TX_OFFSET_FREQUENCY_DIRECTION = TX_OFFSET_FREQUENCY_DIRECTION_OFF;
 	gEeprom.VfoInfo[0].DTMF_PTT_ID_TX_MODE           = PTT_ID_OFF;
+#ifdef ENABLE_DTMF_CALLING
 	gEeprom.VfoInfo[0].DTMF_DECODING_ENABLE          = false;
+#endif
 
 	#ifdef ENABLE_NOAA
 		gIsNoaaMode = false;

board.c

@@ -537,6 +537,9 @@ void BOARD_EEPROM_Init(void)
 	EEPROM_ReadBuffer(0x0E78, Data, 8);
 	gEeprom.BACKLIGHT_MAX 		  = (Data[0] & 0xF) <= 10 ? (Data[0] & 0xF) : 10;
 	gEeprom.BACKLIGHT_MIN 		  = (Data[0] >> 4) < gEeprom.BACKLIGHT_MAX ? (Data[0] >> 4) : 0;
+#ifdef ENABLE_BLMIN_TMP_OFF
+	gEeprom.BACKLIGHT_MIN_STAT	  = BLMIN_STAT_ON;
+#endif
 	gEeprom.CHANNEL_DISPLAY_MODE  = (Data[1] < 4) ? Data[1] : MDF_FREQUENCY;    // 4 instead of 3 - extra display mode
 	gEeprom.CROSS_BAND_RX_TX      = (Data[2] < 3) ? Data[2] : CROSS_BAND_OFF;
 	gEeprom.BATTERY_SAVE          = (Data[3] < 5) ? Data[3] : 4;
@@ -620,10 +623,13 @@ void BOARD_EEPROM_Init(void)
 	// 0ED0..0ED7
 	EEPROM_ReadBuffer(0x0ED0, Data, 8);
 	gEeprom.DTMF_SIDE_TONE               = (Data[0] <   2) ? Data[0] : true;
+
+#ifdef ENABLE_DTMF_CALLING
 	gEeprom.DTMF_SEPARATE_CODE           = DTMF_ValidateCodes((char *)(Data + 1), 1) ? Data[1] : '*';
 	gEeprom.DTMF_GROUP_CALL_CODE         = DTMF_ValidateCodes((char *)(Data + 2), 1) ? Data[2] : '#';
 	gEeprom.DTMF_DECODE_RESPONSE         = (Data[3] <   4) ? Data[3] : 0;
 	gEeprom.DTMF_auto_reset_time         = (Data[4] <  61) ? Data[4] : (Data[4] >= 5) ? Data[4] : 10;
+#endif		
 	gEeprom.DTMF_PRELOAD_TIME            = (Data[5] < 101) ? Data[5] * 10 : 300;
 	gEeprom.DTMF_FIRST_CODE_PERSIST_TIME = (Data[6] < 101) ? Data[6] * 10 : 100;
 	gEeprom.DTMF_HASH_CODE_PERSIST_TIME  = (Data[7] < 101) ? Data[7] * 10 : 100;
@@ -632,9 +638,11 @@ void BOARD_EEPROM_Init(void)
 	EEPROM_ReadBuffer(0x0ED8, Data, 8);
 	gEeprom.DTMF_CODE_PERSIST_TIME  = (Data[0] < 101) ? Data[0] * 10 : 100;
 	gEeprom.DTMF_CODE_INTERVAL_TIME = (Data[1] < 101) ? Data[1] * 10 : 100;
+#ifdef ENABLE_DTMF_CALLING
 	gEeprom.PERMIT_REMOTE_KILL      = (Data[2] <   2) ? Data[2] : true;
 
 	// 0EE0..0EE7
+
 	EEPROM_ReadBuffer(0x0EE0, Data, 8);
 	if (DTMF_ValidateCodes((char *)Data, 8))
 		memmove(gEeprom.ANI_DTMF_ID, Data, 8);
@@ -644,6 +652,7 @@ void BOARD_EEPROM_Init(void)
 		strcpy(gEeprom.ANI_DTMF_ID, "123");
 	}
 
+
 	// 0EE8..0EEF
 	EEPROM_ReadBuffer(0x0EE8, Data, 8);
 	if (DTMF_ValidateCodes((char *)Data, 8))
@@ -663,6 +672,7 @@ void BOARD_EEPROM_Init(void)
 		memset(gEeprom.REVIVE_CODE, 0, sizeof(gEeprom.REVIVE_CODE));
 		strcpy(gEeprom.REVIVE_CODE, "9DCBA");
 	}
+#endif
 
 	// 0EF8..0F07
 	EEPROM_ReadBuffer(0x0EF8, Data, 16);
@@ -698,14 +708,16 @@ void BOARD_EEPROM_Init(void)
 
 	// 0F40..0F47
 	EEPROM_ReadBuffer(0x0F40, Data, 8);
-	gSetting_F_LOCK            = (Data[0] < 6) ? Data[0] : F_LOCK_OFF;
+	gSetting_F_LOCK            = (Data[0] < F_LOCK_LEN) ? Data[0] : F_LOCK_DEF;
 	gSetting_350TX             = (Data[1] < 2) ? Data[1] : false;  // was true
+#ifdef ENABLE_DTMF_CALLING
 	gSetting_KILLED            = (Data[2] < 2) ? Data[2] : false;
+#endif
 	gSetting_200TX             = (Data[3] < 2) ? Data[3] : false;
 	gSetting_500TX             = (Data[4] < 2) ? Data[4] : false;
 	gSetting_350EN             = (Data[5] < 2) ? Data[5] : true;
 	gSetting_ScrambleEnable    = (Data[6] < 2) ? Data[6] : true;
-	gSetting_TX_EN             = (Data[7] & (1u << 0)) ? true : false;
+	//gSetting_TX_EN             = (Data[7] & (1u << 0)) ? true : false;
 	gSetting_live_DTMF_decoder = (Data[7] & (1u << 1)) ? true : false;
 	gSetting_battery_text      = (((Data[7] >> 2) & 3u) <= 2) ? (Data[7] >> 2) & 3 : 2;
 	#ifdef ENABLE_AUDIO_BAR
@@ -724,6 +736,13 @@ void BOARD_EEPROM_Init(void)
 
 	// 0D60..0E27
 	EEPROM_ReadBuffer(0x0D60, gMR_ChannelAttributes, sizeof(gMR_ChannelAttributes));
+	for(uint16_t i = 0; i < sizeof(gMR_ChannelAttributes); i++) {
+		ChannelAttributes_t *att = &gMR_ChannelAttributes[i];
+		if(att->__val == 0xff){
+			att->__val = 0;
+			att->band = 0xf;
+		}	
+	}
 
 	// 0F30..0F3F
 	EEPROM_ReadBuffer(0x0F30, gCustomAesKey, sizeof(gCustomAesKey));

compile-with-docker.bat

@@ -1,4 +1,4 @@
 @echo off
 docker build -t uvk5 .
-docker run -v %CD%\compiled-firmware:/app/compiled-firmware uvk5 /bin/bash -c "cd /app && make clean && make && cp firmware* compiled-firmware/"
+docker run --rm -v %CD%\compiled-firmware:/app/compiled-firmware uvk5 /bin/bash -c "cd /app && make clean && make && cp firmware* compiled-firmware/"
 pause

compile-with-docker.sh

@@ -1,3 +1,3 @@
 #!/bin/sh
 docker build -t uvk5 .
-docker run -v ${PWD}/compiled-firmware:/app/compiled-firmware uvk5 /bin/bash -c "cd /app && make && cp firmware* compiled-firmware/"
+docker run --rm -v ${PWD}/compiled-firmware:/app/compiled-firmware uvk5 /bin/bash -c "cd /app && make && cp firmware* compiled-firmware/"

driver/backlight.c

@@ -94,7 +94,18 @@ void BACKLIGHT_TurnOn(void)
 
 void BACKLIGHT_TurnOff()
 {
+#ifdef ENABLE_BLMIN_TMP_OFF
+	register uint8_t tmp;
+
+	if (gEeprom.BACKLIGHT_MIN_STAT == BLMIN_STAT_ON)
+		tmp = gEeprom.BACKLIGHT_MIN;
+	else
+		tmp = 0;
+
+	BACKLIGHT_SetBrightness(tmp);
+#else
 	BACKLIGHT_SetBrightness(gEeprom.BACKLIGHT_MIN);
+#endif
 	gBacklightCountdown = 0;
 	backlightOn = false;
 }

driver/backlight.h

@@ -23,6 +23,14 @@
 extern uint16_t gBacklightCountdown;
 extern uint8_t gBacklightBrightness;
 
+#ifdef ENABLE_BLMIN_TMP_OFF
+typedef enum {
+    BLMIN_STAT_ON,
+    BLMIN_STAT_OFF,
+    BLMIN_STAT_UNKNOWN
+} BLMIN_STAT_t;
+#endif
+
 void BACKLIGHT_InitHardware();
 void BACKLIGHT_TurnOn();
 void BACKLIGHT_TurnOff();

driver/bk4819.c

@@ -30,6 +30,9 @@
 
 static const uint16_t FSK_RogerTable[7] = {0xF1A2, 0x7446, 0x61A4, 0x6544, 0x4E8A, 0xE044, 0xEA84};
 
+static const uint8_t DTMF_TONE1_GAIN = 65;
+static const uint8_t DTMF_TONE2_GAIN = 93;
+
 static uint16_t gBK4819_GpioOutState;
 
 bool gRxIdleMode;
@@ -984,15 +987,15 @@ void BK4819_EnableDTMF(void)
 
 void BK4819_PlayTone(uint16_t Frequency, bool bTuningGainSwitch)
 {
-	uint16_t ToneConfig;
+	uint16_t ToneConfig = BK4819_REG_70_ENABLE_TONE1;
 
 	BK4819_EnterTxMute();
 	BK4819_SetAF(BK4819_AF_BEEP);
 
 	if (bTuningGainSwitch == 0)
-		ToneConfig = BK4819_REG_70_ENABLE_TONE1 | (96u << BK4819_REG_70_SHIFT_TONE1_TUNING_GAIN);
+		ToneConfig |=  96u << BK4819_REG_70_SHIFT_TONE1_TUNING_GAIN;
 	else
-		ToneConfig = BK4819_REG_70_ENABLE_TONE1 | (28u << BK4819_REG_70_SHIFT_TONE1_TUNING_GAIN);
+		ToneConfig |= 28u << BK4819_REG_70_SHIFT_TONE1_TUNING_GAIN;
 	BK4819_WriteRegister(BK4819_REG_70, ToneConfig);
 
 	BK4819_WriteRegister(BK4819_REG_30, 0);
@@ -1001,6 +1004,7 @@ void BK4819_PlayTone(uint16_t Frequency, bool bTuningGainSwitch)
 	BK4819_WriteRegister(BK4819_REG_71, scale_freq(Frequency));
 }
 
+// level 0 ~ 127
 void BK4819_PlaySingleTone(const unsigned int tone_Hz, const unsigned int delay, const unsigned int level, const bool play_speaker)
 {
 	BK4819_EnterTxMute();
@@ -1013,9 +1017,7 @@ void BK4819_PlaySingleTone(const unsigned int tone_Hz, const unsigned int delay,
 	else
 		BK4819_SetAF(BK4819_AF_MUTE);
 
-	// level 0 ~ 127
+	
-//	BK4819_WriteRegister(BK4819_REG_70, BK4819_REG_70_ENABLE_TONE1 | (96u << BK4819_REG_70_SHIFT_TONE1_TUNING_GAIN));
-//	BK4819_WriteRegister(BK4819_REG_70, BK4819_REG_70_ENABLE_TONE1 | (28u << BK4819_REG_70_SHIFT_TONE1_TUNING_GAIN));
 	BK4819_WriteRegister(BK4819_REG_70, BK4819_REG_70_ENABLE_TONE1 | ((level & 0x7f) << BK4819_REG_70_SHIFT_TONE1_TUNING_GAIN));
 
 	BK4819_EnableTXLink();
@@ -1035,6 +1037,7 @@ void BK4819_PlaySingleTone(const unsigned int tone_Hz, const unsigned int delay,
 	
 	BK4819_WriteRegister(BK4819_REG_70, 0x0000);
 	BK4819_WriteRegister(BK4819_REG_30, 0xC1FE);
+	BK4819_ExitTxMute();
 }
 
 void BK4819_EnterTxMute(void)
@@ -1208,9 +1211,9 @@ void BK4819_EnterDTMF_TX(bool bLocalLoopback)
 
 	BK4819_WriteRegister(BK4819_REG_70,
 		BK4819_REG_70_MASK_ENABLE_TONE1                |
-		(83u << BK4819_REG_70_SHIFT_TONE1_TUNING_GAIN) |
+		(DTMF_TONE1_GAIN << BK4819_REG_70_SHIFT_TONE1_TUNING_GAIN) |
 		BK4819_REG_70_MASK_ENABLE_TONE2                |
-		(83u << BK4819_REG_70_SHIFT_TONE2_TUNING_GAIN));
+		(DTMF_TONE2_GAIN << BK4819_REG_70_SHIFT_TONE2_TUNING_GAIN));
 
 	BK4819_EnableTXLink();
 }
@@ -1249,16 +1252,16 @@ void BK4819_PlayDTMF(char Code)
 	switch (Code)
 	{
 		case '0': tone1 = 941; tone2 = 1336; break;
-		case '1': tone1 = 679; tone2 = 1209; break;
+		case '1': tone1 = 697; tone2 = 1209; break;
 		case '2': tone1 = 697; tone2 = 1336; break;
-		case '3': tone1 = 679; tone2 = 1477; break;
+		case '3': tone1 = 697; tone2 = 1477; break;
 		case '4': tone1 = 770; tone2 = 1209; break;
 		case '5': tone1 = 770; tone2 = 1336; break;
 		case '6': tone1 = 770; tone2 = 1477; break;
 		case '7': tone1 = 852; tone2 = 1209; break;
 		case '8': tone1 = 852; tone2 = 1336; break;
 		case '9': tone1 = 852; tone2 = 1477; break;
-		case 'A': tone1 = 679; tone2 = 1633; break;
+		case 'A': tone1 = 697; tone2 = 1633; break;
 		case 'B': tone1 = 770; tone2 = 1633; break;
 		case 'C': tone1 = 852; tone2 = 1633; break;
 		case 'D': tone1 = 941; tone2 = 1633; break;
@@ -1319,8 +1322,7 @@ void BK4819_TransmitTone(bool bLocalLoopback, uint32_t Frequency)
 	//
 	// set the tone amplitude
 	//
-//	BK4819_WriteRegister(BK4819_REG_70, BK4819_REG_70_MASK_ENABLE_TONE1 | (96u << BK4819_REG_70_SHIFT_TONE1_TUNING_GAIN));
+	BK4819_WriteRegister(BK4819_REG_70, BK4819_REG_70_MASK_ENABLE_TONE1 | (66u << BK4819_REG_70_SHIFT_TONE1_TUNING_GAIN));
-	BK4819_WriteRegister(BK4819_REG_70, BK4819_REG_70_MASK_ENABLE_TONE1 | (28u << BK4819_REG_70_SHIFT_TONE1_TUNING_GAIN));
 
 	BK4819_WriteRegister(BK4819_REG_71, scale_freq(Frequency));
 
@@ -1699,8 +1701,7 @@ void BK4819_PlayRoger(void)
 	BK4819_EnterTxMute();
 	BK4819_SetAF(BK4819_AF_MUTE);
 
-//	BK4819_WriteRegister(BK4819_REG_70, BK4819_REG_70_ENABLE_TONE1 | (96u << BK4819_REG_70_SHIFT_TONE1_TUNING_GAIN));
+	BK4819_WriteRegister(BK4819_REG_70, BK4819_REG_70_ENABLE_TONE1 | (66u << BK4819_REG_70_SHIFT_TONE1_TUNING_GAIN));
-	BK4819_WriteRegister(BK4819_REG_70, BK4819_REG_70_ENABLE_TONE1 | (28u << BK4819_REG_70_SHIFT_TONE1_TUNING_GAIN));
 
 	BK4819_EnableTXLink();
 	SYSTEM_DelayMs(50);
@@ -1781,7 +1782,12 @@ void BK4819_PlayDTMFEx(bool bLocalLoopback, char Code)
 	BK4819_EnterTxMute();
 
 	BK4819_SetAF(bLocalLoopback ? BK4819_AF_BEEP : BK4819_AF_MUTE);
-	BK4819_WriteRegister(BK4819_REG_70, 0xD3D3);
+
+	BK4819_WriteRegister(BK4819_REG_70,
+		BK4819_REG_70_MASK_ENABLE_TONE1                |
+		(DTMF_TONE1_GAIN << BK4819_REG_70_SHIFT_TONE1_TUNING_GAIN) |
+		BK4819_REG_70_MASK_ENABLE_TONE2                |
+		(DTMF_TONE2_GAIN << BK4819_REG_70_SHIFT_TONE2_TUNING_GAIN));
 
 	BK4819_EnableTXLink();
 

frequencies.c

@@ -116,23 +116,17 @@ uint8_t FREQUENCY_CalculateOutputPower(uint8_t TxpLow, uint8_t TxpMid, uint8_t T
 	return TxpMid;
 }
 
-static int32_t rnd(int32_t freq, uint16_t step)
-{
-if(step == 1)
-	return freq;
-return (freq + (step + 1) / 2) / step * step;
-}
 
 uint32_t FREQUENCY_RoundToStep(uint32_t freq, uint16_t step)
 {
 	if(step == 833) {
         uint32_t base = freq/2500*2500;
-        int f = rnd(freq - base, step);
+        int chno = (freq - base) / 700;    // convert entered aviation 8.33Khz channel number scheme to actual frequency. 
-        int x = f / step;
+        return base + (chno * 833) + (chno == 3);
-        return base + f + (x == 3);
 	}
-
+	if(step == 1)
-	return rnd(freq, step);
+		return freq;
+	return (freq + (step + 1) / 2) / step * step;
 }
 
 int TX_freq_check(const uint32_t Frequency)
@@ -147,7 +141,7 @@ int TX_freq_check(const uint32_t Frequency)
 
 	switch (gSetting_F_LOCK)
 	{
-		case F_LOCK_OFF:
+		case F_LOCK_DEF:
 			if (Frequency >= frequencyBandTable[BAND3_137MHz].lower && Frequency < frequencyBandTable[BAND3_137MHz].upper)
 				return 0;
 			if (Frequency >= frequencyBandTable[BAND4_174MHz].lower && Frequency < frequencyBandTable[BAND4_174MHz].upper)
@@ -197,6 +191,15 @@ int TX_freq_check(const uint32_t Frequency)
 			if (Frequency >= 40000000 && Frequency < 43800000)
 				return 0;
 			break;
+
+		case F_LOCK_ALL:
+			break;
+
+		case F_LOCK_NONE:
+			for (uint8_t i = 0; i < ARRAY_SIZE(frequencyBandTable); i++)
+				if (Frequency >= frequencyBandTable[i].lower && Frequency < frequencyBandTable[i].upper)
+					return 0;
+			break;
 	}
 
 	// dis-allowed TX frequency

functions.c

@@ -44,20 +44,20 @@ FUNCTION_Type_t gCurrentFunction;
 
 void FUNCTION_Init(void)
 {
-	#ifdef ENABLE_NOAA
+#ifdef ENABLE_NOAA
-		if (!IS_NOAA_CHANNEL(gRxVfo->CHANNEL_SAVE))
+	if (!IS_NOAA_CHANNEL(gRxVfo->CHANNEL_SAVE))
-	#endif
+#endif
 	{
-		gCurrentCodeType = gSelectedCodeType;
+		gCurrentCodeType = (gRxVfo->Modulation != MODULATION_FM) ? CODE_TYPE_OFF : gRxVfo->pRX->CodeType;
-		if (gCssScanMode == CSS_SCAN_MODE_OFF)
-			gCurrentCodeType = (gRxVfo->Modulation != MODULATION_FM) ? CODE_TYPE_OFF : gRxVfo->pRX->CodeType;
 	}
-	#ifdef ENABLE_NOAA
+#ifdef ENABLE_NOAA
-		else
+	else
-			gCurrentCodeType = CODE_TYPE_CONTINUOUS_TONE;
+		gCurrentCodeType = CODE_TYPE_CONTINUOUS_TONE;
-	#endif
+#endif
 
+#ifdef ENABLE_DTMF_CALLING
 	DTMF_clear_RX();
+#endif
 
 	g_CxCSS_TAIL_Found = false;
 	g_CDCSS_Lost       = false;
@@ -101,9 +101,10 @@ void FUNCTION_Select(FUNCTION_Type_t Function)
 	switch (Function)
 	{
 		case FUNCTION_FOREGROUND:
+#ifdef ENABLE_DTMF_CALLING
 			if (gDTMF_ReplyState != DTMF_REPLY_NONE)
 				RADIO_PrepareCssTX();
-
+#endif
 			if (PreviousFunction == FUNCTION_TRANSMIT)
 			{
 				ST7565_FixInterfGlitch();
@@ -119,13 +120,14 @@ void FUNCTION_Select(FUNCTION_Type_t Function)
 					gFM_RestoreCountdown_10ms = fm_restore_countdown_10ms;
 			#endif
 			
+#ifdef ENABLE_DTMF_CALLING
 			if (gDTMF_CallState == DTMF_CALL_STATE_CALL_OUT ||
 			    gDTMF_CallState == DTMF_CALL_STATE_RECEIVED ||
 				gDTMF_CallState == DTMF_CALL_STATE_RECEIVED_STAY)
 			{
 				gDTMF_auto_reset_time_500ms = gEeprom.DTMF_auto_reset_time * 2;
 			}
-
+#endif
 			gUpdateStatus = true;
 			return;
 
@@ -162,8 +164,10 @@ void FUNCTION_Select(FUNCTION_Type_t Function)
 			// if DTMF is enabled when TX'ing, it changes the TX audio filtering !! .. 1of11
 			BK4819_DisableDTMF();
 
+#ifdef ENABLE_DTMF_CALLING
 			// clear the DTMF RX buffer
 			DTMF_clear_RX();
+#endif
 
 			// clear the DTMF RX live decoder buffer
 			gDTMF_RX_live_timeout = 0;

fw-pack.py

@@ -21,11 +21,10 @@ def obfuscate(fw):
     return bytes([a^b for a, b in zip(fw, cycle(OBFUSCATION))])
 
 plain = open(sys.argv[1], 'rb').read()
-if len(sys.argv[2]) > 10:
-    print('Version suffix is too big!')
-    sys.exit(1)
 
-version = b'*OEFW-' + bytes(sys.argv[2], 'ascii')
+version = b'*' + bytes(sys.argv[2], 'ascii') + b' ' + bytes(sys.argv[3], 'ascii')
+version = version[0:16]
+
 if len(version) < 16:
     version += b'\x00' * (16 - len(version))
 
@@ -36,5 +35,5 @@ crc.update(packed)
 digest = crc.digest()
 digest = bytes([digest[1], digest[0]])
 
-open(sys.argv[3], 'wb').write(packed + digest)
+open(sys.argv[4], 'wb').write(packed + digest)
 

helper/battery.c

@@ -120,7 +120,7 @@ void BATTERY_GetReadings(const bool bDisplayBatteryLevel)
 	}
 
 
-	if ((gScreenToDisplay == DISPLAY_MENU) && GetCurrentMenuId() == MENU_VOL)
+	if ((gScreenToDisplay == DISPLAY_MENU) && UI_MENU_GetCurrentMenuId() == MENU_VOL)
 		gUpdateDisplay = true;
 
 	if (gBatteryCurrent < 501)

misc.c

@@ -30,9 +30,11 @@ const uint8_t     menu_timeout_500ms               =  20000 / 500;  // 20 second
 const uint16_t    menu_timeout_long_500ms          = 120000 / 500;  // 2 minutes
 
 const uint8_t     DTMF_RX_live_timeout_500ms       =  6000 / 500;  // 6 seconds live decoder on screen
+#ifdef ENABLE_DTMF_CALLING
 const uint8_t     DTMF_RX_timeout_500ms            = 10000 / 500;  // 10 seconds till we wipe the DTMF receiver
 const uint8_t     DTMF_decode_ring_countdown_500ms = 15000 / 500;  // 15 seconds .. time we sound the ringing for
 const uint8_t     DTMF_txstop_countdown_500ms      =  3000 / 500;  // 6 seconds
+#endif
 
 const uint8_t     key_input_timeout_500ms          =  8000 / 500;  // 8 seconds
 
@@ -78,11 +80,12 @@ const uint32_t    gDefaultAesKey[4]                = {0x4AA5CC60, 0x0312CC5F, 0x
 const uint8_t     gMicGain_dB2[5]                  = {3, 8, 16, 24, 31};
 
 bool              gSetting_350TX;
+#ifdef ENABLE_DTMF_CALLING
 bool              gSetting_KILLED;
+#endif
 bool              gSetting_200TX;
 bool              gSetting_500TX;
 bool              gSetting_350EN;
-bool              gSetting_TX_EN;
 uint8_t           gSetting_F_LOCK;
 bool              gSetting_ScrambleEnable;
 
@@ -112,7 +115,7 @@ uint16_t          gEEPROM_RSSI_CALIB[7][4];
 uint16_t          gEEPROM_1F8A;
 uint16_t          gEEPROM_1F8C;
 
-uint8_t           gMR_ChannelAttributes[FREQ_CHANNEL_LAST + 1];
+ChannelAttributes_t gMR_ChannelAttributes[FREQ_CHANNEL_LAST + 1];
 
 volatile uint16_t gBatterySaveCountdown_10ms = battery_save_count_10ms;
 
@@ -154,7 +157,11 @@ uint8_t           gVFO_RSSI_bar_level[2];
 
 uint8_t           gReducedService;
 uint8_t           gBatteryVoltageIndex;
-CssScanMode_t     gCssScanMode;
+bool     		  gCssBackgroundScan;
+
+volatile bool     gScheduleScanListen = true;
+volatile uint16_t gScanPauseDelayIn_10ms;
+
 bool              gUpdateRSSI;
 #if defined(ENABLE_ALARM) || defined(ENABLE_TX1750)
 	AlarmState_t  gAlarmState;

misc.h

@@ -75,14 +75,6 @@ enum ReceptionMode_t {
 };
 typedef enum ReceptionMode_t ReceptionMode_t;
 
-enum CssScanMode_t
-{
-	CSS_SCAN_MODE_OFF = 0,
-	CSS_SCAN_MODE_SCANNING,
-	CSS_SCAN_MODE_FOUND,
-};
-typedef enum CssScanMode_t   CssScanMode_t;
-
 enum BacklightOnRxTx_t {
 	BACKLIGHT_ON_TR_OFF,
 	BACKLIGHT_ON_TR_TX,
@@ -101,9 +93,11 @@ extern const uint8_t         menu_timeout_500ms;
 extern const uint16_t        menu_timeout_long_500ms;
 
 extern const uint8_t         DTMF_RX_live_timeout_500ms;
+#ifdef ENABLE_DTMF_CALLING
 extern const uint8_t         DTMF_RX_timeout_500ms;
 extern const uint8_t         DTMF_decode_ring_countdown_500ms;
 extern const uint8_t         DTMF_txstop_countdown_500ms;
+#endif
 
 extern const uint8_t         key_input_timeout_500ms;
 
@@ -150,11 +144,12 @@ extern const uint16_t        scan_pause_delay_in_7_10ms;
 extern const uint8_t         gMicGain_dB2[5];
 
 extern bool                  gSetting_350TX;
+#ifdef ENABLE_DTMF_CALLING
 extern bool                  gSetting_KILLED;
+#endif
 extern bool                  gSetting_200TX;
 extern bool                  gSetting_500TX;
 extern bool                  gSetting_350EN;
-extern bool                  gSetting_TX_EN;
 extern uint8_t               gSetting_F_LOCK;
 extern bool                  gSetting_ScrambleEnable;
 
@@ -185,7 +180,18 @@ extern uint16_t              gEEPROM_RSSI_CALIB[7][4];
 extern uint16_t              gEEPROM_1F8A;
 extern uint16_t              gEEPROM_1F8C;
 
-extern uint8_t               gMR_ChannelAttributes[207];
+typedef union { 
+    struct {
+        uint8_t
+            band : 4,
+            compander : 2,
+            scanlist2 : 1,
+            scanlist1 : 1;
+    };
+    uint8_t __val;
+} ChannelAttributes_t;
+
+extern ChannelAttributes_t   gMR_ChannelAttributes[207];
 
 extern volatile uint16_t     gBatterySaveCountdown_10ms;
 
@@ -229,9 +235,20 @@ extern uint8_t               gVFO_RSSI_bar_level[2];
 extern uint8_t               gReducedService;
 extern uint8_t               gBatteryVoltageIndex;
 
-// if not equal CSS_SCAN_MODE_OFF we are scanning CTCSS/DCS
+// we are searching CTCSS/DCS inside RX ctcss/dcs menu
-// this is a scanning inside RX ctcss/dcs menu
+extern bool         gCssBackgroundScan;
-extern CssScanMode_t         gCssScanMode;
+
+
+enum
+{
+	SCAN_REV = -1,
+	SCAN_OFF =  0,
+	SCAN_FWD = +1
+};
+
+extern volatile bool     gScheduleScanListen;
+extern volatile uint16_t gScanPauseDelayIn_10ms;
+
 extern bool                  gUpdateRSSI;
 extern AlarmState_t          gAlarmState;
 extern uint16_t              gMenuCountdown;

radio.c

@@ -38,10 +38,7 @@
 VFO_Info_t    *gTxVfo;
 VFO_Info_t    *gRxVfo;
 VFO_Info_t    *gCurrentVfo;
-DCS_CodeType_t gSelectedCodeType;
 DCS_CodeType_t gCurrentCodeType;
-uint8_t        gSelectedCode;
-STEP_Setting_t gStepSetting;
 VfoState_t     VfoState[2];
 
 const char gModulationStr[][4] =
@@ -59,24 +56,22 @@ const char gModulationStr[][4] =
 bool RADIO_CheckValidChannel(uint16_t Channel, bool bCheckScanList, uint8_t VFO)
 {	// return true if the channel appears valid
 
-	uint8_t Attributes;
+	ChannelAttributes_t att;
 	uint8_t PriorityCh1;
 	uint8_t PriorityCh2;
 
 	if (!IS_MR_CHANNEL(Channel))
 		return false;
 
-	Attributes = gMR_ChannelAttributes[Channel];
+	att = gMR_ChannelAttributes[Channel];
 
-	if ((Attributes & MR_CH_BAND_MASK) > BAND7_470MHz)
+	if (att.band > BAND7_470MHz)
 		return false;
 
-	if (bCheckScanList)
+	if (bCheckScanList) {
-	{
+		switch (VFO) {
-		switch (VFO)
-		{
 			case 0:
-				if ((Attributes & MR_CH_SCANLIST1) == 0)
+				if (!att.scanlist1)
 					return false;
 
 				PriorityCh1 = gEeprom.SCANLIST_PRIORITY_CH1[0];
@@ -84,7 +79,7 @@ bool RADIO_CheckValidChannel(uint16_t Channel, bool bCheckScanList, uint8_t VFO)
 				break;
 
 			case 1:
-				if ((Attributes & MR_CH_SCANLIST2) == 0)
+				if (!att.scanlist2)
 					return false;
 
 				PriorityCh1 = gEeprom.SCANLIST_PRIORITY_CH1[1];
@@ -131,8 +126,8 @@ void RADIO_InitInfo(VFO_Info_t *pInfo, const uint8_t ChannelSave, const uint32_t
 	memset(pInfo, 0, sizeof(*pInfo));
 
 	pInfo->Band                     = FREQUENCY_GetBand(Frequency);
-	pInfo->SCANLIST1_PARTICIPATION  = true;
+	pInfo->SCANLIST1_PARTICIPATION  = false;
-	pInfo->SCANLIST2_PARTICIPATION  = true;
+	pInfo->SCANLIST2_PARTICIPATION  = false;
 	pInfo->STEP_SETTING             = STEP_12_5kHz;
 	pInfo->StepFrequency            = gStepFrequencyTable[pInfo->STEP_SETTING];
 	pInfo->CHANNEL_SAVE             = ChannelSave;
@@ -146,37 +141,31 @@ void RADIO_InitInfo(VFO_Info_t *pInfo, const uint8_t ChannelSave, const uint32_t
 
 	if (ChannelSave == (FREQ_CHANNEL_FIRST + BAND2_108MHz))
 		pInfo->Modulation = MODULATION_AM;
+	else
+		pInfo->Modulation = MODULATION_FM;
 		
 	RADIO_ConfigureSquelchAndOutputPower(pInfo);
 }
 
 void RADIO_ConfigureChannel(const unsigned int VFO, const unsigned int configure)
 {
-	uint8_t     Channel;
+	VFO_Info_t *pVfo = &gEeprom.VfoInfo[VFO];
-	uint8_t     Attributes;
-	uint8_t     Band;
-	bool        bParticipation2;
-	uint16_t    Base;
-	uint32_t    Frequency;
-	VFO_Info_t *pRadio = &gEeprom.VfoInfo[VFO];
 
-	if (!gSetting_350EN)
+	if (!gSetting_350EN) {
-	{
+		if (gEeprom.FreqChannel[VFO] == FREQ_CHANNEL_FIRST + BAND5_350MHz)
-		if (gEeprom.FreqChannel[VFO] == (FREQ_CHANNEL_LAST - 2))
+			gEeprom.FreqChannel[VFO] = FREQ_CHANNEL_FIRST + BAND6_400MHz;
-			gEeprom.FreqChannel[VFO] = FREQ_CHANNEL_LAST - 1;
 
-		if (gEeprom.ScreenChannel[VFO] == (FREQ_CHANNEL_LAST - 2))
+		if (gEeprom.ScreenChannel[VFO] == FREQ_CHANNEL_FIRST + BAND5_350MHz)
-			gEeprom.ScreenChannel[VFO] = FREQ_CHANNEL_LAST - 1;
+			gEeprom.ScreenChannel[VFO] = FREQ_CHANNEL_FIRST + BAND6_400MHz;
 	}
 
-	Channel = gEeprom.ScreenChannel[VFO];
+	uint8_t channel = gEeprom.ScreenChannel[VFO];
 
-	if (IS_VALID_CHANNEL(Channel))
+	if (IS_VALID_CHANNEL(channel)) {
-	{
 #ifdef ENABLE_NOAA
-		if (Channel >= NOAA_CHANNEL_FIRST)
+		if (channel >= NOAA_CHANNEL_FIRST)
 		{
-			RADIO_InitInfo(pRadio, gEeprom.ScreenChannel[VFO], NoaaFrequencyTable[Channel - NOAA_CHANNEL_FIRST]);
+			RADIO_InitInfo(pVfo, gEeprom.ScreenChannel[VFO], NoaaFrequencyTable[channel - NOAA_CHANNEL_FIRST]);
 
 			if (gEeprom.CROSS_BAND_RX_TX == CROSS_BAND_OFF)
 				return;
@@ -188,248 +177,244 @@ void RADIO_ConfigureChannel(const unsigned int VFO, const unsigned int configure
 		}
 #endif
 
-		if (IS_MR_CHANNEL(Channel))
+		if (IS_MR_CHANNEL(channel)) {
-		{
+			channel = RADIO_FindNextChannel(channel, RADIO_CHANNEL_UP, false, VFO);
-			Channel = RADIO_FindNextChannel(Channel, RADIO_CHANNEL_UP, false, VFO);
+			if (channel == 0xFF) {
-			if (Channel == 0xFF)
+				channel                    = gEeprom.FreqChannel[VFO];
-			{
-				Channel                    = gEeprom.FreqChannel[VFO];
 				gEeprom.ScreenChannel[VFO] = gEeprom.FreqChannel[VFO];
 			}
-			else
+			else {
-			{
+				gEeprom.ScreenChannel[VFO] = channel;
-				gEeprom.ScreenChannel[VFO] = Channel;
+				gEeprom.MrChannel[VFO]     = channel;
-				gEeprom.MrChannel[VFO]     = Channel;
 			}
 		}
 	}
 	else
-		Channel = FREQ_CHANNEL_LAST - 1;
+		channel = FREQ_CHANNEL_LAST - 1;
 
-	Attributes = gMR_ChannelAttributes[Channel];
+	ChannelAttributes_t att = gMR_ChannelAttributes[channel];
-	if (Attributes == 0xFF)
+	if (att.__val == 0xFF) { // invalid/unused channel
-	{	// invalid/unused channel
+		if (IS_MR_CHANNEL(channel)) {
-
+			channel                    = gEeprom.FreqChannel[VFO];
-		uint8_t Index;
+			gEeprom.ScreenChannel[VFO] = channel;
-
-		if (IS_MR_CHANNEL(Channel))
-		{
-			Channel                    = gEeprom.FreqChannel[VFO];
-			gEeprom.ScreenChannel[VFO] = gEeprom.FreqChannel[VFO];
 		}
 
-		Index = Channel - FREQ_CHANNEL_FIRST;
+		uint8_t bandIdx = channel - FREQ_CHANNEL_FIRST;
-
+		RADIO_InitInfo(pVfo, channel, frequencyBandTable[bandIdx].lower);
-		RADIO_InitInfo(pRadio, Channel, frequencyBandTable[Index].lower);
 		return;
 	}
 
-	Band = Attributes & MR_CH_BAND_MASK;
+	uint8_t band = att.band;
-	if (Band > BAND7_470MHz)
+	if (band > BAND7_470MHz) {
-	{
+		band = BAND6_400MHz;
-		Band = BAND6_400MHz;
 	}
 
-	if (IS_MR_CHANNEL(Channel))
+	bool bParticipation1;
-	{
+	bool bParticipation2;
-		gEeprom.VfoInfo[VFO].Band                    = Band;
+	if (IS_MR_CHANNEL(channel)) {
-		gEeprom.VfoInfo[VFO].SCANLIST1_PARTICIPATION = !!(Attributes & MR_CH_SCANLIST1);
+		bParticipation1 = att.scanlist1;
-		bParticipation2                              = !!(Attributes & MR_CH_SCANLIST2);
+		bParticipation2 = att.scanlist2;
 	}
+	else {
+		band = channel - FREQ_CHANNEL_FIRST;
+		bParticipation1 = true;
+		bParticipation2 = true;
+	}
+
+	pVfo->Band                    = band;
+	pVfo->SCANLIST1_PARTICIPATION = bParticipation1;
+	pVfo->SCANLIST2_PARTICIPATION = bParticipation2;
+	pVfo->CHANNEL_SAVE            = channel;
+
+	uint16_t base;
+	if (IS_MR_CHANNEL(channel))
+		base = channel * 16;
 	else
+		base = 0x0C80 + ((channel - FREQ_CHANNEL_FIRST) * 32) + (VFO * 16);
+
+	if (configure == VFO_CONFIGURE_RELOAD || IS_FREQ_CHANNEL(channel))
 	{
-		Band                                         = Channel - FREQ_CHANNEL_FIRST;
+		uint8_t tmp;
-		gEeprom.VfoInfo[VFO].Band                    = Band;
+		uint8_t data[8];
-		bParticipation2                              = true;
-		gEeprom.VfoInfo[VFO].SCANLIST1_PARTICIPATION = true;
-	}
-
-	gEeprom.VfoInfo[VFO].SCANLIST2_PARTICIPATION = bParticipation2;
-	gEeprom.VfoInfo[VFO].CHANNEL_SAVE            = Channel;
-
-	if (IS_MR_CHANNEL(Channel))
-		Base = Channel * 16;
-	else
-		Base = 0x0C80 + ((Channel - FREQ_CHANNEL_FIRST) * 32) + (VFO * 16);
-
-	if (configure == VFO_CONFIGURE_RELOAD || Channel >= FREQ_CHANNEL_FIRST)
-	{
-		uint8_t Tmp;
-		uint8_t Data[8];
 
 		// ***************
 
-		EEPROM_ReadBuffer(Base + 8, Data, sizeof(Data));
+		EEPROM_ReadBuffer(base + 8, data, sizeof(data));
 
-		Tmp = Data[3] & 0x0F;
+		tmp = data[3] & 0x0F;
-		if (Tmp > TX_OFFSET_FREQUENCY_DIRECTION_SUB)
+		if (tmp > TX_OFFSET_FREQUENCY_DIRECTION_SUB)
-			Tmp = 0;
+			tmp = 0;
-		gEeprom.VfoInfo[VFO].TX_OFFSET_FREQUENCY_DIRECTION = Tmp;
+		pVfo->TX_OFFSET_FREQUENCY_DIRECTION = tmp;
-		gEeprom.VfoInfo[VFO].Modulation = (Data[3] >> 4);
+		tmp = data[3] >> 4;
+		if (tmp >= MODULATION_UKNOWN)
+			tmp = MODULATION_FM;		
+		pVfo->Modulation = tmp;
 
-		Tmp = Data[6];
+		tmp = data[6];
-		if (Tmp >= ARRAY_SIZE(gStepFrequencyTable))
+		if (tmp >= ARRAY_SIZE(gStepFrequencyTable))
-			Tmp = STEP_12_5kHz;
+			tmp = STEP_12_5kHz;
-		gEeprom.VfoInfo[VFO].STEP_SETTING  = Tmp;
+		pVfo->STEP_SETTING  = tmp;
-		gEeprom.VfoInfo[VFO].StepFrequency = gStepFrequencyTable[Tmp];
+		pVfo->StepFrequency = gStepFrequencyTable[tmp];
 
-		Tmp = Data[7];
+		tmp = data[7];
-		if (Tmp > (ARRAY_SIZE(gSubMenu_SCRAMBLER) - 1))
+		if (tmp > (ARRAY_SIZE(gSubMenu_SCRAMBLER) - 1))
-			Tmp = 0;
+			tmp = 0;
-		gEeprom.VfoInfo[VFO].SCRAMBLING_TYPE = Tmp;
+		pVfo->SCRAMBLING_TYPE = tmp;
 
-		gEeprom.VfoInfo[VFO].freq_config_RX.CodeType = (Data[2] >> 0) & 0x0F;
+		pVfo->freq_config_RX.CodeType = (data[2] >> 0) & 0x0F;
-		gEeprom.VfoInfo[VFO].freq_config_TX.CodeType = (Data[2] >> 4) & 0x0F;
+		pVfo->freq_config_TX.CodeType = (data[2] >> 4) & 0x0F;
 
-		Tmp = Data[0];
+		tmp = data[0];
-		switch (gEeprom.VfoInfo[VFO].freq_config_RX.CodeType)
+		switch (pVfo->freq_config_RX.CodeType)
 		{
 			default:
 			case CODE_TYPE_OFF:
-				gEeprom.VfoInfo[VFO].freq_config_RX.CodeType = CODE_TYPE_OFF;
+				pVfo->freq_config_RX.CodeType = CODE_TYPE_OFF;
-				Tmp = 0;
+				tmp = 0;
 				break;
 
 			case CODE_TYPE_CONTINUOUS_TONE:
-				if (Tmp > (ARRAY_SIZE(CTCSS_Options) - 1))
+				if (tmp > (ARRAY_SIZE(CTCSS_Options) - 1))
-					Tmp = 0;
+					tmp = 0;
 				break;
 
 			case CODE_TYPE_DIGITAL:
 			case CODE_TYPE_REVERSE_DIGITAL:
-				if (Tmp > (ARRAY_SIZE(DCS_Options) - 1))
+				if (tmp > (ARRAY_SIZE(DCS_Options) - 1))
-					Tmp = 0;
+					tmp = 0;
 				break;
 		}
-		gEeprom.VfoInfo[VFO].freq_config_RX.Code = Tmp;
+		pVfo->freq_config_RX.Code = tmp;
 
-		Tmp = Data[1];
+		tmp = data[1];
-		switch (gEeprom.VfoInfo[VFO].freq_config_TX.CodeType)
+		switch (pVfo->freq_config_TX.CodeType)
 		{
 			default:
 			case CODE_TYPE_OFF:
-				gEeprom.VfoInfo[VFO].freq_config_TX.CodeType = CODE_TYPE_OFF;
+				pVfo->freq_config_TX.CodeType = CODE_TYPE_OFF;
-				Tmp = 0;
+				tmp = 0;
 				break;
 
 			case CODE_TYPE_CONTINUOUS_TONE:
-				if (Tmp > (ARRAY_SIZE(CTCSS_Options) - 1))
+				if (tmp > (ARRAY_SIZE(CTCSS_Options) - 1))
-					Tmp = 0;
+					tmp = 0;
 				break;
 
 			case CODE_TYPE_DIGITAL:
 			case CODE_TYPE_REVERSE_DIGITAL:
-				if (Tmp > (ARRAY_SIZE(DCS_Options) - 1))
+				if (tmp > (ARRAY_SIZE(DCS_Options) - 1))
-					Tmp = 0;
+					tmp = 0;
 				break;
 		}
-		gEeprom.VfoInfo[VFO].freq_config_TX.Code = Tmp;
+		pVfo->freq_config_TX.Code = tmp;
 
-		if (Data[4] == 0xFF)
+		if (data[4] == 0xFF)
 		{
-			gEeprom.VfoInfo[VFO].FrequencyReverse  = false;
+			pVfo->FrequencyReverse  = false;
-			gEeprom.VfoInfo[VFO].CHANNEL_BANDWIDTH = BK4819_FILTER_BW_WIDE;
+			pVfo->CHANNEL_BANDWIDTH = BK4819_FILTER_BW_WIDE;
-			gEeprom.VfoInfo[VFO].OUTPUT_POWER      = OUTPUT_POWER_LOW;
+			pVfo->OUTPUT_POWER      = OUTPUT_POWER_LOW;
-			gEeprom.VfoInfo[VFO].BUSY_CHANNEL_LOCK = false;
+			pVfo->BUSY_CHANNEL_LOCK = false;
 		}
 		else
 		{
-			const uint8_t d4 = Data[4];
+			const uint8_t d4 = data[4];
-			gEeprom.VfoInfo[VFO].FrequencyReverse  = !!((d4 >> 0) & 1u);
+			pVfo->FrequencyReverse  = !!((d4 >> 0) & 1u);
-			gEeprom.VfoInfo[VFO].CHANNEL_BANDWIDTH = !!((d4 >> 1) & 1u);
+			pVfo->CHANNEL_BANDWIDTH = !!((d4 >> 1) & 1u);
-			gEeprom.VfoInfo[VFO].OUTPUT_POWER      =   ((d4 >> 2) & 3u);
+			pVfo->OUTPUT_POWER      =   ((d4 >> 2) & 3u);
-			gEeprom.VfoInfo[VFO].BUSY_CHANNEL_LOCK = !!((d4 >> 4) & 1u);
+			pVfo->BUSY_CHANNEL_LOCK = !!((d4 >> 4) & 1u);
 		}
 
-		if (Data[5] == 0xFF)
+		if (data[5] == 0xFF)
 		{
-			gEeprom.VfoInfo[VFO].DTMF_DECODING_ENABLE = false;
+#ifdef ENABLE_DTMF_CALLING
-			gEeprom.VfoInfo[VFO].DTMF_PTT_ID_TX_MODE  = PTT_ID_OFF;
+			pVfo->DTMF_DECODING_ENABLE = false;
+#endif
+			pVfo->DTMF_PTT_ID_TX_MODE  = PTT_ID_OFF;
 		}
 		else
 		{
-			gEeprom.VfoInfo[VFO].DTMF_DECODING_ENABLE = ((Data[5] >> 0) & 1u) ? true : false;
+#ifdef ENABLE_DTMF_CALLING
-			gEeprom.VfoInfo[VFO].DTMF_PTT_ID_TX_MODE  = ((Data[5] >> 1) & 7u);
+			pVfo->DTMF_DECODING_ENABLE = ((data[5] >> 0) & 1u) ? true : false;
+#endif
+			pVfo->DTMF_PTT_ID_TX_MODE  = ((data[5] >> 1) & 7u);
 		}
 
 		// ***************
 
-		struct
+		struct {
-		{
 			uint32_t Frequency;
 			uint32_t Offset;
-		} __attribute__((packed)) Info;
+		} __attribute__((packed)) info;
+		EEPROM_ReadBuffer(base, &info, sizeof(info));
+		if(info.Frequency==0xFFFFFFFF)
+			pVfo->freq_config_RX.Frequency = frequencyBandTable[band].lower;
+		else
+			pVfo->freq_config_RX.Frequency = info.Frequency;
 
-		EEPROM_ReadBuffer(Base, &Info, sizeof(Info));
+		if (info.Offset >= 100000000)
-
+			info.Offset = 1000000;
-		pRadio->freq_config_RX.Frequency = Info.Frequency;
+		pVfo->TX_OFFSET_FREQUENCY = info.Offset;
-
-		if (Info.Offset >= 100000000)
-			Info.Offset = 1000000;
-		gEeprom.VfoInfo[VFO].TX_OFFSET_FREQUENCY = Info.Offset;
 
 		// ***************
 	}
 
-	Frequency = pRadio->freq_config_RX.Frequency;
+	uint32_t frequency = pVfo->freq_config_RX.Frequency;
 
 	// fix previously set incorrect band
-	Band = FREQUENCY_GetBand(Frequency);
+	band = FREQUENCY_GetBand(frequency);
 
-	if (Frequency < frequencyBandTable[Band].lower)
+	if (frequency < frequencyBandTable[band].lower)
-		Frequency = frequencyBandTable[Band].lower;
+		frequency = frequencyBandTable[band].lower;
-	else
+	else if (frequency > frequencyBandTable[band].upper)
-	if (Frequency > frequencyBandTable[Band].upper)
+		frequency = frequencyBandTable[band].upper;
-		Frequency = frequencyBandTable[Band].upper;
+	else if (channel >= FREQ_CHANNEL_FIRST)
-	else
+		frequency = FREQUENCY_RoundToStep(frequency, pVfo->StepFrequency);
-	if (Channel >= FREQ_CHANNEL_FIRST)
-		Frequency = FREQUENCY_RoundToStep(Frequency, gEeprom.VfoInfo[VFO].StepFrequency);
 
-	pRadio->freq_config_RX.Frequency = Frequency;
+	pVfo->freq_config_RX.Frequency = frequency;
 
-	if (Frequency >= frequencyBandTable[BAND2_108MHz].upper && Frequency < frequencyBandTable[BAND2_108MHz].upper)
+	if (frequency >= frequencyBandTable[BAND2_108MHz].upper && frequency < frequencyBandTable[BAND2_108MHz].upper)
-		gEeprom.VfoInfo[VFO].TX_OFFSET_FREQUENCY_DIRECTION = TX_OFFSET_FREQUENCY_DIRECTION_OFF;
+		pVfo->TX_OFFSET_FREQUENCY_DIRECTION = TX_OFFSET_FREQUENCY_DIRECTION_OFF;
-	else if (!IS_MR_CHANNEL(Channel))
+	else if (!IS_MR_CHANNEL(channel))
-		gEeprom.VfoInfo[VFO].TX_OFFSET_FREQUENCY = FREQUENCY_RoundToStep(gEeprom.VfoInfo[VFO].TX_OFFSET_FREQUENCY, gEeprom.VfoInfo[VFO].StepFrequency);
+		pVfo->TX_OFFSET_FREQUENCY = FREQUENCY_RoundToStep(pVfo->TX_OFFSET_FREQUENCY, pVfo->StepFrequency);
 
-	RADIO_ApplyOffset(pRadio);
+	RADIO_ApplyOffset(pVfo);
 
-	memset(gEeprom.VfoInfo[VFO].Name, 0, sizeof(gEeprom.VfoInfo[VFO].Name));
+	memset(pVfo->Name, 0, sizeof(pVfo->Name));
-	if (IS_MR_CHANNEL(Channel))
+	if (IS_MR_CHANNEL(channel))
 	{	// 16 bytes allocated to the channel name but only 10 used, the rest are 0's
-		EEPROM_ReadBuffer(0x0F50 + (Channel * 16), gEeprom.VfoInfo[VFO].Name + 0, 8);
+		EEPROM_ReadBuffer(0x0F50 + (channel * 16), pVfo->Name + 0, 8);
-		EEPROM_ReadBuffer(0x0F58 + (Channel * 16), gEeprom.VfoInfo[VFO].Name + 8, 2);
+		EEPROM_ReadBuffer(0x0F58 + (channel * 16), pVfo->Name + 8, 2);
 	}
 
-	if (!gEeprom.VfoInfo[VFO].FrequencyReverse)
+	if (!pVfo->FrequencyReverse)
 	{
-		gEeprom.VfoInfo[VFO].pRX = &gEeprom.VfoInfo[VFO].freq_config_RX;
+		pVfo->pRX = &pVfo->freq_config_RX;
-		gEeprom.VfoInfo[VFO].pTX = &gEeprom.VfoInfo[VFO].freq_config_TX;
+		pVfo->pTX = &pVfo->freq_config_TX;
 	}
 	else
 	{
-		gEeprom.VfoInfo[VFO].pRX = &gEeprom.VfoInfo[VFO].freq_config_TX;
+		pVfo->pRX = &pVfo->freq_config_TX;
-		gEeprom.VfoInfo[VFO].pTX = &gEeprom.VfoInfo[VFO].freq_config_RX;
+		pVfo->pTX = &pVfo->freq_config_RX;
 	}
 
 	if (!gSetting_350EN)
 	{
-		FREQ_Config_t *pConfig = gEeprom.VfoInfo[VFO].pRX;
+		FREQ_Config_t *pConfig = pVfo->pRX;
 		if (pConfig->Frequency >= 35000000 && pConfig->Frequency < 40000000)
 			pConfig->Frequency = 43300000;
 	}
 
-	if (gEeprom.VfoInfo[VFO].Modulation != MODULATION_FM)
+	if (pVfo->Modulation != MODULATION_FM)
 	{	// freq/chan is in AM mode
-		gEeprom.VfoInfo[VFO].SCRAMBLING_TYPE         = 0;
+		pVfo->SCRAMBLING_TYPE         = 0;
-//		gEeprom.VfoInfo[VFO].DTMF_DECODING_ENABLE    = false;  // no reason to disable DTMF decoding, aircraft use it on SSB
+//		pVfo->DTMF_DECODING_ENABLE    = false;  // no reason to disable DTMF decoding, aircraft use it on SSB
-		gEeprom.VfoInfo[VFO].freq_config_RX.CodeType = CODE_TYPE_OFF;
+		pVfo->freq_config_RX.CodeType = CODE_TYPE_OFF;
-		gEeprom.VfoInfo[VFO].freq_config_TX.CodeType = CODE_TYPE_OFF;
+		pVfo->freq_config_TX.CodeType = CODE_TYPE_OFF;
 	}
 
-	gEeprom.VfoInfo[VFO].Compander = (Attributes & MR_CH_COMPAND) >> 4;
+	pVfo->Compander = att.compander;
 
-	RADIO_ConfigureSquelchAndOutputPower(pRadio);
+	RADIO_ConfigureSquelchAndOutputPower(pVfo);
 }
 
 void RADIO_ConfigureSquelchAndOutputPower(VFO_Info_t *pInfo)
@@ -682,13 +667,8 @@ void RADIO_SetupRegisters(bool switchToForeground)
 	{
 		if (gRxVfo->Modulation == MODULATION_FM)
 		{	// FM
-			uint8_t CodeType = gSelectedCodeType;
+			uint8_t CodeType = gRxVfo->pRX->CodeType;
-			uint8_t Code     = gSelectedCode;
+			uint8_t Code     = gRxVfo->pRX->Code;
-			if (gCssScanMode == CSS_SCAN_MODE_OFF)
-			{
-				CodeType = gRxVfo->pRX->CodeType;
-				Code     = gRxVfo->pRX->Code;
-			}
 
 			switch (CodeType)
 			{
@@ -1019,7 +999,7 @@ void RADIO_PrepareTX(void)
 			}
 			else
 		#endif
-		if (!gSetting_TX_EN || gSerialConfigCountDown_500ms > 0)
+		if (gSerialConfigCountDown_500ms > 0)
 		{	// TX is disabled or config upload/download in progress
 			State = VFO_STATE_TX_DISABLE;
 		}
@@ -1047,14 +1027,16 @@ void RADIO_PrepareTX(void)
 			gAlarmState = ALARM_STATE_OFF;
 		#endif
 
+#ifdef ENABLE_DTMF_CALLING
 		gDTMF_ReplyState = DTMF_REPLY_NONE;
-
+#endif
 		AUDIO_PlayBeep(BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL);
 		return;
 	}
 
 	// TX is allowed
 
+#ifdef ENABLE_DTMF_CALLING
 	if (gDTMF_ReplyState == DTMF_REPLY_ANI)
 	{
 		if (gDTMF_CallMode == DTMF_CALL_MODE_DTMF)
@@ -1069,6 +1051,7 @@ void RADIO_PrepareTX(void)
 			gDTMF_IsTx      = false;
 		}
 	}
+#endif
 
 	FUNCTION_Select(FUNCTION_TRANSMIT);
 
@@ -1090,7 +1073,10 @@ void RADIO_PrepareTX(void)
 
 	gFlagEndTransmission = false;
 	gRTTECountdown       = 0;
+
+#ifdef ENABLE_DTMF_CALLING
 	gDTMF_ReplyState     = DTMF_REPLY_NONE;
+#endif
 }
 
 void RADIO_EnableCxCSS(void)
@@ -1129,7 +1115,10 @@ void RADIO_SendEndOfTransmission(void)
 	if (gCurrentVfo->DTMF_PTT_ID_TX_MODE == PTT_ID_APOLLO)
 		BK4819_PlaySingleTone(2475, 250, 28, gEeprom.DTMF_SIDE_TONE);
 
-	if (gDTMF_CallState == DTMF_CALL_STATE_NONE &&
+	if (
+#ifdef ENABLE_DTMF_CALLING
+		gDTMF_CallState == DTMF_CALL_STATE_NONE &&
+#endif
 	   (gCurrentVfo->DTMF_PTT_ID_TX_MODE == PTT_ID_TX_DOWN ||
 	    gCurrentVfo->DTMF_PTT_ID_TX_MODE == PTT_ID_BOTH))
 	{	// end-of-tx

radio.h

@@ -23,13 +23,6 @@
 #include "dcs.h"
 #include "frequencies.h"
 
-enum {
-	MR_CH_BAND_MASK   = 0x0F << 0,
-	MR_CH_COMPAND     =   3u << 4,  // new
-	MR_CH_SCANLIST2   =   1u << 6,
-	MR_CH_SCANLIST1   =   1u << 7
-};
-
 enum {
 	RADIO_CHANNEL_UP   = 0x01u,
 	RADIO_CHANNEL_DOWN = 0xFFu,
@@ -124,8 +117,9 @@ typedef struct VFO_Info_t
 	uint8_t        SCANLIST2_PARTICIPATION;
 
 	uint8_t        Band;
-
+#ifdef ENABLE_DTMF_CALLING
 	uint8_t        DTMF_DECODING_ENABLE;
+#endif
 	PTT_ID_t       DTMF_PTT_ID_TX_MODE;
 
 	uint8_t        BUSY_CHANNEL_LOCK;
@@ -138,7 +132,7 @@ typedef struct VFO_Info_t
 } VFO_Info_t;
 
 // Settings of the main VFO that is selected by the user
-// The pointer follows gEeprom.RX_VFO index
+// The pointer follows gEeprom.TX_VFO index
 extern VFO_Info_t    *gTxVfo;
 
 // Settings of the actual VFO that is now used for RX,
@@ -149,11 +143,7 @@ extern VFO_Info_t    *gRxVfo;
 // Equal to gTxVfo unless dual watch changes it on incomming transmition (this can only happen when XB off and DW on)
 extern VFO_Info_t    *gCurrentVfo;
 
-extern DCS_CodeType_t gSelectedCodeType;
 extern DCS_CodeType_t gCurrentCodeType;
-extern uint8_t        gSelectedCode;
-
-extern STEP_Setting_t gStepSetting;
 
 extern VfoState_t     VfoState[2];
 

scheduler.c

@@ -14,6 +14,7 @@
  *     limitations under the License.
  */
 
+#include "app/chFrScanner.h"
 #ifdef ENABLE_FMRADIO
 	#include "app/fm.h"
 #endif
@@ -77,18 +78,18 @@ void SystickHandler(void)
 	if (gCurrentFunction == FUNCTION_POWER_SAVE)
 		DECREMENT_AND_TRIGGER(gPowerSave_10ms, gPowerSaveCountdownExpired);
 
-	if (gScanStateDir == SCAN_OFF && gCssScanMode == CSS_SCAN_MODE_OFF && gEeprom.DUAL_WATCH != DUAL_WATCH_OFF)
+	if (gScanStateDir == SCAN_OFF && !gCssBackgroundScan && gEeprom.DUAL_WATCH != DUAL_WATCH_OFF)
 		if (gCurrentFunction != FUNCTION_MONITOR && gCurrentFunction != FUNCTION_TRANSMIT && gCurrentFunction != FUNCTION_RECEIVE)
 			DECREMENT_AND_TRIGGER(gDualWatchCountdown_10ms, gScheduleDualWatch);
 
 	#ifdef ENABLE_NOAA
-		if (gScanStateDir == SCAN_OFF && gCssScanMode == CSS_SCAN_MODE_OFF && gEeprom.DUAL_WATCH == DUAL_WATCH_OFF)
+		if (gScanStateDir == SCAN_OFF && !gCssBackgroundScan && gEeprom.DUAL_WATCH == DUAL_WATCH_OFF)
 			if (gIsNoaaMode && gCurrentFunction != FUNCTION_MONITOR && gCurrentFunction != FUNCTION_TRANSMIT)
 				if (gCurrentFunction != FUNCTION_RECEIVE)
 					DECREMENT_AND_TRIGGER(gNOAA_Countdown_10ms, gScheduleNOAA);
 	#endif
 
-	if (gScanStateDir != SCAN_OFF || gCssScanMode == CSS_SCAN_MODE_SCANNING)
+	if (gScanStateDir != SCAN_OFF)
 		if (gCurrentFunction != FUNCTION_MONITOR && gCurrentFunction != FUNCTION_TRANSMIT)
 			DECREMENT_AND_TRIGGER(gScanPauseDelayIn_10ms, gScheduleScanListen);
 

settings.c

@@ -141,10 +141,12 @@ void SETTINGS_SaveSettings(void)
 	EEPROM_WriteBuffer(0x0EA8, State);
 
 	State[0] = gEeprom.DTMF_SIDE_TONE;
+#ifdef ENABLE_DTMF_CALLING
 	State[1] = gEeprom.DTMF_SEPARATE_CODE;
 	State[2] = gEeprom.DTMF_GROUP_CALL_CODE;
 	State[3] = gEeprom.DTMF_DECODE_RESPONSE;
 	State[4] = gEeprom.DTMF_auto_reset_time;
+#endif	
 	State[5] = gEeprom.DTMF_PRELOAD_TIME / 10U;
 	State[6] = gEeprom.DTMF_FIRST_CODE_PERSIST_TIME / 10U;
 	State[7] = gEeprom.DTMF_HASH_CODE_PERSIST_TIME / 10U;
@@ -153,7 +155,9 @@ void SETTINGS_SaveSettings(void)
 	memset(State, 0xFF, sizeof(State));
 	State[0] = gEeprom.DTMF_CODE_PERSIST_TIME / 10U;
 	State[1] = gEeprom.DTMF_CODE_INTERVAL_TIME / 10U;
+#ifdef ENABLE_DTMF_CALLING
 	State[2] = gEeprom.PERMIT_REMOTE_KILL;
+#endif
 	EEPROM_WriteBuffer(0x0ED8, State);
 
 	State[0] = gEeprom.SCAN_LIST_DEFAULT;
@@ -169,12 +173,14 @@ void SETTINGS_SaveSettings(void)
 	memset(State, 0xFF, sizeof(State));
 	State[0]  = gSetting_F_LOCK;
 	State[1]  = gSetting_350TX;
+#ifdef ENABLE_DTMF_CALLING
 	State[2]  = gSetting_KILLED;
+#endif
 	State[3]  = gSetting_200TX;
 	State[4]  = gSetting_500TX;
 	State[5]  = gSetting_350EN;
 	State[6]  = gSetting_ScrambleEnable;
-	if (!gSetting_TX_EN)             State[7] &= ~(1u << 0);
+	//if (!gSetting_TX_EN)             State[7] &= ~(1u << 0);
 	if (!gSetting_live_DTMF_decoder) State[7] &= ~(1u << 1);
 	State[7] = (State[7] & ~(3u << 2)) | ((gSetting_battery_text & 3u) << 2);
 	#ifdef ENABLE_AUDIO_BAR
@@ -221,7 +227,11 @@ void SETTINGS_SaveChannel(uint8_t Channel, uint8_t VFO, const VFO_Info_t *pVFO,
 				| (pVFO->OUTPUT_POWER      << 2)
 				| (pVFO->CHANNEL_BANDWIDTH << 1)
 				| (pVFO->FrequencyReverse  << 0);
-			State[5] = ((pVFO->DTMF_PTT_ID_TX_MODE & 7u) << 1) | ((pVFO->DTMF_DECODING_ENABLE & 1u) << 0);
+			State[5] = ((pVFO->DTMF_PTT_ID_TX_MODE & 7u) << 1) 
+#ifdef ENABLE_DTMF_CALLING
+				| ((pVFO->DTMF_DECODING_ENABLE & 1u) << 0)
+#endif
+			;
 			State[6] =  pVFO->STEP_SETTING;
 			State[7] =  pVFO->SCRAMBLING_TYPE;
 			EEPROM_WriteBuffer(OffsetVFO + 8, State);
@@ -263,55 +273,45 @@ void SETTINGS_SaveBatteryCalibration(const uint16_t * batteryCalibration)
 	EEPROM_WriteBuffer(0x1F48, buf);
 }
 
-void SETTINGS_UpdateChannel(uint8_t Channel, const VFO_Info_t *pVFO, bool keep)
+void SETTINGS_UpdateChannel(uint8_t channel, const VFO_Info_t *pVFO, bool keep)
 {
-	#ifdef ENABLE_NOAA
+#ifdef ENABLE_NOAA
-		if (!IS_NOAA_CHANNEL(Channel))
+	if (!IS_NOAA_CHANNEL(channel))
-	#endif
+#endif
 	{
-		uint8_t  State[8];
+		uint8_t  state[8];
-		uint8_t  Attributes = 0xFF;        // default attributes
+		ChannelAttributes_t  att = {
-		uint16_t Offset = 0x0D60 + (Channel & ~7u);
+			.band = 0xf,
+			.compander = 0,
+			.scanlist1 = 0,
+			.scanlist2 = 0,
+			};        // default attributes
 
-		Attributes &= (uint8_t)(~MR_CH_COMPAND);  // default to '0' = compander disabled
+		uint16_t offset = 0x0D60 + (channel & ~7u);
+		EEPROM_ReadBuffer(offset, state, sizeof(state));
 
-		EEPROM_ReadBuffer(Offset, State, sizeof(State));
+		if (keep) {
-
+			att.band = pVFO->Band;
-		if (keep)
+			att.scanlist1 = pVFO->SCANLIST1_PARTICIPATION;
-		{
+			att.scanlist2 = pVFO->SCANLIST2_PARTICIPATION;
-			Attributes = (pVFO->SCANLIST1_PARTICIPATION << 7) | (pVFO->SCANLIST2_PARTICIPATION << 6) | (pVFO->Compander << 4) | (pVFO->Band << 0);
+			att.compander = pVFO->Compander;
-			if (State[Channel & 7u] == Attributes)
+			if (state[channel & 7u] == att.__val)
 				return; // no change in the attributes
 		}
 
-		State[Channel & 7u] = Attributes;
+		state[channel & 7u] = att.__val;
+		EEPROM_WriteBuffer(offset, state);
 
-		EEPROM_WriteBuffer(Offset, State);
+		gMR_ChannelAttributes[channel] = att;
 
-		gMR_ChannelAttributes[Channel] = Attributes;
+		if (IS_MR_CHANNEL(channel)) {	// it's a memory channel
-
+			const uint16_t OffsetMR = channel * 16;
-//		#ifndef ENABLE_KEEP_MEM_NAME
+			if (!keep) {
-			if (IS_MR_CHANNEL(Channel))
+				// clear/reset the channel name
-			{	// it's a memory channel
+				memset(&state, 0x00, sizeof(state));
-		
+				EEPROM_WriteBuffer(0x0F50 + OffsetMR, state);
-				const uint16_t OffsetMR = Channel * 16;
+				EEPROM_WriteBuffer(0x0F58 + OffsetMR, state);
-				if (!keep)
-				{	// clear/reset the channel name
-					//memset(&State, 0xFF, sizeof(State));
-					memset(&State, 0x00, sizeof(State));   // follow the QS way
-					EEPROM_WriteBuffer(0x0F50 + OffsetMR, State);
-					EEPROM_WriteBuffer(0x0F58 + OffsetMR, State);
-				}
-//				else
-//				{	// update the channel name
-//					memmove(State, pVFO->Name + 0, 8);
-//					EEPROM_WriteBuffer(0x0F50 + OffsetMR, State);
-//					//memset(State, 0xFF, sizeof(State));
-//					memset(State, 0x00, sizeof(State));  // follow the QS way
-//					memmove(State, pVFO->Name + 8, 2);
-//					EEPROM_WriteBuffer(0x0F58 + OffsetMR, State);
-//				}
 			}
-//		#endif
+		}
 	}
 }

settings.h

@@ -23,6 +23,7 @@
 #include "frequencies.h"
 #include <helper/battery.h>
 #include "radio.h"
+#include <driver/backlight.h>
 
 enum POWER_OnDisplayMode_t {
 	POWER_ON_DISPLAY_MODE_FULL_SCREEN = 0,
@@ -33,12 +34,15 @@ enum POWER_OnDisplayMode_t {
 typedef enum POWER_OnDisplayMode_t POWER_OnDisplayMode_t;
 
 enum {
-	F_LOCK_OFF = 0,
+	F_LOCK_DEF, //all default frequencies + configurable
 	F_LOCK_FCC,
 	F_LOCK_CE,
 	F_LOCK_GB,
 	F_LOCK_430,
-	F_LOCK_438
+	F_LOCK_438,
+	F_LOCK_ALL,	// disable TX on all frequencies
+	F_LOCK_NONE, // enable TX on all frequencies
+	F_LOCK_LEN
 };
 
 enum {
@@ -85,6 +89,9 @@ enum {
 	ACTION_OPT_A_B,
 	ACTION_OPT_VFO_MR,
 	ACTION_OPT_SWITCH_DEMODUL,
+#ifdef ENABLE_BLMIN_TMP_OFF
+	ACTION_OPT_BLMIN_TMP_OFF, //BackLight Minimum Temporay OFF
+#endif
 	ACTION_OPT_LEN
 };
 
@@ -120,9 +127,9 @@ enum CHANNEL_DisplayMode_t {
 typedef enum CHANNEL_DisplayMode_t CHANNEL_DisplayMode_t;
 
 typedef struct {
-	uint8_t               ScreenChannel[2];
+	uint8_t               ScreenChannel[2]; // current channels set in the radio (memory or frequency channels)
-	uint8_t               FreqChannel[2];
+	uint8_t               FreqChannel[2]; // last frequency channels used
-	uint8_t               MrChannel[2];
+	uint8_t               MrChannel[2]; // last memory channels used
 	#ifdef ENABLE_NOAA
 		uint8_t           NoaaChannel[2];
 	#endif
@@ -189,9 +196,11 @@ typedef struct {
 	uint8_t               MIC_SENSITIVITY;
 	uint8_t               MIC_SENSITIVITY_TUNING;
 	uint8_t               CHAN_1_CALL;
+#ifdef ENABLE_DTMF_CALLING
 	char                  ANI_DTMF_ID[8];
 	char                  KILL_CODE[8];
 	char                  REVIVE_CODE[8];
+#endif
 	char                  DTMF_UP_CODE[16];
 
 	uint8_t               field57_0x6c;
@@ -202,17 +211,21 @@ typedef struct {
 	uint8_t               field60_0x7e;
 	uint8_t               field61_0x7f;
 
+#ifdef ENABLE_DTMF_CALLING
 	char                  DTMF_SEPARATE_CODE;
 	char                  DTMF_GROUP_CALL_CODE;
 	uint8_t               DTMF_DECODE_RESPONSE;
 	uint8_t               DTMF_auto_reset_time;
+#endif	
 	uint16_t              DTMF_PRELOAD_TIME;
 	uint16_t              DTMF_FIRST_CODE_PERSIST_TIME;
 	uint16_t              DTMF_HASH_CODE_PERSIST_TIME;
 	uint16_t              DTMF_CODE_PERSIST_TIME;
 	uint16_t              DTMF_CODE_INTERVAL_TIME;
 	bool                  DTMF_SIDE_TONE;
+#ifdef ENABLE_DTMF_CALLING
 	bool                  PERMIT_REMOTE_KILL;
+#endif
 	int16_t               BK4819_XTAL_FREQ_LOW;
 	#ifdef ENABLE_NOAA
 		bool              NOAA_AUTO_SCAN;
@@ -231,6 +244,9 @@ typedef struct {
 
 	uint8_t 			  KEY_M_LONG_PRESS_ACTION;
 	uint8_t               BACKLIGHT_MIN;
+#ifdef ENABLE_BLMIN_TMP_OFF
+	BLMIN_STAT_t		  BACKLIGHT_MIN_STAT;
+#endif
 	uint8_t               BACKLIGHT_MAX;
 	BATTERY_Type_t		  BATTERY_TYPE;
 } EEPROM_Config_t;
@@ -244,6 +260,6 @@ void SETTINGS_SaveVfoIndices(void);
 void SETTINGS_SaveSettings(void);
 void SETTINGS_SaveChannel(uint8_t Channel, uint8_t VFO, const VFO_Info_t *pVFO, uint8_t Mode);
 void SETTINGS_SaveBatteryCalibration(const uint16_t * batteryCalibration);
-void SETTINGS_UpdateChannel(uint8_t Channel, const VFO_Info_t *pVFO, bool keep);
+void SETTINGS_UpdateChannel(uint8_t channel, const VFO_Info_t *pVFO, bool keep);
 
 #endif

ui/helper.c

@@ -88,11 +88,13 @@ void UI_PrintStringSmall(const char *pString, uint8_t Start, uint8_t End, uint8_
 	const size_t Length = strlen(pString);
 	size_t       i;
 
-	if (End > Start)
-		Start += (((End - Start) - (Length * 8)) + 1) / 2;
-
 	const unsigned int char_width   = ARRAY_SIZE(gFontSmall[0]);
 	const unsigned int char_spacing = char_width + 1;
+
+	if (End > Start)
+		Start += (((End - Start) - (Length * char_spacing)) + 1) / 2;
+
+
 	uint8_t            *pFb         = gFrameBuffer[Line] + Start;
 	for (i = 0; i < Length; i++)
 	{
@@ -180,10 +182,12 @@ void UI_DisplayFrequency(const char *string, uint8_t X, uint8_t Y, bool center)
 	}
 }
 
-void UI_DrawPixel(uint8_t x, uint8_t y, bool black) 
+void UI_DrawPixelBuffer(uint8_t (*buffer)[128], uint8_t x, uint8_t y, bool black) 
 {
-	gFrameBuffer[y/8][x] &= ~(1 << (y%8));
+	if(black)
-	gFrameBuffer[y/8][x] |= black << (y%8);
+		buffer[y/8][x] |= 1 << (y%8);
+	else
+		buffer[y/8][x] &= ~(1 << (y%8));
 }
 
 static void sort(int16_t *a, int16_t *b)
@@ -195,12 +199,12 @@ static void sort(int16_t *a, int16_t *b)
 	}
 }
 
-void UI_DrawLine(int16_t x1, int16_t y1, int16_t x2, int16_t y2, bool black)
+void UI_DrawLineBuffer(uint8_t (*buffer)[128], int16_t x1, int16_t y1, int16_t x2, int16_t y2, bool black)
 {
 	if(x2==x1) {
 		sort(&y1, &y2);
 		for(int16_t i = y1; i <= y2; i++) {
-			UI_DrawPixel(x1, i, black);
+			UI_DrawPixelBuffer(buffer, x1, i, black);
 		}
 	} else {
 		const int multipl = 1000;
@@ -210,17 +214,17 @@ void UI_DrawLine(int16_t x1, int16_t y1, int16_t x2, int16_t y2, bool black)
 		sort(&x1, &x2);
 		for(int i = x1; i<= x2; i++)
 		{
-			UI_DrawPixel(i, i*a/multipl +b, black);
+			UI_DrawPixelBuffer(buffer, i, i*a/multipl +b, black);
 		}
 	}
 }
 
-void UI_DrawRectangle(int16_t x1, int16_t y1, int16_t x2, int16_t y2, bool black)
+void UI_DrawRectangleBuffer(uint8_t (*buffer)[128], int16_t x1, int16_t y1, int16_t x2, int16_t y2, bool black)
 {
-	UI_DrawLine(x1,y1, x1,y2, black);
+	UI_DrawLineBuffer(buffer, x1,y1, x1,y2, black);
-	UI_DrawLine(x1,y1, x2,y1, black);
+	UI_DrawLineBuffer(buffer, x1,y1, x2,y1, black);
-	UI_DrawLine(x2,y1, x2,y2, black);
+	UI_DrawLineBuffer(buffer, x2,y1, x2,y2, black);
-	UI_DrawLine(x1,y2, x2,y2, black);
+	UI_DrawLineBuffer(buffer, x1,y2, x2,y2, black);
 }
 
 void UI_DisplayPopup(const char *string) 
@@ -234,13 +238,13 @@ void UI_DisplayPopup(const char *string)
 	// }
 
 	// for(uint8_t x = 10; x < 118; x++) {
-	// 	UI_DrawPixel(x, 10, true);
+	// 	UI_DrawPixelBuffer(x, 10, true);
-	// 	UI_DrawPixel(x, 46-9, true);
+	// 	UI_DrawPixelBuffer(x, 46-9, true);
 	// }
 
 	// for(uint8_t y = 11; y < 37; y++) {
-	// 	UI_DrawPixel(10, y, true);
+	// 	UI_DrawPixelBuffer(10, y, true);
-	// 	UI_DrawPixel(117, y, true);
+	// 	UI_DrawPixelBuffer(117, y, true);
 	// }
 	// DrawRectangle(9,9, 118,38, true);
 	UI_PrintString(string, 9, 118, 2, 8);

ui/helper.h

@@ -33,7 +33,7 @@ void UI_DisplayFrequency(const char *string, uint8_t X, uint8_t Y, bool center);
 
 void UI_DisplayPopup(const char *string);
 
-void UI_DrawPixel(uint8_t x, uint8_t y, bool black);
+void UI_DrawPixelBuffer(uint8_t (*buffer)[128], uint8_t x, uint8_t y, bool black);
-void UI_DrawLine(int16_t x1, int16_t y1, int16_t x2, int16_t y2, bool black);
+void UI_DrawLineBuffer(uint8_t (*buffer)[128], int16_t x1, int16_t y1, int16_t x2, int16_t y2, bool black);
-void UI_DrawRectangle(int16_t x1, int16_t y1, int16_t x2, int16_t y2, bool black);
+void UI_DrawRectangleBuffer(uint8_t (*buffer)[128], int16_t x1, int16_t y1, int16_t x2, int16_t y2, bool black);
 

ui/main.c

@@ -17,6 +17,7 @@
 #include <string.h>
 #include <stdlib.h>  // abs()
 
+#include "app/chFrScanner.h"
 #include "app/dtmf.h"
 #ifdef ENABLE_AM_FIX_SHOW_DATA
 	#include "am_fix.h"
@@ -52,6 +53,31 @@ static void DrawSmallAntennaAndBars(uint8_t *p, unsigned int level)
 		memset(p + 2 + i*3, bar, 2);
 	}
 }
+#if defined ENABLE_AUDIO_BAR || defined ENABLE_RSSI_BAR
+
+static void DrawLevelBar(uint8_t xpos, uint8_t line, uint8_t level)
+{
+	const char hollowBar[] = {
+		0b01111111,
+		0b01000001,
+		0b01000001,
+		0b01111111
+	};
+
+	uint8_t *p_line = gFrameBuffer[line];
+	level = MIN(level, 13);
+
+	for(uint8_t i = 0; i < level; i++) {
+		if(i < 9) {
+			for(uint8_t j = 0; j < 4; j++)
+				p_line[xpos + i * 5 + j] = (~(0x7F >> (i+1))) & 0x7F;
+		}
+		else {
+			memcpy(p_line + (xpos + i * 5), &hollowBar, ARRAY_SIZE(hollowBar));
+		}
+	}
+}
+#endif
 
 #ifdef ENABLE_AUDIO_BAR
 
@@ -76,14 +102,17 @@ void UI_DisplayAudioBar(void)
 {
 	if (gSetting_mic_bar)
 	{
+		if(gLowBattery && !gLowBatteryConfirmed)
+			return;
+
 		const unsigned int line      = 3;
-		const unsigned int bar_x     = 2;
-		const unsigned int bar_width = LCD_WIDTH - 2 - bar_x;
-		unsigned int       i;
 
 		if (gCurrentFunction != FUNCTION_TRANSMIT ||
-			gScreenToDisplay != DISPLAY_MAIN      ||
+			gScreenToDisplay != DISPLAY_MAIN
-			gDTMF_CallState != DTMF_CALL_STATE_NONE)
+#ifdef ENABLE_DTMF_CALLING
+			|| gDTMF_CallState != DTMF_CALL_STATE_NONE
+#endif
+			)
 		{
 			return;  // screen is in use
 		}
@@ -95,16 +124,14 @@ void UI_DisplayAudioBar(void)
 		const unsigned int voice_amp  = BK4819_GetVoiceAmplitudeOut();  // 15:0
 
 		// make non-linear to make more sensitive at low values
-		const unsigned int level      = voice_amp * 8;
+		const unsigned int level      = MIN(voice_amp * 8, 65535u);
-		const unsigned int sqrt_level = sqrt16((level < 65535) ? level : 65535);
+		const unsigned int sqrt_level = MIN(sqrt16(level), 124u);
-		const unsigned int len        = (sqrt_level <= bar_width) ? sqrt_level : bar_width;
+		uint8_t bars = 13 * sqrt_level / 124;
 
 		uint8_t *p_line = gFrameBuffer[line];
-
 		memset(p_line, 0, LCD_WIDTH);
 
-		for (i = 0; i < bar_width; i++)
+		DrawLevelBar(62, line, bars);
-			p_line[bar_x + i] = (i > len) ? ((i & 1) == 0) ? 0x41 : 0x00 : ((i & 1) == 0) ? 0x7f : 0x3e;
 
 		if (gCurrentFunction == FUNCTION_TRANSMIT)
 			ST7565_BlitFullScreen();
@@ -112,6 +139,7 @@ void UI_DisplayAudioBar(void)
 }
 #endif
 
+
 static void DisplayRSSIBar(const int16_t rssi, const bool now)
 {
 #if defined(ENABLE_RSSI_BAR)
@@ -134,26 +162,32 @@ static void DisplayRSSIBar(const int16_t rssi, const bool now)
 			0b00011000,
 		};
 
-		const char hollowBar[] = {
-			0b01111111, 
-			0b01000001, 
-			0b01000001, 
-			0b01111111
-		};
-
 		if (gEeprom.KEY_LOCK && gKeypadLocked > 0)
 			return;     // display is in use
 
 		if (gCurrentFunction == FUNCTION_TRANSMIT ||
-			gScreenToDisplay != DISPLAY_MAIN ||
+			gScreenToDisplay != DISPLAY_MAIN
-			gDTMF_CallState != DTMF_CALL_STATE_NONE)
+#ifdef ENABLE_DTMF_CALLING
+			|| gDTMF_CallState != DTMF_CALL_STATE_NONE
+#endif
+			)
 			return;     // display is in use
 
 		if (now)
 			memset(p_line, 0, LCD_WIDTH);
 		
-		const int16_t      s0_dBm       = -147;                  // S0 .. base level
+		const int8_t dBmCorrTable[7] = {
-		const int16_t      rssi_dBm     = (rssi / 2) - 160;
+			-15, // band 1
+			-25, // band 2
+			-20, // band 3
+			-4, // band 4
+			-7, // band 5
+			-6, // band 6
+			 -1  // band 7
+		};
+
+		const int16_t      s0_dBm       = -130;                  // S0 .. base level
+		const int16_t      rssi_dBm     = (rssi / 2) - 160 + dBmCorrTable[gRxVfo->Band];
 
 		const uint8_t s_level = MIN(MAX((rssi_dBm - s0_dBm) / 6, 0), 9); // S0 - S9
 		uint8_t overS9dBm = MIN(MAX(rssi_dBm - (s0_dBm + 9*6), 0), 99);
@@ -169,13 +203,7 @@ static void DisplayRSSIBar(const int16_t rssi, const bool now)
 
 		UI_PrintStringSmall(str, 2, 0, line);
 
-		for(uint8_t i = 0; i < s_level; i++) { // S bars
+		DrawLevelBar(bar_x, line, s_level + overS9Bars);
-			for(uint8_t j = 0; j < 4; j++)
-				p_line[bar_x + i * 5 + j] = (~(0x7F >> (i+1))) & 0x7F;
-		}
-		for(uint8_t i = 0; i < overS9Bars; i++) { // +10 hollow bars
-			memcpy(p_line + (bar_x + (i + 9) * 5), &hollowBar, ARRAY_SIZE(hollowBar));
-		}
 	}
 #else
 
@@ -260,13 +288,31 @@ void UI_DisplayMain(void)
 
 		if (activeTxVFO != vfo_num) // this is not active TX VFO
 		{
-			if (gDTMF_CallState != DTMF_CALL_STATE_NONE || gDTMF_IsTx || gDTMF_InputMode)
+#ifdef ENABLE_SCAN_RANGES
-			{	// show DTMF stuff
+			if(gScanRangeStart) {
+					UI_PrintString("ScnRng", 5, 0, line, 8);
+					sprintf(String, "%3u.%05u", gScanRangeStart / 100000, gScanRangeStart % 100000);
+					UI_PrintStringSmall(String, 56, 0, line);
+					uint32_t frq = gEeprom.VfoInfo[vfo_num].pRX->Frequency;
+					sprintf(String, "%3u.%05u", frq / 100000, frq % 100000);
+					UI_PrintStringSmall(String, 56, 0, line + 1);
+				continue;
+			}
+#endif
 
+
+			if (
+#ifdef ENABLE_DTMF_CALLING
+				gDTMF_CallState != DTMF_CALL_STATE_NONE || gDTMF_IsTx || 
+#endif				
+				gDTMF_InputMode)
+			{	// show DTMF stuff
+#ifdef ENABLE_DTMF_CALLING
 				char Contact[16];
 
 				if (!gDTMF_InputMode)
 				{
+
 					memset(Contact, 0, sizeof(Contact));
 					if (gDTMF_CallState == DTMF_CALL_STATE_CALL_OUT)
 						strcpy(String, (gDTMF_State == DTMF_STATE_CALL_OUT_RSP) ? "CALL OUT(RSP)" : "CALL OUT");
@@ -278,14 +324,14 @@ void UI_DisplayMain(void)
 						strcpy(String, (gDTMF_State == DTMF_STATE_TX_SUCC) ? "DTMF TX(SUCC)" : "DTMF TX");
 				}
 				else
+#endif				
 				{
 					sprintf(String, ">%s", gDTMF_InputBox);
 				}
 				UI_PrintString(String, 2, 0, 0 + (vfo_num * 3), 8);
-
+#ifdef ENABLE_DTMF_CALLING
 				memset(String,  0, sizeof(String));
-				if (!gDTMF_InputMode)
+				if (!gDTMF_InputMode) {
-				{
 					memset(Contact, 0, sizeof(Contact));
 					if (gDTMF_CallState == DTMF_CALL_STATE_CALL_OUT)
 						sprintf(String, ">%s", (DTMF_FindContact(gDTMF_String, Contact)) ? Contact : gDTMF_String);
@@ -296,8 +342,9 @@ void UI_DisplayMain(void)
 					if (gDTMF_IsTx)
 						sprintf(String, ">%s", gDTMF_String);
 				}
-				UI_PrintString(String, 2, 0, 2 + (vfo_num * 3), 8);
 
+				UI_PrintString(String, 2, 0, 2 + (vfo_num * 3), 8);
+#endif
 				center_line = CENTER_LINE_IN_USE;
 				continue;
 			}
@@ -422,7 +469,7 @@ void UI_DisplayMain(void)
 				UI_PrintString(String, 32, 0, line, 8);
 			}
 
-			break;
+			continue;
 		}
 		else
 		{
@@ -436,15 +483,15 @@ void UI_DisplayMain(void)
 			{	// it's a channel
 
 				// show the scan list assigment symbols
-				const uint8_t attributes = gMR_ChannelAttributes[gEeprom.ScreenChannel[vfo_num]];
+				const ChannelAttributes_t att = gMR_ChannelAttributes[gEeprom.ScreenChannel[vfo_num]];
-				if (attributes & MR_CH_SCANLIST1)
+				if (att.scanlist1)
 					memmove(p_line0 + 113, BITMAP_ScanList1, sizeof(BITMAP_ScanList1));
-				if (attributes & MR_CH_SCANLIST2)
+				if (att.scanlist2)
 					memmove(p_line0 + 120, BITMAP_ScanList2, sizeof(BITMAP_ScanList2));
 
 				// compander symbol
 #ifndef ENABLE_BIG_FREQ
-				if ((attributes & MR_CH_COMPAND) > 0)
+				if (att.compander)
 					memmove(p_line0 + 120 + LCD_WIDTH, BITMAP_compand, sizeof(BITMAP_compand));
 #else
 				// TODO:  // find somewhere else to put the symbol
@@ -522,8 +569,8 @@ void UI_DisplayMain(void)
 				}
 
 				// show the channel symbols
-				const uint8_t attributes = gMR_ChannelAttributes[gEeprom.ScreenChannel[vfo_num]];
+				const ChannelAttributes_t att = gMR_ChannelAttributes[gEeprom.ScreenChannel[vfo_num]];
-				if ((attributes & MR_CH_COMPAND) > 0)
+				if (att.compander)
 #ifdef ENABLE_BIG_FREQ
 					memmove(p_line0 + 120, BITMAP_compand, sizeof(BITMAP_compand));
 #else
@@ -613,9 +660,11 @@ void UI_DisplayMain(void)
 			UI_PrintStringSmall(String, LCD_WIDTH + 70, 0, line + 1);
 		}
 
+#ifdef ENABLE_DTMF_CALLING
 		// show the DTMF decoding symbol
 		if (gEeprom.VfoInfo[vfo_num].DTMF_DECODING_ENABLE || gSetting_KILLED)
 			UI_PrintStringSmall("DTMF", LCD_WIDTH + 78, 0, line + 1);
+#endif
 
 		// show the audio scramble symbol
 		if (gEeprom.VfoInfo[vfo_num].SCRAMBLING_TYPE > 0 && gSetting_ScrambleEnable)
@@ -640,8 +689,11 @@ void UI_DisplayMain(void)
 #if defined(ENABLE_AM_FIX) && defined(ENABLE_AM_FIX_SHOW_DATA)
 		if (rx && gEeprom.VfoInfo[gEeprom.RX_VFO].Modulation == MODULATION_AM && gSetting_AM_fix)
 		{
-			if (gScreenToDisplay != DISPLAY_MAIN ||
+			if (gScreenToDisplay != DISPLAY_MAIN 
-				gDTMF_CallState != DTMF_CALL_STATE_NONE)
+#ifdef ENABLE_DTMF_CALLING
+				|| gDTMF_CallState != DTMF_CALL_STATE_NONE
+#endif
+				)
 				return;
 
 			center_line = CENTER_LINE_AM_FIX_DATA;
@@ -666,8 +718,11 @@ void UI_DisplayMain(void)
 					const unsigned int len = strlen(gDTMF_RX_live);
 					const unsigned int idx = (len > (17 - 5)) ? len - (17 - 5) : 0;  // limit to last 'n' chars
 
-					if (gScreenToDisplay != DISPLAY_MAIN ||
+					if (gScreenToDisplay != DISPLAY_MAIN
-						gDTMF_CallState != DTMF_CALL_STATE_NONE)
+#ifdef ENABLE_DTMF_CALLING
+						|| gDTMF_CallState != DTMF_CALL_STATE_NONE
+#endif
+						)
 						return;
 						
 					center_line = CENTER_LINE_DTMF_DEC;
@@ -697,8 +752,11 @@ void UI_DisplayMain(void)
 #ifdef ENABLE_SHOW_CHARGE_LEVEL
 			else if (gChargingWithTypeC)
 			{	// charging .. show the battery state
-				if (gScreenToDisplay != DISPLAY_MAIN ||
+				if (gScreenToDisplay != DISPLAY_MAIN
-					gDTMF_CallState != DTMF_CALL_STATE_NONE)
+#ifdef ENABLE_DTMF_CALLING
+					|| gDTMF_CallState != DTMF_CALL_STATE_NONE
+#endif
+					)
 					return;
 						
 				center_line = CENTER_LINE_CHARGE_DATA;

ui/menu.c

@@ -97,16 +97,22 @@ const t_menu_item MenuList[] =
 #ifdef ENABLE_ALARM
 	{"AlarmT", VOICE_ID_INVALID,                       MENU_AL_MOD        },
 #endif
+#ifdef ENABLE_DTMF_CALLING
 	{"ANI ID", VOICE_ID_ANI_CODE,                      MENU_ANI_ID        },
+#endif
 	{"UPCode", VOICE_ID_INVALID,                       MENU_UPCODE        },
 	{"DWCode", VOICE_ID_INVALID,                       MENU_DWCODE        },
 	{"PTT ID", VOICE_ID_INVALID,                       MENU_PTT_ID        },
 	{"D ST",   VOICE_ID_INVALID,                       MENU_D_ST          },
+#ifdef ENABLE_DTMF_CALLING
     {"D Resp", VOICE_ID_INVALID,                       MENU_D_RSP         },
 	{"D Hold", VOICE_ID_INVALID,                       MENU_D_HOLD        },
+#endif
 	{"D Prel", VOICE_ID_INVALID,                       MENU_D_PRE         },
+#ifdef ENABLE_DTMF_CALLING
 	{"D Decd", VOICE_ID_INVALID,                       MENU_D_DCD         },
 	{"D List", VOICE_ID_INVALID,                       MENU_D_LIST        },
+#endif
 	{"D Live", VOICE_ID_INVALID,                       MENU_D_LIVE_DEC    }, // live DTMF decoder
 #ifdef ENABLE_AM_FIX
 	{"AM Fix", VOICE_ID_INVALID,                       MENU_AM_FIX        },
@@ -129,7 +135,6 @@ const t_menu_item MenuList[] =
 	{"Tx 500", VOICE_ID_INVALID,                       MENU_500TX         }, // was "500TX"
 	{"350 En", VOICE_ID_INVALID,                       MENU_350EN         }, // was "350EN"
 	{"ScraEn", VOICE_ID_INVALID,                       MENU_SCREN         }, // was "SCREN"
-	{"TxEnab", VOICE_ID_INVALID,                       MENU_TX_EN         }, // enable TX
 #ifdef ENABLE_F_CAL_MENU
 	{"FrCali", VOICE_ID_INVALID,                       MENU_F_CALI        }, // reference xtal calibration
 #endif
@@ -142,33 +147,33 @@ const t_menu_item MenuList[] =
 
 const uint8_t FIRST_HIDDEN_MENU_ITEM = MENU_F_LOCK;
 
-const char gSubMenu_TXP[3][5] =
+const char gSubMenu_TXP[][5] =
 {
 	"LOW",
 	"MID",
 	"HIGH"
 };
 
-const char gSubMenu_SFT_D[3][4] =
+const char gSubMenu_SFT_D[][4] =
 {
 	"OFF",
 	"+",
 	"-"
 };
 
-const char gSubMenu_W_N[2][7] =
+const char gSubMenu_W_N[][7] =
 {
 	"WIDE",
 	"NARROW"
 };
 
-const char gSubMenu_OFF_ON[2][4] =
+const char gSubMenu_OFF_ON[][4] =
 {
 	"OFF",
 	"ON"
 };
 
-const char gSubMenu_SAVE[5][4] =
+const char gSubMenu_SAVE[][4] =
 {
 	"OFF",
 	"1:1",
@@ -177,7 +182,7 @@ const char gSubMenu_SAVE[5][4] =
 	"1:4"
 };
 
-const char gSubMenu_TOT[11][7] =
+const char gSubMenu_TOT[][7] =
 {
 	"30 sec",
 	"1 min",
@@ -192,7 +197,7 @@ const char gSubMenu_TOT[11][7] =
 	"15 min"
 };
 
-const char* gSubMenu_RXMode[4] =
+const char* gSubMenu_RXMode[] =
 {
 	"MAIN\nONLY", 		// TX and RX on main only
 	"DUAL RX\nRESPOND", // Watch both and respond
@@ -201,7 +206,7 @@ const char* gSubMenu_RXMode[4] =
 };
 
 #ifdef ENABLE_VOICE
-	const char gSubMenu_VOICE[3][4] =
+	const char gSubMenu_VOICE[][4] =
 	{
 		"OFF",
 		"CHI",
@@ -209,14 +214,14 @@ const char* gSubMenu_RXMode[4] =
 	};
 #endif
 
-const char gSubMenu_SC_REV[3][8] =
+const char gSubMenu_SC_REV[][8] =
 {
 	"TIMEOUT",
 	"CARRIER",
 	"STOP"
 };
 
-const char* gSubMenu_MDF[4] =
+const char* gSubMenu_MDF[] =
 {
 	"FREQ",
 	"CHANNEL\nNUMBER",
@@ -225,31 +230,33 @@ const char* gSubMenu_MDF[4] =
 };
 
 #ifdef ENABLE_ALARM
-	const char gSubMenu_AL_MOD[2][5] =
+	const char gSubMenu_AL_MOD[][5] =
 	{
 		"SITE",
 		"TONE"
 	};
 #endif
 
-const char gSubMenu_D_RSP[4][11] =
+#ifdef ENABLE_DTMF_CALLING
+const char gSubMenu_D_RSP[][11] =
 {
 	"DO\nNOTHING",
 	"RING",
 	"REPLY",
 	"BOTH"
 };
+#endif
 
-const char* gSubMenu_PTT_ID[5] =
+const char* gSubMenu_PTT_ID[] =
 {
 	"OFF",
-	"KEY\nUP",
+	"UP CODE",
-	"KEY\nDOWN",
+	"DOWN CODE",
-	"KEY\nUP+DOWN",
+	"UP+DOWN\nCODE",
 	"APOLLO\nQUINDAR"
 };
 
-const char gSubMenu_PONMSG[4][8] =
+const char gSubMenu_PONMSG[][8] =
 {
 	"FULL",
 	"MESSAGE",
@@ -257,30 +264,32 @@ const char gSubMenu_PONMSG[4][8] =
 	"NONE"
 };
 
-const char* gSubMenu_ROGER[3] =
+const char gSubMenu_ROGER[][6] =
 {
 	"OFF",
 	"ROGER",
-	"MDC\n1200"
+	"MDC"
 };
 
-const char gSubMenu_RESET[2][4] =
+const char gSubMenu_RESET[][4] =
 {
 	"VFO",
 	"ALL"
 };
 
-const char gSubMenu_F_LOCK[6][4] =
+const char * gSubMenu_F_LOCK[] =
 {
-	"OFF",
+	"DEFAULT+\n137-174\n400-470",
-	"FCC",
+	"FCC HAM\n144-148\n420-450",
-	"CE",
+	"CE HAM\n144-146\n430-440",
-	"GB",
+	"GB HAM\n144-148\n430-440",
-	"430",
+	"137-174\n400-430",
-	"438"
+	"137-174\n400-438",
+	"DISABLE\nALL",
+	"UNLOCK\nALL",
 };
 
-const char gSubMenu_BACKLIGHT[8][7] =
+const char gSubMenu_BACKLIGHT[][7] =
 {
 	"OFF",
 	"5 sec",
@@ -292,7 +301,7 @@ const char gSubMenu_BACKLIGHT[8][7] =
 	"ON"
 };
 
-const char gSubMenu_RX_TX[4][6] =
+const char gSubMenu_RX_TX[][6] =
 {
 	"OFF",
 	"TX",
@@ -301,7 +310,7 @@ const char gSubMenu_RX_TX[4][6] =
 };
 
 #ifdef ENABLE_AM_FIX_TEST1
-	const char gSubMenu_AM_fix_test1[4][8] =
+	const char gSubMenu_AM_fix_test1[][8] =
 	{
 		"LNA-S 0",
 		"LNA-S 1",
@@ -310,20 +319,20 @@ const char gSubMenu_RX_TX[4][6] =
 	};
 #endif
 
-const char gSubMenu_BAT_TXT[3][8] =
+const char gSubMenu_BAT_TXT[][8] =
 {
 	"NONE",
 	"VOLTAGE",
 	"PERCENT"
 };
 
-const char gSubMenu_BATTYP[2][9] =
+const char gSubMenu_BATTYP[][9] =
 {
 	"1600mAh",
 	"2200mAh"
 };
 
-const char gSubMenu_SCRAMBLER[11][7] =
+const char gSubMenu_SCRAMBLER[][7] =
 {
 	"OFF",
 	"2600Hz",
@@ -361,19 +370,30 @@ const t_sidefunction SIDEFUNCTIONS[] =
 	{"SWITCH\nVFO",		ACTION_OPT_A_B},
 	{"VFO/MR",			ACTION_OPT_VFO_MR},
 	{"SWITCH\nDEMODUL",	ACTION_OPT_SWITCH_DEMODUL},
+#ifdef ENABLE_BLMIN_TMP_OFF
+	{"BLMIN\nTMP OFF",  ACTION_OPT_BLMIN_TMP_OFF}, 		//BackLight Minimum Temporay OFF
+#endif
 };
 const t_sidefunction* gSubMenu_SIDEFUNCTIONS = SIDEFUNCTIONS;
 const uint8_t gSubMenu_SIDEFUNCTIONS_size = ARRAY_SIZE(SIDEFUNCTIONS);
 
 bool    gIsInSubMenu;
 uint8_t gMenuCursor;
-int GetCurrentMenuId() {
+int UI_MENU_GetCurrentMenuId() {
 	if(gMenuCursor < ARRAY_SIZE(MenuList))
 		return MenuList[gMenuCursor].menu_id;
 	else
 		return MenuList[ARRAY_SIZE(MenuList)-1].menu_id;
 }
-int8_t  gMenuScrollDirection;
+
+uint8_t UI_MENU_GetMenuIdx(uint8_t id)
+{
+	for(uint8_t i = 0; i < ARRAY_SIZE(MenuList); i++)
+		if(MenuList[i].menu_id == id)
+			return i;
+	return 0;
+}
+
 int32_t gSubMenuSelection;
 
 // edit box
@@ -388,7 +408,10 @@ void UI_DisplayMenu(void)
 	const unsigned int menu_item_x2    = LCD_WIDTH - 1;
 	unsigned int       i;
 	char               String[64];  // bigger cuz we can now do multi-line in one string (use '\n' char)
+
+#ifdef ENABLE_DTMF_CALLING
 	char               Contact[16];
+#endif
 
 	// clear the screen buffer
 	memset(gFrameBuffer, 0, sizeof(gFrameBuffer));
@@ -476,7 +499,7 @@ void UI_DisplayMenu(void)
 
 	bool already_printed = false;
 
-	switch (GetCurrentMenuId())
+	switch (UI_MENU_GetCurrentMenuId())
 	{
 		case MENU_SQL:
 			sprintf(String, "%d", gSubMenuSelection);
@@ -613,7 +636,9 @@ void UI_DisplayMenu(void)
 		case MENU_S_ADD2:
 		case MENU_STE:
 		case MENU_D_ST:
+#ifdef ENABLE_DTMF_CALLING
 		case MENU_D_DCD:
+#endif
 		case MENU_D_LIVE_DEC:
 		#ifdef ENABLE_NOAA
 			case MENU_NOAA_S:
@@ -623,7 +648,6 @@ void UI_DisplayMenu(void)
 		case MENU_500TX:
 		case MENU_350EN:
 		case MENU_SCREN:
-		case MENU_TX_EN:
 			strcpy(String, gSubMenu_OFF_ON[gSubMenuSelection]);
 			break;
 
@@ -732,10 +756,11 @@ void UI_DisplayMenu(void)
 				break;
 		#endif
 
+#ifdef ENABLE_DTMF_CALLING
 		case MENU_ANI_ID:
 			strcpy(String, gEeprom.ANI_DTMF_ID);
 			break;
-
+#endif
 		case MENU_UPCODE:
 			strcpy(String, gEeprom.DTMF_UP_CODE);
 			break;
@@ -744,6 +769,7 @@ void UI_DisplayMenu(void)
 			strcpy(String, gEeprom.DTMF_DOWN_CODE);
 			break;
 
+#ifdef ENABLE_DTMF_CALLING
 		case MENU_D_RSP:
 			strcpy(String, gSubMenu_D_RSP[gSubMenuSelection]);
 			break;
@@ -751,7 +777,7 @@ void UI_DisplayMenu(void)
 		case MENU_D_HOLD:
 			sprintf(String, "%ds", gSubMenuSelection);
 			break;
-
+#endif
 		case MENU_D_PRE:
 			sprintf(String, "%d*10ms", gSubMenuSelection);
 			break;
@@ -764,6 +790,7 @@ void UI_DisplayMenu(void)
 			strcpy(String, gSubMenu_BAT_TXT[gSubMenuSelection]);
 			break;
 
+#ifdef ENABLE_DTMF_CALLING
 		case MENU_D_LIST:
 			gIsDtmfContactValid = DTMF_GetContact((int)gSubMenuSelection - 1, Contact);
 			if (!gIsDtmfContactValid)
@@ -771,6 +798,7 @@ void UI_DisplayMenu(void)
 			else
 				memmove(String, Contact, 8);
 			break;
+#endif
 
 		case MENU_PONMSG:
 			strcpy(String, gSubMenu_PONMSG[gSubMenuSelection]);
@@ -791,7 +819,10 @@ void UI_DisplayMenu(void)
 			break;
 
 		case MENU_F_LOCK:
-			strcpy(String, gSubMenu_F_LOCK[gSubMenuSelection]);
+			if(!gIsInSubMenu && gUnlockAllTxConfCnt>0 && gUnlockAllTxConfCnt<10)
+				strcpy(String, "READ\nMANUAL");
+			else
+				strcpy(String, gSubMenu_F_LOCK[gSubMenuSelection]);
 			break;
 
 		#ifdef ENABLE_F_CAL_MENU
@@ -884,9 +915,9 @@ void UI_DisplayMenu(void)
 		}
 	}
 
-	if (GetCurrentMenuId() == MENU_SLIST1 || GetCurrentMenuId() == MENU_SLIST2)
+	if (UI_MENU_GetCurrentMenuId() == MENU_SLIST1 || UI_MENU_GetCurrentMenuId() == MENU_SLIST2)
 	{
-		i = (GetCurrentMenuId() == MENU_SLIST1) ? 0 : 1;
+		i = (UI_MENU_GetCurrentMenuId() == MENU_SLIST1) ? 0 : 1;
 
 //		if (gSubMenuSelection == 0xFF)
 		if (gSubMenuSelection < 0)
@@ -931,9 +962,9 @@ void UI_DisplayMenu(void)
 		}
 	}
 
-	if (GetCurrentMenuId() == MENU_MEM_CH   ||
+	if (UI_MENU_GetCurrentMenuId() == MENU_MEM_CH   ||
-	    GetCurrentMenuId() == MENU_DEL_CH   ||
+	    UI_MENU_GetCurrentMenuId() == MENU_DEL_CH   ||
-	    GetCurrentMenuId() == MENU_1_CALL)
+	    UI_MENU_GetCurrentMenuId() == MENU_1_CALL)
 	{	// display the channel name
 		char s[11];
 		BOARD_fetchChannelName(s, gSubMenuSelection);
@@ -942,39 +973,46 @@ void UI_DisplayMenu(void)
 		UI_PrintString(s, menu_item_x1, menu_item_x2, 2, 8);
 	}
 
-	if ((GetCurrentMenuId() == MENU_R_CTCS || GetCurrentMenuId() == MENU_R_DCS) && gCssScanMode != CSS_SCAN_MODE_OFF)
+	if ((UI_MENU_GetCurrentMenuId() == MENU_R_CTCS || UI_MENU_GetCurrentMenuId() == MENU_R_DCS) && gCssBackgroundScan)
 		UI_PrintString("SCAN", menu_item_x1, menu_item_x2, 4, 8);
 		
-	if (GetCurrentMenuId() == MENU_UPCODE)
+
+	if (UI_MENU_GetCurrentMenuId() == MENU_UPCODE)
 		if (strlen(gEeprom.DTMF_UP_CODE) > 8)
 			UI_PrintString(gEeprom.DTMF_UP_CODE + 8, menu_item_x1, menu_item_x2, 4, 8);
 
-	if (GetCurrentMenuId() == MENU_DWCODE)
+	if (UI_MENU_GetCurrentMenuId() == MENU_DWCODE)
 		if (strlen(gEeprom.DTMF_DOWN_CODE) > 8)
 			UI_PrintString(gEeprom.DTMF_DOWN_CODE + 8, menu_item_x1, menu_item_x2, 4, 8);
 
-	if (GetCurrentMenuId() == MENU_D_LIST && gIsDtmfContactValid)
+#ifdef ENABLE_DTMF_CALLING
+	if (UI_MENU_GetCurrentMenuId() == MENU_D_LIST && gIsDtmfContactValid)
 	{
 		Contact[11] = 0;
 		memmove(&gDTMF_ID, Contact + 8, 4);
 		sprintf(String, "ID:%s", Contact + 8);
 		UI_PrintString(String, menu_item_x1, menu_item_x2, 4, 8);
 	}
+#endif
+
+	if (UI_MENU_GetCurrentMenuId() == MENU_R_CTCS ||
+	    UI_MENU_GetCurrentMenuId() == MENU_T_CTCS ||
+	    UI_MENU_GetCurrentMenuId() == MENU_R_DCS  ||
+	    UI_MENU_GetCurrentMenuId() == MENU_T_DCS
+#ifdef ENABLE_DTMF_CALLING
+	    || UI_MENU_GetCurrentMenuId() == MENU_D_LIST
+#endif		
+		)
 
-	if (GetCurrentMenuId() == MENU_R_CTCS ||
-	    GetCurrentMenuId() == MENU_T_CTCS ||
-	    GetCurrentMenuId() == MENU_R_DCS  ||
-	    GetCurrentMenuId() == MENU_T_DCS  ||
-	    GetCurrentMenuId() == MENU_D_LIST)
 	{
 		sprintf(String, "%2d", gSubMenuSelection);
 		UI_PrintStringSmall(String, 105, 0, 0);
 	}
 
-	if ((GetCurrentMenuId() == MENU_RESET    ||
+	if ((UI_MENU_GetCurrentMenuId() == MENU_RESET    ||
-	     GetCurrentMenuId() == MENU_MEM_CH   ||
+	     UI_MENU_GetCurrentMenuId() == MENU_MEM_CH   ||
-	     GetCurrentMenuId() == MENU_MEM_NAME ||
+	     UI_MENU_GetCurrentMenuId() == MENU_MEM_NAME ||
-	     GetCurrentMenuId() == MENU_DEL_CH) && gAskForConfirmation)
+	     UI_MENU_GetCurrentMenuId() == MENU_DEL_CH) && gAskForConfirmation)
 	{	// display confirmation
 		strcpy(String, (gAskForConfirmation == 1) ? "SURE?" : "WAIT!");
 		UI_PrintString(String, menu_item_x1, menu_item_x2, 5, 8);

ui/menu.h

@@ -21,6 +21,7 @@
 #include <stdint.h>
 
 #include "audio.h"     // VOICE_ID_t
+#include "settings.h"
 
 typedef struct {
 	const char  name[7];    // menu display area only has room for 6 characters
@@ -78,16 +79,22 @@ enum
 #ifdef ENABLE_ALARM
 	MENU_AL_MOD,
 #endif
+#ifdef ENABLE_DTMF_CALLING
 	MENU_ANI_ID,
+#endif
 	MENU_UPCODE,
 	MENU_DWCODE,
 	MENU_PTT_ID,
 	MENU_D_ST,
+#ifdef ENABLE_DTMF_CALLING
 	MENU_D_RSP,
 	MENU_D_HOLD,
+#endif
 	MENU_D_PRE,
+#ifdef ENABLE_DTMF_CALLING	
 	MENU_D_DCD,
 	MENU_D_LIST,
+#endif
 	MENU_D_LIVE_DEC,
 	MENU_PONMSG,
 	MENU_ROGER,
@@ -110,8 +117,6 @@ enum
 	MENU_500TX,
 	MENU_350EN,
 	MENU_SCREN,
-
-	MENU_TX_EN,   // enable TX
 #ifdef ENABLE_F_CAL_MENU
 	MENU_F_CALI,  // reference xtal calibration
 #endif
@@ -143,12 +148,14 @@ extern const char*       gSubMenu_MDF[4];
 #ifdef ENABLE_ALARM
 	extern const char    gSubMenu_AL_MOD[2][5];
 #endif
+#ifdef ENABLE_DTMF_CALLING
 extern const char        gSubMenu_D_RSP[4][11];
+#endif
 extern const char*       gSubMenu_PTT_ID[5];
 extern const char        gSubMenu_PONMSG[4][8];
-extern const char*       gSubMenu_ROGER[3];
+extern const char        gSubMenu_ROGER[3][6];
 extern const char        gSubMenu_RESET[2][4];
-extern const char        gSubMenu_F_LOCK[6][4];
+extern const char*       gSubMenu_F_LOCK[F_LOCK_LEN];
 extern const char        gSubMenu_BACKLIGHT[8][7];
 extern const char        gSubMenu_RX_TX[4][6];
 #ifdef ENABLE_AM_FIX_TEST1
@@ -165,8 +172,7 @@ extern const t_sidefunction* gSubMenu_SIDEFUNCTIONS;
 extern bool              gIsInSubMenu;
 				         
 extern uint8_t           gMenuCursor;
-int GetCurrentMenuId();
+
-extern int8_t            gMenuScrollDirection;
 extern int32_t           gSubMenuSelection;
 				         
 extern char              edit_original[17];
@@ -174,5 +180,7 @@ extern char              edit[17];
 extern int               edit_index;
 
 void UI_DisplayMenu(void);
+int UI_MENU_GetCurrentMenuId();
+uint8_t UI_MENU_GetMenuIdx(uint8_t id);
 
 #endif

ui/scanner.c

@@ -50,7 +50,7 @@ void UI_DisplayScanner(void)
 	UI_PrintString(String, 2, 0, 3, 8);
 
 	memset(String, 0, sizeof(String));
-	if (gScannerEditState == 2)
+	if (gScannerSaveState == SCAN_SAVE_CHANNEL)
 	{
 		strcpy(String, "SAVE?");
 
@@ -59,19 +59,15 @@ void UI_DisplayScanner(void)
 	}
 	else
 	{
-		if (gScannerEditState == 1)
+		if (gScannerSaveState == SCAN_SAVE_CHAN_SEL) {
-		{
 			strcpy(String, "SAVE:");
 			UI_GenerateChannelStringEx(String + 5, gShowChPrefix, gScanChannel);
 		}
-		else
+		else if (gScanCssState < SCAN_CSS_STATE_FOUND) {
-		if (gScanCssState < SCAN_CSS_STATE_FOUND)
-		{
 			strcpy(String, "SCAN");
 			memset(String + 4, '.', (gScanProgressIndicator & 7) + 1);
 		}
-		else
+		else if (gScanCssState == SCAN_CSS_STATE_FOUND)
-		if (gScanCssState == SCAN_CSS_STATE_FOUND)
 			strcpy(String, "SCAN CMP.");
 		else
 			strcpy(String, "SCAN FAIL.");

ui/status.c

@@ -16,10 +16,11 @@
 
 #include <string.h>
 
-#include "app/scanner.h"
+#include "app/chFrScanner.h"
 #ifdef ENABLE_FMRADIO
 	#include "app/fm.h"
 #endif
+#include "app/scanner.h"
 #include "bitmaps.h"
 #include "driver/keyboard.h"
 #include "driver/st7565.h"
@@ -79,17 +80,20 @@ void UI_DisplayStatus()
 		// hmmm, what to put in it's place
 	#endif
 
+#ifdef ENABLE_DTMF_CALLING
 	if (gSetting_KILLED)
 	{
 		memset(line + x, 0xFF, 10);
 		x1 = x + 10;
 	}
 	else 
+#endif
+	{
 		// SCAN indicator
-		if (gScanStateDir != SCAN_OFF || gScreenToDisplay == DISPLAY_SCANNER)
+		if (gScanStateDir != SCAN_OFF || SCANNER_IsScanning())
 		{
 			char * s = "";
-			if (IS_MR_CHANNEL(gNextMrChannel) && gScreenToDisplay != DISPLAY_SCANNER)
+			if (IS_MR_CHANNEL(gNextMrChannel) && !SCANNER_IsScanning())
 			{	// channel mode
 				switch(gEeprom.SCAN_LIST_DEFAULT) {
 					case 0: s = "1"; break;
@@ -104,6 +108,7 @@ void UI_DisplayStatus()
 			UI_PrintStringSmallBuffer(s, line + x);
 			x1 = x + 7;
 		}
+	}
 	x += 7;  // font character width
 
 	#ifdef ENABLE_VOICE
@@ -119,7 +124,7 @@ void UI_DisplayStatus()
 	#endif
 
 	x++;
-	if(gScreenToDisplay != DISPLAY_SCANNER) {
+	if(!SCANNER_IsScanning()) {
 		uint8_t dw = (gEeprom.DUAL_WATCH != DUAL_WATCH_OFF) + (gEeprom.CROSS_BAND_RX_TX != CROSS_BAND_OFF) * 2;
 		if(dw == 1 || dw == 3) { // DWR - dual watch + respond
 			if(gDualWatchActive) 

ui/ui.c

@@ -16,11 +16,11 @@
 
 #include <string.h>
 
+#include "app/chFrScanner.h"
 #include "app/dtmf.h"
 #ifdef ENABLE_FMRADIO
 	#include "app/fm.h"
 #endif
-#include "app/scanner.h"
 #include "driver/keyboard.h"
 #include "misc.h"
 #ifdef ENABLE_AIRCOPY
@@ -86,7 +86,7 @@ void GUI_SelectNextDisplay(GUI_DisplayType_t Display)
 
 		gInputBoxIndex       = 0;
 		gIsInSubMenu         = false;
-		gCssScanMode         = CSS_SCAN_MODE_OFF;
+		gCssBackgroundScan         = false;
 		gScanStateDir        = SCAN_OFF;
 		#ifdef ENABLE_FMRADIO
 			gFM_ScanState    = FM_SCAN_OFF;

ui/welcome.c

@@ -77,7 +77,7 @@ void UI_DisplayWelcome(void)
 
 		UI_PrintString(WelcomeString0, 0, 127, 0, 10);
 		UI_PrintString(WelcomeString1, 0, 127, 2, 10);
-		UI_PrintStringSmall(Version, 0, 0, 6);
+		UI_PrintStringSmall(Version, 0, 128, 6);
 
 		ST7565_BlitStatusLine();  // blank status line
 		ST7565_BlitFullScreen();

version.c

@@ -1,16 +1,11 @@
 
-#define ONE_OF_ELEVEN_VER
+#ifdef VERSION_STRING
-
+	#define VER     " "VERSION_STRING
-#ifdef GIT_HASH
-	#define VER     GIT_HASH
 #else
-	#define VER     "231004"
+	#define VER     ""
 #endif
 
-#ifndef ONE_OF_ELEVEN_VER
+
-	const char Version[]      = "OEFW-"VER;
+const char Version[]      = AUTHOR_STRING VER;
-	const char UART_Version[] = "UV-K5 Firmware, Open Edition, OEFW-"VER"\r\n";
+const char UART_Version[] = "UV-K5 Firmware, Open Edition, " AUTHOR_STRING VER "\r\n";
-#else
+
-	const char Version[]      = "1o11+fagci-"VER;
-	const char UART_Version[] = "UV-K5 Firmware, Open Edition, 1o11+fagci-"VER"\r\n";
-#endif