All kenwoods to have 3-char commands for functions and return whatever value the rig returns instead of 0/1

Changes to add more ts890 capabilities, e.g. NB2, BC2

kenwood/kenwood.c

@@ -2056,7 +2056,12 @@ int kenwood_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
     return kenwood_transaction(rig, buf, NULL, 0);
 
   case RIG_FUNC_COMP:
+    if (RIG_MODEL_TS890S == rig->caps->rig_model) {
+      snprintf(buf, sizeof (buf), "PR0%c", (status == 0) ? '0' : '1');
+    }
+    else {
       snprintf(buf, sizeof (buf), "PR%c", (status == 0) ? '0' : '1');
+    }
     return kenwood_transaction(rig, buf, NULL, 0);
 
   case RIG_FUNC_TONE:
@@ -2076,13 +2081,24 @@ int kenwood_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
     return kenwood_transaction(rig, buf, NULL, 0);
 
   case RIG_FUNC_NR:
+    if (RIG_MODEL_TS890S == rig->caps->rig_model) {
+      char c = '1';
+      if (status == 2) c = '2';
+      snprintf(buf, sizeof (buf), "NR%c", (status == 0) ? '0' : c);
+    }
+    else {
       snprintf(buf, sizeof (buf), "NR%c", (status == 0) ? '0' : '1');
+    }
     return kenwood_transaction(rig, buf, NULL, 0);
 
   case RIG_FUNC_BC:
     snprintf(buf, sizeof (buf), "BC%c", (status == 0) ? '0' : '1');
     return kenwood_transaction(rig, buf, NULL, 0);
 
+  case RIG_FUNC_BC2:
+    snprintf(buf, sizeof (buf), "BC%c", (status == 0) ? '0' : '2');
+    return kenwood_transaction(rig, buf, NULL, 0);
+
   case RIG_FUNC_ANF:
     snprintf(buf, sizeof (buf), "NT%c", (status == 0) ? '0' : '1');
     return kenwood_transaction(rig, buf, NULL, 0);
@@ -2112,8 +2128,9 @@ int kenwood_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
 }
 
 /*
- * works for any 'format 1' command
+ * works for any 'format 1' command or newer command like the TS890 has
- * answer is always 4 bytes: two byte command id, status and terminator
+ * as long as the return is a number 0-9
+ * answer is always 4 bytes or 5 bytes: two or three byte command id, status and terminator
  */
 int get_kenwood_func(RIG *rig, const char *cmd, int *status)
 {
@@ -2125,11 +2142,14 @@ int get_kenwood_func(RIG *rig, const char *cmd, int *status)
   int retval;
   char buf[10];
 
-  retval = kenwood_safe_transaction(rig, cmd, buf, 10, 3);
+  int offset=2;
+  if (strlen(cmd)==3) offset=3; // some commands are 3 letters 
+
+  retval = kenwood_safe_transaction(rig, cmd, buf, sizeof(buf), offset+1);
   if (retval != RIG_OK)
     return retval;
 
-  *status = buf[2] == '0' ? 0 : 1;
+  *status = buf[offset] - '0'; // just return whatever the rig returns
 
   return RIG_OK;
 };
@@ -2139,6 +2159,7 @@ int get_kenwood_func(RIG *rig, const char *cmd, int *status)
  */
 int kenwood_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status)
 {
+  char *cmd;
   rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
 
   if (!rig || !status)
@@ -2157,7 +2178,11 @@ int kenwood_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status)
     return RIG_OK;
 
   case RIG_FUNC_NB:
-    return get_kenwood_func(rig, "NB", status);
+    cmd = "NB";
+    if (RIG_MODEL_TS890S == rig->caps->rig_model) {
+      cmd = "NB1";
+    }
+    return get_kenwood_func(rig, cmd, status);
 
   case RIG_FUNC_NB2:
     return get_kenwood_func(rig, "NB2", status);
@@ -2181,8 +2206,20 @@ int kenwood_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status)
     return get_kenwood_func(rig, "NR", status);
 
   /* FIXME on TS2000 */
-  case RIG_FUNC_BC:
+  // Check for BC #1
-    return get_kenwood_func(rig, "BC", status);
+  case RIG_FUNC_BC: // Most will return BC1 or BC0, if BC2 then BC1 is off
+    retval = get_kenwood_func(rig, "BC", status);
+    if (retval == RIG_OK) {
+      *status = *status == '1' ? '1': '0'; 
+    }
+    return retval;
+
+  case RIG_FUNC_BC2: // TS-890 check Beat Cancel 2 we return boolean true/false
+    retval = get_kenwood_func(rig, "BC", status);
+    if (retval == RIG_OK) {
+      *status = *status == '2' ? '1': '0'; 
+    }
+    return retval;
 
   case RIG_FUNC_ANF:
     return get_kenwood_func(rig, "NT", status);

