In theory, the code has now been modified to allow CW transmission when

used with the IOP.  However, at the moment, there is no way to put the
IOP into CW mode.

Intended behavior:
PTT/Key in SSB = transmit (PTT)
PTT/Key in CW = key down

ubitx_20/ubitx_20.ino

@@ -316,6 +316,17 @@ unsigned long delayBeforeTime = 0;
 byte delay_background(unsigned delayTime, byte fromType){ //fromType : 4 autoCWKey -> Check Paddle
   delayBeforeTime = millis();
 
+  /*
+   * KC4UPR - IOP review, 2020-05-03
+   * 
+   * I don't see anything in here that is either important to, or will adversely affect, IOP 
+   * operation.  I'm not planning on using the uBITX autokeyer (since all keying will be in the
+   * IOP), so neither getPaddle() nor autoSendPTTCheck() will be issues.  I do need to look into
+   * overall CAT operation, in general.
+   * 
+   * UPDATE:  Fixed getPaddle() to be compatible.
+   */
+
   while (millis() - delayBeforeTime <= delayTime) {
 
     if (fromType == 4)
@@ -678,6 +689,10 @@ void ritDisable(){
  */
 
 void checkPTT(){  
+  /*
+   * KC4UPR - note that some of this is superfluous now that checkPTT() is only executed
+   * in SSB mode, and cwKeyer is only executed in CW mode...
+   */
   //we don't check for ptt when transmitting cw
   if (cwTimeout > 0)
     return;
@@ -1459,15 +1474,34 @@ void checkAutoSaveFreqMode()
 }
 
 void loop(){ 
-  if (isCWAutoMode == 0){  //when CW AutoKey Mode, disable this process
+  /*
-    if (!txCAT)
+   * KC4UPR - IOP update, 2020-05-03
+   * 
+   * Getting rid of the autokeyer code... not planning on using, since any autokeying
+   * would actually be done by the IOP.  We'll check the PTT, but only in SSB mode
+   * (same line as CW, so it would be caught by cwKeyer() in CW mode).
+   * 
+   * Only check the CW keyer if we are in one of the CW modes.  Why?  Because we
+   * are using the same input for PTT and CW.
+   */
+//  if (isCWAutoMode == 0){  //when CW AutoKey Mode, disable this process
+//    if (!txCAT)
+//      checkPTT();
+//    checkButton();
+//  }
+// else
+//    controlAutoCW();
+  // KC4UPR:  Note, implementation below leaves no manual way to abort TX due to CAT.  May
+  // want to add in a way to interrupt CAT transmission with a PTT/CW event.
+  if (!txCAT) {
+    if (cwMode == 0)
       checkPTT();
+    else
+      cwKeyer();
     checkButton();    
   }
- else
-    controlAutoCW();
   
-  cwKeyer(); 
+//cwKeyer(); 
   
   //tune only when not tranmsitting 
   if (!inTx){

ubitx_20/ubitx_keyer.ino

@@ -39,6 +39,22 @@ char lastPaddle = 0;
 
 //reads the analog keyer pin and reports the paddle
 byte getPaddle(){
+  /*
+   * KC4UPR - IOP update, 2020-05-03
+   * 
+   * Modifying this for the uBITX IOP.  Big picture:
+   * 
+   * (1) It uses the PTT input line.
+   * 
+   * (2) It's always "straight key" mode (the IOP provides the keyer).
+   */
+
+  if (digitalRead(PTT) == 1)  // key/PTT is up
+    return 0;
+  else
+    return PADDLE_STRAIGHT;
+
+/*
   int paddle = analogRead(ANALOG_KEYER);
 
   if (paddle > 800)         // above 4v is up
@@ -52,6 +68,7 @@ byte getPaddle(){
     return PADDLE_BOTH;     //both are between 1 and 2v
   else
     return PADDLE_STRAIGHT; //less than 1v is the straight key
+*/
 }
 
 /**
@@ -96,11 +113,20 @@ 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) {
+  /*
+   * KC4UPR - IOP update, 2020-05-03
+   * 
+   * Modifying this for the uBITX IOP.  Big picture:
+   * 
+   * No iambic keyer.  It's always "straight key" based on the IOP.
+   * 
+   * It uses the PTT line.
+   */
+  return (digitalRead(PTT) ? 0 : DIT_L);
+/*   
   unsigned char tmpKeyerControl = 0;
   int paddle = analogRead(ANALOG_KEYER);
   
-  return 0;  // KC4UPR:  temporarily disabling keyer while doing ubitx_iop development.
-  
   if (paddle >= cwAdcDashFrom && paddle <= cwAdcDashTo)
     tmpKeyerControl |= DAH_L;
   else if (paddle >= cwAdcDotFrom && paddle <= cwAdcDotTo)
@@ -121,6 +147,7 @@ char update_PaddleLatch(byte isUpdateKeyState) {
     keyerControl |= tmpKeyerControl;
 
   return tmpKeyerControl;
+*/
 }
 
 /*****************************************************************************
@@ -128,106 +155,113 @@ char update_PaddleLatch(byte isUpdateKeyState) {
 // 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
+   * KC4UPR - IOP update, 2020-05-03
-          keyerControl &= ~(DIT_L + DAH_L); // clear both paddle latch bits
+   * 
-          keyerState = KEYED; // next state
+   * Modifying this for the uBITX IOP.  Big picture:
-          if (!inTx){
+   * 
-            //DelayTime Option
+   * No iambic keyer.  It's always "straight key" based on the IOP.
-            delay_background(delayBeforeCWStartTime * 2, 2);
-            
-            keyDown = 0;
-            cwTimeout = millis() + cwDelayTime * 10;  //+ CW_TIMEOUT;
-            startTx(TX_CW, 1);
-          }
    */
-          if (!inTx){
+//  lastPaddle = 0;
-            //DelayTime Option
+//  bool continue_loop = true;
-            delay_background(delayBeforeCWStartTime * 2, 2);
+//  unsigned tmpKeyControl = 0;
-            
+//  
-            keyDown = 0;
+//  if( Iambic_Key ) {
-            cwTimeout = millis() + cwDelayTime * 10;  //+ CW_TIMEOUT;
+//    while(continue_loop) {
-            startTx(TX_CW, 1);
+//      switch (keyerState) {
-          }
+//        case IDLE:
-          ktimer += millis(); // set ktimer to interval end time
+//          tmpKeyControl = update_PaddleLatch(0);
-          keyerControl &= ~(DIT_L + DAH_L); // clear both paddle latch bits
+//          if ( tmpKeyControl == DAH_L || tmpKeyControl == DIT_L || 
-          keyerState = KEYED; // next state
+//            tmpKeyControl == (DAH_L | DIT_L) || (keyerControl & 0x03)) {
-          
+//             update_PaddleLatch(1);
-          cwKeydown();
+//             keyerState = CHK_DIT;
-          break;
+//          }else{
-    
+//            if (0 < cwTimeout && cwTimeout < millis()){
-        case KEYED:
+//              cwTimeout = 0;
-          if (millis() > ktimer) { // are we at end of key down ?
+//              stopTx();
-           cwKeyUp();
+//            }
-           ktimer = millis() + cwSpeed; // inter-element time
+//            continue_loop = false;
-            keyerState = INTER_ELEMENT; // next state
+//          }
-          }else if (keyerControl & IAMBICB) {
+//          break;
-            update_PaddleLatch(1); // early paddle latch in Iambic B mode
+//    
-          }
+//        case CHK_DIT:
-          break;
+//          if (keyerControl & DIT_L) {
-    
+//            keyerControl |= DIT_PROC;
-        case INTER_ELEMENT:
+//            ktimer = cwSpeed;
-          // Insert time between dits/dahs
+//            keyerState = KEYED_PREP;
-          update_PaddleLatch(1); // latch paddle state
+//          }else{
-          if (millis() > ktimer) { // are we at end of inter-space ?
+//            keyerState = CHK_DAH;
-            if (keyerControl & DIT_PROC) { // was it a dit or dah ?
+//          }
-              keyerControl &= ~(DIT_L + DIT_PROC); // clear two bits
+//          break;
-              keyerState = CHK_DAH; // dit done, check for dah
+//    
-            }else{
+//        case CHK_DAH:
-              keyerControl &= ~(DAH_L); // clear dah latch
+//          if (keyerControl & DAH_L) {
-              keyerState = IDLE; // go idle
+//            ktimer = cwSpeed*3;
-            }
+//            keyerState = KEYED_PREP;
-          }
+//          }else{
-          break;
+//            keyerState = IDLE;
-      }
+//          }
-  
+//          break;
-      Check_Cat(2);
+//    
-    } //end of while
+//        case KEYED_PREP:
-  }
+//          //modified KD8CEC
-  else{
+//          /*
+//          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
@@ -264,7 +298,7 @@ void cwKeyer(void){
 
       Check_Cat(2);
     } //end of while
-  }   //end of elese
+//  }   //end of elese
 }