Example #1
0
int sprintf_mode(char *str, rmode_t mode)
{
    int i, len = 0;

    *str = '\0';

    if (mode == RIG_MODE_NONE)
    {
        return 0;
    }

    for (i = 0; i < 30; i++)
    {
        const char *ms = rig_strrmode(mode & (1UL << i));

        if (!ms || !ms[0])
        {
            continue;    /* unknown, FIXME! */
        }

        strcat(str, ms);
        strcat(str, " ");
        len += strlen(ms) + 1;
    }

    return len;
}
Example #2
0
static int flex6k_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
  rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);

  if (!rig)
    return -RIG_EINVAL;

  struct kenwood_priv_caps *caps = kenwood_caps(rig);
  char buf[10];
  char kmode;
  int idx;
  int err;

  kmode = rmode2kenwood(mode, caps->mode_table);
  if (kmode < 0 ) {
    rig_debug(RIG_DEBUG_WARN, "%s: unsupported mode '%s'\n",
	      __func__, rig_strrmode(mode));
    return -RIG_EINVAL;
  }

  sprintf(buf, "MD%c", '0' + kmode);
  err = kenwood_simple_cmd(rig, buf);
  if (err != RIG_OK)
    return err;

  err = flex6k_find_width(mode, width, &idx);
  if (err != RIG_OK)
    return err;

  if ((vfo == RIG_VFO_VFO) || (vfo == RIG_VFO_CURR)) {
    vfo = rig->state.current_vfo;
    rig_debug(RIG_DEBUG_VERBOSE, "%s: setting VFO to current\n", __func__);
  }
  /*
   * The Flex CAT interface does not support FW for reading filter width,
   * so use the ZZFI or ZZFJ command
   */
  switch (vfo) {
  case RIG_VFO_A:
    sprintf(buf, "ZZFI%02d;", idx);
    break;
  case RIG_VFO_B:
    sprintf(buf, "ZZFJ%02d;", idx);
    break;
  default:
    rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %d\n", __func__, vfo);
    return -RIG_EINVAL;
  }

  err = kenwood_simple_cmd(rig, buf);
  if (err != RIG_OK)
    return err;
  return RIG_OK;
}
Example #3
0
/*
 * barrett_get_mode
 * Assumes rig!=NULL
 * Note that 2050 does not have set or get width
 */
int barrett_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
{
    rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo=%s\n", __FUNCTION__, rig_strvfo(vfo));

    char *result = NULL;
    int retval = barrett_transaction(rig, "IB", 0, &result);

    if (retval != RIG_OK) {
        rig_debug(RIG_DEBUG_ERR, "%s: bad response=%s\n", __FUNCTION__, result);
        return retval;
    }

    //dump_hex((unsigned char *)result,strlen(result));
    switch (result[1]) {
    case 'L':
        *mode = RIG_MODE_LSB;
        break;

    case 'U':
        *mode = RIG_MODE_USB;
        break;

    case 'A':
        *mode = RIG_MODE_AM;
        break;

    case 'F':
        *mode = RIG_MODE_RTTY;
        break;

    case 'C':
        *mode = RIG_MODE_CW;
        break;

    default:
        rig_debug(RIG_DEBUG_ERR, "%s: Unknown mode='%c%c'\n", __FUNCTION__,  result[0],
                  result[1]);
        return -RIG_EPROTO;
    }

    *width = 3000; // we'll default this to 3000 for now
    rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo=%s mode=%s width=%d\n", __FUNCTION__,
              rig_strvfo(vfo), rig_strrmode(*mode), *width);

    return RIG_OK;
}
Example #4
0
static int netrigctl_set_split_mode(RIG *rig, vfo_t vfo, rmode_t tx_mode, pbwidth_t tx_width)
{
  int ret, len;
  char cmd[CMD_MAX];
  char buf[BUF_MAX];

  rig_debug(RIG_DEBUG_VERBOSE,"%s called\n", __FUNCTION__);

  len = sprintf(cmd, "X %s %li\n",
  		rig_strrmode(tx_mode), tx_width);

  ret = netrigctl_transaction(rig, cmd, len, buf);
  if (ret > 0)
	return -RIG_EPROTO;
  else
  	return ret;
}
Example #5
0
bool rigControl::getMode(QString &mode)
{
    if(catParams.enableXMLRPC)
    {
        mode =xmlIntfPtr->getMode();
    }
    else
    {
        rmode_t rmode;
        pbwidth_t width;
        int retcode;
        if(!rigControlEnabled) return false;
        retcode = rig_get_mode(my_rig, RIG_VFO_CURR, &rmode, &width);
        if (retcode != RIG_OK ) {errorMessage(retcode,"getMode"); return false; }
        mode=QString(rig_strrmode(rmode));
    }
    return true;
}
Example #6
0
/*
 * th_set_mode
 * Assumes rig!=NULL
 */