kenwood/ts480.c

@@ -39,7 +39,8 @@
 #define TS480_VFO (RIG_VFO_A|RIG_VFO_B)
 
 #define TS480_LEVEL_ALL (RIG_LEVEL_RFPOWER|RIG_LEVEL_AF|RIG_LEVEL_RF|RIG_LEVEL_SQL|RIG_LEVEL_AGC)
-#define TS480_FUNC_ALL (RIG_FUNC_NB|RIG_FUNC_COMP|RIG_FUNC_VOX|RIG_FUNC_NR|RIG_FUNC_NR|RIG_FUNC_BC)
+#define TS480_FUNC_ALL (RIG_FUNC_NB|RIG_FUNC_COMP|RIG_FUNC_VOX|RIG_FUNC_NR|RIG_FUNC_NR|RIG_FUNC_BC|RIG_FUNC_BC2)
+#define TS890_FUNC_ALL (RIG_FUNC_NB|RIG_FUNC_NB2|RIG_FUNC_COMP|RIG_FUNC_VOX|RIG_FUNC_NR|RIG_FUNC_NR|RIG_FUNC_BC|RIG_FUNC_BC2)
 
 
 /*
@@ -53,24 +54,34 @@ kenwood_ts480_get_info (RIG * rig)
     int retval;
 
     retval = kenwood_transaction(rig, "TY", firmbuf, sizeof(firmbuf));
+
     if (retval != RIG_OK)
+    {
         return NULL;
+    }
+
     size_t firm_len = strlen(firmbuf);
+
     if (firm_len != 5)
     {
         rig_debug(RIG_DEBUG_ERR, "kenwood_get_info: wrong answer len=%d\n", firm_len);
         return NULL;
     }
+
     switch (firmbuf[4])
     {
     case '0':
         return "TS-480HX (200W)";
+
     case '1':
         return "TS-480SAT (100W + AT)";
+
     case '2':
         return "Japanese 50W type";
+
     case '3':
         return "Japanese 20W type";
+
     default:
         return "Firmware: unknown";
     }
@@ -91,6 +102,9 @@ kenwood_ts480_set_level (RIG * rig, vfo_t vfo, setting_t level, value_t val)
 {
     char levelbuf[16];
     int kenwood_val;
+    int rf_max_level = 100; /* 100 for TS-480 and 255 for TS-890S */
+
+    rig_debug(RIG_DEBUG_TRACE, "%s called\n", __func__);
 
     switch (level)
     {
@@ -101,37 +115,106 @@ kenwood_ts480_set_level (RIG * rig, vfo_t vfo, setting_t level, value_t val)
 
     case RIG_LEVEL_AF:
         kenwood_val = val.f * 255;    /* possible values for TS480 are 000.. 255 */
+
+        if (rig->caps->rig_model == RIG_MODEL_TS890S)
+        {
+            sprintf(levelbuf, "AG%03d", kenwood_val);
+        }
+        else
+        {
             sprintf(levelbuf, "AG0%03d", kenwood_val);
+        }
+
         break;
 
     case RIG_LEVEL_RF:
-      kenwood_val = val.f * 100;	/* possible values for TS480 are 000.. 100 */
+        if (rig->caps->rig_model == RIG_MODEL_TS890S)
+        {
+            rf_max_level = 255;
+        }
+
+        kenwood_val = val.f *
+                      rf_max_level;   /* possible values for TS480 are 000.. 100 */
         sprintf(levelbuf, "RG%03d", kenwood_val);
         break;
 
     case RIG_LEVEL_SQL:
         kenwood_val = val.f * 255;    /* possible values for TS480 are 000.. 255 */
+
+        if (rig->caps->rig_model == RIG_MODEL_TS890S)
+        {
+            sprintf(levelbuf, "SQ%03d", kenwood_val);
+        }
+        else
+        {
             sprintf(levelbuf, "SQ0%03d", kenwood_val);
+        }
+
         break;
 
-    case RIG_LEVEL_AGC:	/* possible values for TS480 000(=off), 001(=fast), 002(=slow) */
+    case RIG_LEVEL_AGC: 
         /* hamlib argument is int, possible values rig.h:enum agc_level_e */
+        /* possible values for TS480 000(=off), 001(=fast), 002(=slow) */
+        /* possible values for TS890 0(=off), 1(=slow), 2(=mid), 3(=fast), 4(=off/Last) */
+        if (rig->caps->rig_model == RIG_MODEL_TS890S)
+        {
+            rig_debug(RIG_DEBUG_VERBOSE, "%s TS890S RIG_LEVEL_AGC\n", __func__);
+
             switch (val.i)
             {
             case RIG_AGC_OFF:
                 kenwood_val = 0;
                 break;
-	case RIG_AGC_FAST:
+
+            case RIG_AGC_SLOW:
                 kenwood_val = 1;
                 break;
-	case RIG_AGC_SLOW:
+
+            case RIG_AGC_MEDIUM:
                 kenwood_val = 2;
                 break;
+
+            case RIG_AGC_FAST:
+                kenwood_val = 3;
+                break;
+
+            case RIG_AGC_AUTO:
+                kenwood_val = 4;
+                break;
+
             default:
                 rig_debug(RIG_DEBUG_ERR, "Unsupported agc value");
                 return -RIG_EINVAL;
-	};
+            }
+
+            sprintf(levelbuf, "GC%d", kenwood_val);
+        }
+        else
+        {
+            rig_debug(RIG_DEBUG_VERBOSE, "%s TS480 RIG_LEVEL_AGC\n", __func__);
+
+            switch (val.i)
+            {
+            case RIG_AGC_OFF:
+                kenwood_val = 0;
+                break;
+
+            case RIG_AGC_FAST:
+                kenwood_val = 1;
+                break;
+
+            case RIG_AGC_SLOW:
+                kenwood_val = 2;
+                break;
+
+            default:
+                rig_debug(RIG_DEBUG_ERR, "Unsupported agc value");
+                return -RIG_EINVAL;
+            }
+
             sprintf(levelbuf, "GT%03d", kenwood_val);
+        }
+
         break;
 
     default:
