mirror
/
Hamlib
kopia lustrzana https://github.com/Hamlib/Hamlib
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność
Hamlib/gnuradio/gnuradio.cc

1143 wiersze
28 KiB
C++
Czysty Wina Historia

/* -*- Mode: c++ -*- */
/*
* Hamlib GNUradio backend - main file
* Copyright (c) 2001-2003 by Stephane Fillod
*
* $Id: gnuradio.cc,v 1.4 2003-04-06 18:50:21 fillods Exp $
*
* This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
/*
* Simple backend of a chirp source.
*/
#include <VrSigSource.h>
#include <VrAudioSource.h>
#include <VrFileSource.h>
#include <VrNullSink.h>
#include <VrAudioSink.h>
#include <VrFileSink.h>
#include <VrFixOffset.h>
#include <GrMC4020Source.h>
#include <VrConnect.h>
#include <VrMultiTask.h>
#include <GrFreqXlatingFIRfilterSCF.h>
#include <GrFreqXlatingFIRfilterCCF.h>
#include <GrFIRfilterFSF.h>
#include <GrFIRfilterFFF.h>
#include <VrQuadratureDemod.h> /* FM */
//#include <VrAmplitudeDemod.h> /* AM */
/* SSB mod */
//#include <GrSSBMod.h>
//#include <GrHilbert.h>
#include <gr_firdes.h>
#include <gr_fir_builderF.h>
/* Chirp param's */
#define CARRIER_FREQ 1.070e6 // AM 1070
#define AMPLITUDE 3000
#include <stdlib.h>
#include <stdio.h> /* Standard input/output definitions */
#include <string.h> /* String function definitions */
#include <unistd.h> /* UNIX standard function definitions */
#include <fcntl.h> /* File control definitions */
#include <errno.h> /* Error number definitions */
#include <sys/ioctl.h>
#include <math.h>
#include <pthread.h>
#include <hamlib/rig.h>
#include <misc.h>
#include <token.h>
#include "gnuradio.h"
#include "gr_priv.h" // struct gnuradio_priv_data
/*
* TODO: fft scope, with ext_level to display them
*/
#define TOK_TUNER_MODEL TOKEN_BACKEND(1)
const struct confparams gnuradio_cfg_params[] = {
{ TOK_TUNER_MODEL, "tuner_model", "Tuner model", "Hamlib rig tuner model number",
"1" /* RIG_MODEL_DUMMY */, RIG_CONF_NUMERIC, { /* .n = */ { 0, INT_MAX, 1 } }
},
/*
* TODO: IF_center_freq, input_rate, etc.
*/
{ RIG_CONF_END, NULL, }
};
static void init_chan(RIG *rig, vfo_t vfo, channel_t *chan)
{
chan->channel_num = 0;
chan->vfo = vfo;
strcpy(chan->channel_desc, strvfo(vfo));
chan->freq = RIG_FREQ_NONE;
chan->mode = RIG_MODE_NONE;
chan->width = 0;
chan->tx_freq = chan->freq;
chan->tx_mode = chan->mode;
chan->tx_width = chan->width;
chan->split = RIG_SPLIT_OFF;
chan->rptr_shift = RIG_RPT_SHIFT_NONE;
chan->rptr_offs = 0;
chan->ctcss_tone = 0;
chan->dcs_code = 0;
chan->ctcss_sql = 0;
chan->dcs_sql = 0;
chan->rit = 0;
chan->xit = 0;
chan->tuning_step = 0;
chan->ant = 0;
chan->funcs = (setting_t)0;
memset(chan->levels, 0, RIG_SETTING_MAX*sizeof(value_t));
}
int gr_init(RIG *rig)
{
struct gnuradio_priv_data *priv;
const struct gnuradio_priv_caps *priv_caps = (const struct gnuradio_priv_caps*)rig->caps->priv;
int i;
priv = (struct gnuradio_priv_data*)malloc(sizeof(struct gnuradio_priv_data));
if (!priv)
return -RIG_ENOMEM;
rig->state.priv = (void*)priv;
rig_debug(RIG_DEBUG_VERBOSE,"%s called\n", __FUNCTION__ );
rig->state.rigport.type.rig = RIG_PORT_NONE;
memset(priv->parms, 0, RIG_SETTING_MAX*sizeof(value_t));
priv->m = NULL;
priv->sink = NULL;
priv->source = NULL;
priv->need_fixer = 0;
for (i=0; i<NUM_CHAN; i++) {
init_chan(rig, RIG_VFO_N(i), &priv->chans[i]);
priv->chans[i].levels[rig_setting2idx(RIG_LEVEL_AF)].f = 1.0;
priv->chans[i].levels[rig_setting2idx(RIG_LEVEL_RF)].f = 1.0;
}
priv->curr_vfo = RIG_VFO_A;
priv->tuner_model = priv_caps->tuner_model;
priv->input_rate = priv_caps->input_rate;
priv->IF_center_freq = priv_caps->IF_center_freq;
pthread_mutex_init(&priv->mutex_process, NULL);
return RIG_OK;
}
/*
* Assumes rig!=NULL, rig->state.priv!=NULL
*/
int gnuradio_set_conf(RIG *rig, token_t token, const char *val)
{
struct gnuradio_priv_data *priv;
struct rig_state *rs;
rs = &rig->state;
priv = (struct gnuradio_priv_data*)rs->priv;
switch(token) {
case TOK_TUNER_MODEL:
priv->tuner_model = atoi(val);
break;
default:
/* if it's not for the gnuradio backend, maybe it's for the tuner */
return rig_set_conf(priv->tuner, token, val);
}
return RIG_OK;
}
/*
* assumes rig!=NULL,
* Assumes rig!=NULL, rig->state.priv!=NULL
* and val points to a buffer big enough to hold the conf value.
*/
int gnuradio_get_conf(RIG *rig, token_t token, char *val)
{
struct gnuradio_priv_data *priv;
struct rig_state *rs;
rs = &rig->state;
priv = (struct gnuradio_priv_data*)rs->priv;
switch(token) {
case TOK_TUNER_MODEL:
sprintf(val, "%d", priv->tuner_model);
break;
default:
/* if it's not for the gnuradio backend, maybe it's for the tuner */
return rig_get_conf(priv->tuner, token, val);
}
return RIG_OK;
}
/*
* GNUradio process thread
*
* the thread is _created_ with priv->mutex_process held
*
* TODO: change process name to give a hint about this CPU hungry process
* also shouldn't we block couple of disturbing signals?
*/
static void *gnuradio_process(void *arg)
{
RIG *rig = (RIG *)arg;
struct gnuradio_priv_data *priv;
priv = (struct gnuradio_priv_data*)rig->state.priv;
/* the mutex lock is not to gurantee reentrancy of rig_debug,
* this is just to know when backend want us start running
*/
pthread_mutex_lock(&priv->mutex_process);
rig_debug(RIG_DEBUG_TRACE,"gnuradio process thread started\n");
pthread_mutex_unlock(&priv->mutex_process);
while (priv->do_process) {
pthread_mutex_lock(&priv->mutex_process);
priv->m->process();
pthread_mutex_unlock(&priv->mutex_process);
}
return NULL;
}
int gr_open(RIG *rig)
{
struct gnuradio_priv_data *priv = (struct gnuradio_priv_data*)rig->state.priv;
const struct gnuradio_priv_caps *priv_caps = (const struct gnuradio_priv_caps*)rig->caps->priv;
int ret;
rig_debug(RIG_DEBUG_VERBOSE,"%s called\n", __FUNCTION__);
/*
* make sure gnuradio's tuner is not gnuradio!
*/
if (RIG_BACKEND_NUM(priv_caps->tuner_model) == RIG_GNURADIO) {
return -RIG_ECONF;
}
priv->tuner = rig_init(priv->tuner_model);
if (!priv->tuner) {
/* FIXME: wrong rig model? */
return -RIG_ENOMEM;
}
rig_open(priv->tuner);
/* TODO:
* copy priv->tuner->rx_range/tx_range to rig->state,
* and override available modes with gnuradio's
*/
/* ** Source ** */
// --> short
priv->source = new VrFileSource<short>(priv->input_rate, "/tmp/fm95_5_half.dat", true);
// Chirp
if (!priv->source)
priv->source = new VrSigSource<IOTYPE>(priv->input_rate, VR_SIN_WAVE, CARRIER_FREQ, AMPLITUDE);
//new VrChirpSource<IOTYPE>(priv->input_rate, AMPLITUDE, 4);
/* VrFileSource (double sampling_freq, const char *file, bool repeat = false) */
//priv->source = new VrFileSource<short>(priv->input_rate, "microtune_source.sw", true);
// short --> short
priv->need_fixer = 1;
priv->offset_fixer = new VrFixOffset<short,short>();
NWO_CONNECT (priv->source, priv->offset_fixer);
priv->sink = new VrAudioSink<short>();
/* ** Sink ** */
if (!priv->sink)
priv->sink = new VrNullSink<short>();
//priv->sink = new VrFileSink<short>("microtune_audio.sw");
priv->m = new VrMultiTask ();
priv->m->start();
/* or set it to MODE_NONE? */
//gr_set_mode(rig, RIG_VFO_CURR, RIG_MODE_WFM, RIG_PASSBAND_NORMAL);
if (priv->tuner_model == RIG_MODEL_DUMMY) {
gr_set_freq(rig, RIG_VFO_CURR, priv->IF_center_freq);
}
priv->do_process = 1;
pthread_mutex_lock(&priv->mutex_process);
ret = pthread_create(&priv->process_thread, NULL, gnuradio_process, (void*)rig);
pthread_mutex_unlock(&priv->mutex_process);
if (ret != 0) {
/* TODO: undo the close*/
rig_debug(RIG_DEBUG_ERR, "%s: pthread_create failed: %s\n", __FUNCTION__, strerror(errno));
return -RIG_ENOMEM; /* huh? */
}
return RIG_OK;
}
/* TODO: error checking of new */
int mc4020_open(RIG *rig)
{
struct gnuradio_priv_data *priv = (struct gnuradio_priv_data*)rig->state.priv;
/* input sample rate from PCI-DAS4020/12: 20000000 */
priv->source = new GrMC4020Source<short>(priv->input_rate, MCC_CH3_EN | MCC_ALL_1V);
return gr_open(rig);
}
/*
* sound card source override
*/
int graudio_open(RIG *rig)
{
struct gnuradio_priv_data *priv = (struct gnuradio_priv_data*)rig->state.priv;
/*
* assumes sound card is full duplex!
*/
priv->source = new VrAudioSource<short>(priv->input_rate);
return gr_open(rig);
}
int gr_close(RIG *rig)
{
struct gnuradio_priv_data *priv = (struct gnuradio_priv_data*)rig->state.priv;
int ret;
rig_debug(RIG_DEBUG_VERBOSE,"%s called\n", __FUNCTION__);
priv->do_process = 0;
pthread_mutex_lock(&priv->mutex_process);
priv->m->stop();
pthread_mutex_unlock(&priv->mutex_process);
ret = pthread_join(priv->process_thread, NULL);
if (ret != 0) {
rig_debug(RIG_DEBUG_ERR, "%s: pthread_join failed: %s\n", __FUNCTION__, strerror(errno));
}
rig_debug(RIG_DEBUG_TRACE,"%s: process thread stopped\n", __FUNCTION__);
delete priv->m;
delete priv->sink;
delete priv->source;
if (priv->need_fixer)
delete priv->offset_fixer;
priv->m = NULL;
priv->sink = NULL;
priv->source = NULL;
priv->need_fixer = 0;
rig_close(priv->tuner);
return RIG_OK;
}
int gr_cleanup(RIG *rig)
{
struct gnuradio_priv_data *priv = (struct gnuradio_priv_data*)rig->state.priv;
rig_debug(RIG_DEBUG_VERBOSE,"%s called\n", __FUNCTION__);
rig_cleanup(priv->tuner);
/* note: mutex must be unlocked! */
pthread_mutex_destroy(&priv->mutex_process);
if (rig->state.priv)
free(rig->state.priv);
rig->state.priv = NULL;
return RIG_OK;
}
static int vfo2chan_num(RIG *rig, vfo_t vfo)
{
struct gnuradio_priv_data *priv = (struct gnuradio_priv_data *)rig->state.priv;
if (vfo == RIG_VFO_CURR)
vfo = priv->curr_vfo;
switch (vfo) {
case RIG_VFO_A:
return 0;
case RIG_VFO_B:
return 1;
}
rig_debug(RIG_DEBUG_WARN,"%s unknown vfo: %d\n", vfo);
return 0;
}
/*
* tuner_freq is the display freq on tuner of the IF in digital domain
* freq is the desired freq
*/
static int update_freq(RIG *rig, unsigned chan_num, freq_t tuner_freq, freq_t freq)
{
struct gnuradio_priv_data *priv = (struct gnuradio_priv_data *)rig->state.priv;
channel_t *chan = &priv->chans[chan_num];
struct mod_data *mod = &priv->mods[chan_num];
double freq_offset;
/*
* In case the tuner is not a real tuner
*/
if (priv->tuner_model == RIG_MODEL_DUMMY)
tuner_freq = priv->IF_center_freq;
freq_offset = (double) (freq - tuner_freq);
rig_debug(RIG_DEBUG_VERBOSE, "%s: %lld %lld freq_offset=%g\n",
__FUNCTION__, tuner_freq, freq, freq_offset);
if (freq_offset == 0)
return RIG_OK; /* nothing to do */
/* TODO: change mode plumbing (don't forget locking!)
* workaround?: set_mode(NONE), set_mode(previous)
*/
pthread_mutex_lock(&priv->mutex_process);
switch (chan->mode) {
case RIG_MODE_WFM:
case RIG_MODE_FM:
case RIG_MODE_USB:
/* not so sure about if setCenter_Freq is the Right thing to do(tm). */
mod->chan_filter->setCenterFreq(priv->IF_center_freq + freq_offset);
break;
/*
* set_freq for SSB mod
* mod->ssb.shifter->set_freq(2*M_PI*freq_offset/(double)priv->input_rate);
*/
case RIG_MODE_NONE:
break;
default:
rig_debug(RIG_DEBUG_WARN, "%s: mode %s unimplemented!\n",
__FUNCTION__, strrmode(chan->mode));
break;
}
pthread_mutex_unlock(&priv->mutex_process);
return RIG_OK;
}
/*
* rig_set_freq is a good candidate for the GNUradio GUI setFrequency callback?
*/
int gr_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
{
struct gnuradio_priv_data *priv = (struct gnuradio_priv_data *)rig->state.priv;
int chan_num = vfo2chan_num(rig, vfo);
channel_t *chan = &priv->chans[chan_num];
freq_t tuner_freq;
int ret, i;
char fstr[20];
sprintf_freq(fstr, freq);
rig_debug(RIG_DEBUG_TRACE,"%s called: %s %s\n",
__FUNCTION__, strvfo(vfo), fstr);
ret = rig_get_freq(priv->tuner, RIG_VFO_CURR, &tuner_freq);
if (ret != RIG_OK)
return ret;
/* check if we're out of current IF window
* TODO: with several VFO's, center the IF inbetween if out of window
*/
if (freq < tuner_freq ||
freq /* + mode_width */ > tuner_freq+GR_MAX_FREQUENCY(priv)) {
/*
* do not set tuner to freq, but center it
*/
ret = rig_set_freq(priv->tuner, RIG_VFO_CURR, freq + GR_MAX_FREQUENCY(priv)/2);
if (ret != RIG_OK)
return ret;
/*
* query freq right back, because wanted freq may not be real freq,
* because of resolution of tuner
*/
ret = rig_get_freq(priv->tuner, RIG_VFO_CURR, &tuner_freq);
if (ret != RIG_OK)
return ret;
/*
* tuner freq changed, so adjust frequency offset of other channels
*/
for (i = 0; i<NUM_CHAN; i++) {
if (i != chan_num)
update_freq(rig, i, tuner_freq, priv->chans[i].freq);
}
}
ret = update_freq(rig, chan_num, tuner_freq, freq);
if (ret == RIG_OK)
chan->freq = freq;
return ret;
}
int gr_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
{
struct gnuradio_priv_data *priv = (struct gnuradio_priv_data *)rig->state.priv;
int chan_num = vfo2chan_num(rig, vfo);
channel_t *chan = &priv->chans[chan_num];
rig_debug(RIG_DEBUG_VERBOSE,"%s called: %s\n", __FUNCTION__, strvfo(vfo));
*freq = chan->freq;
return RIG_OK;
}
/*
* WIP
*/
int gr_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
struct gnuradio_priv_data *priv = (struct gnuradio_priv_data *)rig->state.priv;
int chan_num = vfo2chan_num(rig, vfo);
channel_t *chan = &priv->chans[chan_num];
struct mod_data *mod = &priv->mods[chan_num];
char buf[16];
freq_t tuner_freq;
int ret = RIG_OK;
double freq_offset;
if (width == RIG_PASSBAND_NORMAL)
width = rig_passband_normal(rig, mode);
sprintf_freq(buf, width);
rig_debug(RIG_DEBUG_VERBOSE,"%s called: %s %s %s\n",
__FUNCTION__, strvfo(vfo), strrmode(mode), buf);
if (mode == chan->mode && width == chan->width)
return RIG_OK;
/*
* TODO: check if only change in width
*/
ret = rig_get_freq(priv->tuner, RIG_VFO_CURR, &tuner_freq);
if (ret != RIG_OK)
return ret;
/*
* In case the tuner is not a real tuner
*/
if (priv->tuner_model == RIG_MODEL_DUMMY)
tuner_freq = 0;
freq_offset = (double) (chan->freq - tuner_freq);
rig_debug(RIG_DEBUG_VERBOSE, "%s: freq_offset=%g\n",
__FUNCTION__, freq_offset);
pthread_mutex_lock(&priv->mutex_process);
/* TODO: destroy GNUradio connections beforehand if different mode? */
if (chan->mode != RIG_MODE_NONE && mode != chan->mode) {
switch (chan->mode) {
case RIG_MODE_FM:
case RIG_MODE_WFM:
delete mod->demod.wfm.demod;
delete mod->chan_filter;
delete mod->audio_filter;
break;
case RIG_MODE_USB:
delete mod->audio_filter;
delete mod->chan_filter;
break;
case RIG_MODE_AM:
delete mod->chan_filter;
delete mod->audio_filter;
default:
break;
}
}
/* TODO: if same mode, but different width, then adapt */
priv->m->stop();
switch (mode) {
case RIG_MODE_FM:
{
mod->CFIRdecimate = 20;
mod->CFIRdecimate2 = 25;
mod->RFIRdecimate = 5;
const float channelSpacing = 80e3;
const float demodBW = 3e3;
const float TAU = 75e-6; // 75us in US, 50us in EUR
const int quadRate = priv->input_rate / mod->CFIRdecimate / mod->CFIRdecimate2;
const int audioRate = quadRate / mod->RFIRdecimate;
//
// design first stage selection filter
//
// width of transition band.
//
// We make this twice as wide as you would think. This allows
// some aliasing, but it's outside our final bandwidth, determined
// by the next filter
float transition_width = (priv->input_rate / mod->CFIRdecimate - width);
vector<float> cs1_coeffs =
gr_firdes::low_pass (1.0, // gain
priv->input_rate, // sampling rate
width / 2, // low-pass cutoff freq
transition_width,
gr_firdes::WIN_HANN);
cerr << "Number of cs1_coeffs: " << cs1_coeffs.size () << endl;
//
// design second stage channel selection filter
//
// This is the one that we tune
//
vector<float> cs2_coeffs =
gr_firdes::low_pass (1.0,
priv->input_rate / mod->CFIRdecimate,
width / 2,
(channelSpacing - width) / 2,
gr_firdes::WIN_HANN);
cerr << "Number of cs2_coeffs: " << cs2_coeffs.size () << endl;
//
// design audio filter
//
vector<float> audio_coeffs =
gr_firdes::band_pass (1e3, // gain
quadRate, // sampling rate
300,
demodBW,
250,
gr_firdes::WIN_HAMMING);
cerr << "Number of audio_coeffs: " << audio_coeffs.size () << endl;
//
// design demphasis filter
//
vector<double> fftaps = vector<double>(2);
vector<double> fbtaps = vector<double>(2);
fftaps[0] = 1 - exp(-1/(TAU*audioRate));
fftaps[1] = 0;
fbtaps[0] = 0;
fbtaps[1] = exp(-1/TAU/priv->input_rate*50);;
//
// now instantiate the modules
//
// short --> VrComplex
mod->chan_filter =
new GrFreqXlatingFIRfilterSCF (mod->CFIRdecimate,
cs1_coeffs,
priv->IF_center_freq - freq_offset);
// VrComplex --> VrComplex
mod->demod.fm.chan2_filter =
new GrFreqXlatingFIRfilterCCF (mod->CFIRdecimate2, cs2_coeffs, 0);
// VrComplex --> float
mod->demod.fm.demod = new VrQuadratureDemod<float>(1);
// float --> float
mod->audioF_filter = new GrFIRfilterFFF (mod->RFIRdecimate, audio_coeffs);
// float --> float
mod->demod.fm.deemph =
new GrIIRfilter<float,float,double> (1,fftaps,fbtaps);
// float --> short
mod->demod.fm.cfs = new GrConvertFS ();
//connect the modules together
NWO_CONNECT (GR_SOURCE(priv), mod->chan_filter);
NWO_CONNECT (mod->chan_filter, mod->demod.fm.chan2_filter);
NWO_CONNECT (mod->demod.fm.chan2_filter, mod->demod.fm.demod);
NWO_CONNECT (mod->demod.fm.demod, mod->audioF_filter);
NWO_CONNECT (mod->audioF_filter, mod->demod.fm.deemph);
NWO_CONNECT (mod->demod.fm.deemph, mod->demod.fm.cfs);
NWO_CONNECT (mod->demod.fm.cfs, priv->sink);
break;
}
case RIG_MODE_WFM:
{
mod->CFIRdecimate = 125;
mod->RFIRdecimate = 5;
const int quadRate = priv->input_rate / mod->CFIRdecimate;
const int audioRate = quadRate / mod->RFIRdecimate;
rig_debug(RIG_DEBUG_VERBOSE, "Input Sampling Rate: %d\n", priv->input_rate);
rig_debug(RIG_DEBUG_VERBOSE, "Complex FIR decimation factor: %d\n", mod->CFIRdecimate);
rig_debug(RIG_DEBUG_VERBOSE, "QuadDemod Sampling Rate: %d\n", quadRate);
rig_debug(RIG_DEBUG_VERBOSE, "Real FIR decimation factor: %d\n", mod->RFIRdecimate);
rig_debug(RIG_DEBUG_VERBOSE, "Audio Sampling Rate: %d\n", audioRate);
// build channel filter
//
// note that the totally bogus transition width is because
// we don't have enough mips right now to really do the right thing.
// This results in a filter with 83 taps, which is just a few
// more than the original 75 in microtune_fm_demo.
vector<float> channel_coeffs =
gr_firdes::low_pass (1.0, // gain
priv->input_rate, // sampling rate
width, // low-pass cutoff: freq 250e3
8*100e3, // width of transition band
gr_firdes::WIN_HAMMING);
rig_debug(RIG_DEBUG_VERBOSE, "Number of channel_coeffs: %d\n", channel_coeffs.size ());
// short --> VrComplex
mod->chan_filter =
new GrFreqXlatingFIRfilterSCF(mod->CFIRdecimate, channel_coeffs,
priv->IF_center_freq - freq_offset);
// float --> short
double width_of_transition_band = audioRate / 32;
vector<float> audio_coeffs =
gr_firdes::low_pass (1.0, // gain
quadRate, // sampling rate
audioRate/2 - width_of_transition_band, // low-pass cutoff freq
width_of_transition_band,
gr_firdes::WIN_HAMMING);
rig_debug(RIG_DEBUG_VERBOSE, "Number of audio_coeffs: %d\n", audio_coeffs.size ());
rig_debug(RIG_DEBUG_VERBOSE, "Low-pass cutoff freq: %d\n", audioRate/2 - (int)width_of_transition_band);
mod->audio_filter =
new GrFIRfilterFSF(mod->RFIRdecimate, audio_coeffs);
mod->demod.wfm.FMdemodGain = 2200;
float volume = chan->levels[rig_setting2idx(RIG_LEVEL_AF)].f;
//
// setup Wide FM demodulator chain
//
// VrComplex --> float
mod->demod.wfm.demod =
new VrQuadratureDemod<float>(volume * mod->demod.wfm.FMdemodGain);
//connect the modules together
NWO_CONNECT (GR_SOURCE(priv), mod->chan_filter);
NWO_CONNECT (mod->chan_filter, mod->demod.wfm.demod);
NWO_CONNECT (mod->demod.wfm.demod, mod->audio_filter);
NWO_CONNECT (mod->audio_filter, priv->sink);
break;
}
case RIG_MODE_USB:
{
float rf_gain = chan->levels[rig_setting2idx(RIG_LEVEL_RF)].f;
#if 0
//SSB mod:
mod->ssb.hilb = new GrHilbert<short>(31); /* what's that 31? */
mod->ssb.shifter = new GrSSBMod<short>(2*M_PI*freq_offset/(double)priv->input_rate,
rf_gain);
#endif
//connect the modules together
NWO_CONNECT (GR_SOURCE(priv), mod->chan_filter);
NWO_CONNECT (mod->chan_filter, mod->demod.fm.demod);
NWO_CONNECT (mod->demod.fm.demod, mod->audio_filter);
NWO_CONNECT (mod->audio_filter, priv->sink);
break;
}
#if 0
case RIG_MODE_AM:
{
float volume = chan->levels[rig_setting2idx(RIG_LEVEL_AF)].f;
//
// setup Wide FM demodulator chain
//
// VrComplex --> float
mod->am.demod =
new VrAmplitudeDemod<float>(0.0, 0.05);
//connect the modules together
NWO_CONNECT (GR_SOURCE(priv), mod->chan_filter);
NWO_CONNECT (mod->chan_filter, mod->am.demod);
NWO_CONNECT (mod->am.demod, mod->audio_filter);
NWO_CONNECT (mod->audio_filter, priv->sink);
break;
}
#endif
case RIG_MODE_NONE:
/* ez */
break;
default:
ret = -RIG_EINVAL;
}
priv->m->add (priv->sink);
priv->m->start();
pthread_mutex_unlock(&priv->mutex_process);
if (ret == RIG_OK) {
chan->mode = mode;
chan->width = width;
}
return ret;
}
int gr_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
{
struct gnuradio_priv_data *priv = (struct gnuradio_priv_data *)rig->state.priv;
int chan_num = vfo2chan_num(rig, vfo);
channel_t *chan = &priv->chans[chan_num];
rig_debug(RIG_DEBUG_VERBOSE,"%s called: %s\n", __FUNCTION__, strvfo(vfo));
*mode = chan->mode;
*width = chan->width;
return RIG_OK;
}
int gr_set_vfo(RIG *rig, vfo_t vfo)
{
struct gnuradio_priv_data *priv = (struct gnuradio_priv_data *)rig->state.priv;
if (vfo == RIG_VFO_VFO || vfo == RIG_VFO_RX)
return RIG_OK;
if (vfo != RIG_VFO_A && vfo != RIG_VFO_B)
return -RIG_EINVAL;
priv->curr_vfo = vfo;
rig_debug(RIG_DEBUG_VERBOSE,"%s called: %s\n", __FUNCTION__, strvfo(vfo));
return RIG_OK;
}
int gr_get_vfo(RIG *rig, vfo_t *vfo)
{
struct gnuradio_priv_data *priv = (struct gnuradio_priv_data *)rig->state.priv;
*vfo = priv->curr_vfo;
rig_debug(RIG_DEBUG_VERBOSE,"%s called: %s\n", __FUNCTION__, strvfo(*vfo));
return RIG_OK;
}
static int set_rf_gain(RIG *rig, channel_t *chan, struct mod_data *mod, float gain)
{
struct gnuradio_priv_data *priv = (struct gnuradio_priv_data *)rig->state.priv;
pthread_mutex_lock(&priv->mutex_process);
switch (chan->mode) {
case RIG_MODE_USB:
{
//mod->ssb.shifter->set_gain(gain);
break;
}
case RIG_MODE_NONE:
break;
case RIG_MODE_WFM:
case RIG_MODE_FM:
/* chan_filter/VrComplexFIRfilter is missing a setGain method! */
default:
rig_debug(RIG_DEBUG_WARN, "%s: mode %s unimplemented!\n",
__FUNCTION__, strrmode(chan->mode));
break;
}
pthread_mutex_unlock(&priv->mutex_process);
return RIG_OK;
}
/*
* TODO:
* restart machinery after level change (e.g. volume, etc.)
*/
int gnuradio_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
{
struct gnuradio_priv_data *priv = (struct gnuradio_priv_data *)rig->state.priv;
int chan_num = vfo2chan_num(rig, vfo);
channel_t *chan = &priv->chans[chan_num];
struct mod_data *mod = &priv->mods[chan_num];
char lstr[32];
int idx;
int ret = RIG_OK;
idx = rig_setting2idx(level);
if (idx < RIG_SETTING_MAX)
chan->levels[idx] = val;
if (RIG_LEVEL_IS_FLOAT(level))
sprintf(lstr, "%f", val.f);
else
sprintf(lstr, "%d", val.i);
rig_debug(RIG_DEBUG_VERBOSE,"%s called: %s %s\n",__FUNCTION__,
strlevel(level), lstr);
/* TODO: check val is in range */
switch (level) {
case RIG_LEVEL_RF:
ret = set_rf_gain(rig, chan, mod, val.f);
break;
default:
rig_debug(RIG_DEBUG_WARN, "%s: level %s unimplemented!\n",
__FUNCTION__, strlevel(level));
break;
}
return ret;
}
int gnuradio_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
{
struct gnuradio_priv_data *priv = (struct gnuradio_priv_data *)rig->state.priv;
int chan_num = vfo2chan_num(rig, vfo);
channel_t *chan = &priv->chans[chan_num];
int idx;
idx = rig_setting2idx(level);
if (idx < RIG_SETTING_MAX)
*val = chan->levels[idx];
rig_debug(RIG_DEBUG_VERBOSE,"%s called: %s\n",__FUNCTION__,
strlevel(level));
return RIG_OK;
}
/*
* TODO: change BFO...
*/
int gnuradio_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit)
{
struct gnuradio_priv_data *priv = (struct gnuradio_priv_data *)rig->state.priv;
int chan_num = vfo2chan_num(rig, vfo);
channel_t *chan = &priv->chans[chan_num];
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __FUNCTION__);
chan->rit = rit;
return RIG_OK;
}
int gnuradio_get_rit(RIG *rig, vfo_t vfo, shortfreq_t *rit)
{
struct gnuradio_priv_data *priv = (struct gnuradio_priv_data *)rig->state.priv;
int chan_num = vfo2chan_num(rig, vfo);
channel_t *chan = &priv->chans[chan_num];
*rit = chan->rit;
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __FUNCTION__);
return RIG_OK;
}
/*
* nothing much to be done but remembering
*/
int gnuradio_set_ts(RIG *rig, vfo_t vfo, shortfreq_t ts)
{
struct gnuradio_priv_data *priv = (struct gnuradio_priv_data *)rig->state.priv;
int chan_num = vfo2chan_num(rig, vfo);
channel_t *chan = &priv->chans[chan_num];
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __FUNCTION__);
chan->tuning_step = ts;
return RIG_OK;
}
int gnuradio_get_ts(RIG *rig, vfo_t vfo, shortfreq_t *ts)
{
struct gnuradio_priv_data *priv = (struct gnuradio_priv_data *)rig->state.priv;
int chan_num = vfo2chan_num(rig, vfo);
channel_t *chan = &priv->chans[chan_num];
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __FUNCTION__);
*ts = chan->tuning_step;
return RIG_OK;
}
int gnuradio_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op)
{
freq_t freq;
shortfreq_t ts;
int ret = RIG_OK;
rig_debug(RIG_DEBUG_VERBOSE,"%s called: %s\n",__FUNCTION__,
strvfop(op));
switch (op) {
case RIG_OP_UP:
ret = gr_get_freq(rig, vfo, &freq);
if (ret != RIG_OK) break;
ret = gnuradio_get_ts(rig, vfo, &ts);
if (ret != RIG_OK) break;
ret = gr_set_freq(rig, vfo, freq+ts); /* up */
break;
case RIG_OP_DOWN:
ret = gr_get_freq(rig, vfo, &freq);
if (ret != RIG_OK) break;
ret = gnuradio_get_ts(rig, vfo, &ts);
if (ret != RIG_OK) break;
ret = gr_set_freq(rig, vfo, freq-ts); /* down */
break;
default:
break;
}
return ret;
}
int initrigs_gnuradio(void *be_handle)
{
rig_debug(RIG_DEBUG_VERBOSE, "gnuradio: _init called\n");
rig_register(&gr_caps);
rig_register(&mc4020_caps);
rig_register(&graudio_caps);
return RIG_OK;
}
#if 0
VrGUI *guimain = 0;
VrGUILayout *horiz = 0;
VrGUILayout *vert = 0;
if (use_gui_p){
guimain = new VrGUI(argc, argv);
horiz = guimain->top->horizontal();
vert = horiz->vertical();
}
VrSink<VrComplex> *fft_sink1 = 0;
VrSink<float> *fft_sink2 = 0;
VrSink<short> *fft_sink3 = 0;
if (use_gui_p){
// sink1 is channel filter output
fft_sink1 = new GrFFTSink<VrComplex>(vert, 50, 130, 512);
// sink2 is fm demod output
fft_sink2 = new GrFFTSink<float>(vert, 40, 140, 512);
// sink3 is audio output
fft_sink3 = new GrFFTSink<short>(horiz, 40, 140, 512);
}
if (use_gui_p)
NWO_CONNECT (chan_filter, fft_sink1);
if (use_gui_p)
NWO_CONNECT (demod, fft_sink2);
if (use_gui_p)
NWO_CONNECT (audio_filter, fft_sink3);
VrMultiTask *m = new VrMultiTask ();
if (use_gui_p){
m->add (fft_sink1);
m->add (fft_sink3);
m->add (fft_sink2);
}
m->add (final_sink);
if (use_gui_p)
guimain->start ();
while (1){
if (use_gui_p)
guimain->processEvents(10 /*ms*/);
#endif
Reference in New Issue View Git Blame Kopiuj bezpośredni odnośnik