int
th_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
	char kmode, mdbuf[8];
	int retval;
	const struct kenwood_priv_caps *priv=(const struct kenwood_priv_caps *)rig->caps->priv;

	rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);

	if (vfo != RIG_VFO_CURR && vfo != rig->state.current_vfo)
		return kenwood_wrong_vfo(__func__, vfo);


	if (priv->mode_table) {

		kmode = rmode2kenwood(mode, priv->mode_table);
		if (kmode == -1) {
			rig_debug(RIG_DEBUG_WARN, "%s: Unsupported Mode value '%s'\n",
				__func__, rig_strrmode(mode));
			return -RIG_EINVAL;
		}
		kmode += '0';

	} else	{

		switch (mode) {
		case RIG_MODE_FM: kmode = '0'; break; /* TH-D7A(G) modes */
		case RIG_MODE_AM: kmode = '1'; break;
		default:
			rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Mode %d\n", __func__, mode);
			return -RIG_EINVAL;
		}
	}

	sprintf(mdbuf, "MD %c", kmode);

	retval = kenwood_cmd(rig, mdbuf);
	if (retval != RIG_OK)
		return retval;

	return RIG_OK;
}
Example #7
0
int main(int argc, char *argv[])
{
    RIG *my_rig;        /* handle to rig (nstance) */
    freq_t freq;        /* frequency  */
    rmode_t rmode;      /* radio mode of operation */
    pbwidth_t width;
    vfo_t vfo;          /* vfo selection */
    int strength;       /* S-Meter level */
    int rit = 0;        /* RIT status */
    int xit = 0;        /* XIT status */
    int retcode;        /* generic return code from functions */

    rig_model_t myrig_model;


    printf("testrig: Hello, I am your main() !\n");

    /* Turn off backend debugging ouput */
    rig_set_debug_level(RIG_DEBUG_NONE);

    /*
     * allocate memory, setup & open port
     */

    if (argc < 2)
    {
        hamlib_port_t myport;
        /* may be overriden by backend probe */
        myport.type.rig = RIG_PORT_SERIAL;
        myport.parm.serial.rate = 9600;
        myport.parm.serial.data_bits = 8;
        myport.parm.serial.stop_bits = 1;
        myport.parm.serial.parity = RIG_PARITY_NONE;
        myport.parm.serial.handshake = RIG_HANDSHAKE_NONE;
        strncpy(myport.pathname, SERIAL_PORT, FILPATHLEN - 1);

        rig_load_all_backends();
        myrig_model = rig_probe(&myport);
    }
    else
    {
        myrig_model = atoi(argv[1]);
    }

    my_rig = rig_init(myrig_model);

    if (!my_rig)
    {
        fprintf(stderr, "Unknown rig num: %d\n", myrig_model);
        fprintf(stderr, "Please check riglist.h\n");
        exit(1); /* whoops! something went wrong (mem alloc?) */
    }

    strncpy(my_rig->state.rigport.pathname, SERIAL_PORT, FILPATHLEN - 1);

    retcode = rig_open(my_rig);

    if (retcode != RIG_OK)
    {
        printf("rig_open: error = %s\n", rigerror(retcode));
        exit(2);
    }

    printf("Port %s opened ok\n", SERIAL_PORT);

    /*
     * Below are examples of set/get routines.
     * Must add checking of functionality map prior to command execution -- FS
     *
     */

    /*
     * Example of setting rig paameters
     * and some error checking on the return code.
     */

    retcode = rig_set_vfo(my_rig, RIG_VFO_B);


    if (retcode != RIG_OK)
    {
        printf("rig_set_vfo: error = %s \n", rigerror(retcode));
    }


    /*
     * Lets try some frequencies and modes. Return code is not checked.
     * Examples of checking return code are further down.
     *
     */

    /* 10m FM Narrow */

    printf("\nSetting 10m FM Narrow...\n");

    retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 29620000); /* 10m */
    retcode = rig_set_mode(my_rig, RIG_VFO_CURR, RIG_MODE_FM,
                           rig_passband_narrow(my_rig, RIG_MODE_FM));

    if (retcode != RIG_OK)
    {
        printf("rig_set_freq: error = %s \n", rigerror(retcode));
    }

    rig_get_freq(my_rig, RIG_VFO_CURR, &freq);
    rig_get_mode(my_rig, RIG_VFO_CURR, &rmode, &width);

    printf(" Freq: %.6f MHz, Mode: %s, Passband: %.3f kHz\n\n",
           freq / 1000000,
           rig_strrmode(rmode),
           width / 1000.0);

    sleep(1);       /* so you can see it -- FS */

    /* 15m USB */

    printf("Setting 15m USB...\n");

    retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 21235175); /* 15m  */
    retcode = rig_set_mode(my_rig,
                           RIG_VFO_CURR,
                           RIG_MODE_USB,
                           rig_passband_normal(my_rig, RIG_MODE_USB));

    if (retcode != RIG_OK)
    {
        printf("rig_set_freq: error = %s \n", rigerror(retcode));
    }

    rig_get_freq(my_rig, RIG_VFO_CURR, &freq);
    rig_get_mode(my_rig, RIG_VFO_CURR, &rmode, &width);

    printf(" Freq: %.6f MHz, Mode: %s, Passband: %.3f kHz\n\n",
           freq / 1000000, rig_strrmode(rmode), width / 1000.0);
    sleep(1);

    /* 40m LSB */

    printf("Setting 40m LSB...\n");

    retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 7250100); /* 40m  */
    retcode = rig_set_mode(my_rig,
                           RIG_VFO_CURR,
                           RIG_MODE_LSB,
                           RIG_PASSBAND_NORMAL);

    if (retcode != RIG_OK)
    {
        printf("rig_set_freq: error = %s \n", rigerror(retcode));
    }

    rig_get_freq(my_rig, RIG_VFO_CURR, &freq);
    rig_get_mode(my_rig, RIG_VFO_CURR, &rmode, &width);

    printf(" Freq: %.6f MHz, Mode: %s, Passband: %.3f kHz\n\n",
           freq / 1000000,
           rig_strrmode(rmode),
           width / 1000.0);
    sleep(1);

    /* 80m AM Narrow */

    printf("Setting 80m AM Narrow...\n");

    retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 3885000); /* 80m  */
    retcode = rig_set_mode(my_rig,
                           RIG_VFO_CURR,
                           RIG_MODE_AM,
                           rig_passband_narrow(my_rig, RIG_MODE_AM));

    if (retcode != RIG_OK)
    {
        printf("rig_set_freq: error = %s \n", rigerror(retcode));
    }

    rig_get_freq(my_rig, RIG_VFO_CURR, &freq);
    rig_get_mode(my_rig, RIG_VFO_CURR, &rmode, &width);

    printf(" Freq: %.6f MHz, Mode: %s, Passband: %.3f kHz\n\n",
           freq / 1000000,
           rig_strrmode(rmode),
           width / 1000.0);

    sleep(1);

    /* 160m CW Normal */

    printf("Setting 160m CW...\n");

    retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 1875000); /* 160m  */
    retcode = rig_set_mode(my_rig,
                           RIG_VFO_CURR,
                           RIG_MODE_CW,
                           RIG_PASSBAND_NORMAL);

    if (retcode != RIG_OK)
    {
        printf("rig_set_freq: error = %s \n", rigerror(retcode));
    }

    rig_get_freq(my_rig, RIG_VFO_CURR, &freq);
    rig_get_mode(my_rig, RIG_VFO_CURR, &rmode, &width);

    printf(" Freq: %.3f kHz, Mode: %s, Passband: %li Hz\n\n",
           freq / 1000,
           rig_strrmode(rmode),
           width);

    sleep(1);

    /* 160m CW Narrow -- The band is noisy tonight -- FS*/

    printf("Setting 160m CW Narrow...\n");

    retcode = rig_set_mode(my_rig,
                           RIG_VFO_CURR,
                           RIG_MODE_CW,
                           rig_passband_narrow(my_rig, RIG_MODE_CW));

    if (retcode != RIG_OK)
    {
        printf("rig_set_freq: error = %s \n", rigerror(retcode));
    }

    rig_get_freq(my_rig, RIG_VFO_CURR, &freq);
    rig_get_mode(my_rig, RIG_VFO_CURR, &rmode, &width);

    printf(" Freq: %.3f kHz, Mode: %s, Passband: %li Hz\n\n",
           freq / 1000,
           rig_strrmode(rmode),
           width);

    sleep(1);

    /* AM Broadcast band */

    printf("Setting Medium Wave AM...\n");

    retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 770000); /* KAAM */
    retcode = rig_set_mode(my_rig,
                           RIG_VFO_CURR,
                           RIG_MODE_AM,
                           RIG_PASSBAND_NORMAL);

    if (retcode != RIG_OK)
    {
        printf("rig_set_freq: error = %s \n", rigerror(retcode));
    }

    rig_get_freq(my_rig, RIG_VFO_CURR, &freq);
    rig_get_mode(my_rig, RIG_VFO_CURR, &rmode, &width);

    printf(" Freq: %.3f kHz, Mode: %s, Passband: %.3f kHz\n\n",
           freq / 1000,
           rig_strrmode(rmode),
           width / 1000.0);

    sleep(1);

    /* 20m USB on VFO_A */

    printf("Setting 20m on VFO A with two functions...\n");

    retcode = rig_set_vfo(my_rig, RIG_VFO_A);
    retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 14250375); /* cq de vk3fcs */

    if (retcode != RIG_OK)
    {
        printf("rig_set_freq: error = %s \n", rigerror(retcode));
    }

    rig_get_freq(my_rig, RIG_VFO_CURR, &freq);
    rig_get_vfo(my_rig, &vfo);

    printf(" Freq: %.6f MHz, VFO: %s\n\n", freq / 1000000, rig_strvfo(vfo));

    sleep(1);

    /* 20m USB on VFO_A , with only 1 call */

    printf("Setting  20m on VFO A with one function...\n");
    retcode = rig_set_freq(my_rig, RIG_VFO_A, 14295125); /* cq de vk3fcs */

    if (retcode != RIG_OK)
    {
        printf("rig_set_freq: error = %s \n", rigerror(retcode));
    }

    rig_get_freq(my_rig, RIG_VFO_CURR, &freq);
    rig_get_vfo(my_rig, &vfo);

    printf(" Freq: %.6f MHz, VFO: %s\n\n", freq / 1000000, rig_strvfo(vfo));

    sleep(1);


