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; }
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; }
void __fastcall TTestRigMain::Timer1Timer( TObject *Sender ) { static in_timer = false; if ( in_timer ) return ; static bool closed = false; if ( !closed ) { if ( checkCloseEvent() ) { closed = true; CloseButtonClick( Sender ); } } in_timer = true; freq_t freq; shortfreq_t ritfreq; shortfreq_t xitfreq; rmode_t mode; pbwidth_t width; char buff[ 1024 ]; DWORD t = GetTickCount(); int ferr = rig_get_freq( my_rig, RIG_VFO_CURR, &freq ); // int rerr = rig_get_rit(my_rig, RIG_VFO_CURR, &ritfreq); // int xerr = rig_get_xit(my_rig, RIG_VFO_CURR, &xitfreq); int merr = rig_get_mode( my_rig, RIG_VFO_CURR, &mode, &width ); DWORD t1 = GetTickCount(); if ( ferr != RIG_OK ) { sprintf( buff, "Time %d rig_getFreq: error = %s", ( int ) ( t1 - t ), rigerror( ferr ) ); Label2->Caption = buff; } else { sprintf( buff, "rig_getFreq Time %d Freq %lld", ( int ) ( t1 - t ), ( long long ) freq ); Label2->Caption = buff; noSetFreq = true; FreqSlider->Position = ( freq - 28000000 ) / 100; noSetFreq = false; } if ( merr != RIG_OK ) { sprintf( buff, "Time %d rig_get_mode: error = %s", ( int ) ( t1 - t ), rigerror( ferr ) ); Label2->Caption = buff; } else { sprintf( buff, "rig_get_mode Time %d mode %d", ( int ) ( t1 - t ), ( long ) mode ); Label2->Caption = buff; noSetMode = true; switch ( mode ) { case RIG_MODE_AM: ModeRadioGroup->ItemIndex = 0; break; case RIG_MODE_CW: ModeRadioGroup->ItemIndex = 1; break; case RIG_MODE_USB: ModeRadioGroup->ItemIndex = 2; break; case RIG_MODE_LSB: ModeRadioGroup->ItemIndex = 2; break; case RIG_MODE_RTTY: ModeRadioGroup->ItemIndex = 0; break; case RIG_MODE_FM: ModeRadioGroup->ItemIndex = 0; break; case RIG_MODE_WFM: ModeRadioGroup->ItemIndex = 0; break; case RIG_MODE_CWR: ModeRadioGroup->ItemIndex = 1; break; case RIG_MODE_RTTYR: ModeRadioGroup->ItemIndex = 0; break; case RIG_MODE_AMS: ModeRadioGroup->ItemIndex = 0; break; case RIG_MODE_PKTLSB: ModeRadioGroup->ItemIndex = 2; break; case RIG_MODE_PKTUSB: ModeRadioGroup->ItemIndex = 2; break; case RIG_MODE_PKTFM: ModeRadioGroup->ItemIndex = 0; break; case RIG_MODE_ECSSUSB: ModeRadioGroup->ItemIndex = 2; break; case RIG_MODE_ECSSLSB: ModeRadioGroup->ItemIndex = 2; break; case RIG_MODE_FAX: ModeRadioGroup->ItemIndex = 0; break; case RIG_MODE_NONE: default: ModeRadioGroup->ItemIndex = 0; break; } noSetMode = false; } in_timer = false; }
/* * stores current VFO state into chan by emulating rig_get_channel */ static int generic_save_channel(RIG *rig, channel_t *chan) { int i, retval; int chan_num; vfo_t vfo; setting_t setting; const channel_cap_t *mem_cap = NULL; chan_num = chan->channel_num; vfo = chan->vfo; memset(chan, 0, sizeof(channel_t)); chan->channel_num = chan_num; chan->vfo = vfo; if (vfo == RIG_VFO_MEM) { const chan_t *chan_cap; chan_cap = rig_lookup_mem_caps(rig, chan_num); if (chan_cap) mem_cap = &chan_cap->mem_caps; } /* If vfo!=RIG_VFO_MEM or incomplete backend, try all properties */ if (mem_cap == NULL || rig_mem_caps_empty(mem_cap)) { mem_cap = &mem_cap_all; } if (mem_cap->freq) { retval = rig_get_freq(rig, RIG_VFO_CURR, &chan->freq); /* empty channel ? */ if (retval == -RIG_ENAVAIL || chan->freq == RIG_FREQ_NONE) return -RIG_ENAVAIL; } if (mem_cap->vfo) rig_get_vfo(rig, &chan->vfo); if (mem_cap->mode || mem_cap->width) rig_get_mode(rig, RIG_VFO_CURR, &chan->mode, &chan->width); chan->split = RIG_SPLIT_OFF; if (mem_cap->split) rig_get_split_vfo(rig, RIG_VFO_CURR, &chan->split, &chan->tx_vfo); if (chan->split != RIG_SPLIT_OFF) { if (mem_cap->tx_freq) rig_get_split_freq(rig, RIG_VFO_CURR, &chan->tx_freq); if (mem_cap->tx_mode || mem_cap->tx_width) rig_get_split_mode(rig, RIG_VFO_CURR, &chan->tx_mode, &chan->tx_width); } else { chan->tx_freq = chan->freq; chan->tx_mode = chan->mode; chan->tx_width = chan->width; } if (mem_cap->rptr_shift) rig_get_rptr_shift(rig, RIG_VFO_CURR, &chan->rptr_shift); if (mem_cap->rptr_offs) rig_get_rptr_offs(rig, RIG_VFO_CURR, &chan->rptr_offs); if (mem_cap->ant) rig_get_ant(rig, RIG_VFO_CURR, &chan->ant); if (mem_cap->tuning_step) rig_get_ts(rig, RIG_VFO_CURR, &chan->tuning_step); if (mem_cap->rit) rig_get_rit(rig, RIG_VFO_CURR, &chan->rit); if (mem_cap->xit) rig_get_xit(rig, RIG_VFO_CURR, &chan->xit); for (i=0; i<RIG_SETTING_MAX; i++) { setting = rig_idx2setting(i); if ((setting & mem_cap->levels) && RIG_LEVEL_SET(setting)) rig_get_level(rig, RIG_VFO_CURR, setting, &chan->levels[i]); } for (i=0; i<RIG_SETTING_MAX; i++) { int fstatus; setting = rig_idx2setting(i); if ((setting & mem_cap->funcs) && (rig_get_func(rig, RIG_VFO_CURR, setting, &fstatus) == RIG_OK)) chan->funcs |= fstatus ? setting : 0; } if (mem_cap->ctcss_tone) rig_get_ctcss_tone(rig, RIG_VFO_CURR, &chan->ctcss_tone); if (mem_cap->ctcss_sql) rig_get_ctcss_sql(rig, RIG_VFO_CURR, &chan->ctcss_sql); if (mem_cap->dcs_code) rig_get_dcs_code(rig, RIG_VFO_CURR, &chan->dcs_code); if (mem_cap->dcs_sql) rig_get_dcs_sql(rig, RIG_VFO_CURR, &chan->dcs_sql); /* * TODO: (missing calls) * - channel_desc * - bank_num * - scan_group * - flags */ rig_ext_level_foreach(rig, generic_retr_extl, (rig_ptr_t)chan); return RIG_OK; }
void __fastcall TRigCtlMain::Timer1Timer( TObject */*Sender*/ ) { if ( !my_rig ) return ; static in_timer = false; if ( in_timer ) return ; in_timer = true; static freq_t lastFreq = 0; freq_t freq; shortfreq_t ritfreq; shortfreq_t xitfreq; static rmode_t last_mode = RIG_MODE_NONE; rmode_t mode; pbwidth_t width; char buff[ 1024 ]; char fbuff[ 1024 ]; DWORD t = GetTickCount(); int ferr = rig_get_freq( my_rig, RIG_VFO_CURR, &freq ); // int rerr = rig_get_rit(my_rig, RIG_VFO_CURR, &ritfreq); // int xerr = rig_get_xit(my_rig, RIG_VFO_CURR, &xitfreq); int merr = rig_get_mode( my_rig, RIG_VFO_CURR, &mode, &width ); DWORD t1 = GetTickCount(); if ( ferr != RIG_OK ) { sprintf( buff, "Time %d rig_getFreq: error = %s", ( int ) ( t1 - t ), rigerror( ferr ) ); Label2->Caption = buff; } else { freq += rigTransConversion; sprintf( fbuff, "%lld", ( long long ) freq ); sprintf( buff, "rig_get_op_params Time %d Freq %s", ( int ) ( t1 - t ), fbuff ); Label2->Caption = buff; } // and publish the value... if ( freq != lastFreq ) { RPCPubSub::publish( "RigControl", "Frequency", fbuff, psPublished ); lastFreq = freq; } if ( merr != RIG_OK ) { sprintf( buff, "Time %d rig_get_mode: error = %s", ( int ) ( t1 - t ), rigerror( ferr ) ); Label2->Caption = buff; } else { if ( mode != last_mode ) { std::string strMode; switch ( mode ) { case RIG_MODE_AM: strMode = "A3E"; break; case RIG_MODE_CW: strMode = "A1A"; break; case RIG_MODE_USB: strMode = "J3E"; break; case RIG_MODE_LSB: strMode = "J3E"; break; case RIG_MODE_RTTY: strMode = "RTTY"; break; case RIG_MODE_FM: strMode = "F3E"; break; case RIG_MODE_WFM: strMode = "F3E"; break; case RIG_MODE_CWR: strMode = "A1A"; break; case RIG_MODE_RTTYR: strMode = "RTTY"; break; case RIG_MODE_AMS: strMode = "AMS"; break; case RIG_MODE_PKTLSB: strMode = "PKT"; break; case RIG_MODE_PKTUSB: strMode = "PKT"; break; case RIG_MODE_PKTFM: strMode = "PKT"; break; case RIG_MODE_ECSSUSB: strMode = "A3E"; break; case RIG_MODE_ECSSLSB: strMode = "J3E"; break; case RIG_MODE_FAX: strMode = "FAX"; break; case RIG_MODE_NONE: default: strMode = "UNK"; break; } switch ( mode ) { case RIG_MODE_AM: ModeRadioGroup->ItemIndex = 0; break; case RIG_MODE_CW: ModeRadioGroup->ItemIndex = 1; break; case RIG_MODE_USB: ModeRadioGroup->ItemIndex = 2; break; case RIG_MODE_LSB: ModeRadioGroup->ItemIndex = 2; break; case RIG_MODE_RTTY: ModeRadioGroup->ItemIndex = 0; break; case RIG_MODE_FM: ModeRadioGroup->ItemIndex = 0; break; case RIG_MODE_WFM: ModeRadioGroup->ItemIndex = 0; break; case RIG_MODE_CWR: ModeRadioGroup->ItemIndex = 1; break; case RIG_MODE_RTTYR: ModeRadioGroup->ItemIndex = 0; break; case RIG_MODE_AMS: ModeRadioGroup->ItemIndex = 0; break; case RIG_MODE_PKTLSB: ModeRadioGroup->ItemIndex = 2; break; case RIG_MODE_PKTUSB: ModeRadioGroup->ItemIndex = 2; break; case RIG_MODE_PKTFM: ModeRadioGroup->ItemIndex = 0; break; case RIG_MODE_ECSSUSB: ModeRadioGroup->ItemIndex = 2; break; case RIG_MODE_ECSSLSB: ModeRadioGroup->ItemIndex = 2; break; case RIG_MODE_FAX: ModeRadioGroup->ItemIndex = 0; break; case RIG_MODE_NONE: default: ModeRadioGroup->ItemIndex = 0; break; } last_mode = mode; RPCPubSub::publish( "RigControl", "Mode", strMode, psPublished ); } } in_timer = false; }
static void *hamlib_loop(void *args) { struct timespec sleep; gdouble freq = 0.0; rmode_t mode = RIG_MODE_USB; gint ret; gchar *str; sleep.tv_sec = 0; sleep.tv_nsec = 100000000L; /* 100ms */ for (;;) { nanosleep(&sleep, NULL); // need_freq = (hamlib_waterfall || hamlib_qsodata || hamlib_qsy); // need_mode = need_freq; /* see if we are being canceled */ if (hamlib_exit) break; if (need_freq) { freq_t f; G_LOCK(hamlib_mutex); ret = rig_get_freq(rig, RIG_VFO_CURR, &f); G_UNLOCK(hamlib_mutex); if (ret != RIG_OK) { str = g_strdup_printf(_("rig_get_freq failed: %s"), rigerror(ret)); statusbar_set("mainstatusbar", str); g_free(str); continue; } freq = (gdouble) f; } /* see if we are being canceled */ if (hamlib_exit) break; if (need_mode) { pbwidth_t width; G_LOCK(hamlib_mutex); ret = rig_get_mode(rig, RIG_VFO_CURR, &mode, &width); G_UNLOCK(hamlib_mutex); if (ret != RIG_OK) { str = g_strdup_printf(_("rig_get_mode failed: %s"), rigerror(ret)); statusbar_set("mainstatusbar", str); g_free(str); continue; } } if (hamlib_qsy) { gfloat f = conf_get_float("hamlib/cfreq"); hamlib_qsy = FALSE; G_LOCK(hamlib_mutex); ret = rig_set_freq(rig, RIG_VFO_CURR, ((gdouble) freq) + trx_get_freq() - f); G_UNLOCK(hamlib_mutex); if (ret != RIG_OK) { str = g_strdup_printf(_("rig_set_freq failed: %s"), rigerror(ret)); statusbar_set("mainstatusbar", str); g_free(str); continue; } waterfall_set_frequency(waterfall, f); } if (hamlib_waterfall) { waterfall_set_carrier_frequency(waterfall, freq); if (mode == RIG_MODE_LSB) waterfall_set_lsb(waterfall, TRUE); else waterfall_set_lsb(waterfall, FALSE); } if (hamlib_qsodata) { gchar *str, *fmt; if (mode == RIG_MODE_LSB) freq -= trx_get_freq(); else freq += trx_get_freq(); switch (hamlib_res) { case 2: fmt = "%.6f"; break; case 1: fmt = "%.3f"; break; case 0: default: fmt = "%.0f"; break; } str = g_strdup_printf(fmt, freq / 1000000.0); gdk_threads_enter(); qsodata_set_band_mode(QSODATA_BAND_ENTRY); qsodata_set_freq(str); gdk_threads_leave(); g_free(str); } /* see if we are being canceled */ if (hamlib_exit) break; } if (hamlib_waterfall) { waterfall_set_carrier_frequency(waterfall, 0.0); waterfall_set_lsb(waterfall, FALSE); } if (hamlib_qsodata) { gdk_threads_enter(); qsodata_set_band_mode(QSODATA_BAND_COMBO); qsodata_set_freq(""); gdk_threads_leave(); } /* this will exit the hamlib thread */ return NULL; }
void hamlib_init(void) { rig_model_t model; struct timespec sleep; freq_t freq; rmode_t mode; pbwidth_t width; gboolean enable; gchar *port, *conf, *spd; gint ret, speed; if (rig != NULL) return; enable = conf_get_bool("hamlib/enable"); model = conf_get_int("hamlib/rig"); port = conf_get_filename("hamlib/port"); speed = conf_get_int("hamlib/speed"); conf = conf_get_string("hamlib/conf"); if (!enable || !model || port[0] == 0) return; rig_set_debug(RIG_DEBUG_ERR); rig = rig_init(model); if (rig == NULL) { errmsg(_("Hamlib init: rig_init failed (model=%d)"), model); return; } g_strstrip(conf); if (conf[0]) { gchar **v, **p, *q; v = g_strsplit(conf, ",", 0); for (p = v; *p; p++) { if ((q = strchr(*p, '=')) == NULL) { errmsg(_("Hamlib init: Bad param=value pair: '%s'"), *p); break; } *q++ = 0; g_strstrip(*p); g_strstrip(q); if (hamlib_set_param(*p, q) == FALSE) break; } g_strfreev(v); } g_free(conf); hamlib_set_param("rig_pathname", port); g_free(port); spd = g_strdup_printf("%d", speed); hamlib_set_param("serial_speed", spd); g_free(spd); ret = rig_open(rig); if (ret != RIG_OK) { errmsg(_("Hamlib init: rig_open failed: %s"), rigerror(ret)); rig_cleanup(rig); rig = NULL; return; } /* Polling the rig sometimes fails right after opening it */ sleep.tv_sec = 0; sleep.tv_nsec = 100000000L; /* 100ms */ nanosleep(&sleep, NULL); if (need_freq == TRUE && \ (ret = rig_get_freq(rig, RIG_VFO_CURR, &freq)) != RIG_OK) { errmsg(_("Hamlib init: rig_get_freq failed: %s"), rigerror(ret)); hamlib_waterfall = FALSE; hamlib_qsodata = FALSE; need_freq = FALSE; need_mode = FALSE; } if (need_mode == TRUE && (ret = rig_get_mode(rig, RIG_VFO_CURR, &mode, &width)) != RIG_OK) { errmsg(_("Hamlib init: rig_get_mode failed: %s.\nAssuming USB mode."), rigerror(ret)); need_mode = FALSE; } if (hamlib_ptt == TRUE && (ret = rig_set_ptt(rig, RIG_VFO_CURR, RIG_PTT_OFF)) != RIG_OK) { errmsg(_("Hamlib init: rig_set_ptt failed: %s.\nHamlib PTT disabled"), rigerror(ret)); hamlib_ptt = FALSE; } /* Don't create the thread if frequency data is not needed */ if (need_freq == FALSE) { // g_warning("Freq data not needed, thread not started."); /* If PTT isn't needed either then close everything */ if (hamlib_ptt == FALSE) { // g_warning("PTT not needed, closing rig."); rig_close(rig); rig_cleanup(rig); rig = NULL; } return; } if (pthread_create(&hamlib_thread, NULL, hamlib_loop, NULL) < 0) { errmsg(_("Hamlib init: pthread_create: %m")); rig_close(rig); rig_cleanup(rig); rig = NULL; } }
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; }