int main(int argc, char *argv[])
{
struct track *track;
if (argc != 3) {
fprintf(stderr, "usage: %s <command> <path>\n", argv[0]);
return -1;
}
if (thread_global_init() == -1)
return -1;
rig_init();
track = track_get_by_import(argv[1], argv[2]);
if (track == NULL)
return -1;
rig_main();
track_put(track);
rig_clear();
thread_global_clear();
return 0;
}
bool rigControl::init()
{
int retcode;
if(!catParams.enableCAT) return false;
addToLog(QString("rigcontrol:init myport pathname: %1").arg(myport.pathname),LOGRIGCTRL);
catParams.radioModelNumber=getModelNumber(getRadioModelIndex());
my_rig = rig_init(catParams.radioModelNumber);
if(!my_rig)
{
addToLog(QString("Error in connection using radio model %1").arg(catParams.radioModel),LOGALL);
initError=QString("Error in connection using radio model %1").arg(catParams.radioModel);
return false;
}
if(QString(my_rig->caps->mfg_name)=="Icom")
{
if(!catParams.civAddress.isEmpty())
{
rig_set_conf(my_rig, rig_token_lookup(my_rig, "civaddr"), catParams.civAddress.toLatin1());
}
}
strncpy(my_rig->state.rigport.pathname,(const char *)catParams.serialPort.toLatin1().data(),FILPATHLEN);
strncpy(my_rig->state.pttport.pathname,(const char *)catParams.serialPort.toLatin1().data(),FILPATHLEN);
my_rig->state.rigport.parm.serial.rate = catParams.baudrate;
my_rig->state.rigport.parm.serial.data_bits=catParams.databits;
my_rig->state.rigport.parm.serial.stop_bits=catParams.stopbits;
if(catParams.parity=="Even") my_rig->state.rigport.parm.serial.parity= RIG_PARITY_EVEN;
else if (catParams.parity=="Odd") my_rig->state.rigport.parm.serial.parity = RIG_PARITY_ODD;
else my_rig->state.rigport.parm.serial.parity = RIG_PARITY_NONE;
if(catParams.handshake=="XOn/Xoff") my_rig->state.rigport.parm.serial.handshake = RIG_HANDSHAKE_XONXOFF;
if(catParams.handshake=="Hardware") my_rig->state.rigport.parm.serial.handshake = RIG_HANDSHAKE_HARDWARE;
else my_rig->state.rigport.parm.serial.handshake = RIG_HANDSHAKE_NONE;
my_rig->state.pttport.type.ptt = catParams.pttType;
addToLog(QString("rigcontrol:init rigport.pathname: %1").arg(my_rig->state.rigport.pathname),LOGRIGCTRL);
retcode = rig_open(my_rig);
if (retcode != RIG_OK )
{
addToLog(QString("CAT Error: %1").arg(QString(rigerror(retcode))),LOGALL);
initError=QString("CAT Error: %1").arg(QString(rigerror(retcode)));
return false;
}
addToLog("rigcontroller successfully opened",LOGRIGCTRL);
rigControlEnabled=true;
// int verbose=0;
// rig_set_debug(verbose<2 ? RIG_DEBUG_NONE: (rig_debug_level_e)verbose);
// rig_debug(RIG_DEBUG_VERBOSE, "rigctl, %s\n", hamlib_version);
// test if we can contact the tranceiver
double fr;
if(!getFrequency(fr))
{
// rigControlEnabled=false;
}
return true;
}
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;
};
int initialize_rig()
{
RIG *my_rig; /* handle to rig (nstance) */
int retcode;
config_setting_t *rig_control_settings;
rig_control_settings = config_lookup(&cfg, "repeater.rig_control");
int rig_id, baud_rate, data_bits, stop_bits, enabled;
const char *serial_port, *frequency;
config_setting_lookup_int(rig_control_settings, "rig_id", &rig_id);
config_setting_lookup_int(rig_control_settings, "baud_rate", &baud_rate);
config_setting_lookup_int(rig_control_settings, "data_bits", &data_bits);
config_setting_lookup_int(rig_control_settings, "stop_bits", &stop_bits);
config_setting_lookup_bool(rig_control_settings, "enabled", &enabled);
config_setting_lookup_string(rig_control_settings, "frequency", &frequency);
config_setting_lookup_string(rig_control_settings, "serial_port", &serial_port);
if (!enabled)
return -1;
printf("frequency: %s\n", frequency);
rig_set_debug(RIG_DEBUG_WARN);
my_rig = rig_init(rig_id);
if (!my_rig) {
fprintf(stderr,"Unknown rig num: %d\n", rig_id);
fprintf(stderr,"Please check riglist.h\n");
exit(1); /* whoops! something went wrong (mem alloc?) */
}
strncpy(my_rig->state.rigport.pathname, "/dev/ttyS0", FILPATHLEN - 1);
my_rig->state.rigport.parm.serial.rate = baud_rate;
my_rig->state.rigport.parm.serial.data_bits = data_bits;
my_rig->state.rigport.parm.serial.stop_bits = stop_bits;
retcode = rig_open(my_rig);
if (retcode != RIG_OK) {
printf("rig_open: error = %s\n", rigerror(retcode));
exit(2);
}
return rig_set_freq(my_rig, RIG_VFO_CURR, atoi(frequency));
}
void Hamlib::setFrequency(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;
std::string f = request->getContent();
if (sscanf(f.c_str(), "%lf", &freq) != 1) {
LOG_WARN(logger, "Unable to read freq " << f)
fprintf(stderr, "ERROR: Unable to read freq.\n");
}
std::cout << boost::lexical_cast<std::string>((double) freq) << "\n";
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_set_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);
}
void __fastcall TRigCtlMain::RigSelectButtonClick( TObject *Sender )
{
if ( my_rig )
{
rig_cleanup( my_rig );
my_rig = 0;
}
int rig_model = ( int ) RigCombo->Items->Objects[ RigCombo->ItemIndex ];
std::string port = PortCombo->Text.t_str();
// my_rig = rig_init(RIG_MODEL_FT1000MP);
my_rig = rig_init( rig_model );
if ( !my_rig )
{
Label1->Caption = "rig_init failed";
return ;
}
strncpy( my_rig->state.rigport.pathname, port.c_str(), FILPATHLEN );
int retcode = rig_open( my_rig );
char buff[ 1024 ];
if ( retcode != RIG_OK )
{
sprintf( buff, "rig_open: error = %s \n", rigerror( retcode ) );
Label1->Caption = buff;
my_rig = 0;
}
else
{
sprintf( buff, "Opened rig model %d, '%s'\n", my_rig->caps->rig_model,
my_rig->caps->model_name );
TIniFile *t = new TIniFile( ".\\Configuration\\RigSelect.ini" );
t->WriteString( "RigControl", "Manufacturer", my_rig->caps->mfg_name );
t->WriteString( "RigControl", "Model", my_rig->caps->model_name );
delete t;
Label1->Caption = buff;
trace( std::string( "Rig selected: " ) + buff );
ChangeButtonClick( Sender );
}
}
void __fastcall TTestRigMain::RigSelectButtonClick( TObject */*Sender*/ )
{
if ( my_rig )
{
rig_cleanup( my_rig );
my_rig = 0;
}
int rig_model = ( int ) RigCombo->Items->Objects[ RigCombo->ItemIndex ];
String port = PortCombo->Text;
my_rig = rig_init( rig_model );
if ( !my_rig )
{
Label1->Caption = "rig_init failed";
return ;
}
strncpy( my_rig->state.rigport.pathname, port.t_str(), FILPATHLEN );
int retcode = rig_open( my_rig );
char buff[ 1024 ];
if ( retcode != RIG_OK )
{
sprintf( buff, "rig_open: error = %s \n", rigerror( retcode ) );
Label1->Caption = buff;
my_rig = 0;
}
else
{
sprintf( buff, "Opened rig model %d, %s '%s'\n", my_rig->caps->rig_model,
my_rig->caps->mfg_name, my_rig->caps->model_name );
TIniFile *t = new TIniFile( ".\\Configuration\\RigSelect.ini" );
t->WriteString( "TestRig", "Manufacturer", my_rig->caps->mfg_name );
t->WriteString( "TestRig", "Model", my_rig->caps->model_name );
delete t;
Label1->Caption = buff;
}
}
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;
}
int main (int argc, char *argv[])
{
RIG *my_rig; /* handle to rig (instance) */
rig_model_t my_model = RIG_MODEL_DUMMY;
int retcode; /* generic return code from functions */
int verbose = 0;
int show_conf = 0;
int dump_caps_opt = 0;
const char *rig_file=NULL, *ptt_file=NULL, *dcd_file=NULL;
ptt_type_t ptt_type = RIG_PTT_NONE;
dcd_type_t dcd_type = RIG_DCD_NONE;
int serial_rate = 0;
char *civaddr = NULL; /* NULL means no need to set conf */
char conf_parms[MAXCONFLEN] = "";
struct addrinfo hints, *result, *saved_result;
int sock_listen;
int reuseaddr = 1;
char host[NI_MAXHOST];
char serv[NI_MAXSERV];
while(1) {
int c;
int option_index = 0;
c = getopt_long (argc, argv, SHORT_OPTIONS,
long_options, &option_index);
if (c == -1)
break;
switch(c) {
case 'h':
usage();
exit(0);
case 'V':
version();
exit(0);
case 'm':
if (!optarg) {
usage(); /* wrong arg count */
exit(1);
}
my_model = atoi(optarg);
break;
case 'r':
if (!optarg) {
usage(); /* wrong arg count */
exit(1);
}
rig_file = optarg;
break;
case 'p':
if (!optarg) {
usage(); /* wrong arg count */
exit(1);
}
ptt_file = optarg;
break;
case 'd':
if (!optarg) {
usage(); /* wrong arg count */
exit(1);
}
dcd_file = optarg;
break;
case 'P':
if (!optarg) {
usage(); /* wrong arg count */
exit(1);
}
if (!strcmp(optarg, "RIG"))
ptt_type = RIG_PTT_RIG;
else if (!strcmp(optarg, "DTR"))
ptt_type = RIG_PTT_SERIAL_DTR;
else if (!strcmp(optarg, "RTS"))
ptt_type = RIG_PTT_SERIAL_RTS;
else if (!strcmp(optarg, "PARALLEL"))
ptt_type = RIG_PTT_PARALLEL;
else if (!strcmp(optarg, "CM108"))
ptt_type = RIG_PTT_CM108;
else if (!strcmp(optarg, "NONE"))
ptt_type = RIG_PTT_NONE;
else
ptt_type = atoi(optarg);
break;
case 'D':
if (!optarg) {
usage(); /* wrong arg count */
exit(1);
}
if (!strcmp(optarg, "RIG"))
dcd_type = RIG_DCD_RIG;
else if (!strcmp(optarg, "DSR"))
dcd_type = RIG_DCD_SERIAL_DSR;
else if (!strcmp(optarg, "CTS"))
dcd_type = RIG_DCD_SERIAL_CTS;
else if (!strcmp(optarg, "CD"))
dcd_type = RIG_DCD_SERIAL_CAR;
else if (!strcmp(optarg, "PARALLEL"))
dcd_type = RIG_DCD_PARALLEL;
else if (!strcmp(optarg, "NONE"))
dcd_type = RIG_DCD_NONE;
else
dcd_type = atoi(optarg);
break;
case 'c':
if (!optarg) {
usage(); /* wrong arg count */
exit(1);
}
civaddr = optarg;
break;
case 's':
if (!optarg) {
usage(); /* wrong arg count */
exit(1);
}
serial_rate = atoi(optarg);
break;
case 'C':
if (!optarg) {
usage(); /* wrong arg count */
exit(1);
}
if (*conf_parms != '\0')
strcat(conf_parms, ",");
strncat(conf_parms, optarg, MAXCONFLEN-strlen(conf_parms));
break;
case 't':
if (!optarg) {
usage(); /* wrong arg count */
exit(1);
}
portno = optarg;
break;
case 'T':
if (!optarg) {
usage(); /* wrong arg count */
exit(1);
}
src_addr = optarg;
break;
case 'o':
vfo_mode++;
break;
case 'v':
verbose++;
break;
case 'L':
show_conf++;
break;
case 'l':
list_models();
exit(0);
case 'u':
dump_caps_opt++;
break;
default:
usage(); /* unknown option? */
exit(1);
}
}
rig_set_debug(verbose);
rig_debug(RIG_DEBUG_VERBOSE, "rigctld, %s\n", hamlib_version);
rig_debug(RIG_DEBUG_VERBOSE, "Report bugs to "
"<*****@*****.**>\n\n");
my_rig = rig_init(my_model);
if (!my_rig) {
fprintf(stderr, "Unknown rig num %d, or initialization error.\n",
my_model);
fprintf(stderr, "Please check with --list option.\n");
exit(2);
}
retcode = set_conf(my_rig, conf_parms);
if (retcode != RIG_OK) {
fprintf(stderr, "Config parameter error: %s\n", rigerror(retcode));
exit(2);
}
if (rig_file)
strncpy(my_rig->state.rigport.pathname, rig_file, FILPATHLEN - 1);
/*
* ex: RIG_PTT_PARALLEL and /dev/parport0
*/
if (ptt_type != RIG_PTT_NONE)
my_rig->state.pttport.type.ptt = ptt_type;
if (dcd_type != RIG_DCD_NONE)
my_rig->state.dcdport.type.dcd = dcd_type;
if (ptt_file)
strncpy(my_rig->state.pttport.pathname, ptt_file, FILPATHLEN - 1);
if (dcd_file)
strncpy(my_rig->state.dcdport.pathname, dcd_file, FILPATHLEN - 1);
/* FIXME: bound checking and port type == serial */
if (serial_rate != 0)
my_rig->state.rigport.parm.serial.rate = serial_rate;
if (civaddr)
rig_set_conf(my_rig, rig_token_lookup(my_rig, "civaddr"), civaddr);
/*
* print out conf parameters
*/
if (show_conf) {
rig_token_foreach(my_rig, print_conf_list, (rig_ptr_t)my_rig);
}
/*
* print out conf parameters, and exits immediately
* We may be interested only in only caps, and rig_open may fail.
*/
if (dump_caps_opt) {
dumpcaps(my_rig, stdout);
rig_cleanup(my_rig); /* if you care about memory */
exit(0);
}
retcode = rig_open(my_rig);
if (retcode != RIG_OK) {
fprintf(stderr,"rig_open: error = %s \n", rigerror(retcode));
exit(2);
}
if (verbose > 0)
printf("Opened rig model %d, '%s'\n", my_rig->caps->rig_model,
my_rig->caps->model_name);
rig_debug(RIG_DEBUG_VERBOSE, "Backend version: %s, Status: %s\n",
my_rig->caps->version, rig_strstatus(my_rig->caps->status));
#ifdef __MINGW32__
# ifndef SO_OPENTYPE
# define SO_OPENTYPE 0x7008
# endif
# ifndef SO_SYNCHRONOUS_NONALERT
# define SO_SYNCHRONOUS_NONALERT 0x20
# endif
# ifndef INVALID_SOCKET
# define INVALID_SOCKET -1
# endif
WSADATA wsadata;
if (WSAStartup(MAKEWORD(1,1), &wsadata) == SOCKET_ERROR) {
fprintf(stderr,"WSAStartup socket error\n");
exit(1);
}
int sockopt = SO_SYNCHRONOUS_NONALERT;
setsockopt(INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, (char *)&sockopt, sizeof(sockopt));
#endif
/*
* Prepare listening socket
*/
memset(&hints, 0, sizeof(struct addrinfo));
hints.ai_family = AF_UNSPEC; /* Allow IPv4 or IPv6 */
hints.ai_socktype = SOCK_STREAM;/* TCP socket */
hints.ai_flags = AI_PASSIVE; /* For wildcard IP address */
hints.ai_protocol = 0; /* Any protocol */
retcode = getaddrinfo(src_addr, portno, &hints, &result);
if (retcode != 0) {
fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(retcode));
exit(2);
}
saved_result = result;
do
{
sock_listen = socket(result->ai_family, result->ai_socktype,
result->ai_protocol);
if (sock_listen < 0) {
handle_error (RIG_DEBUG_ERR, "socket");
freeaddrinfo(saved_result); /* No longer needed */
exit(2);
}
if (setsockopt(sock_listen, SOL_SOCKET, SO_REUSEADDR,
(char *)&reuseaddr, sizeof(reuseaddr)) < 0) {
handle_error (RIG_DEBUG_ERR, "setsockopt");
freeaddrinfo(saved_result); /* No longer needed */
exit (1);
}
#ifdef __MINGW32__
/* allow IPv4 mapped to IPv6 clients, MS default this to 1! */
sockopt = 0;
if (setsockopt(sock_listen, IPPROTO_IPV6, IPV6_V6ONLY,
(char *)&sockopt, sizeof(sockopt)) < 0) {
handle_error (RIG_DEBUG_ERR, "setsockopt");
freeaddrinfo(saved_result); /* No longer needed */
exit (1);
}
#endif
if (0 == bind(sock_listen, result->ai_addr, result->ai_addrlen)) {
break;
}
handle_error (RIG_DEBUG_WARN, "binding failed (trying next interface)");
#ifdef __MINGW32__
closesocket (sock_listen);
#else
close (sock_listen);
#endif
} while ((result = result->ai_next) != NULL);
freeaddrinfo(saved_result); /* No longer needed */
if (NULL == result)
{
rig_debug(RIG_DEBUG_ERR, "bind error - no available interface\n");
exit (1);
}
if (listen(sock_listen, 4) < 0) {
handle_error (RIG_DEBUG_ERR, "listening");
exit (1);
}
/*
* main loop accepting connections
*/
do {
#ifdef HAVE_PTHREAD
pthread_t thread;
pthread_attr_t attr;
#endif
struct handle_data *arg;
arg = malloc(sizeof(struct handle_data));
if (!arg) {
rig_debug(RIG_DEBUG_ERR, "malloc: %s\n", strerror(errno));
exit (1);
}
arg->rig = my_rig;
arg->clilen = sizeof (arg->cli_addr);
arg->sock = accept(sock_listen, (struct sockaddr *)&arg->cli_addr, &arg->clilen);
if (arg->sock < 0) {
handle_error (RIG_DEBUG_ERR, "accept");
break;
}
if ((retcode = getnameinfo ((struct sockaddr const *)&arg->cli_addr, arg->clilen, host, sizeof (host)
, serv, sizeof (serv), NI_NOFQDN)) < 0)
{
rig_debug (RIG_DEBUG_WARN, "Peer lookup error: %s", gai_strerror (retcode));
}
rig_debug(RIG_DEBUG_VERBOSE, "Connection opened from %s:%s\n",
host, serv);
#ifdef HAVE_PTHREAD
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
retcode = pthread_create(&thread, &attr, handle_socket, arg);
if (retcode != 0) {
rig_debug(RIG_DEBUG_ERR, "pthread_create: %s\n", strerror(retcode));
break;
}
#else
handle_socket(arg);
#endif
}
while (retcode == 0);
rig_close(my_rig); /* close port */
rig_cleanup(my_rig); /* if you care about memory */
#ifdef __MINGW32__
WSACleanup();
#endif
return 0;
}
int main(int argc, char *argv[])
{
int rc = -1, n, priority;
const char *importer, *scanner, *geo;
char *endptr;
size_t nctl;
double speed;
struct timecode_def *timecode;
bool protect, use_mlock, phono;
struct controller ctl[2];
struct rt rt;
struct library library;
#if defined WITH_OSS || WITH_ALSA
int rate;
#endif
#ifdef WITH_OSS
int oss_buffers, oss_fragment;
#endif
#ifdef WITH_ALSA
int alsa_buffer;
#endif
fprintf(stderr, "%s\n\n" NOTICE "\n\n", banner);
if (thread_global_init() == -1)
return -1;
if (rig_init() == -1)
return -1;
rt_init(&rt);
library_init(&library);
ndeck = 0;
geo = "";
nctl = 0;
priority = DEFAULT_PRIORITY;
importer = DEFAULT_IMPORTER;
scanner = DEFAULT_SCANNER;
timecode = NULL;
speed = 1.0;
protect = false;
phono = false;
use_mlock = false;
#if defined WITH_OSS || WITH_ALSA
rate = DEFAULT_RATE;
#endif
#ifdef WITH_ALSA
alsa_buffer = DEFAULT_ALSA_BUFFER;
#endif
#ifdef WITH_OSS
oss_fragment = DEFAULT_OSS_FRAGMENT;
oss_buffers = DEFAULT_OSS_BUFFERS;
#endif
/* Skip over command name */
argv++;
argc--;
while (argc > 0) {
if (!strcmp(argv[0], "-h")) {
usage(stdout);
return 0;
#ifdef WITH_OSS
} else if (!strcmp(argv[0], "-f")) {
/* Set fragment size for subsequent devices */
if (argc < 2) {
fprintf(stderr, "-f requires an integer argument.\n");
return -1;
}
oss_fragment = strtol(argv[1], &endptr, 10);
if (*endptr != '\0') {
fprintf(stderr, "-f requires an integer argument.\n");
return -1;
}
/* Fragment sizes greater than the default aren't useful
* as they are dependent on DEVICE_FRAME */
if (oss_fragment < DEFAULT_OSS_FRAGMENT) {
fprintf(stderr, "Fragment size must be %d or more; aborting.\n",
DEFAULT_OSS_FRAGMENT);
return -1;
}
argv += 2;
argc -= 2;
} else if (!strcmp(argv[0], "-b")) {
/* Set number of buffers for subsequent devices */
if (argc < 2) {
fprintf(stderr, "-b requires an integer argument.\n");
return -1;
}
oss_buffers = strtol(argv[1], &endptr, 10);
if (*endptr != '\0') {
fprintf(stderr, "-b requires an integer argument.\n");
return -1;
}
argv += 2;
argc -= 2;
#endif
#if defined WITH_OSS || WITH_ALSA
} else if (!strcmp(argv[0], "-r")) {
/* Set sample rate for subsequence devices */
if (argc < 2) {
fprintf(stderr, "-r requires an integer argument.\n");
return -1;
}
rate = strtol(argv[1], &endptr, 10);
if (*endptr != '\0') {
fprintf(stderr, "-r requires an integer argument.\n");
return -1;
}
argv += 2;
argc -= 2;
#endif
#ifdef WITH_ALSA
} else if (!strcmp(argv[0], "-m")) {
/* Set size of ALSA buffer for subsequence devices */
if (argc < 2) {
fprintf(stderr, "-m requires an integer argument.\n");
return -1;
}
alsa_buffer = strtol(argv[1], &endptr, 10);
if (*endptr != '\0') {
fprintf(stderr, "-m requires an integer argument.\n");
return -1;
}
argv += 2;
argc -= 2;
#endif
} else if (!strcmp(argv[0], "-d") || !strcmp(argv[0], "-a") ||
!strcmp(argv[0], "-j"))
{
int r;
unsigned int sample_rate;
struct deck *ld;
struct device *device;
struct timecoder *timecoder;
/* Create a deck */
if (argc < 2) {
fprintf(stderr, "-%c requires a device name as an argument.\n",
argv[0][1]);
return -1;
}
if (ndeck == ARRAY_SIZE(deck)) {
fprintf(stderr, "Too many decks; aborting.\n");
return -1;
}
fprintf(stderr, "Initialising deck %zd (%s)...\n", ndeck, argv[1]);
ld = &deck[ndeck];
device = &ld->device;
timecoder = &ld->timecoder;
ld->importer = importer;
ld->protect = protect;
/* Work out which device type we are using, and initialise
* an appropriate device. */
switch(argv[0][1]) {
#ifdef WITH_OSS
case 'd':
r = oss_init(device, argv[1], rate, oss_buffers, oss_fragment);
break;
#endif
#ifdef WITH_ALSA
case 'a':
r = alsa_init(device, argv[1], rate, alsa_buffer);
break;
#endif
#ifdef WITH_JACK
case 'j':
r = jack_init(device, argv[1]);
break;
#endif
default:
fprintf(stderr, "Device type is not supported by this "
"distribution of xwax.\n");
return -1;
}
if (r == -1)
return -1;
sample_rate = device_sample_rate(device);
/* Default timecode decoder where none is specified */
if (timecode == NULL) {
timecode = timecoder_find_definition(DEFAULT_TIMECODE);
assert(timecode != NULL);
}
timecoder_init(timecoder, timecode, speed, sample_rate, phono);
/* Connect up the elements to make an operational deck */
r = deck_init(ld, &rt, ndeck);
if (r == -1)
return -1;
/* Connect this deck to available controllers */
for (n = 0; n < nctl; n++)
controller_add_deck(&ctl[n], &deck[ndeck]);
/* Connect this deck to OSC server */
osc_add_deck();
ndeck++;
argv += 2;
argc -= 2;
} else if (!strcmp(argv[0], "-t")) {
/* Set the timecode definition to use */
if (argc < 2) {
fprintf(stderr, "-t requires a name as an argument.\n");
return -1;
}
timecode = timecoder_find_definition(argv[1]);
if (timecode == NULL) {
fprintf(stderr, "Timecode '%s' is not known.\n", argv[1]);
return -1;
}
argv += 2;
argc -= 2;
} else if (!strcmp(argv[0], "-33")) {
speed = 1.0;
argv++;
argc--;
} else if (!strcmp(argv[0], "-45")) {
speed = 1.35;
argv++;
argc--;
} else if (!strcmp(argv[0], "-c")) {
protect = true;
argv++;
argc--;
} else if (!strcmp(argv[0], "-u")) {
protect = false;
argv++;
argc--;
} else if (!strcmp(argv[0], "--line")) {
phono = false;
argv++;
argc--;
} else if (!strcmp(argv[0], "--phono")) {
phono = true;
argv++;
argc--;
} else if (!strcmp(argv[0], "-k")) {
use_mlock = true;
track_use_mlock();
argv++;
argc--;
} else if (!strcmp(argv[0], "-q")) {
if (argc < 2) {
fprintf(stderr, "-q requires an integer argument.\n");
return -1;
}
priority = strtol(argv[1], &endptr, 10);
if (*endptr != '\0') {
fprintf(stderr, "-q requires an integer argument.\n");
return -1;
}
if (priority < 0) {
fprintf(stderr, "Priority (%d) must be zero or positive.\n",
priority);
return -1;
}
argv += 2;
argc -= 2;
} else if (!strcmp(argv[0], "-g")) {
if (argc < 2) {
fprintf(stderr, "-g requires an argument.\n");
return -1;
}
geo = argv[1];
argv += 2;
argc -= 2;
} else if (!strcmp(argv[0], "-i")) {
/* Importer script for subsequent decks */
if (argc < 2) {
fprintf(stderr, "-i requires an executable path "
"as an argument.\n");
return -1;
}
importer = argv[1];
argv += 2;
argc -= 2;
} else if (!strcmp(argv[0], "-s")) {
/* Scan script for subsequent libraries */
if (argc < 2) {
fprintf(stderr, "-s requires an executable path "
"as an argument.\n");
return -1;
}
scanner = argv[1];
argv += 2;
argc -= 2;
} else if (!strcmp(argv[0], "-l")) {
/* Load in a music library */
if (argc < 2) {
fprintf(stderr, "-%c requires a pathname as an argument.\n",
argv[0][1]);
return -1;
}
if (library_import(&library, scanner, argv[1]) == -1)
return -1;
argv += 2;
argc -= 2;
#ifdef WITH_ALSA
} else if (!strcmp(argv[0], "--dicer")) {
struct controller *c;
if (nctl == sizeof ctl) {
fprintf(stderr, "Too many controllers; aborting.\n");
return -1;
}
c = &ctl[nctl];
if (argc < 2) {
fprintf(stderr, "Dicer requires an ALSA device name.\n");
return -1;
}
if (dicer_init(c, &rt, argv[1]) == -1)
return -1;
nctl++;
argv += 2;
argc -= 2;
#endif
} else {
fprintf(stderr, "'%s' argument is unknown; try -h.\n", argv[0]);
return -1;
}
}
#ifdef WITH_ALSA
alsa_clear_config_cache();
#endif
if (ndeck == 0) {
fprintf(stderr, "You need to give at least one audio device to use "
"as a deck; try -h.\n");
return -1;
}
rc = EXIT_FAILURE; /* until clean exit */
if (osc_start((struct deck *)&deck, &library) == -1)
return -1;
osc_start_updater_thread();
/* Order is important: launch realtime thread first, then mlock.
* Don't mlock the interface, use sparingly for audio threads */
if (rt_start(&rt, priority) == -1)
return -1;
if (use_mlock && mlockall(MCL_CURRENT) == -1) {
perror("mlockall");
goto out_rt;
}
if (interface_start(&library, geo) == -1)
goto out_rt;
if (rig_main() == -1)
goto out_interface;
rc = EXIT_SUCCESS;
fprintf(stderr, "Exiting cleanly...\n");
out_interface:
interface_stop();
out_rt:
rt_stop(&rt);
for (n = 0; n < ndeck; n++)
deck_clear(&deck[n]);
for (n = 0; n < nctl; n++)
controller_clear(&ctl[n]);
timecoder_free_lookup();
library_clear(&library);
rt_clear(&rt);
rig_clear();
osc_stop();
thread_global_clear();
if (rc == EXIT_SUCCESS)
fprintf(stderr, "Done.\n");
return rc;
}
int main (int argc, char *argv[])
{
RIG *my_rig; /* handle to rig (nstance) */
int retcode; /* generic return code from functions */
int i, count = 0;
if (argc != 2) {
fprintf(stderr,"%s <rig_num>\n", argv[0]);
exit(1);
}
printf("testrig:hello, I am your main() !\n");
/*
* allocate memory, setup & open port
*/
my_rig = rig_init(atoi(argv[1]));
if (!my_rig) {
fprintf(stderr,"Unknown rig num: %d\n",atoi(argv[1]));
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);
if (rig_open(my_rig))
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
*
*/
retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 439700000);
if (retcode != RIG_OK ) {
printf("rig_set_freq: error = %s \n", rigerror(retcode));
}
rig_set_freq_callback(my_rig, myfreq_event, (rig_ptr_t)&count);
retcode = rig_set_trn(my_rig, RIG_TRN_RIG);
if (retcode != RIG_OK ) {
printf("rig_set_trn: error = %s \n", rigerror(retcode));
}
for (i=0;i<12;i++)
{
printf("Loop count: %d\n", i);
sleep(10); /* or anything smarter */
}
printf("Frequency changed %d times\n", count);
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 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; /* handle to rig (nstance) */
rig_model_t my_model = RIG_MODEL_DUMMY;
int retcode; /* generic return code from functions */
int exitcode;
int verbose = 0;
int show_conf = 0;
int dump_caps_opt = 0;
#ifdef HAVE_READLINE_HISTORY
int rd_hist = 0;
int sv_hist = 0;
const char *hist_dir = NULL;
const char hist_file[] = "/.rigctl_history";
char *hist_path = NULL;
struct stat hist_dir_stat;
#endif
const char *rig_file=NULL, *ptt_file=NULL, *dcd_file=NULL;
ptt_type_t ptt_type = RIG_PTT_NONE;
dcd_type_t dcd_type = RIG_DCD_NONE;
int serial_rate = 0;
char *civaddr = NULL; /* NULL means no need to set conf */
char conf_parms[MAXCONFLEN] = "";
while(1) {
int c;
int option_index = 0;
c = getopt_long (argc, argv, SHORT_OPTIONS HST_SHRT_OPTS,
long_options, &option_index);
if (c == -1)
break;
switch(c) {
case 'h':
usage();
exit(0);
case 'V':
version();
exit(0);
case 'm':
if (!optarg) {
usage(); /* wrong arg count */
exit(1);
}
my_model = atoi(optarg);
break;
case 'r':
if (!optarg) {
usage(); /* wrong arg count */
exit(1);
}
rig_file = optarg;
break;
case 'p':
if (!optarg) {
usage(); /* wrong arg count */
exit(1);
}
ptt_file = optarg;
break;
case 'd':
if (!optarg) {
usage(); /* wrong arg count */
exit(1);
}
dcd_file = optarg;
break;
case 'P':
if (!optarg) {
usage(); /* wrong arg count */
exit(1);
}
if (!strcmp(optarg, "RIG"))
ptt_type = RIG_PTT_RIG;
else if (!strcmp(optarg, "DTR"))
ptt_type = RIG_PTT_SERIAL_DTR;
else if (!strcmp(optarg, "RTS"))
ptt_type = RIG_PTT_SERIAL_RTS;
else if (!strcmp(optarg, "PARALLEL"))
ptt_type = RIG_PTT_PARALLEL;
else if (!strcmp(optarg, "CM108"))
ptt_type = RIG_PTT_CM108;
else if (!strcmp(optarg, "GPIO"))
ptt_type = RIG_PTT_GPIO;
else if (!strcmp(optarg, "GPION"))
ptt_type = RIG_PTT_GPION;
else if (!strcmp(optarg, "NONE"))
ptt_type = RIG_PTT_NONE;
else
ptt_type = atoi(optarg);
break;
case 'D':
if (!optarg) {
usage(); /* wrong arg count */
exit(1);
}
if (!strcmp(optarg, "RIG"))
dcd_type = RIG_DCD_RIG;
else if (!strcmp(optarg, "DSR"))
dcd_type = RIG_DCD_SERIAL_DSR;
else if (!strcmp(optarg, "CTS"))
dcd_type = RIG_DCD_SERIAL_CTS;
else if (!strcmp(optarg, "CD"))
dcd_type = RIG_DCD_SERIAL_CAR;
else if (!strcmp(optarg, "PARALLEL"))
dcd_type = RIG_DCD_PARALLEL;
else if (!strcmp(optarg, "CM108"))
dcd_type = RIG_DCD_CM108;
else if (!strcmp(optarg, "NONE"))
dcd_type = RIG_DCD_NONE;
else
dcd_type = atoi(optarg);
break;
case 'c':
if (!optarg) {
usage(); /* wrong arg count */
exit(1);
}
civaddr = optarg;
break;
case 't':
if (!optarg) {
usage(); /* wrong arg count */
exit(1);
}
if (strlen(optarg) > 1)
send_cmd_term = strtol(optarg, NULL, 0);
else
send_cmd_term = optarg[0];
break;
case 's':
if (!optarg) {
usage(); /* wrong arg count */
exit(1);
}
serial_rate = atoi(optarg);
break;
case 'C':
if (!optarg) {
usage(); /* wrong arg count */
exit(1);
}
if (*conf_parms != '\0')
strcat(conf_parms, ",");
strncat(conf_parms, optarg, MAXCONFLEN-strlen(conf_parms));
break;
case 'o':
vfo_mode++;
break;
case 'n':
rig_no_restore_ai();
break;
#ifdef HAVE_READLINE_HISTORY
case 'i':
rd_hist++;
break;
case 'I':
sv_hist++;
break;
#endif
case 'v':
verbose++;
break;
case 'L':
show_conf++;
break;
case 'l':
rig_set_debug(verbose);
list_models();
exit(0);
case 'u':
dump_caps_opt++;
break;
default:
usage(); /* unknown option? */
exit(1);
}
}
rig_set_debug(verbose);
rig_debug(RIG_DEBUG_VERBOSE, "rigctl, %s\n", hamlib_version);
rig_debug(RIG_DEBUG_VERBOSE, "Report bugs to "
"<*****@*****.**>\n\n");
/*
* at least one command on command line,
* disable interactive mode
*/
if (optind < argc)
interactive = 0;
my_rig = rig_init(my_model);
if (!my_rig) {
fprintf(stderr, "Unknown rig num %d, or initialization error.\n",
my_model);
fprintf(stderr, "Please check with --list option.\n");
exit(2);
}
retcode = set_conf(my_rig, conf_parms);
if (retcode != RIG_OK) {
fprintf(stderr, "Config parameter error: %s\n", rigerror(retcode));
exit(2);
}
if (rig_file)
strncpy(my_rig->state.rigport.pathname, rig_file, FILPATHLEN - 1);
/*
* ex: RIG_PTT_PARALLEL and /dev/parport0
*/
if (ptt_type != RIG_PTT_NONE)
my_rig->state.pttport.type.ptt = ptt_type;
if (dcd_type != RIG_DCD_NONE)
my_rig->state.dcdport.type.dcd = dcd_type;
if (ptt_file)
strncpy(my_rig->state.pttport.pathname, ptt_file, FILPATHLEN - 1);
if (dcd_file)
strncpy(my_rig->state.dcdport.pathname, dcd_file, FILPATHLEN - 1);
/* FIXME: bound checking and port type == serial */
if (serial_rate != 0)
my_rig->state.rigport.parm.serial.rate = serial_rate;
if (civaddr)
rig_set_conf(my_rig, rig_token_lookup(my_rig, "civaddr"), civaddr);
/*
* print out conf parameters
*/
if (show_conf) {
dumpconf(my_rig, stdout);
}
/*
* print out capabilities, and exists immediately
* We may be interested only in only caps, and rig_open may fail.
*/
if (dump_caps_opt) {
dumpcaps(my_rig, stdout);
rig_cleanup(my_rig); /* if you care about memory */
exit(0);
}
retcode = rig_open(my_rig);
if (retcode != RIG_OK) {
fprintf(stderr,"rig_open: error = %s \n", rigerror(retcode));
exit(2);
}
if (verbose > 0)
printf("Opened rig model %d, '%s'\n", my_rig->caps->rig_model,
my_rig->caps->model_name);
rig_debug(RIG_DEBUG_VERBOSE, "Backend version: %s, Status: %s\n",
my_rig->caps->version, rig_strstatus(my_rig->caps->status));
exitcode = 0;
#ifdef HAVE_LIBREADLINE
if (interactive && prompt && have_rl) {
rl_readline_name = "rigctl";
#ifdef HAVE_READLINE_HISTORY
using_history(); /* Initialize Readline History */
if (rd_hist || sv_hist) {
if (!(hist_dir = getenv("RIGCTL_HIST_DIR")))
hist_dir = getenv("HOME");
if (((stat(hist_dir, &hist_dir_stat) == -1) && (errno == ENOENT))
|| !(S_ISDIR(hist_dir_stat.st_mode))) {
fprintf(stderr, "Warning: %s is not a directory!\n", hist_dir);
}
hist_path = (char *)calloc((sizeof(char) * (strlen(hist_dir) + strlen(hist_file) + 1)), sizeof(char));
strncpy(hist_path, hist_dir, strlen(hist_dir));
strncat(hist_path, hist_file, strlen(hist_file));
}
if (rd_hist && hist_path)
if (read_history(hist_path) == ENOENT)
fprintf(stderr, "Warning: Could not read history from %s\n", hist_path);
#endif
}
#endif /* HAVE_LIBREADLINE */
do {
retcode = rigctl_parse(my_rig, stdin, stdout, argv, argc);
if (retcode == 2)
exitcode = 2;
}
while (retcode == 0 || retcode == 2);
#ifdef HAVE_LIBREADLINE
if (interactive && prompt && have_rl) {
#ifdef HAVE_READLINE_HISTORY
if (sv_hist && hist_path)
if (write_history(hist_path) == ENOENT)
fprintf(stderr, "\nWarning: Could not write history to %s\n", hist_path);
if ((rd_hist || sv_hist) && hist_path) {
free(hist_path);
hist_path = (char *)NULL;
}
#endif
}
#endif
rig_close(my_rig); /* close port */
rig_cleanup(my_rig); /* if you care about memory */
return exitcode;
}
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;
};
