void RigThread::run() {
int retcode, status;
std::cout << "Rig thread starting." << std::endl;
rig = rig_init(rigModel);
strncpy(rig->state.rigport.pathname, rigFile.c_str(), FILPATHLEN - 1);
rig->state.rigport.parm.serial.rate = serialRate;
retcode = rig_open(rig);
if (retcode != 0) {
std::cout << "Rig failed to init. " << std::endl;
terminated.store(true);
return;
}
char *info_buf = (char *)rig_get_info(rig);
std::cout << "Rig info: " << info_buf << std::endl;
while (!terminated.load()) {
std::this_thread::sleep_for(std::chrono::milliseconds(150));
if (freqChanged.load()) {
status = rig_get_freq(rig, RIG_VFO_CURR, &freq);
if (freq != newFreq) {
freq = newFreq;
rig_set_freq(rig, RIG_VFO_CURR, freq);
// std::cout << "Set Rig Freq: %f" << newFreq << std::endl;
}
freqChanged.store(false);
} else {
freq_t checkFreq;
status = rig_get_freq(rig, RIG_VFO_CURR, &checkFreq);
if (checkFreq != freq) {
freq = checkFreq;
wxGetApp().setFrequency((long long)checkFreq);
} else if (wxGetApp().getFrequency() != freq) {
freq = wxGetApp().getFrequency();
rig_set_freq(rig, RIG_VFO_CURR, freq);
}
}
// std::cout << "Rig Freq: " << freq << std::endl;
}
rig_close(rig);
rig_cleanup(rig);
std::cout << "Rig thread exiting." << std::endl;
};
void Hamlib::sendFrequency(Session::ref session, Request::ref request, Reply::ref reply) {
Config *config = m_server->getConfig();
if (config->getUnregistered().find("hamlib.device") == config->getUnregistered().end()) {
LOG_ERROR(logger, "Set '[hamlib] device' in config file.");
}
std::string device = config->getUnregistered().find("hamlib.device")->second;
RIG *my_rig;
freq_t freq;
int retcode;
rig_set_debug(RIG_DEBUG_NONE);
// rig_set_debug(RIG_DEBUG_TRACE);
rig_model_t myrig_model = RIG_MODEL_IC706MKIIG;
my_rig = rig_init(myrig_model);
my_rig->state.rigport.type.rig = RIG_PORT_SERIAL;
my_rig->state.rigport.parm.serial.rate = 19200;
my_rig->state.rigport.parm.serial.data_bits = 8;
my_rig->state.rigport.parm.serial.stop_bits = 1;
my_rig->state.rigport.parm.serial.parity = RIG_PARITY_NONE;
my_rig->state.rigport.parm.serial.handshake = RIG_HANDSHAKE_NONE;
strncpy(my_rig->state.rigport.pathname, device.c_str(), FILPATHLEN - 1);
if ((retcode = rig_open(my_rig)) != RIG_OK)
{
fprintf(stderr, "rig_open: error = %s\n", rigerror(retcode));
LOG_ERROR(logger, "rig_open: error " << rigerror(retcode));
}
if ((retcode = rig_get_freq(my_rig, RIG_VFO_CURR, &freq) != RIG_OK))
{
LOG_ERROR(logger, "rig_set_freq: error " << rigerror(retcode));
}
rig_get_freq(my_rig, RIG_VFO_CURR, &freq);
rig_close(my_rig);
rig_cleanup(my_rig);
freq = freq / 1000;
std::string f = roundedCast(freq, 6);
reply->setContent(f);
}
bool rigControl::getFrequency(double &frequency)
{
int retcode;
if(catParams.enableXMLRPC)
{
frequency=xmlIntfPtr->getFrequency();
}
else
{
if(!rigControlEnabled) return false;
retcode = rig_get_freq(my_rig, RIG_VFO_CURR, &frequency);
if (retcode != RIG_OK )
frequency=lastFrequency;
// {errorMessage(retcode,"getFrequency"); return false; }
}
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;
}
void RigThread::run() {
int retcode, status;
termStatus = 0;
std::cout << "Rig thread starting." << std::endl;
rig = rig_init(rigModel);
strncpy(rig->state.rigport.pathname, rigFile.c_str(), FILPATHLEN - 1);
rig->state.rigport.parm.serial.rate = serialRate;
retcode = rig_open(rig);
if (retcode != 0) {
std::cout << "Rig failed to init. " << std::endl;
IOThread::terminate();
return;
}
char *info_buf = (char *)rig_get_info(rig);
if (info_buf) {
std::cout << "Rig info: " << info_buf << std::endl;
} else {
std::cout << "Rig info was NULL." << std::endl;
}
while (!stopping) {
std::this_thread::sleep_for(std::chrono::milliseconds(150));
auto activeDemod = wxGetApp().getDemodMgr().getActiveDemodulator();
auto lastDemod = wxGetApp().getDemodMgr().getLastActiveDemodulator();
if (freqChanged.load() && (controlMode.load() || setOneShot.load())) {
status = rig_get_freq(rig, RIG_VFO_CURR, &freq);
if (status == 0 && !stopping) {
if (freq != newFreq && setOneShot.load()) {
freq = newFreq;
rig_set_freq(rig, RIG_VFO_CURR, freq);
// std::cout << "Set Rig Freq: %f" << newFreq << std::endl;
}
freqChanged.store(false);
setOneShot.store(false);
} else {
termStatus = 0;
break;
}
} else {
freq_t checkFreq;
status = rig_get_freq(rig, RIG_VFO_CURR, &checkFreq);
if (status == 0 && !stopping) {
if (checkFreq != freq && followMode.load()) {
freq = checkFreq;
if (followModem.load()) {
if (lastDemod) {
lastDemod->setFrequency(freq);
lastDemod->updateLabel(freq);
lastDemod->setFollow(true);
}
} else {
wxGetApp().setFrequency((long long)checkFreq);
}
} else if (wxGetApp().getFrequency() != freq && controlMode.load() && !centerLock.load() && !followModem.load()) {
freq = wxGetApp().getFrequency();
rig_set_freq(rig, RIG_VFO_CURR, freq);
} else if (followModem.load()) {
if (lastDemod) {
if (lastDemod->getFrequency() != freq) {
lastDemod->setFrequency(freq);
lastDemod->updateLabel(freq);
lastDemod->setFollow(true);
}
}
}
} else {
termStatus = 0;
break;
}
}
if (!centerLock.load() && followModem.load() && wxGetApp().getFrequency() != freq && (lastDemod && lastDemod != activeDemod)) {
wxGetApp().setFrequency((long long)freq);
}
// std::cout << "Rig Freq: " << freq << std::endl;
}
rig_close(rig);
rig_cleanup(rig);
std::cout << "Rig thread exiting status " << termStatus << "." << std::endl;
};
