示例#1
0
void __fastcall TRigCtlMain::FormShow( TObject */*Sender*/ )
{
   TIniFile * t = new TIniFile( ".\\Configuration\\RigSelect.ini" );
   mfg = t->ReadString( "RigControl", "Manufacturer", "NoMfG" );
   model = t->ReadString( "RigControl", "Model", "NoMoDeL" );
   delete t;
   makeRPCObjects();
   XMPPInitialise( "RigCtl" );
   rig_load_all_backends();

   selected = -1;
   int status = rig_list_foreach( print_model_list, NULL );
   if ( status != RIG_OK )
   {
      char buff[ 1024 ];
      sprintf( buff, "rig_list_foreach: error = %s \n", rigerror( status ) );
      trace( buff );
   }
   RigCombo->Sorted = true;

   if ( selected != -1 )
   {
      RigCombo->ItemIndex = RigCombo->Items->IndexOfObject( ( TObject * ) selected );
      RigSelectButtonClick( this );
   }
   else
      RigCombo->ItemIndex = 0;
}
示例#2
0
void __fastcall TTestRigMain::FormShow( TObject */*Sender*/ )
{
   StartupTimer->Enabled = true;
   TIniFile * t = new TIniFile( ".\\Configuration\\RigSelect.ini" );
   mfg = t->ReadString( "TestRig", "Manufacturer", "NoMfG" );
   model = t->ReadString( "TestRig", "Model", "NoMoDeL" );
   delete t;
   rig_load_all_backends();

   selected = -1;
   int status = rig_list_foreach( print_model_list, NULL );
   if ( status != RIG_OK )
   {
      return ;
   }
   RigCombo->Sorted = true;

   if ( selected != -1 )
   {
      RigCombo->ItemIndex = RigCombo->Items->IndexOfObject( ( TObject * ) selected );
      RigSelectButtonClick( this );
   }
   else
      RigCombo->ItemIndex = 0;
}
示例#3
0
void rigControl::getRadioList()
{
    if(!radiolistLoaded)
    {
        capsList.clear();
        rig_load_all_backends();
        rig_list_foreach(collect,0);
        qSort(capsList.begin(),capsList.end(),model_Sort);
        radiolistLoaded=true;
    }
}
示例#4
0
RigList &RigThread::enumerate() {
    if (RigThread::rigCaps.empty()) {
        rig_set_debug(RIG_DEBUG_ERR);
        rig_load_all_backends();
        
        rig_list_foreach(RigThread::add_hamlib_rig, 0);
        std::sort(RigThread::rigCaps.begin(), RigThread::rigCaps.end(), rigGreater());
        std::cout << "Loaded " << RigThread::rigCaps.size() << " rig models via hamlib." << std::endl;
    }
    return RigThread::rigCaps;
}
GSList *riglist_get_list(void)
{
	if (riglist == NULL) {
		rig_set_debug(RIG_DEBUG_NONE);
		rig_load_all_backends();
		rig_set_debug(RIG_DEBUG_ERR);

		rig_list_foreach(riglist_make_list, NULL);
	}

	return riglist;
}
示例#6
0
文件: testrig.c 项目: airween/hamlib
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;
}
示例#7
0
int main(int argc, char *argv[])
{
    time_t gentime;
    int set_or_get;
    int i;
    char *pbuf, prntbuf[512];

    rig_load_all_backends();


    printf("<TABLE BORDER=1>");
    printf("<TR><TD>Model</TD><TD>Mfg</TD><TD>Vers.</TD><TD>Status</TD>"
           "<TD>Type</TD><TD>Freq. range</TD><TD>Parameters</TD>"
           "<TD>Capabilities</TD>"
           "<TD>Get func</TD>"
           "<TD>Set func</TD>"
           "<TD>Get level</TD>"
           "<TD>Set level</TD>"
           "<TD>Get parm</TD>"
           "<TD>Set parm</TD>"
           "</TR>\n");
    rig_list_foreach(print_caps_sum, NULL);
    printf("</TABLE>\n");

    printf("<P>");

    printf("<TABLE BORDER=1>\n");
    printf("<TR><TD>Model</TD><TD>PTT</TD><TD>DCD</TD><TD>Port</TD>"
           "<TD>Speed min</TD><TD>Speed max</TD>"
           "<TD>Parm.</TD><TD>Handshake</TD><TD>Write delay</TD>"
           "<TD>Post delay</TD><TD>Timeout</TD><TD>Retry</TD></TR>\n");
    rig_list_foreach(print_caps_parameters, NULL);
    printf("</TABLE>\n");

    printf("<P>");

    printf("<TABLE BORDER=1>\n");
    printf("<TR><TD>Model</TD><TD>Freq. range</TD></TR>\n");
    rig_list_foreach(print_caps_range, NULL);
    printf("</TABLE>\n");

    printf("<P>");

    printf("<TABLE BORDER=1>\n");
    printf("<TR><TD>Model</TD><TD>Target VFO</TD>"
           "<TD>Set freq</TD><TD>Get freq</TD>"
           "<TD>Set mode</TD><TD>Get mode</TD>"
           "<TD>Set VFO</TD><TD>Get VFO</TD>"
           "<TD>Set PTT</TD><TD>Get PTT</TD><TD>Get DCD</TD>"
           "<TD>Set rptr shift</TD><TD>Get rptr shift</TD>"
           "<TD>Set rptr offs</TD><TD>Get rptr offs</TD>"
           "<TD>Set split frq</TD><TD>Get split frq</TD>"
           "<TD>Set split</TD><TD>Get split</TD>"
           "<TD>Set ts</TD><TD>Get ts</TD>"
           "<TD>Set CTCSS</TD><TD>Get CTCSS</TD>"
           "<TD>Set DCS</TD><TD>Get DCS</TD>"
           "<TD>Set Power Stat</TD><TD>Get Power Stat</TD>"
           "<TD>Set trn</TD><TD>Get trn</TD>"
           "<TD>Decode</TD><TD>Get info</TD>"
           "</TR>\n");
    rig_list_foreach(print_caps_caps, NULL);
    printf("</TABLE>\n");

    printf("<P>");

    bitmap_func = 0;
    prntbuf[0] = '\0';
    pbuf = prntbuf;

    for (i = 0; i < RIG_SETTING_MAX; i++)
    {
        setting_t func = rig_idx2setting(i);
        const char *s = rig_strfunc(func);

        if (!s)
        {
            continue;
        }

        bitmap_func |= func;
        pbuf += sprintf(pbuf, "<TD>%s</TD>", s);
    }

    printf("Has set func");
    printf("<TABLE BORDER=1>\n");
    printf("<TR><TD>Model</TD>%s</TR>\n", prntbuf);
    set_or_get = 1;
    rig_list_foreach(print_caps_func, &set_or_get);
    printf("</TABLE>\n");

    printf("<P>");

    printf("Has get func");
    printf("<TABLE BORDER=1>\n");
    printf("<TR><TD>Model</TD>%s</TR>\n", prntbuf);
    set_or_get = 0;
    rig_list_foreach(print_caps_func, &set_or_get);
    printf("</TABLE>\n");

    printf("<P>");

    bitmap_level = 0;
    prntbuf[0] = '\0';
    pbuf = prntbuf;

    for (i = 0; i < RIG_SETTING_MAX; i++)
    {
        setting_t level = rig_idx2setting(i);
        const char *s = rig_strlevel(level);

        if (!s)
        {
            continue;
        }

        bitmap_level |= level;
        pbuf += sprintf(pbuf, "<TD>%s</TD>", s);
    }

    printf("Set level");
    printf("<TABLE BORDER=1>\n");
    printf("<TR><TD>Model</TD>%s</TR>\n", prntbuf);
    set_or_get = 1;
    rig_list_foreach(print_caps_level, &set_or_get);
    printf("</TABLE>\n");

    printf("<P>");

    printf("Get level");
    printf("<TABLE BORDER=1>\n");
    printf("<TR><TD>Model</TD>%s</TR>\n", prntbuf);
    set_or_get = 0;
    rig_list_foreach(print_caps_level, &set_or_get);
    printf("</TABLE>\n");

    printf("<P>");

    bitmap_parm = 0;
    prntbuf[0] = '\0';
    pbuf = prntbuf;

    for (i = 0; i < RIG_SETTING_MAX; i++)
    {
        setting_t parm = rig_idx2setting(i);
        const char *s = rig_strparm(parm);

        if (!s)
        {
            continue;
        }

        bitmap_parm |= parm;
        pbuf += sprintf(pbuf, "<TD>%s</TD>", s);
    }

    printf("Set parm");
    printf("<TABLE BORDER=1>\n");
    printf("<TR><TD>Model</TD>%s</TR>\n", prntbuf);
    set_or_get = 1;
    rig_list_foreach(print_caps_parm, &set_or_get);
    printf("</TABLE>\n");

    printf("<P>");

    printf("Get parm");
    printf("<TABLE BORDER=1>\n");
    printf("<TR><TD>Model</TD>%s</TR>\n", prntbuf);
    set_or_get = 0;
    rig_list_foreach(print_caps_parm, &set_or_get);
    printf("</TABLE>\n");

    printf("<P>");

    time(&gentime);
    printf("Rigmatrix generated %s by %s\n", ctime(&gentime), getenv("USER"));

    printf("</body></html>\n");

    return 0;
}
示例#8
0
int main(int argc, char *argv[]) {
    RIG *my_rig;
    char *rig_file, *info_buf, *mm;
    freq_t freq;
    value_t rawstrength, power, strength;
    float s_meter, rig_raw2val();
    int status, retcode, isz;
    unsigned int mwpower;
    rmode_t mode;
    pbwidth_t width;
    rig_model_t myrig_model;
    char portname[64];
    port_t myport;

    strncpy(portname, argv[2], 63);
    portname[63] = '\0';

    if ((strcmp(argv[2], "--help") == 0) || (argc < 2)) {
        printf("use like: ./%s <portname>\n", argv[0]);
        printf("example:  ./%s /dev/ttyS0\n", argv[0]);
        return 0;
    }

    /* Try to detect rig */
    /* may be overridden 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, portname, FILPATHLEN);

    rig_load_all_backends();
    myrig_model = rig_probe(&myport);
    /* Set verbosity level - errors only */
    rig_set_debug(RIG_DEBUG_ERR);
    /* Instantiate a rig - your rig */
    /* my_rig = rig_init(RIG_MODEL_TT565); */
    my_rig = rig_init(myrig_model);
    /* Set up serial port, baud rate - serial device + baudrate */
    rig_file = "/dev/ttyUSB0";
    strncpy(my_rig->state.rigport.pathname, rig_file, FILPATHLEN - 1);
    my_rig->state.rigport.parm.serial.rate = 57600;
    my_rig->state.rigport.parm.serial.rate = 9600;
    /* Open my rig */
    retcode = rig_open(my_rig);
    printf("retcode of rig_open = %d \n", retcode);
    /* Give me ID info, e.g., firmware version. */
    info_buf = (char *)rig_get_info(my_rig);
    printf("Rig_info: '%s'\n", info_buf);

    /* Note: As a general practice, we should check to see if a given
     * function is within the rig's capabilities before calling it, but
     * we are simplifying here. Also, we should check each call's returned
     * status in case of error. (That's an inelegant way to catch an unsupported
     * operation.)
     */

    /* Main VFO frequency */
    status = rig_get_freq(my_rig, RIG_VFO_CURR, &freq);
    printf("status of rig_get_freq = %d \n", status);
    printf("VFO freq. = %.1f Hz\n", freq);
    /* Current mode */
    status = rig_get_mode(my_rig, RIG_VFO_CURR, &mode, &width);
    printf("status of rig_get_mode = %d \n", status);
    switch(mode) {
        case RIG_MODE_USB: mm = "USB"; break;
        case RIG_MODE_LSB: mm = "LSB"; break;
        case RIG_MODE_CW:  mm = "CW"; break;
        case RIG_MODE_CWR: mm = "CWR"; break;
        case RIG_MODE_AM:  mm = "AM"; break;
        case RIG_MODE_FM:  mm = "FM"; break;
        case RIG_MODE_WFM: mm = "WFM"; break;
        case RIG_MODE_RTTY:mm = "RTTY"; break;
        default: mm = "unrecognized"; break; /* there are more possibilities! */
        }
    printf("Current mode = 0x%X = %s, width = %d\n", mode, mm, (int) width);
    /* rig power output */
    status = rig_get_level(my_rig, RIG_VFO_CURR, RIG_LEVEL_RFPOWER, &power);
    printf("RF Power relative setting = %.3f (0.0 - 1.0)\n", power.f);
    /* Convert power reading to watts */
    status = rig_power2mW(my_rig, &mwpower, power.f, freq, mode);
    printf("RF Power calibrated = %.1f Watts\n", mwpower/1000.);
    /* Raw and calibrated S-meter values */
    status = rig_get_level(my_rig, RIG_VFO_CURR, RIG_LEVEL_RAWSTR, &rawstrength);
    printf("Raw receive strength = %d\n", rawstrength.i);
    isz = my_rig->caps->str_cal.size;
    printf("isz = %d \n", isz);
    s_meter = rig_raw2val(rawstrength.i, &my_rig->caps->str_cal);
    printf("S-meter value = %.2f dB relative to S9\n", s_meter);
    /* now try using RIG_LEVEL_STRENGTH itself */
    status = rig_get_strength(my_rig, RIG_VFO_CURR, &strength);
    printf("status of rig_get_strength = %d \n", status);
    printf("LEVEL_STRENGTH returns %d\n", strength.i);
return 0;
}