#if 0
    retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 145100000); /* 2m  */
    sleep(2);
    retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 435125000); /* 70cm  */
    sleep(2);
#endif

    printf("Setting rig Mode to LSB.\n");
    retcode = rig_set_mode(my_rig,
                           RIG_VFO_CURR,
                           RIG_MODE_LSB,
                           RIG_PASSBAND_NORMAL);

    if (retcode != RIG_OK)
    {
        printf("rig_set_mode: error = %s \n", rigerror(retcode));
    }

    sleep(1);

    printf("Setting rig PTT ON.\n");
    retcode = rig_set_ptt(my_rig, RIG_VFO_A, RIG_PTT_ON);  /* stand back ! */

    if (retcode != RIG_OK)
    {
        printf("rig_set_ptt: error = %s \n", rigerror(retcode));
    }

    sleep(1);

    printf("Setting rig PTT OFF.\n");
    retcode = rig_set_ptt(my_rig, RIG_VFO_A, RIG_PTT_OFF);  /* phew ! */

    if (retcode != RIG_OK)
    {
        printf("rig_set_ptt: error = %s \n", rigerror(retcode));
    }

    sleep(1);

    /*
     * Simple examples of getting rig information -- FS
     *
     */

    printf("\nGet various raw rig values:\n");
    retcode = rig_get_vfo(my_rig, &vfo); /* try to get vfo info */

    if (retcode == RIG_OK)
    {
        printf("rig_get_vfo: vfo = %i \n", vfo);
    }
    else
    {
        printf("rig_get_vfo: error =  %s \n", rigerror(retcode));
    }

    retcode = rig_get_freq(my_rig, RIG_VFO_CURR, &freq);

    if (retcode == RIG_OK)
    {
        printf("rig_get_freq: freq = %"PRIfreq"\n", freq);
    }
    else
    {
        printf("rig_get_freq: error =  %s \n", rigerror(retcode));
    }

    retcode = rig_get_mode(my_rig, RIG_VFO_CURR, &rmode, &width);

    if (retcode == RIG_OK)
    {
        printf("rig_get_mode: mode = %"PRIll"\n", rmode);
    }
    else
    {
        printf("rig_get_mode: error =  %s \n", rigerror(retcode));
    }

    retcode = rig_get_strength(my_rig, RIG_VFO_CURR, &strength);

    if (retcode == RIG_OK)
    {
        printf("rig_get_strength: strength = %i \n", strength);
    }
    else
    {
        printf("rig_get_strength: error =  %s \n", rigerror(retcode));
    }

    if (rig_has_set_func(my_rig, RIG_FUNC_RIT))
    {
        retcode = rig_set_func(my_rig, RIG_VFO_CURR, RIG_FUNC_RIT, 1);
        printf("rig_set_func: Setting RIT ON\n");
    }

    if (rig_has_get_func(my_rig, RIG_FUNC_RIT))
    {
        retcode = rig_get_func(my_rig, RIG_VFO_CURR, RIG_FUNC_RIT, &rit);
        printf("rig_get_func: RIT: %d\n", rit);
    }

    if (rig_has_set_func(my_rig, RIG_FUNC_XIT))
    {
        retcode = rig_set_func(my_rig, RIG_VFO_CURR, RIG_FUNC_XIT, 1);
        printf("rig_set_func: Setting XIT ON\n");
    }

    if (rig_has_get_func(my_rig, RIG_FUNC_XIT))
    {
        retcode = rig_get_func(my_rig, RIG_VFO_CURR, RIG_FUNC_XIT, &xit);
        printf("rig_get_func: XIT: %d\n", xit);
    }

    rig_close(my_rig); /* close port */
    rig_cleanup(my_rig); /* if you care about memory */

    printf("port %s closed ok \n", SERIAL_PORT);

    return 0;
}
Example #8
0
File: ft847.c Project: dh1tw/hamlib
int ft847_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) {
  unsigned char cmd_index;	/* index of sequence to send */
  struct rig_state *rs = &rig->state;
  unsigned char p_cmd[YAESU_CMD_LENGTH]; /* sequence to send */
  int ret;

  /*
   * translate mode from generic to ft847 specific
   */

  rig_debug(RIG_DEBUG_VERBOSE,"ft847: generic mode = %x \n", mode);


  switch(mode) {
  case RIG_MODE_AM:
    cmd_index = FT_847_NATIVE_CAT_SET_MODE_MAIN_AM;
    break;
  case RIG_MODE_CW:
    cmd_index = FT_847_NATIVE_CAT_SET_MODE_MAIN_CW;
    break;
  case RIG_MODE_CWR:
    cmd_index = FT_847_NATIVE_CAT_SET_MODE_MAIN_CWR;
    break;
  case RIG_MODE_USB:
    cmd_index = FT_847_NATIVE_CAT_SET_MODE_MAIN_USB;
    break;
  case RIG_MODE_LSB:
    cmd_index = FT_847_NATIVE_CAT_SET_MODE_MAIN_LSB;
    break;
  case RIG_MODE_FM:
    cmd_index = FT_847_NATIVE_CAT_SET_MODE_MAIN_FM;
    break;
  default:
    return -RIG_EINVAL;		/* sorry, wrong MODE */
  }


  /*
   * Now set width
   */
  if (width != RIG_PASSBAND_NOCHANGE) {
    if (width == rig_passband_narrow(rig, mode)) {
      switch(mode) {
      case RIG_MODE_AM:
        cmd_index = FT_847_NATIVE_CAT_SET_MODE_MAIN_AMN;
        break;
      case RIG_MODE_FM:
        cmd_index = FT_847_NATIVE_CAT_SET_MODE_MAIN_FMN;
        break;
      case RIG_MODE_CW:
        cmd_index = FT_847_NATIVE_CAT_SET_MODE_MAIN_CWN;
        break;
      case RIG_MODE_CWR:
        cmd_index = FT_847_NATIVE_CAT_SET_MODE_MAIN_CWRN;
        break;
      case RIG_MODE_USB:
      case RIG_MODE_LSB:
        break;
      default:
        rig_debug(RIG_DEBUG_ERR,"%s: unsupported mode/width: %s/%d, narrow: %d\n",
                  __FUNCTION__, rig_strrmode(mode), width,
                  rig_passband_narrow(rig, mode));
        return -RIG_EINVAL;		/* sorry, wrong MODE/WIDTH combo  */
      }
    } else {
  		if (width != RIG_PASSBAND_NORMAL &&
          width != rig_passband_normal(rig, mode)) {
        return -RIG_EINVAL;		/* sorry, wrong MODE/WIDTH combo  */
      }
    }
  }

  /*
   * Now send the command
   */
  ret = opcode_vfo(rig, p_cmd, cmd_index, vfo);
  if (ret != RIG_OK)
	  return ret;

  return write_block(&rs->rigport, (char*)p_cmd, YAESU_CMD_LENGTH);
}
Example #9
0
int ts2000_set_channel(RIG *rig, const channel_t *chan)
{
	rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);

	if (!rig || !chan)
		return -RIG_EINVAL;

	char buf[128];
	char mode, tx_mode = 0;
	int err;
	int tone = 0;
	

	struct kenwood_priv_caps *caps = kenwood_caps(rig);

	mode = rmode2kenwood(chan->mode, caps->mode_table);
		if (mode < 0 ) {
				rig_debug(RIG_DEBUG_ERR, "%s: unsupported mode '%s'\n",
								   __func__, rig_strrmode(chan->mode));
				return -RIG_EINVAL;
		}

	if (chan->split == RIG_SPLIT_ON) {
		tx_mode = rmode2kenwood(chan->tx_mode, caps->mode_table);
			if (tx_mode < 0 ) {
					rig_debug(RIG_DEBUG_ERR, "%s: unsupported mode '%s'\n",
	   							   __func__, rig_strrmode(chan->tx_mode));
					return -RIG_EINVAL;
			}
	}

	/* find tone */
	char sqltype = '0';
	if (chan->ctcss_tone) {
		for (; rig->caps->ctcss_list[tone] != 0; tone++) {
			if (chan->ctcss_tone == rig->caps->ctcss_list[tone])
				break;
		}
		if (chan->ctcss_tone != rig->caps->ctcss_list[tone]) tone = -1;
		else sqltype = '1';
	}else{
	  tone = -1; /* -1 because we will add 1 when outputing; this is necessary as CTCSS codes are numbered from 1 */
	}
	/* find CTCSS code */
	short code = 0;
	if (chan->ctcss_sql) {
		for (; rig->caps->ctcss_list[code] != 0; code++) {
			if (chan->ctcss_sql == rig->caps->ctcss_list[code])
				break;
		}
		if (chan->ctcss_sql != rig->caps->ctcss_list[code]) code = -1;
		else sqltype = '2';
	}else{
	  code = -1;
	}
	/* find DCS code */
	short dcscode = 0;
	if (chan->dcs_code) {
		for (; rig->caps->dcs_list[dcscode] != 0; dcscode++) {
			if (chan->dcs_code == rig->caps->dcs_list[dcscode])
				break;
		}
		if (chan->dcs_code != rig->caps->dcs_list[dcscode]) dcscode = 0;
		else sqltype = '3';
	}else{
	  dcscode = 0;
	}
	
	char shift = '0';
	if( chan->rptr_shift == RIG_RPT_SHIFT_PLUS ){
	  shift = '1';
	}
	if( chan->rptr_shift ==  RIG_RPT_SHIFT_MINUS ){
	  shift = '2';
	}
	int tstep = 0;
    if(  (chan->mode == RIG_MODE_AM) || (chan->mode == RIG_MODE_FM) ){
       switch( chan->tuning_step ){
          case s_kHz(6.25):   tstep = 1; break;
          case s_kHz(10):     tstep = 2; break;
          case s_kHz(12.5):   tstep = 3; break;
          case s_kHz(15):     tstep = 4; break;
          case s_kHz(20):     tstep = 5; break;
          case s_kHz(25):     tstep = 6; break;
          case s_kHz(30):     tstep = 7; break;
          case s_kHz(50):     tstep = 8; break;
          case s_kHz(100):    tstep = 9; break;
          default:            tstep = 0;
       }
    }else{
       switch( chan->tuning_step ){
          case s_kHz(2.5):    tstep = 1; break;
          case s_kHz(5):      tstep = 2; break;
          case s_kHz(10):     tstep = 3; break;
          default:            tstep = 0;
       }
    }

    /* P-number       2-3    4 5 6 7   8   9  101112  13 141516  */
	snprintf(buf, sizeof(buf), "MW0%03d%011u%c%c%c%02d%02d%03d%c%c%09d0%c%c%s;", 
		chan->channel_num,
		(unsigned) chan->freq,		/*  4 - frequency */
		'0' + mode,					/*  5 - mode */
		(chan->flags & RIG_CHFLAG_SKIP) ? '1' : '0',    /*  6 - lockout status */
		sqltype,					/*  7 - squelch and tone type */
		tone+1,						/*  8 - tone code */
		code+1,						/*  9 - CTCSS code */
		dcscode,					/* 10 - DCS code */
		(chan->funcs & RIG_FUNC_REV ) ? '1' : '0',/* 11 - Reverse status */
		shift,						/* 12 - shift type */
		(int) chan->rptr_offs,				/* 13 - offset frequency */
		tstep + '0',   						/* 14 - Step size */
        chan->scan_group + '0',         /* 15 - Memory group no */
		chan->channel_desc 				/* 16 - description */
		);
	rig_debug( RIG_DEBUG_VERBOSE, "The command will be: %s\n", buf );

	err = kenwood_transaction(rig, buf, NULL, 0);
	if (err != RIG_OK)
		return err;
	
    if( chan->split == RIG_SPLIT_ON ){
	  sprintf(buf, "MW1%03d%011u%c%c%c%02d%02d%03d%c%c%09d0%c%c%s;\n", 
		chan->channel_num,
		(unsigned) chan->tx_freq, 		/*  4 - frequency */
		'0' + tx_mode,     				/*  5 - mode */
		(chan->flags & RIG_CHFLAG_SKIP) ? '1' : '0',    /*  6 - lockout status */
		sqltype,					/*  7 - squelch and tone type */
		tone+1,						/*  8 - tone code */
		code+1,						/*  9 - CTCSS code */
		dcscode+1,					/* 10 - DCS code */
		(chan->funcs & RIG_FUNC_REV ) ? '1' : '0',/* 11 - Reverse status */
		shift,						/* 12 - shift type */
		(int) chan->rptr_offs,				/* 13 - offset frequency */
		tstep + '0',   						/* 14 - Step size */
        chan->scan_group + '0',         /* Memory group no */
		chan->channel_desc 				/* 16 - description */
		);
	  rig_debug( RIG_DEBUG_VERBOSE, "Split, the command will be: %s\n", buf );
	
	  err = kenwood_transaction(rig, buf, NULL, 0);
	}
	return err;
}
Example #10
0
File: pcr.c Project: DF4OR/hamlib
int
pcr_set_mode(RIG * rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
	struct pcr_priv_data *priv = (struct pcr_priv_data *) rig->state.priv;
	struct pcr_rcvr *rcvr = is_sub_rcvr(rig, vfo) ? &priv->sub_rcvr : &priv->main_rcvr;

	unsigned char buf[20];
	int buf_len, err;
	int pcrmode, pcrfilter;

	rig_debug(RIG_DEBUG_VERBOSE, "%s: mode = %d (%s), width = %d\n",
		  __func__, mode, rig_strrmode(mode), width);

	/* XXX? */
	if (mode == RIG_MODE_NONE)
		mode = RIG_MODE_FM;

	/*
	 * not so sure about modes and filters
	 * as I write this from manual (no testing) --SF
	 */
	switch (mode) {
	case RIG_MODE_CW:
		pcrmode = MD_CW;
		break;
	case RIG_MODE_USB:
		pcrmode = MD_USB;
		break;
	case RIG_MODE_LSB:
		pcrmode = MD_LSB;
		break;
	case RIG_MODE_AM:
		pcrmode = MD_AM;
		break;
	case RIG_MODE_WFM:
		pcrmode = MD_WFM;
		break;
	case RIG_MODE_FM:
		pcrmode = MD_FM;
		break;
	default:
		rig_debug(RIG_DEBUG_ERR, "%s: unsupported mode %d\n",
			  __func__, mode);
		return -RIG_EINVAL;
	}

	if (width == RIG_PASSBAND_NORMAL)
		width = rig_passband_normal(rig, mode);

	rig_debug(RIG_DEBUG_VERBOSE, "%s: will set to %d\n",
		  __func__, width);

	switch (width) {
		/* nop, pcrfilter already set
		 * TODO: use rig_passband_normal instead?
		 */
	case s_kHz(2.8):
		pcrfilter = FLT_2_8kHz;
		break;
	case s_kHz(6):
		pcrfilter = FLT_6kHz;
		break;
	case s_kHz(15):
		pcrfilter = FLT_15kHz;
		break;
	case s_kHz(50):
		pcrfilter = FLT_50kHz;
		break;
	case s_kHz(230):
		pcrfilter = FLT_230kHz;
		break;
	default:
		rig_debug(RIG_DEBUG_ERR, "%s: unsupported width %d\n",
			  __func__, width);
		return -RIG_EINVAL;
	}

	rig_debug(RIG_DEBUG_VERBOSE, "%s: filter set to %d (%c)\n",
		  __func__, width, pcrfilter);

	buf_len = sprintf((char *) buf, "K%c%010" PRIll "0%c0%c00",
			is_sub_rcvr(rig, vfo) ? '1':'0',
			(int64_t) rcvr->last_freq, pcrmode, pcrfilter);
	if (buf_len < 0)
		return -RIG_ETRUNC;

	err = pcr_transaction(rig, (char *) buf);
	if (err != RIG_OK)
		return err;

	rig_debug(RIG_DEBUG_VERBOSE, "%s: saving values\n",
		  __func__);

	rcvr->last_mode = pcrmode;
	rcvr->last_filter = pcrfilter;

	return RIG_OK;
}
Example #11
0
/* Caution! Keep the function consistent with dump_csv_name and set_channel_data! */
int dump_csv_chan(RIG *rig,
                  channel_t **chan_pp,
                  int channel_num,
                  const chan_t *chan_list,
                  rig_ptr_t arg)
{
    FILE *f = arg;
    static channel_t chan;
    static int first_time = 1;
    const channel_cap_t *mem_caps = &chan_list->mem_caps;

    if (first_time)
    {
        dump_csv_name(mem_caps, f);
        first_time = 0;
    }

    if (*chan_pp == NULL)
    {
        /*
         * Hamlib frontend demand application an allocated
         * channel_t pointer for next round.
         */
        *chan_pp = &chan;

        return RIG_OK;
    }

    fprintf(f, "%d%c", chan.channel_num, csv_sep);

    if (mem_caps->bank_num)
    {
        fprintf(f, "%d%c", chan.bank_num, csv_sep);
    }

    if (mem_caps->channel_desc)
    {
        fprintf(f, "%s%c", chan.channel_desc, csv_sep);
    }

    if (mem_caps->vfo)
    {
        fprintf(f, "%s%c", rig_strvfo(chan.vfo), csv_sep);
    }

    if (mem_caps->ant)
    {
        fprintf(f, "%d%c", chan.ant, csv_sep);
    }

    if (mem_caps->freq)
    {
        fprintf(f, "%.0"PRIfreq"%c", chan.freq, csv_sep);
    }

    if (mem_caps->mode)
    {
        fprintf(f, "%s%c", rig_strrmode(chan.mode), csv_sep);
    }

    if (mem_caps->width)
    {
        fprintf(f, "%d%c", (int)chan.width, csv_sep);
    }

    if (mem_caps->tx_freq)
    {
        fprintf(f, "%.0"PRIfreq"%c", chan.tx_freq, csv_sep);
    }

    if (mem_caps->tx_mode)
    {
        fprintf(f, "%s%c", rig_strrmode(chan.tx_mode), csv_sep);
    }

    if (mem_caps->tx_width)
    {
        fprintf(f, "%d%c", (int)chan.tx_width, csv_sep);
    }

    if (mem_caps->split)
    {
        fprintf(f, "%s%c", chan.split == RIG_SPLIT_ON ? "on" : "off", csv_sep);
    }

    if (mem_caps->tx_vfo)
    {
        fprintf(f, "%s%c", rig_strvfo(chan.tx_vfo), csv_sep);
    }

    if (mem_caps->rptr_shift)
    {
        fprintf(f, "%s%c", rig_strptrshift(chan.rptr_shift), csv_sep);
    }

    if (mem_caps->rptr_offs)
    {
        fprintf(f, "%d%c", (int)chan.rptr_offs, csv_sep);
    }

    if (mem_caps->tuning_step)
    {
        fprintf(f, "%d%c", (int)chan.tuning_step, csv_sep);
    }

    if (mem_caps->rit)
    {
        fprintf(f, "%d%c", (int)chan.rit, csv_sep);
    }

    if (mem_caps->xit)
    {
        fprintf(f, "%d%c", (int)chan.xit, csv_sep);
    }

    if (mem_caps->funcs)
    {
        fprintf(f, "%"PRXll"%c", chan.funcs, csv_sep);
    }

    if (mem_caps->ctcss_tone)
    {
        fprintf(f, "%d%c", chan.ctcss_tone, csv_sep);
    }

    if (mem_caps->ctcss_sql)
    {
        fprintf(f, "%d%c", chan.ctcss_sql, csv_sep);
    }

    if (mem_caps->dcs_code)
    {
        fprintf(f, "%d%c", chan.dcs_code, csv_sep);
    }

    if (mem_caps->dcs_sql)
    {
        fprintf(f, "%d%c", chan.dcs_sql, csv_sep);
    }

    if (mem_caps->scan_group)
    {
        fprintf(f, "%d%c", chan.scan_group, csv_sep);
    }

    if (mem_caps->flags)
    {
        fprintf(f, "%x%c", chan.flags, csv_sep);
    }

    fprintf(f, "\n");

    /*
     * keep the same *chan_pp for next round, thanks
     * to chan being static
     */

    return RIG_OK;
}