Attempted incorporation of W0EB interrupt-based keying code from Raduino I2C clone. Kept locking up during the setFrequency() and/or SetCarrierFreq() calls that occurred within startTx() when called from the ISR. Don't have time to work through understanding how to integrated the KD8CEC complex spaghetti codebase with the otherwise relatively straightforward ISR. So I think I will revert to the non-ISR version.

changed version number for nextion lcd protocol

README.md

@@ -1,31 +1,21 @@
-#IMPORTANT INFORMATION
+#KC4UPR'S NOTE
 ----------------------------------------------------------------------------
-- Beta 0.26 and Beta 0.261, Beta 0.262, Beta 0.27 is complete test
-- You can download and use it.
+This is a fork of the KD8CEC firmware that will be specific to my uBITX V5
+installation.  My intent is to remove unnecessary code, as well as make some
+GPIO changes based on my use of the Nextion LCD.  Specifically, I'd like to 
+eliminate the use of analog I/O for reading the CW keys, and possibly enable
+control of accessories such as filters using the extra GPIO pins that are
+now available.
 
 #NOTICE
 ----------------------------------------------------------------------------
-I received uBITX a month ago and found that many features are required, and began coding with the idea of implementing minimal functionality as a general hf transceiver rather than an experimental device.
-
-- fixed bugs...
-- Diallock for uBITX's sensitive encoders
-- built in softare Memory keyer and cw options control for CW communication
-- Implementation of CAT communication protocol for Digital Communication (as FT8, JT65, etc)
-- Delay Options for external Linear.
-- and more...
-
-Most of the basic functions of the HF transceiver I thought were implemented.
-The minimum basic specification for uBITX to operate as a radio, I think it is finished.
-So I will release the 0.27 version and if I do not see the bug anymore, I will try to change the version name to 1.0.
-Now uBITX is an HF radio and will be able to join you in your happy hams life.
-Based on this source, you can use it by adding functions.
-
-I am going to do a new project based on this source, linking with WSPR, WSJT-X and so on.
-Of course, this repository is still running. If you have any bugs or ideas, please feel free to email me.
+- Now Release Version 1.20 on my blog (http://www.hamskey.com)
+- You can download and compiled hex file and uBITX Manager application on release section (https://github.com/phdlee/ubitx/releases)
+- For more information, see my blog (http://www.hamskey.com)
 
 http://www.hamskey.com
 
-DE KD8CEC
+Ian KD8CEC
 kd8cec@gmail.com
 
 #uBITX
@@ -36,16 +26,143 @@ The copyright information of the original is below.
 KD8CEC
 ----------------------------------------------------------------------------
 Prepared or finished tasks for the next version
-  - Most of them are implemented and included in version 0.27.
-  - User Interface on LCD -> Option by user (not need)
-  - Include WSPR Beacone function - (implement other new repository)
-    complete experiment
-    need solve : Big code size (over 100%, then remove some functions for experment)
-                 need replace Si5351 Library (increase risk and need more beta tester)
-                 W3PM sent me his wonderful source - using BITX, GPS 
+  - Add TTS module
+  - Direct control for Student
   
 ----------------------------------------------------------------------------
 ## REVISION RECORD
+1.20
+ - Support uBITX V5
+ - Change to SDR Frequency (Remove just RTL-SDR's error Frequency (2390Hz))
+1.12
+ - Support Custom LPF Control
+ - Other Minor Bugs
+1.1
+ - Support Nextion LCD, TJC LCD
+ - Read & Backup uBITX, ADC Monitoring, ATT, IF-Shift and more on Nextion LCD (TJC LCD)
+ - Factory Reset (Both Character LCD and Nextion LCD are applicable)
+ - Support Signal Meter using ADC (A7 Port)
+ - Supoort I2C Signal Meter
+ - Spectrum
+ - Band Scan
+ - Memory Control on Nextion LCD (TJC LCD)
+ - Speed Change CW-Option on Nextion LCD
+ - Fixed Band Change Bug (Both Character LCD and Nextion LCD are applicable)
+ - uBITX Manager removed the Encode and Decode buttons. The procedure has become a bit easier.
+ - I2C Device Scan on uBITX Manager ( Both Character LCD and Nextion LCD are applicable)
+ - Si5351 I2C Address can be changed
+ - Recovery using QR-Code Data from Server
+ - Nextion LCD and TJC LCD can display Spectrum and CW Decode (using Stand alone S-Meter)
+ - Other Minor Bugs
+ 
+1.09 (Beta)
+- include 1.094 beta, 1.095 beta, 1.097 beta
+
+1.08
+ - Receive performance is improved compared to the original firmware or version 1.061
+ - ATT function has been added to reduce RF gain (Shift 45Mhz IF)
+ - Added the ability to connect SDR. (Low cost RTL-SDR available)
+ - Added a protocol to ADC Monitoring in CAT communications
+ - Various LCD support, 16x02 Parallel LCD - It is the LCD equipped with uBITX, 16x02 I2C LCD, 20x04 Parallel LCD, 20x04 I2C LCD, 16x02 I2C Dual LCD
+ - Added Extended Switch Support
+ - Support S Meter
+ - Added S-Meter setting assistant to uBITX Manager
+ - Add recovery mode (such as Factory Reset)
+ - There have been many other improvements and fixes. More information is available on the blog. (http://www.hamskey.com)
+
+1.07 (Beta)
+ - include 1.071 beta, 1.073 beta, 1.075 beta
+ - Features implemented in the beta version have been applied to Version 1.08 above.
+
+1.061
+ - Added WSPR
+   You only need uBITX to use WSPR. No external devices are required.
+   Added Si5351 module for WSPR
+ - Update uBITX Manager to Version 1.0
+ - Reduce program size
+   for WSPR
+   for other Module
+ - Fixed IF Shift Bug
+   Disable IF Shift on TX
+   IF shift available in USB mode
+   Fixed cat routine in IF Shift setup
+- Bugs fixed
+   cw start delay option
+   Auto key Bug
+   (found bug : LZ1LDO)
+   Message selection when Auto Key is used in RIT mode
+   (found bug : gerald)
+- Improve CW Keying (start TX)
+
+1.05
+ - include 1.05W, 1.051, 1.051W
+ - for WSPR Beta Test Version
+
+1.04
+  - Optimized from Version1.03
+  - Reduce program size (97% -> 95%)
+  
+1.03
+  - Change eBFO Calibration Step (50 to 5)
+  - Change CW Frequency Display type
+  
+1.02
+  - Applied CW Start Delay to New CW Key logic (This is my mistake when applying the new CW Key Logic.Since uBITX operations are not significantly affected, this does not create a separate Release, It will be reflected in the next release.) - complete
+  - Modified CW Key Logic for Auto Key, (available AutoKey function by any cw keytype) - complete
+  - reduce cpu use usage (working)
+  - reduce (working)
+
+1.01
+  - Fixed Cat problem with (IAMBIC A or B Selected)
+1.0 
+  - rename 0.30 to 1.0
+  
+0.35
+  - vfo to channel bug fixed (not saved mode -> fixed, channel has frequency and mode)
+  - add Channel tag (ch.1 ~ 10) by uBITX Manager
+  - add VFO to Channel, Channel To VFO
+  
+0.34
+  - TX Status check in auto Keysend logic
+  - optimize codes
+  - change default tune step size, and fixed bug
+  - change IF shift step (1Hz -> 50Hz)
+  
+0.33
+  - Added CWL, CWU Mode, (dont complete test yet)
+  - fixed VFO changed bug.
+  - Added Additional BFO for CWL, CWL
+  - Added IF Shift
+  - Change confirmation key PTT -> function key (not critical menus)
+  - Change CW Key Select type, (toggle -> select by dial)
+  
+0.32
+  - Added function Scroll Frequencty on upper line
+  - Added Example code for Draw meter and remarked (you can see and use this code in source codes)
+  - Added Split function, just toggle VFOs when TX/RX
+
+0.31
+  - Fixed CW ADC Range error
+  - Display Message on Upper Line (anothor VFO Frequency, Tune Step, Selected Key Type)
+
+0.30
+ - implemented the function to monitor the value of all analog inputs. This allows you to monitor the status of the CW keys connected to your uBITX. 
+ - possible to set the ADC range for CW Keying. If no setting is made, it will have the same range as the original code. If you set the CW Keying ADC Values using uBITX Manager 0.3, you can reduce the key error.
+ - Added the function to select Straight Key, IAMBICA, IAMBICB key from the menu.
+ - default Band select is Ham Band mode, if you want common type, long press function key at band select menu, uBITX Manager can be used to modify frequencies to suit your country.
+
+0.29
+ - Remove the use of initialization values in BFO settings - using crruent value, if factory reset
+ - Select Tune Step, default 0, 20, 50, 100, 200, Use the uBITX Manager to set the steps value you want. You can select Step by pressing and holding the Function Key (1sec ~ 2sec).
+ - Modify Dial Lock Function, Press the Function key for more than 3 seconds to toggle dial lock.
+ - created a new frequency tune method. remove original source codes, Threshold has been applied to reduce malfunction. checked the continuity of the user operating to make natural tune possible.
+ - stabilize and remove many warning messages - by Pullrequest and merge
+ - Changed cw keying method. removed the original code and applied Ron's code and Improved compatibility with original hardware and CAT commnication. It can be used without modification of hardware.
+ 
+0.28
+ - Fixed CAT problem with hamlib on Linux
+ - restore Protocol autorecovery logic
+
 0.27 
    (First alpha test version, This will be renamed to the major version 1.0)
  - Dual VFO Dial Lock (vfoA Dial lock)

ubitx_20/cw_autokey.ino

@@ -31,6 +31,7 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 **************************************************************************/
+/*
 #include <avr/pgmspace.h>
 
 //27 + 10 + 18 + 1(SPACE) = //56 
@@ -398,3 +399,4 @@ void controlAutoCW(){
     }
 }
 
+*/

ubitx_20/softserial_tiny.cpp

@@ -70,7 +70,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 The latest version of this library can always be found at
 http://arduiniana.org.
  */
-#include <arduino.h>
+#include <Arduino.h>
 
 //================================================================
 //Public Variable

ubitx_20/ubitx.h

@@ -22,25 +22,34 @@
 //==============================================================================
 // Compile Option
 //==============================================================================
+//Ubitx Board Version
+#define UBITX_BOARD_VERSION 5           //v1 ~ v4 : 4, v5: 5
+
 //Depending on the type of LCD mounted on the uBITX, uncomment one of the options below.
 //You must select only one.
 //#define UBITX_DISPLAY_LCD1602P        //LCD mounted on unmodified uBITX (Parallel)
 //#define UBITX_DISPLAY_LCD1602I        //I2C type 16 x 02 LCD
 //#define UBITX_DISPLAY_LCD1602I_DUAL   //I2C type 16 x02 LCD Dual
 //#define UBITX_DISPLAY_LCD2004P        //24 x 04 LCD (Parallel)
-#define UBITX_DISPLAY_LCD2004I        //I2C type 24 x 04 LCD
-//#define UBITX_DISPLAY_NEXTION         //NEXTION LCD
+//#define UBITX_DISPLAY_LCD2004I        //I2C type 24 x 04 LCD
+#define UBITX_DISPLAY_NEXTION         //NEXTION LCD
 
 //#define UBITX_DISPLAY_NEXTION_SAFE      //Only EEProm Write 770~775
 #define I2C_LCD_MASTER_ADDRESS_DEFAULT  0x27     //0x27  //DEFAULT, if Set I2C Address by uBITX Manager, read from EEProm
 #define I2C_LCD_SECOND_ADDRESS_DEFAULT  0x3F     //0x27  //only using Dual LCD Mode
 
 //Select betwen Analog S-Meter and DSP (I2C) Meter
-#define USE_I2CSMETER
+//#define USE_I2CSMETER
 
-#define EXTEND_KEY_GROUP1               //MODE, BAND(-), BAND(+), STEP
+// Use alternate keyer?
+#define USE_ALTKEYER
+
+//#define EXTEND_KEY_GROUP1               //MODE, BAND(-), BAND(+), STEP
 //#define EXTEND_KEY_GROUP2             //Numeric (0~9), Point(.), Enter  //Not supported in Version 1.0x
 
+//Custom LPF Filter Mod
+//#define USE_CUSTOM_LPF_FILTER           //LPF FILTER MOD
+
 //#define ENABLE_FACTORYALIGN
 #define FACTORY_RECOVERY_BOOTUP         //Whether to enter Factory Recovery mode by pressing FKey and turning on power
 #define ENABLE_ADCMONITOR               //Starting with Version 1.07, you can read ADC values directly from uBITX Manager. So this function is not necessary.
@@ -213,6 +222,12 @@ extern byte I2C_LCD_SECOND_ADDRESS;     //only using Dual LCD Mode
 #define ANALOG_SPARE  (A7)
 #define ANALOG_SMETER (A7)  //by KD8CEC
 
+#ifdef USE_ALTKEYER
+  #define DIGITAL_DOT     (11) // can't remember if I need to swap still???
+  #define DIGITAL_DASH    (12)
+  #define DIGITAL_KEY     (A3)
+#endif
+
 /** 
  *  The second set of 16 pins on the Raduino's bottom connector are have the three clock outputs and the digital lines to control the rig.
  *  This assignment is as follows :
@@ -326,6 +341,22 @@ extern void DisplayVersionInfo(const char* fwVersionInfo);
 //I2C Signal Meter, Version 1.097
 extern int GetI2CSmeterValue(int valueType);  //ubitx_ui.ino
 
+#define DIT_L 0x01 // DIT latch
+#define DAH_L 0x02 // DAH latch
+#define DIT_PROC 0x04 // DIT is being processed
+#define PDLSWAP 0x08
+enum KSTYPE {IDLE, CHK_DIT, CHK_DAH, KEYED_PREP, KEYED, INTER_ELEMENT };
+
+#define IAMBICB 0x10 // 0 for Iambic A, 1 for Iambic B
+
+// For compatibility w/ W0EB code
+#define MODE_USB  0
+#define MODE_LSB  1
+#define MODE_CW   2
+#define MODE_CWR  3
+#define MODE_SWU  4
+#define MODE_SWL  5
+
+#define PTT_HNDKEY_DEBOUNCE_CT 2
+
 #endif    //end of if header define
-
-

ubitx_20/ubitx_20.ino

@@ -6,9 +6,11 @@
 //    So I put + in the sense that it was improved one by one based on Original Firmware.
 //    This firmware has been gradually changed based on the original firmware created by Farhan, Jack, Jerry and others.
 
-#define FIRMWARE_VERSION_INFO F("+v1.097")  
+#define FIRMWARE_VERSION_INFO F("+v1.200")  
 #define FIRMWARE_VERSION_NUM 0x04       //1st Complete Project : 1 (Version 1.061), 2st Project : 2, 1.08: 3, 1.09 : 4
 
+extern void Connect_Interrupts(void);
+
 /**
  Cat Suppoort uBITX CEC Version
  This firmware has been gradually changed based on the original firmware created by Farhan, Jack, Jerry and others.
@@ -72,10 +74,43 @@
 
 // the second oscillator should ideally be at 57 MHz, however, the crystal filter's center frequency 
 // is shifted down a little due to the loading from the impedance matching L-networks on either sides
-#define SECOND_OSC_USB (56995000l)
-#define SECOND_OSC_LSB (32995000l) 
-//these are the two default USB and LSB frequencies. The best frequencies depend upon your individual taste and filter shape
-#define INIT_USB_FREQ   (11996500l)
+
+#if UBITX_BOARD_VERSION == 5
+//For Test  //45005000
+  //#define SECOND_OSC_USB (56064200l)
+  //#define SECOND_OSC_LSB (33945800l) 
+
+/*
+  //For Test //4500000
+  #define SECOND_OSC_USB (56059200l)
+  #define SECOND_OSC_LSB (33940800l) 
+*/
+
+/*
+  //For Test // V1.121  44991500(LSB), 44998500 (USB), abs : 7k
+  #define SECOND_OSC_USB (56057700l)
+  #define SECOND_OSC_LSB (33932300l) 
+*/
+
+  //==============================================================================================================================
+  //For Test // V1.200 V1.122  45002500 (LSB), 45002000 (USB) (Change Default BFO Frequency 11056xxx, adjust bfo and ifshift ), abs: 0.5k
+  //Best, Test 3 uBITX V5
+  //Last Value, If more data is collected, it can be changed to a better value.
+  #define SECOND_OSC_USB (56058700l)
+  #define SECOND_OSC_LSB (33945800l) 
+
+  //Not used, Just comment (Default)
+  #define INIT_USB_FREQ   (11056500l)
+  //-----------------------------------------------------------------------------------------------------------------------------
+#else
+  #define SECOND_OSC_USB (56995000l)
+  #define SECOND_OSC_LSB (32995000l) 
+  //these are the two default USB and LSB frequencies. The best frequencies depend upon your individual taste and filter shape
+  //Not used, Just comment (Default)
+  #define INIT_USB_FREQ   (11996500l)
+#endif
+  
+
 // limits the tuning and working range of the ubitx between 3 MHz and 30 MHz
 #define LOWEST_FREQ  (3000000l)
 #define HIGHEST_FREQ (30000000l)
@@ -132,7 +167,6 @@ int cwAdcBothFrom = 0;
 int cwAdcBothTo = 0;
 byte cwKeyType = 0; //0: straight, 1 : iambica, 2: iambicb
 bool Iambic_Key = true;
-#define IAMBICB 0x10 // 0 for Iambic A, 1 for Iambic B
 unsigned char keyerControl = IAMBICB;
 
 byte isShiftDisplayCWFreq = 1;  //Display Frequency 
@@ -154,10 +188,10 @@ byte userCallsignLength = 0;    //7 : display callsign at system startup, 6~0 :
 /**
  * Raduino needs to keep track of current state of the transceiver. These are a few variables that do it
  */
-boolean txCAT = false;        //turned on if the transmitting due to a CAT command
-char inTx = 0;                //it is set to 1 if in transmit mode (whatever the reason : cw, ptt or cat)
+volatile boolean txCAT = false;        //turned on if the transmitting due to a CAT command
+bool inTx = false;                //it is set to 1 if in transmit mode (whatever the reason : cw, ptt or cat)
 char splitOn = 0;             //working split, uses VFO B as the transmit frequency
-char keyDown = 0;             //in cw mode, denotes the carrier is being transmitted
+//char keyDown = 0;             //in cw mode, denotes the carrier is being transmitted
 char isUSB = 0;               //upper sideband was selected, this is reset to the default for the 
 
 char cwMode = 0;              //compatible original source, and extend mode //if cwMode == 0, mode check : isUSB, cwMode > 0, mode Check : cwMode
@@ -196,6 +230,13 @@ int ifShiftValue = 0;   //
 
 byte TriggerBySW = 0;   //Action Start from Nextion LCD, Other MCU
 
+//Use Custom Filter
+//#define CUST_LPF_ENABLED 48
+//#define CUST_LPF_START   49
+char isCustomFilter = 0;
+char isCustomFilter_A7 = 0;
+char CustFilters[7][2];
+                              
 /**
  * Below are the basic functions that control the uBitx. Understanding the functions before 
  * you start hacking around
@@ -272,6 +313,7 @@ void saveBandFreqByIndex(unsigned long f, unsigned long mode, char bandIndex) {
   When the delay is used, the program will generate an error because it is not communicating, 
   so Create a new delay function that can do background processing.
  */
+ 
 unsigned long delayBeforeTime = 0;
 byte delay_background(unsigned delayTime, byte fromType){ //fromType : 4 autoCWKey -> Check Paddle
   delayBeforeTime = millis();
@@ -281,11 +323,11 @@ byte delay_background(unsigned delayTime, byte fromType){ //fromType : 4 autoCWK
     if (fromType == 4)
     {
       //CHECK PADDLE
-      if (getPaddle() != 0) //Interrupt : Stop cw Auto mode by Paddle -> Change Auto to Manual
-        return 1;
+//      if (getPaddle() != 0) //Interrupt : Stop cw Auto mode by Paddle -> Change Auto to Manual
+//        return 1;
         
       //Check PTT while auto Sending
-      autoSendPTTCheck();
+      //autoSendPTTCheck();
       
       Check_Cat(3);
     }
@@ -300,6 +342,7 @@ byte delay_background(unsigned delayTime, byte fromType){ //fromType : 4 autoCWK
 }
 
  
+
 /**
  * Select the properly tx harmonic filters
  * The four harmonic filters use only three relays
@@ -317,27 +360,74 @@ byte delay_background(unsigned delayTime, byte fromType){ //fromType : 4 autoCWK
  */
 
 void setTXFilters(unsigned long freq){
+#ifdef USE_CUSTOM_LPF_FILTER 
+  freq = freq / 1000000UL;
+  for (byte i = 0; i < 7; i++) {
+    if (freq >= CustFilters[i][0])
+    {
+      char aIn = CustFilters[i][1];
+      digitalWrite(TX_LPF_A, aIn & 0x01);
+      digitalWrite(TX_LPF_B, aIn & 0x02);
+      digitalWrite(TX_LPF_C, aIn & 0x04);
 
-  if (freq > 21000000L){  // the default filter is with 35 MHz cut-off
-    digitalWrite(TX_LPF_A, 0);
-    digitalWrite(TX_LPF_B, 0);
-    digitalWrite(TX_LPF_C, 0);
-  }
-  else if (freq >= 14000000L){ //thrown the KT1 relay on, the 30 MHz LPF is bypassed and the 14-18 MHz LPF is allowd to go through
-    digitalWrite(TX_LPF_A, 1);
-    digitalWrite(TX_LPF_B, 0);
-    digitalWrite(TX_LPF_C, 0);
-  }
-  else if (freq > 7000000L){
-    digitalWrite(TX_LPF_A, 1);
-    digitalWrite(TX_LPF_B, 1);
-    digitalWrite(TX_LPF_C, 0);    
-  }
-  else {
-    digitalWrite(TX_LPF_A, 1);
-    digitalWrite(TX_LPF_B, 1);
-    digitalWrite(TX_LPF_C, 1);    
-  }
+      if (isCustomFilter_A7 == 1)
+      {
+        digitalWrite(10, aIn & 0x08);
+        digitalWrite(11, aIn & 0x10);
+        digitalWrite(12, aIn & 0x20);
+        digitalWrite(13, aIn & 0x40);
+      }
+      return;
+    }
+  } //end of for
+#else
+  
+  #if UBITX_BOARD_VERSION == 5
+    if (freq > 21000000L){  // the default filter is with 35 MHz cut-off
+      digitalWrite(TX_LPF_A, 0);
+      digitalWrite(TX_LPF_B, 0);
+      digitalWrite(TX_LPF_C, 0);
+    }
+    else if (freq >= 14000000L){ //thrown the KT1 relay on, the 30 MHz LPF is bypassed and the 14-18 MHz LPF is allowd to go through
+      digitalWrite(TX_LPF_A, 1);
+      digitalWrite(TX_LPF_B, 0);
+      digitalWrite(TX_LPF_C, 0);
+    }
+    else if (freq > 7000000L){
+      digitalWrite(TX_LPF_A, 0);
+      digitalWrite(TX_LPF_B, 1);
+      digitalWrite(TX_LPF_C, 0);    
+    }
+    else {
+      digitalWrite(TX_LPF_A, 0);
+      digitalWrite(TX_LPF_B, 0);
+      digitalWrite(TX_LPF_C, 1);    
+    }
+  #else
+    if (freq > 21000000L){  // the default filter is with 35 MHz cut-off
+      digitalWrite(TX_LPF_A, 0);
+      digitalWrite(TX_LPF_B, 0);
+      digitalWrite(TX_LPF_C, 0);
+    }
+    else if (freq >= 14000000L){ //thrown the KT1 relay on, the 30 MHz LPF is bypassed and the 14-18 MHz LPF is allowd to go through
+      digitalWrite(TX_LPF_A, 1);
+      digitalWrite(TX_LPF_B, 0);
+      digitalWrite(TX_LPF_C, 0);
+    }
+    else if (freq > 7000000L){
+      digitalWrite(TX_LPF_A, 1);
+      digitalWrite(TX_LPF_B, 1);
+      digitalWrite(TX_LPF_C, 0);    
+    }
+    else {
+      digitalWrite(TX_LPF_A, 1);
+      digitalWrite(TX_LPF_B, 1);
+      digitalWrite(TX_LPF_C, 1);    
+    }
+  #endif
+
+
+#endif
 }
 
 /**
@@ -357,7 +447,7 @@ void setFrequency(unsigned long f){
   f = (f / arTuneStep[tuneStepIndex -1]) * arTuneStep[tuneStepIndex -1];
   setTXFilters(f);
 
-  unsigned long appliedCarrier = ((cwMode == 0 ? usbCarrier : cwmCarrier) + (isIFShift && (inTx == 0) ? ifShiftValue : 0));
+  unsigned long appliedCarrier = ((cwMode == 0 ? usbCarrier : cwmCarrier) + (isIFShift && (!inTx) ? ifShiftValue : 0));
   int appliedTuneValue = 0;
 
   //applied if tune 
@@ -367,7 +457,7 @@ void setFrequency(unsigned long f){
     appliedTuneValue = if1TuneValue;
 
     //In the LSB state, the optimum reception value was found. To apply to USB, 3Khz decrease is required.
-    if (sdrModeOn && (inTx == 0))
+    if (sdrModeOn && (!inTx))
       appliedTuneValue -= 15; //decrease 1.55Khz
       
     //if (isUSB)
@@ -377,13 +467,13 @@ void setFrequency(unsigned long f){
 
    //if1Tune RX, TX Enabled, ATT : only RX Mode
   //The IF Tune shall be measured at the LSB. Then, move the 3Khz down for USB.
-  long if1AdjustValue = ((inTx == 0) ? (attLevel * 100) : 0) + (appliedTuneValue * 100); //if1Tune RX, TX Enabled, ATT : only RX Mode  //5600
+  long if1AdjustValue = ((!inTx) ? (attLevel * 100) : 0) + (appliedTuneValue * 100); //if1Tune RX, TX Enabled, ATT : only RX Mode  //5600
 
   //for DIY uBITX (custom filter)
   if ((advancedFreqOption1 & 0x80) != 0x00)  //Reverse IF Tune (- Value for DIY uBITX)
     if1AdjustValue *= -1;
     
-  if (sdrModeOn && (inTx == 0))  //IF SDR MODE
+  if (sdrModeOn && (!inTx))  //IF SDR MODE
   {
     //Fixed Frequency SDR (Default Frequency : 32Mhz, available change sdr Frequency by uBITX Manager)
     //Dynamic Frequency is for SWL without cat
@@ -416,13 +506,23 @@ void setFrequency(unsigned long f){
       moveFrequency = (f % 1000000);
     }
 
+#if UBITX_BOARD_VERSION == 5    
+    si5351bx_setfreq(2, 45002000 + if1AdjustValue + f);
+    si5351bx_setfreq(1, 45002000 
+      + if1AdjustValue 
+      + SDR_Center_Freq 
+      //+ ((advancedFreqOption1 & 0x04) == 0x00 ? 0 : (f % 10000000))
+      + moveFrequency);
+      // + 2390);  //RTL-SDR Frequency Error, Do not add another SDR because the error is different. V1.3
+#else
     si5351bx_setfreq(2, 44991500 + if1AdjustValue + f);
     si5351bx_setfreq(1, 44991500 
       + if1AdjustValue 
       + SDR_Center_Freq 
       //+ ((advancedFreqOption1 & 0x04) == 0x00 ? 0 : (f % 10000000))
-      + moveFrequency
-      + 2390);
+      + moveFrequency );
+      //+ 2390); Do not add another SDR because the error is different. V1.3
+#endif
   }
   else
   {
@@ -448,7 +548,7 @@ void setFrequency(unsigned long f){
  * put the uBitx in tx mode. It takes care of rit settings, sideband settings
  * Note: In cw mode, doesnt key the radio, only puts it in tx mode
  */
-void startTx(byte txMode, byte isDisplayUpdate){
+void startTx(byte txMode, byte isDisplayUpdate = 0){
   //Check Hamband only TX //Not found Hamband index by now frequency
   if (tuneTXType >= 100 && getIndexHambanBbyFreq(ritOn ? ritTxFrequency :  frequency) == -1) {
     //no message
@@ -458,7 +558,7 @@ void startTx(byte txMode, byte isDisplayUpdate){
   if ((isTxType & 0x01) != 0x01)
     digitalWrite(TX_RX, 1);
 
-  inTx = 1;
+  inTx = true;
   
   if (ritOn){
     //save the current as the rx frequency
@@ -518,10 +618,12 @@ void startTx(byte txMode, byte isDisplayUpdate){
   //reduce latency time when begin of CW mode
   if (isDisplayUpdate == 1)
     updateDisplay();
+
+  Serial.println("exiting startTx()");
 }
 
 void stopTx(void){
-  inTx = 0;
+  inTx = false;
 
   digitalWrite(TX_RX, 0);           //turn off the tx
   SetCarrierFreq();
@@ -585,12 +687,12 @@ void checkPTT(){
   if (cwTimeout > 0)
     return;
     
-  if (digitalRead(PTT) == 0 && inTx == 0){
+  if (digitalRead(PTT) == 0 && !inTx){
     startTx(TX_SSB, 1);
     delay(50); //debounce the PTT
   }
   
-  if (digitalRead(PTT) == 1 && inTx == 1)
+  if (digitalRead(PTT) == 1 && inTx)
     stopTx();
 }
 #ifdef EXTEND_KEY_GROUP1  
@@ -951,6 +1053,24 @@ void initSettings(){
     KeyValues[i][2] = EEPROM.read(EXTENDED_KEY_RANGE + (i * 3) + 2);    //KEY TYPE 
   }
 
+#ifdef USE_CUSTOM_LPF_FILTER 
+  //Custom Filters
+  EEPROM.get(CUST_LPF_ENABLED, isCustomFilter);
+  if (isCustomFilter == 0x58)
+  {
+    isCustomFilter_A7 = 1;
+  }
+  isCustomFilter = (isCustomFilter == 0x58 || isCustomFilter == 0x57);
+  
+  for (byte i = 0; i < 7; i++) {
+    CustFilters[i][0] = EEPROM.read(CUST_LPF_START + (i * 2));        //LPF (To) Mhz
+    CustFilters[i][1] = EEPROM.read(CUST_LPF_START + (i * 2) + 1);    //Enabled I/O
+  }
+//char isCustomFilter = 0;
+//char isCustomFilter_A7 = 0;
+//char CustFilters[2][7];
+#endif
+
   //User callsign information
   if (EEPROM.read(USER_CALLSIGN_KEY) == 0x59)
     userCallsignLength = EEPROM.read(USER_CALLSIGN_LEN);  //MAXIMUM 18 LENGTH
@@ -1112,12 +1232,22 @@ void initSettings(){
   if (vfoB_mode < 2)
     vfoB_mode = 3;
 
+
+#if UBITX_BOARD_VERSION == 5
+  //original code with modified by kd8cec
+  if (usbCarrier > 11060000l || usbCarrier < 11048000l)
+    usbCarrier = 11052000l;
+
+  if (cwmCarrier > 11060000l || cwmCarrier < 11048000l)
+    cwmCarrier = 11052000l;
+#else
   //original code with modified by kd8cec
   if (usbCarrier > 12010000l || usbCarrier < 11990000l)
     usbCarrier = 11997000l;
 
   if (cwmCarrier > 12010000l || cwmCarrier < 11990000l)
     cwmCarrier = 11997000l;
+#endif
     
   if (vfoA > 35000000l || 3500000l > vfoA) {
      vfoA = 7150000l;
@@ -1167,6 +1297,21 @@ void initPorts(){
   pinMode(ANALOG_KEYER, INPUT_PULLUP);
   pinMode(ANALOG_SMETER, INPUT); //by KD8CEC
 
+#ifdef USE_ALTKEYER
+  pinMode(DIGITAL_DOT, INPUT_PULLUP);
+  pinMode(DIGITAL_DASH, INPUT_PULLUP);
+#endif
+
+#ifdef USE_CUSTOM_LPF_FILTER 
+  if (isCustomFilter_A7)
+  {
+    pinMode(10, OUTPUT);
+    pinMode(11, OUTPUT);
+    pinMode(12, OUTPUT);
+    pinMode(13, OUTPUT);
+  }
+#endif  
+
   pinMode(CW_TONE, OUTPUT);  
   digitalWrite(CW_TONE, 0);
   
@@ -1297,6 +1442,8 @@ void setup()
     factory_alignment();
 #endif
 
+  Connect_Interrupts();
+
 }
 
 //Auto save Frequency and Mode with Protected eeprom life by KD8CEC
@@ -1325,14 +1472,21 @@ void checkAutoSaveFreqMode()
 
 void loop(){ 
   if (isCWAutoMode == 0){  //when CW AutoKey Mode, disable this process
-    if (!txCAT)
-      checkPTT();
+#ifdef USE_ALTKEYER
+    // when using the alternate keyer, don't check the PTT if we're in CW mode, because 
+    // the PTT is also a straight key
+//    if (!txCAT && (cwMode == 0))
+//      checkPTT();
+#else
+//    if (!txCAT)
+//      checkPTT();
+#endif
     checkButton();
   }
  else
-    controlAutoCW();
+    ; //controlAutoCW();
 
-  cwKeyer(); 
+  //cwKeyer(); 
   
   //tune only when not tranmsitting 
   if (!inTx){
@@ -1352,7 +1506,8 @@ void loop(){
   } //end of check TX Status
 
   //we check CAT after the encoder as it might put the radio into TX
-  Check_Cat(inTx? 1 : 0);
+  // Maybe make this do all four versions of Check_Cat depending on state
+  Check_Cat(inTx ? 1 : 0);
 
   //for SEND SW Serial
   #ifdef USE_SW_SERIAL

ubitx_20/ubitx_eemap.h

@@ -39,6 +39,20 @@
 //==============================================================================
 #define RESERVE_FOR_FACTORY1  32
 
+//==============================================================================
+// custom LPF Filter
+// 48 : Using Custom LPF Filter  (48 = 0x57 or 0x58 => Using Custom LPF Filter, 0x58 = using A7 IO
+// 49, 50 : LPF1  (49 : MHz  (~ Mhz), 50 : Enabled PIN
+// 51, 52 : LPF2
+// 53, 54 : LPF3
+// 55, 56 : LPF4
+// 57, 58 : LPF5
+// 59, 60 : LPF6
+// 61, 62 : LPF7
+//==============================================================================
+#define CUST_LPF_ENABLED 48
+#define CUST_LPF_START   49
+
 //SI5351 I2C Address (Version 1.097)
 #define I2C_ADDR_SI5351       63
 

ubitx_20/ubitx_factory_alignment.ino

@@ -1,3 +1,4 @@
+#include "ubitx.h"
 
 /**
  * This procedure is only for those who have a signal generator/transceiver tuned to exactly 7.150 and a dummy load 
@@ -27,14 +28,25 @@ void factory_alignment(){
   printLine2("#2 BFO");
   delay(1000);
 
+#if UBITX_BOARD_VERSION == 5
+  usbCarrier = 11053000l;
+  menuSetupCarrier(1);
+  if (usbCarrier == 11053000l){
+    printLine2("Setup Aborted");
+    return;
+  }
+  
+#else
   usbCarrier = 11994999l;
   menuSetupCarrier(1);
-
   if (usbCarrier == 11994999l){
     printLine2("Setup Aborted");
     return;
   }
 
+#endif
+
+
   
   printLine2("#3:Test 3.5MHz");
   cwMode = 0;
@@ -88,4 +100,3 @@ void factory_alignment(){
   updateDisplay();  
   
 }
-

ubitx_20/ubitx_keyer.cpp

@@ -0,0 +1,336 @@
+/**
+ * File name ubitx_keyer.cpp
+ * CW Keyer
+ *
+ * The CW keyer handles either a straight key or an iambic / paddle key.
+ * D12 for DOT Paddle  and D11 for DASH Paddle  and D* for PTT/Handkey
+ *
+ * Generating CW
+ * The CW is cleanly generated by unbalancing the front-end mixer
+ * and putting the local oscillator directly at the CW transmit frequency.
+ * The sidetone, generated by the Arduino is injected into the volume control
+ */
+#include "ubitx.h"
+#include <Arduino.h>
+
+extern void stopTx(void);
+extern void startTx(byte txMode, byte isDisplayUpdate = 0);
+
+extern unsigned long sideTone;
+extern int cwSpeed;
+// extern long CW_TIMEOUT;
+extern long cwTimeout;
+#define CW_TIMEOUT (cwTimeout)
+extern volatile bool inTx;
+// extern volatile int ubitx_mode;
+extern char isUSB;
+extern char cwMode;
+
+extern volatile unsigned char keyerControl;
+// extern volatile unsigned char keyerState;
+volatile unsigned char keyerState = IDLE;
+// extern unsigned volatile char IAMBICB;
+// extern unsigned volatile char PDLSWAP;
+
+// extern volatile unsigned long Ubitx_Voltage;
+// extern volatile int Ubitx_Voltage_Timer;
+
+volatile bool keyDown = false; // in cw mode, denotes the carrier is being transmitted
+volatile uint8_t Last_Bits = 0xFF;
+;
+
+volatile bool Dot_in_Progress = false;
+volatile unsigned long Dot_Timer_Count = 0;
+volatile bool Dash_in_Progress = false;
+volatile unsigned long Dash_Timer_Count = 0;
+volatile bool Inter_Bit_in_Progress = false;
+volatile unsigned long Inter_Bit_Timer_Count = 0;
+volatile bool Turn_Off_Carrier_in_Progress = false;
+volatile unsigned long Turn_Off_Carrier_Timer_Count = 0;
+volatile bool Ubitx_Voltage_Act = false;
+volatile bool PTT_HANDKEY_ACTIVE = false;
+volatile long last_interrupt_time = 20;
+// extern bool Cat_Lock;
+// extern volatile bool TX_In_Progress;
+extern volatile bool txCAT;
+
+/**
+ * Starts transmitting the carrier with the sidetone
+ * It assumes that we have called cwTxStart and not called cwTxStop
+ * each time it is called, the cwTimeOut is pushed further into the future
+ */
+void cwKeydown(void) {
+  keyDown = 1; // tracks the CW_KEY
+  tone(CW_TONE, (int)sideTone);
+  digitalWrite(CW_KEY, 1);
+#ifdef XMIT_LED
+  digitalWrite(ON_AIR, 0); // extinguish the LED on NANO's pin 13
+#endif
+}
+/**
+ * Stops the CW carrier transmission along with the sidetone
+ * Pushes the cwTimeout further into the future
+ */
+void cwKeyUp(void) {
+  keyDown = 0; // tracks the CW_KEY
+  noTone(CW_TONE);
+  digitalWrite(CW_KEY, 0);
+#ifdef XMIT_LED
+  digitalWrite(ON_AIR, 1); // extinguish the LED on NANO's pin 13
+#endif
+}
+
+void update_PaddleLatch() {
+  //  if (!digitalRead(DIGITAL_DOT) ) keyerControl |= DIT_L;
+  //  if (!digitalRead(DIGITAL_DASH)  ) keyerControl |= DAH_L;
+  if (digitalRead(DIGITAL_DOT) == LOW) {
+    if (keyerControl & PDLSWAP)
+      keyerControl |= DAH_L;
+    else
+      keyerControl |= DIT_L;
+  }
+  if (digitalRead(DIGITAL_DASH) == LOW) {
+    if (keyerControl & PDLSWAP)
+      keyerControl |= DIT_L;
+    else
+      keyerControl |= DAH_L;
+  }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+//   interupt  handlers
+
+////   timers
+ISR(TIMER1_OVF_vect) {
+  static volatile bool i_am_running = false;
+  bool continue_loop = true;
+
+  if (i_am_running) return;
+  i_am_running = true;
+
+  // process if CW modes
+  // if( (ubitx_mode == MODE_CW)||(ubitx_mode == MODE_CWR)){
+  if (cwMode > 0) {
+
+    // process DOT and DASH timing
+    if ((Dot_in_Progress) && (Dot_Timer_Count > 0)) {
+      if (!inTx) {
+        keyDown = 0;
+        startTx(TX_CW);
+      }
+      if (keyDown == 0)
+        cwKeydown();
+      Dot_Timer_Count = Dot_Timer_Count - 1;
+      if (Dot_Timer_Count <= 0) {
+        Dot_Timer_Count = 0;
+        Dot_in_Progress = false;
+        cwKeyUp();
+      }
+    }
+
+    // process Inter Bit Timing
+    if ((Inter_Bit_in_Progress) && (Inter_Bit_Timer_Count > 0)) {
+      Inter_Bit_Timer_Count = Inter_Bit_Timer_Count - 1;
+      if (Inter_Bit_Timer_Count <= 0) {
+        Inter_Bit_Timer_Count = 0;
+        Inter_Bit_in_Progress = false;
+      }
+    }
+
+    // process turning off carrier
+    if ((Turn_Off_Carrier_in_Progress) && (Turn_Off_Carrier_Timer_Count > 0)) {
+      Turn_Off_Carrier_Timer_Count = Turn_Off_Carrier_Timer_Count - 1;
+      if (Turn_Off_Carrier_Timer_Count <= 0) {
+        Turn_Off_Carrier_in_Progress = false;
+        Turn_Off_Carrier_Timer_Count = 0;
+        stopTx();
+      }
+    }
+
+    // process hand key
+    if (digitalRead(DIGITAL_KEY) == 0) {
+      // If interrupts come faster than 5ms, assume it's a bounce and ignore
+      last_interrupt_time = last_interrupt_time - 1;
+      if (last_interrupt_time <= 0) {
+        last_interrupt_time = 0;
+        if (!inTx) {
+          keyDown = 0;
+          startTx(TX_CW);
+        }
+        if (keyDown == 0)
+          cwKeydown();
+        PTT_HANDKEY_ACTIVE = true;
+        Turn_Off_Carrier_Timer_Count = CW_TIMEOUT;
+      }
+    } else if ((keyDown == 1) && (PTT_HANDKEY_ACTIVE == true)) {
+      cwKeyUp();
+      Turn_Off_Carrier_Timer_Count = CW_TIMEOUT;
+      Turn_Off_Carrier_in_Progress = true;
+      last_interrupt_time = PTT_HNDKEY_DEBOUNCE_CT;
+      PTT_HANDKEY_ACTIVE = false;
+    } else
+      last_interrupt_time = PTT_HNDKEY_DEBOUNCE_CT;
+
+    if (PTT_HANDKEY_ACTIVE == false) {
+      while (continue_loop) {
+        switch (keyerState) {
+        case IDLE:
+          if ((!digitalRead(DIGITAL_DOT)) || (!digitalRead(DIGITAL_DASH)) ||
+              (keyerControl & 0x03)) {
+            update_PaddleLatch();
+            keyerState = CHK_DIT;
+            Dot_in_Progress = false;
+            Dot_Timer_Count = 0;
+            Turn_Off_Carrier_Timer_Count = 0;
+            Turn_Off_Carrier_in_Progress = false;
+          } else {
+            continue_loop = false;
+          }
+          break;
+
+        case CHK_DIT:
+          if (keyerControl & DIT_L) {
+            keyerControl |= DIT_PROC;
+            keyerState = KEYED_PREP;
+            Dot_Timer_Count = cwSpeed;
+          } else {
+            keyerState = CHK_DAH;
+          }
+          break;
+
+        case CHK_DAH:
+          if (keyerControl & DAH_L) {
+            keyerState = KEYED_PREP;
+            Dot_Timer_Count = cwSpeed * 3;
+          } else {
+            continue_loop = false;
+            keyerState = IDLE;
+          }
+          break;
+
+        case KEYED_PREP:
+          keyerControl &= ~(DIT_L + DAH_L); // clear both paddle latch bits
+          keyerState = KEYED;               // next state
+          Turn_Off_Carrier_Timer_Count = 0;
+          Turn_Off_Carrier_in_Progress = false;
+          Dot_in_Progress = true;
+          break;
+
+        case KEYED:
+          if (Dot_in_Progress == false) { // are we at end of key down ?
+            Inter_Bit_in_Progress = true;
+            Inter_Bit_Timer_Count = cwSpeed;
+            keyerState = INTER_ELEMENT; // next state
+          } else if (keyerControl & IAMBICB) {
+            update_PaddleLatch(); // early paddle latch in Iambic B mode
+            continue_loop = false;
+          } else
+            continue_loop = false;
+          break;
+
+        case INTER_ELEMENT:
+          // Insert time between dits/dahs
+          update_PaddleLatch();                 // latch paddle state
+          if (Inter_Bit_in_Progress == false) { // are we at end of inter-space ?
+            Turn_Off_Carrier_Timer_Count = CW_TIMEOUT;
+            Turn_Off_Carrier_in_Progress = true;
+            if (keyerControl & DIT_PROC) {         // was it a dit or dah ?
+              keyerControl &= ~(DIT_L + DIT_PROC); // clear two bits
+              keyerState = CHK_DAH;                // dit done, check for dah
+            } else {
+              keyerControl &= ~(DAH_L); // clear dah latch
+              keyerState = IDLE;        // go idle
+            }
+          } else
+            continue_loop = false;
+          break;
+        }
+      }
+    }
+  }
+
+  // process PTT
+  //  if( (ubitx_mode == MODE_USB)|| (ubitx_mode == MODE_LSB)){
+  if (cwMode == 0) {
+    if (digitalRead(PTT) == 0) {
+      // If interrupts come faster than 5ms, assume it's a bounce and ignore
+      last_interrupt_time = last_interrupt_time - 1;
+      if (last_interrupt_time <= 0) {
+        last_interrupt_time = 0;
+        if (!inTx)
+          startTx(TX_SSB);
+      }
+    } else if ((inTx) && (txCAT == false)) {
+      last_interrupt_time = PTT_HNDKEY_DEBOUNCE_CT;
+      stopTx();
+    } else
+      last_interrupt_time = PTT_HNDKEY_DEBOUNCE_CT;
+  }
+
+  i_am_running = false;
+}
+void Connect_Interrupts(void) {
+  keyerControl = 0;
+  cli();
+  TIMSK1 |= (1 << TOIE1);
+  sei();
+}
+
+/*
+#define     N_MORSE  (sizeof(morsetab)/sizeof(morsetab[0]))
+// Morse table
+struct t_mtab { char c, pat; } ;
+struct t_mtab morsetab[] = {
+  {'.', 106}, {',', 115}, {'?', 76}, {'/', 41}, {'A', 6},  {'B', 17}, {'C', 21}, {'D', 9},
+        {'E', 2},   {'F', 20},  {'G', 11}, {'H', 16}, {'I', 4},  {'J', 30}, {'K', 13}, {'L', 18},
+        {'M', 7},   {'N', 5},   {'O', 15}, {'P', 22}, {'Q', 27}, {'R', 10}, {'S', 8},  {'T', 3},
+        {'U', 12},  {'V', 24},  {'W', 14}, {'X', 25}, {'Y', 29}, {'Z', 19}, {'1', 62}, {'2', 60},
+        {'3', 56},  {'4', 48},  {'5', 32}, {'6', 33}, {'7', 35}, {'8', 39}, {'9', 47}, {'0', 63}
+  };
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+// CW generation routines for CQ message
+void key(int LENGTH){
+
+    if( !inTx ) startTx(TX_CW);
+    cwKeydown();
+    delay(LENGTH*2);
+    cwKeyUp();
+    delay(cwSpeed*2);
+
+}
+
+
+void send(char c){
+  int i ;
+
+
+  if (c == ' ') {
+    delay(7*cwSpeed) ;
+    return ;
+  }
+  for (i=0; i<N_MORSE; i++){
+    if (morsetab[i].c == c){
+      unsigned char p = morsetab[i].pat ;
+      while (p != 1) {
+        if (p & 1) Dot_Timer_Count = cwSpeed*3;
+        else Dot_Timer_Count = cwSpeed;
+        key(Dot_Timer_Count);
+        p = p / 2 ;
+      }
+      delay(cwSpeed*5) ;
+      return ;
+    }
+  }
+}
+
+
+
+void sendmsg(char *str){
+
+  while (*str) send(*str++);
+  delay(650);
+  stopTx();
+}
+*/

ubitx_20/ubitx_keyer.ino

@@ -1,369 +0,0 @@
-/**
- CW Keyer
- CW Key logic change with ron's code (ubitx_keyer.cpp)
- Ron's logic has been modified to work with the original uBITX by KD8CEC
-
- Original Comment ----------------------------------------------------------------------------
- * The CW keyer handles either a straight key or an iambic / paddle key.
- * They all use just one analog input line. This is how it works.
- * The analog line has the internal pull-up resistor enabled. 
- * When a straight key is connected, it shorts the pull-up resistor, analog input is 0 volts
- * When a paddle is connected, the dot and the dash are connected to the analog pin through
- * a 10K and a 2.2K resistors. These produce a 4v and a 2v input to the analog pins.
- * So, the readings are as follows :
- * 0v - straight key
- * 1-2.5 v - paddle dot
- * 2.5 to 4.5 v - paddle dash
- * 2.0 to 0.5 v - dot and dash pressed
- * 
- * The keyer is written to transparently handle all these cases
- * 
- * Generating CW
- * The CW is cleanly generated by unbalancing the front-end mixer
- * and putting the local oscillator directly at the CW transmit frequency.
- * The sidetone, generated by the Arduino is injected into the volume control
- */
-
-
-// in milliseconds, this is the parameter that determines how long the tx will hold between cw key downs
-//#define CW_TIMEOUT (600l)   //Change to CW Delaytime for value save to eeprom
-#define PADDLE_DOT 1
-#define PADDLE_DASH 2
-#define PADDLE_BOTH 3
-#define PADDLE_STRAIGHT 4
-
-//we store the last padde's character 
-//to alternatively send dots and dashes 
-//when both are simultaneously pressed
-char lastPaddle = 0;
-
-//reads the analog keyer pin and reports the paddle
-byte getPaddle(){
-  int paddle = analogRead(ANALOG_KEYER);
-
-  if (paddle > 800)         // above 4v is up
-    return 0;
-    
-  if (paddle > 600)    // 4-3v is dot
-    return PADDLE_DASH;
-  else if (paddle > 300)    //1-2v is dash
-    return PADDLE_DOT;
-  else if (paddle > 50)
-    return PADDLE_BOTH;     //both are between 1 and 2v
-  else
-    return PADDLE_STRAIGHT; //less than 1v is the straight key
-}
-
-/**
- * Starts transmitting the carrier with the sidetone
- * It assumes that we have called cwTxStart and not called cwTxStop
- * each time it is called, the cwTimeOut is pushed further into the future
- */
-void cwKeydown(){
-  keyDown = 1;                  //tracks the CW_KEY
-  tone(CW_TONE, (int)sideTone); 
-  digitalWrite(CW_KEY, 1);     
-
-  //Modified by KD8CEC, for CW Delay Time save to eeprom
-  //cwTimeout = millis() + CW_TIMEOUT;
-  cwTimeout = millis() + cwDelayTime * 10;  
-}
-
-/**
- * Stops the cw carrier transmission along with the sidetone
- * Pushes the cwTimeout further into the future
- */
-void cwKeyUp(){
-  keyDown = 0;    //tracks the CW_KEY
-  noTone(CW_TONE);
-  digitalWrite(CW_KEY, 0);    
-  
-  //Modified by KD8CEC, for CW Delay Time save to eeprom
-  //cwTimeout = millis() + CW_TIMEOUT;
-  cwTimeout = millis() + cwDelayTime * 10;
-}
-
-//Variables for Ron's new logic
-#define DIT_L 0x01 // DIT latch
-#define DAH_L 0x02 // DAH latch
-#define DIT_PROC 0x04 // DIT is being processed
-#define PDLSWAP 0x08 // 0 for normal, 1 for swap
-#define IAMBICB 0x10 // 0 for Iambic A, 1 for Iambic B
-enum KSTYPE {IDLE, CHK_DIT, CHK_DAH, KEYED_PREP, KEYED, INTER_ELEMENT };
-static unsigned long ktimer;
-unsigned char keyerState = IDLE;
-
-//Below is a test to reduce the keying error. do not delete lines
-//create by KD8CEC for compatible with new CW Logic
-char update_PaddleLatch(byte isUpdateKeyState) {
-  unsigned char tmpKeyerControl = 0;
-  int paddle = analogRead(ANALOG_KEYER);
-
-  if (paddle >= cwAdcDashFrom && paddle <= cwAdcDashTo)
-    tmpKeyerControl |= DAH_L;
-  else if (paddle >= cwAdcDotFrom && paddle <= cwAdcDotTo)
-    tmpKeyerControl |= DIT_L;
-  else if (paddle >= cwAdcBothFrom && paddle <= cwAdcBothTo)
-    tmpKeyerControl |= (DAH_L | DIT_L) ;     
-  else 
-  {
-    if (Iambic_Key)
-      tmpKeyerControl = 0 ;
-    else if (paddle >= cwAdcSTFrom && paddle <= cwAdcSTTo)
-      tmpKeyerControl = DIT_L ;
-     else
-       tmpKeyerControl = 0 ; 
-  }
-  
-  if (isUpdateKeyState == 1)
-    keyerControl |= tmpKeyerControl;
-
-  return tmpKeyerControl;
-}
-
-/*****************************************************************************
-// New logic, by RON
-// modified by KD8CEC
-******************************************************************************/
-void cwKeyer(void){
-  lastPaddle = 0;
-  bool continue_loop = true;
-  unsigned tmpKeyControl = 0;
-  
-  if( Iambic_Key ) {
-    while(continue_loop) {
-      switch (keyerState) {
-        case IDLE:
-          tmpKeyControl = update_PaddleLatch(0);
-          if ( tmpKeyControl == DAH_L || tmpKeyControl == DIT_L || 
-            tmpKeyControl == (DAH_L | DIT_L) || (keyerControl & 0x03)) {
-             update_PaddleLatch(1);
-             keyerState = CHK_DIT;
-          }else{
-            if (0 < cwTimeout && cwTimeout < millis()){
-              cwTimeout = 0;
-              stopTx();
-            }
-            continue_loop = false;
-          }
-          break;
-    
-        case CHK_DIT:
-          if (keyerControl & DIT_L) {
-            keyerControl |= DIT_PROC;
-            ktimer = cwSpeed;
-            keyerState = KEYED_PREP;
-          }else{
-            keyerState = CHK_DAH;
-          }
-          break;
-    
-        case CHK_DAH:
-          if (keyerControl & DAH_L) {
-            ktimer = cwSpeed*3;
-            keyerState = KEYED_PREP;
-          }else{
-            keyerState = IDLE;
-          }
-          break;
-    
-        case KEYED_PREP:
-          //modified KD8CEC
-          /*
-          ktimer += millis(); // set ktimer to interval end time
-          keyerControl &= ~(DIT_L + DAH_L); // clear both paddle latch bits
-          keyerState = KEYED; // next state
-          if (!inTx){
-            //DelayTime Option
-            delay_background(delayBeforeCWStartTime * 2, 2);
-            
-            keyDown = 0;
-            cwTimeout = millis() + cwDelayTime * 10;  //+ CW_TIMEOUT;
-            startTx(TX_CW, 1);
-          }
-          */
-          if (!inTx){
-            //DelayTime Option
-            delay_background(delayBeforeCWStartTime * 2, 2);
-            
-            keyDown = 0;
-            cwTimeout = millis() + cwDelayTime * 10;  //+ CW_TIMEOUT;
-            startTx(TX_CW, 1);
-          }
-          ktimer += millis(); // set ktimer to interval end time
-          keyerControl &= ~(DIT_L + DAH_L); // clear both paddle latch bits
-          keyerState = KEYED; // next state
-          
-          cwKeydown();
-          break;
-    
-        case KEYED:
-          if (millis() > ktimer) { // are we at end of key down ?
-           cwKeyUp();
-           ktimer = millis() + cwSpeed; // inter-element time
-            keyerState = INTER_ELEMENT; // next state
-          }else if (keyerControl & IAMBICB) {
-            update_PaddleLatch(1); // early paddle latch in Iambic B mode
-          }
-          break;
-    
-        case INTER_ELEMENT:
-          // Insert time between dits/dahs
-          update_PaddleLatch(1); // latch paddle state
-          if (millis() > ktimer) { // are we at end of inter-space ?
-            if (keyerControl & DIT_PROC) { // was it a dit or dah ?
-              keyerControl &= ~(DIT_L + DIT_PROC); // clear two bits
-              keyerState = CHK_DAH; // dit done, check for dah
-            }else{
-              keyerControl &= ~(DAH_L); // clear dah latch
-              keyerState = IDLE; // go idle
-            }
-          }
-          break;
-      }
-  
-      Check_Cat(2);
-    } //end of while
-  }
-  else{
-    while(1){
-      if (update_PaddleLatch(0) == DIT_L) {
-        // if we are here, it is only because the key is pressed
-        if (!inTx){
-          //DelayTime Option
-          delay_background(delayBeforeCWStartTime * 2, 2);
-          
-          keyDown = 0;
-          cwTimeout = millis() + cwDelayTime * 10;  //+ CW_TIMEOUT; 
-          startTx(TX_CW, 1);
-        }
-        cwKeydown();
-        
-        while ( update_PaddleLatch(0) == DIT_L ) 
-          delay_background(1, 3);
-          
-        cwKeyUp();
-      }
-      else{
-        if (0 < cwTimeout && cwTimeout < millis()){
-          cwTimeout = 0;
-          keyDown = 0;
-          stopTx();
-        }
-        //if (!cwTimeout) //removed by KD8CEC
-        //   return;
-        // got back to the beginning of the loop, if no further activity happens on straight key
-        // we will time out, and return out of this routine 
-        //delay(5);
-        //delay_background(5, 3); //removed by KD8CEC
-        //continue;               //removed by KD8CEC
-        return;                   //Tx stop control by Main Loop
-      }
-
-      Check_Cat(2);
-    } //end of while
-  }   //end of elese
-}
-
-
-//=======================================================================================
-//Before logic
-//by Farhan and modified by KD8CEC
-//======================================================================================
-
-/**
- * The keyer handles the straight key as well as the iambic key
- * This module keeps looping until the user stops sending cw
- * if the cwTimeout is set to 0, then it means, we have to exit the keyer loop
- * Each time the key is hit the cwTimeout is pushed to a time in the future by cwKeyDown()
- */
- /*
-void cwKeyer(){
-  byte paddle;
-  lastPaddle = 0;
-
-  while(1){
-    paddle = getPaddle();
-    
-    // do nothing if the paddle has not been touched, unless
-    // we are in the cw mode and we have timed out
-    if (!paddle){
-       //modifed by KD8CEC for auto CW Send
-      if (isCWAutoMode > 1)  //if while auto cw sending, dont stop tx by paddle position
-        return;
-        
-      if (0 < cwTimeout && cwTimeout < millis()){
-        cwTimeout = 0;
-        keyDown = 0;
-        stopTx();
-      }
-
-      if (!cwTimeout)
-        return;
-
-      Check_Cat(2); //for uBITX on Raspberry pi, when straight keying, disconnect / test complete
-      continue;
-    }
-
-    //if while auto cw send, stop auto cw
-    //but isAutoCWHold for Manual Keying with cwAutoSend
-    if (isCWAutoMode > 1 && isAutoCWHold == 0)
-      isCWAutoMode = 1;                         //read status
-
-    //Remoark Debug code / Serial Use by CAT Protocol
-    //Serial.print("paddle:");Serial.println(paddle);
-    // if we are here, it is only because the key or the paddle is pressed
-    if (!inTx){
-      keyDown = 0;
-      //Modified by KD8CEC, for CW Delay Time save to eeprom
-      //cwTimeout = millis() + CW_TIMEOUT;
-      cwTimeout = millis() + cwDelayTime * 10;
-      
-      startTx(TX_CW, 0);  //disable updateDisplay Command for reduce latency time
-      updateDisplay();
-
-      //DelayTime Option
-      delay_background(delayBeforeCWStartTime * 2, 2);
-    }
-    
-    // star the transmission)
-    // we store the transmitted character in the lastPaddle
-    cwKeydown();
-    if (paddle == PADDLE_DOT){
-      //delay(cwSpeed);
-      delay_background(cwSpeed, 3);
-      lastPaddle = PADDLE_DOT;
-    }
-    else if (paddle == PADDLE_DASH){
-      //delay(cwSpeed * 3);
-      delay_background(cwSpeed * 3, 3);
-      lastPaddle = PADDLE_DASH;
-    }
-    else if (paddle == PADDLE_BOTH){ //both paddles down
-      //depending upon what was sent last, send the other 
-      if (lastPaddle == PADDLE_DOT) {
-        //delay(cwSpeed * 3);
-        delay_background(cwSpeed * 3, 3);
-        lastPaddle = PADDLE_DASH;
-      }else{      
-        //delay(cwSpeed);
-        delay_background(cwSpeed, 3);
-        lastPaddle = PADDLE_DOT;
-      }
-    }
-    else if (paddle == PADDLE_STRAIGHT){
-      while (getPaddle() == PADDLE_STRAIGHT) {
-        delay(1);
-        Check_Cat(2);
-      }
-      lastPaddle = PADDLE_STRAIGHT;
-    }
-    cwKeyUp();
-    //introduce a dot long gap between characters if the keyer was used
-    if (lastPaddle != PADDLE_STRAIGHT)
-      delay(cwSpeed);
-  }
-}
-*/
-
-

ubitx_20/ubitx_lcd_nextion.ino

@@ -93,7 +93,7 @@ char L_ritOn;
 unsigned long L_ritTxFrequency; //ritTxFrequency
 
 #define CMD_IS_TX         't' //ct
-char L_inTx;
+bool L_inTx;
 
 #define CMD_IS_DIALLOCK   'l' //cl
 byte L_isDialLock;            //byte isDialLock
@@ -1041,7 +1041,7 @@ void SendUbitxData(void)
   EEPROM.get(EXTERNAL_DEVICE_OPT1, nextionDisplayOption); 
   SendCommandUL(CMD_DISP_OPTION2, nextionDisplayOption);
 
-  SendCommandStr(CMD_VERSION, (char *)("+v1.097")); //Version
+  SendCommandStr(CMD_VERSION, (char *)("+v1.200")); //Version
   SendEEPromData(CMD_CALLSIGN, 0, userCallsignLength -1, 0);
 
   /*

ubitx_20/ubitx_menu.ino

@@ -8,6 +8,10 @@ Ian KD8CEC
 #include "ubitx.h"
 #include "ubitx_eemap.h"
 
+extern void cwKeydown();
+extern void cwKeyUp();
+extern volatile bool keyDown;
+
 //Current Frequency and mode to active VFO by KD8CEC
 void FrequencyToVFO(byte isSaveFreq)
 {
@@ -1662,6 +1666,15 @@ void menuSetupCarrier(int btn){
   delay_background(1000, 0);
 
   //usbCarrier = 11995000l; //Remarked by KD8CEC, Suggest from many user, if entry routine factoryrest
+  /*
+  //for uBITX V5.0, but not used by KD8CEC, if you want default value of carrier on Calibration, delete remark symbols
+#if UBITX_BOARD_VERSION == 5
+  usbCarrier = 11053000l;
+#else
+  usbCarrier = 11995000l;
+#endif
+   */
+
   
   si5351bx_setfreq(0, usbCarrier);
   printCarrierFreq(usbCarrier);
@@ -1705,4 +1718,3 @@ void menuSetupCarrier(int btn){
   //menuOn = 0; 
   menuClearExit(0);
 }
-

ubitx_20/ubitx_si5351.ino

@@ -13,6 +13,7 @@
  * The output clock channel that controls the frequency is connected to the PLL-B. 
  * The WSPR protocol is generated by changing the clock of the PLL-B.
  ************************************************************************************/
+#include "ubitx.h"
 
 // *************  SI5315 routines - tks Jerry Gaffke, KE7ER   ***********************
 // An minimalist standalone set of Si5351 routines.
@@ -58,7 +59,13 @@ uint8_t SI5351BX_ADDR;                    // I2C address of Si5351   (variable f
 // User program may have reason to poke new values into these 3 RAM variables
 uint32_t si5351bx_vcoa = (SI5351BX_XTAL*SI5351BX_MSA);  // 25mhzXtal calibrate
 uint8_t  si5351bx_rdiv = 0;             // 0-7, CLK pin sees fout/(2**rdiv)
+
+#if UBITX_BOARD_VERSION == 5
+uint8_t  si5351bx_drive[3] = {3, 3, 3}; // 0=2ma 1=4ma 2=6ma 3=8ma for CLK 0,1,2
+#else
 uint8_t  si5351bx_drive[3] = {1, 1, 1}; // 0=2ma 1=4ma 2=6ma 3=8ma for CLK 0,1,2
+#endif
+
 uint8_t  si5351bx_clken = 0xFF;         // Private, all CLK output drivers off
 int32_t calibration = 0;
 
@@ -92,6 +99,18 @@ void si5351bx_init() {                  // Call once at power-up, start PLLA
   
   i2cWriten(26, si5351Val, 8);               // Write to 8 PLLA msynth regs
   i2cWrite(177, 0x20);                  // Reset PLLA  (0x80 resets PLLB)
+
+
+#if UBITX_BOARD_VERSION == 5
+  //why? TODO : CHECK by KD8CEC
+  //initializing the ppl2 as well
+  i2cWriten(34, si5351Val, 8);          // Write to 8 PLLA msynth regs
+  i2cWrite(177, 0xa0);                  // Reset PLLA  & PPLB (0x80 resets PLLB)
+#else
+  //
+#endif
+
+    
 }
 
 void si5351bx_setfreq(uint8_t clknum, uint32_t fout) {  // Set a CLK to fout Hz
@@ -126,9 +145,9 @@ void si5351_set_calibration(int32_t cal){
 
 void SetCarrierFreq()
 {
-  unsigned long appliedCarrier = ((cwMode == 0 ? usbCarrier : cwmCarrier) + (isIFShift && (inTx == 0) ? ifShiftValue : 0));
+  unsigned long appliedCarrier = ((cwMode == 0 ? usbCarrier : cwmCarrier) + (isIFShift && (!inTx) ? ifShiftValue : 0));
   //si5351bx_setfreq(0, (sdrModeOn ? 0 : appliedCarrier));
-  si5351bx_setfreq(0, ((sdrModeOn && (inTx == 0)) ? 0 : appliedCarrier)); //found bug by KG4GEK
+  si5351bx_setfreq(0, ((sdrModeOn && (!inTx)) ? 0 : appliedCarrier)); //found bug by KG4GEK
   
 
     /*
@@ -169,6 +188,3 @@ void TXSubFreq(unsigned long P2)
   i2cWrite(40, (P2 & 65280) >> 8);
   i2cWrite(41, P2 & 255);
 }
-
-
-