@@ -151,81 +234,201 @@ int
 kenwood_ts480_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 {
     char ackbuf[50];
-  size_t ack_len;
+    size_t ack_len, ack_len_expected;
     int levelint;
+    int offset_level=3; // default offset for the level return value
     int retval;
+    int rf_max_level;
+
+    rig_debug(RIG_DEBUG_TRACE, "%s called\n", __func__);
+
+    if (rig->caps->rig_model == RIG_MODEL_TS890S)
+    {
+        rf_max_level = 255;
+    }
+    else
+    {
+        rf_max_level = 100;
+    }
 
     switch (level)
     {
     case RIG_LEVEL_RFPOWER:
         retval = kenwood_transaction(rig, "PC", ackbuf, sizeof(ackbuf));
+
         if (RIG_OK != retval)
+        {
             return retval;
+        }
+
         ack_len = strlen(ackbuf);
+
         if (5 != ack_len)
+        {
             return -RIG_EPROTO;
+        }
+
         if (1 != sscanf(&ackbuf[2], "%d", &levelint))
+        {
             return -RIG_EPROTO;
+        }
+
         val->f = (float) levelint / 100.;
         return RIG_OK;
 
     case RIG_LEVEL_AF:
+        if (rig->caps->rig_model == RIG_MODEL_TS890S)
+        {
+            retval = kenwood_transaction(rig, "AG", ackbuf, sizeof(ackbuf));
+            offset_level = 2;
+        }
+        else
+        {
             retval = kenwood_transaction(rig, "AG0", ackbuf, sizeof(ackbuf));
+            offset_level = 3;
+        }
+
         if (RIG_OK != retval)
+        {
             return retval;
+        }
+
         ack_len = strlen(ackbuf);
-      if (6 != ack_len)
+
+        if (offset_level+3 != ack_len)
+        {
             return -RIG_EPROTO;
-      if (1 != sscanf (&ackbuf[3], "%d", &levelint))
+        }
+
+        if (1 != sscanf(&ackbuf[offset_level], "%d", &levelint))
+        {
             return -RIG_EPROTO;
-      val->f = (float) levelint / 255.;
+        }
+
+        val->f = levelint / (float) rf_max_level;
         return RIG_OK;
 
     case RIG_LEVEL_RF:
         retval = kenwood_transaction(rig, "RG", ackbuf, sizeof(ackbuf));
+
         if (RIG_OK != retval)
+        {
             return retval;
+        }
+
         ack_len = strlen(ackbuf);
+
         if (5 != ack_len)
+        {
             return -RIG_EPROTO;
+        }
+
         if (1 != sscanf(&ackbuf[2], "%d", &levelint))
+        {
             return -RIG_EPROTO;
-      val->f = (float) levelint / 100.;
+        }
+
+        val->f = levelint / (float) rf_max_level;
         return RIG_OK;
 
     case RIG_LEVEL_SQL:
+        if (rig->caps->rig_model == RIG_MODEL_TS890S)
+        {
+            retval = kenwood_transaction(rig, "SQ", ackbuf, sizeof(ackbuf));
+            ack_len_expected = 5;
+        }
+        else
+        {
             retval = kenwood_transaction(rig, "SQ0", ackbuf, sizeof(ackbuf));
+            ack_len_expected = 6;
+        }
+
         if (RIG_OK != retval)
+        {
             return retval;
+        }
+
         ack_len = strlen(ackbuf);
-      if (6 != ack_len)
+
+        if (ack_len != ack_len_expected)
+        {
             return -RIG_EPROTO;
-      if (1 != sscanf (&ackbuf[3], "%d", &levelint))
+        }
+
+        if (1 != sscanf(&ackbuf[ack_len_expected - 3], "%d", &levelint))
+        {
             return -RIG_EPROTO;
+        }
+
         val->f = (float) levelint / 255.;
         return RIG_OK;
 
     case RIG_LEVEL_AGC:
+        if (rig->caps->rig_model == RIG_MODEL_TS890S)
+        {
+            retval = kenwood_transaction(rig, "GC", ackbuf, sizeof(ackbuf));
+            ack_len_expected = 3;
+        }
+        else
+        {
             retval = kenwood_transaction(rig, "GT", ackbuf, sizeof(ackbuf));
+            ack_len_expected = 5;
+        }
+
         if (RIG_OK != retval)
+        {
             return retval;
+        }
+
         ack_len = strlen(ackbuf);
-      if (5 != ack_len)
+
+        if (ack_len != ack_len_expected)
+        {
             return -RIG_EPROTO;
-      switch (ackbuf[4])
+        }
+
+        switch (ackbuf[ack_len_expected - 1])
         {
         case '0':
             val->i = RIG_AGC_OFF;
             break;
+
         case '1':
+            if (rig->caps->rig_model == RIG_MODEL_TS890S)
+            {
+                val->i = RIG_AGC_SLOW;
+            }
+            else
+            {
+                val->i = RIG_AGC_FAST;
+            }
+
+            break;
+
+        case '2':
+            if (rig->caps->rig_model == RIG_MODEL_TS890S)
+            {
+                val->i = RIG_AGC_MEDIUM;
+            }
+            else
+            {
+                val->i = RIG_AGC_SLOW;
+            }
+
+            break;
+
+        case '3':
             val->i = RIG_AGC_FAST;
             break;
-	case '2':
+
-	  val->i = RIG_AGC_SLOW;
+        case '4':
+            val->i = RIG_AGC_AUTO;
             break;
+
         default:
             return -RIG_EPROTO;
         }
+
         return RIG_OK;
 
     case RIG_LEVEL_MICGAIN:
@@ -251,11 +454,13 @@ kenwood_ts480_get_level (RIG * rig, vfo_t vfo, setting_t level, value_t * val)
     return RIG_OK;        /* never reached */
 }
 
-static struct kenwood_priv_caps ts480_priv_caps = {
+static struct kenwood_priv_caps ts480_priv_caps =
+{
     .cmdtrm = EOM_KEN,
 };
 
-static struct kenwood_priv_caps ts890s_priv_caps = {
+static struct kenwood_priv_caps ts890s_priv_caps =
+{
     .cmdtrm = EOM_KEN,
 };
 
@@ -265,7 +470,8 @@ static struct kenwood_priv_caps ts890s_priv_caps = {
  * Notice that some rigs share the same functions.
  * Also this struct is READONLY!
  */
-const struct rig_caps ts480_caps = {
+const struct rig_caps ts480_caps =
+{
     .rig_model = RIG_MODEL_TS480,
     .model_name = "TS-480",
     .mfg_name = "Kenwood",
@@ -419,13 +625,14 @@ const struct rig_caps ts480_caps = {
  * Notice that some rigs share the same functions.
  * Also this struct is READONLY!
  */
-const struct rig_caps ts890s_caps = {
+const struct rig_caps ts890s_caps =
+{
     .rig_model = RIG_MODEL_TS890S,
     .model_name = "TS-890S",
     .mfg_name = "Kenwood",
-  .version = BACKEND_VER ".2",
+    .version = BACKEND_VER ".3",
     .copyright = "LGPL",
-  .status = RIG_STATUS_BETA,
+    .status = RIG_STATUS_STABLE,
     .rig_type = RIG_TYPE_TRANSCEIVER,
     .ptt_type = RIG_PTT_RIG_MICDATA,
     .dcd_type = RIG_DCD_RIG,
@@ -560,22 +767,9 @@ const struct rig_caps ts890s_caps = {
     .has_get_level = TS480_LEVEL_ALL,
     .set_level = kenwood_ts480_set_level,
     .get_level = kenwood_ts480_get_level,
-  .has_get_func = TS480_FUNC_ALL,
+    .has_get_func = TS890_FUNC_ALL,
-  .has_set_func = TS480_FUNC_ALL,
+    .has_set_func = TS890_FUNC_ALL,
     .set_func = kenwood_set_func,
     .get_func = kenwood_get_func,
 };
 
-
-/*
- * my notes:
- *  format with:  indent --line-length 200 ts480.c
- *
- * for the TS480 the function NR and BC have tree state: NR0,1,2 and BC0,1,2
- * this cannot be send through the on/off logic of set_function!
- */
-
-
-/*
- * Function definitions below
- */