BandpassMixer::BandpassMixer( char* instance_name,
PracSimModel* outer_model,
Signal< float >* in_sig_1,
Signal< float >* in_sig_2,
Signal< float >* out_sig )
:PracSimModel(instance_name,
outer_model)
{
MODEL_NAME(BandpassMixer);
//-----------------------------------------
// Read model config parms
//OPEN_PARM_BLOCK;
//--------------------------------------
// Connect input and output signals
Out_Sig = out_sig;
In_Sig_1 = in_sig_1;
In_Sig_2 = in_sig_2;
MAKE_OUTPUT( Out_Sig );
MAKE_INPUT( In_Sig_1 );
MAKE_INPUT( In_Sig_2 );
}
ComplexVco::ComplexVco( char* instance_name,
PracSimModel* outer_model,
Signal<float>* in_sig,
Signal< complex<float> >* out_sig)
:PracSimModel(instance_name,
outer_model)
{
MODEL_NAME(ComplexVco);
//----------------------------------------
// Read model config parms
OPEN_PARM_BLOCK;
GET_DOUBLE_PARM(Freq_Lo_Hz);
GET_DOUBLE_PARM(Freq_Hi_Hz);
GET_FLOAT_PARM(Lo_Control_Val);
GET_FLOAT_PARM(Hi_Control_Val);
//-------------------------------------
// Connect input and output signals
In_Sig = in_sig;
Out_Sig = out_sig;
MAKE_OUTPUT( Out_Sig );
MAKE_INPUT( In_Sig );
//----------------------------------
// Compute derived parameters
Hz_Per_Volt = (Freq_Hi_Hz - Freq_Lo_Hz)/(Hi_Control_Val - Lo_Control_Val);
}
QuadCarrierRecovGenie::QuadCarrierRecovGenie( char* instance_name,
PracSimModel* outer_model,
Signal<float> *i_recov_carrier,
Signal<float> *q_recov_carrier )
:PracSimModel(instance_name,
outer_model)
{
MODEL_NAME(QuadCarrierRecovGenie);
//-----------------------------------
// Read configuration parameters
OPEN_PARM_BLOCK;
GET_DOUBLE_PARM(Carrier_Freq);
Carrier_Freq_Rad = TWO_PI * Carrier_Freq;
GET_DOUBLE_PARM(Phase_Offset_Deg);
Phase_Offset_Rad = PI * Phase_Offset_Deg /180.0;
//-----------------------------------
// Signals
I_Recov_Carrier = i_recov_carrier;
Q_Recov_Carrier = q_recov_carrier;
MAKE_OUTPUT( I_Recov_Carrier );
MAKE_OUTPUT( Q_Recov_Carrier );
return;
}
BesselFilterByIir<T>::BesselFilterByIir( char *instance_name,
PracSimModel *outer_model,
Signal<T> *in_sig,
Signal<T> *out_sig )
:AnalogFilterByIir<T>( instance_name,
outer_model,
in_sig,
out_sig )
{
MODEL_NAME(BesselFilterByIir);
//OPEN_PARM_BLOCK;
// All of the parameters needed to specify a Butterworth filter
// are common to all the classic types: Chebyshev, Elliptical, Bessel.
// Since they will be needed by all types of filters they are
// read by the AnalogFilter base class.
if( !Bypass_Enabled)
{
GET_BOOL_PARM(Delay_Norm_Enabled);
// construct a Bessel prototype
Lowpass_Proto_Filt = new BesselPrototype( Prototype_Order,
Delay_Norm_Enabled);
Lowpass_Proto_Filt->DumpBiquads(DebugFile);
Lowpass_Proto_Filt->GetDenomPoly(false);
}
return;
};
Upsampler< T >::Upsampler( char* instance_name,
PracSimModel* outer_model,
Signal<T>* in_signal,
Signal<T>* out_signal )
:PracSimModel(instance_name,
outer_model)
{
MODEL_NAME(Upsampler);
ENABLE_MULTIRATE;
// ActiveModel = this;
//-----------------------------------
// Read configuration parameters
OPEN_PARM_BLOCK;
GET_INT_PARM(Interp_Rate);
//-----------------------------------
// Signals
In_Sig = in_signal;
Out_Sig = out_signal;
MAKE_OUTPUT( Out_Sig );
MAKE_INPUT( In_Sig );
CHANGE_RATE(In_Sig, Out_Sig, Interp_Rate);
};
YuleWalkerPsdEstim::YuleWalkerPsdEstim(
char* instance_name,
PracSimModel* outer_model,
Signal<float>* in_sig )
:PracSimModel( instance_name,
outer_model )
{
MODEL_NAME(YuleWalkerPsdEstim);
OPEN_PARM_BLOCK;
GET_INT_PARM(Seg_Len);
GET_INT_PARM(Ar_Order);
GET_INT_PARM(Hold_Off);
GET_INT_PARM(Num_Freq_Pts);
Psd_File_Name = new char[64];
strcpy(Psd_File_Name, "\0");
GET_STRING_PARM(Psd_File_Name);
GET_DOUBLE_PARM(Freq_Norm_Factor);
GET_BOOL_PARM(Output_In_Decibels);
GET_BOOL_PARM(Plot_Two_Sided);
GET_BOOL_PARM(Halt_When_Completed);
In_Sig = in_sig;
MAKE_INPUT(In_Sig);
Time_Seg = new double[Seg_Len];
Sample_Spectrum = new double[Seg_Len];
for(int is=0; is<Seg_Len; is++){
Sample_Spectrum[is] = 0.0;
}
Processing_Completed = false;
}
RateChanger< T >::RateChanger( char* instance_name,
PracSimModel* outer_model,
Signal<T>* in_signal,
Signal<T>* out_signal )
:PracSimModel(instance_name,
outer_model)
{
MODEL_NAME(RateChanger);
ENABLE_MULTIRATE;
ENABLE_CONST_INTERVAL;
ActiveModel = this;
//-----------------------------------
// Read configuration parameters
OPEN_PARM_BLOCK;
GET_INT_PARM(Num_Sidelobes);
GET_DOUBLE_PARM(Rate_Change_Factor);
//-----------------------------------
// Signals
In_Sig = in_signal;
Out_Sig = out_signal;
MAKE_INPUT( In_Sig );
MAKE_OUTPUT( Out_Sig );
// one sample per bit at input
CHANGE_RATE( In_Sig, Out_Sig, Rate_Change_Factor );
return;
}
ContinuousDelayTester< T >::ContinuousDelayTester( char* instance_name,
PracSimModel* outer_model,
Signal<T>* in_signal,
Signal<T>* out_signal,
Control<float> *delay_value,
Control<bool> *delay_change_enabled )
:PracSimModel(instance_name,
outer_model)
{
MODEL_NAME(ContinuousDelayTester);
//-----------------------------------
// Signals
In_Sig = in_signal;
Out_Sig = out_signal;
MAKE_OUTPUT( Out_Sig );
MAKE_INPUT( In_Sig );
//--------------------------------
// Controls
Delay_Value = delay_value;
Delay_Change_Enabled = delay_change_enabled;
return;
}
const MODEL *
sim_model_lookup (const char *name)
{
const MACH **machp;
const MODEL *model;
for (machp = & sim_machs[0]; *machp != NULL; ++machp)
{
for (model = MACH_MODELS (*machp); MODEL_NAME (model) != NULL; ++model)
{
if (strcmp (MODEL_NAME (model), name) == 0)
return model;
}
}
return NULL;
}
//====================================================
SignalAnchor::SignalAnchor( char* instance_name,
PracSimModel* outer_model,
Signal<bit_t>* bit_signal,
Signal<byte_t>* byte_signal )
:PracSimModel(instance_name,
outer_model)
{
MODEL_NAME(SignalAnchor);
int block_size;
double samp_intvl;
OPEN_PARM_BLOCK;
GET_DOUBLE_PARM( samp_intvl );
GET_INT_PARM( block_size );
Bit_Signal = bit_signal;
Byte_Signal = byte_signal;
MAKE_INPUT(Bit_Signal);
MAKE_INPUT(Byte_Signal);
SET_SAMP_INTVL(Bit_Signal, samp_intvl);
SET_BLOCK_SIZE(Bit_Signal, block_size);
SET_SAMP_INTVL(Byte_Signal, samp_intvl);
SET_BLOCK_SIZE(Byte_Signal, block_size);
}
FskCarrierGenie::FskCarrierGenie( char* instance_name,
PracSimModel* outer_model,
Signal< std::complex<float> > *lo_ref_sig,
Signal< std::complex<float> > *hi_ref_sig )
:PracSimModel(instance_name,
outer_model)
{
MODEL_NAME(FskCarrierGenie);
//-----------------------------------
// Read configuration parameters
OPEN_PARM_BLOCK;
GET_DOUBLE_PARM(Carrier_Freq_Hz);
GET_DOUBLE_PARM(Freq_Offset_Hz);
GET_INT_PARM( Lo_Ref_Samp_Shift );
GET_INT_PARM( Hi_Ref_Samp_Shift );
//-----------------------------------
// Signals
Lo_Ref_Sig = lo_ref_sig;
Hi_Ref_Sig = hi_ref_sig;
MAKE_OUTPUT( Lo_Ref_Sig );
MAKE_OUTPUT( Hi_Ref_Sig );
//----------------------------------
// Compute derived parameters
Freq_Hi_Hz = Carrier_Freq_Hz + Freq_Offset_Hz;
Freq_Lo_Hz = Carrier_Freq_Hz - Freq_Offset_Hz;
return;
}
ChebyshevFilterByIir<T>::ChebyshevFilterByIir( char *instance_name,
PracSimModel *outer_model,
Signal<T> *in_sig,
Signal<T> *out_sig )
:AnalogFilterByIir<T>( instance_name,
outer_model,
in_sig,
out_sig )
{
MODEL_NAME(ChebyshevFilterByIir);
OPEN_PARM_BLOCK;
// Most of the parameters needed to specify a Chebyshev filter
// are common to all the classic types and are therefore
// read by the AnalogFilter base class.
//
// 'Ripple' is specific to Chebyshev so it is read here in the drerived class
if( !Bypass_Enabled)
{
GET_DOUBLE_PARM(Passband_Ripple_In_Db);
GET_BOOL_PARM(Bw_Is_Ripple_Bw);
// construct a Chebyshev prototype
Lowpass_Proto_Filt = new ChebyshevPrototype( Prototype_Order,
Passband_Ripple_In_Db,
Bw_Is_Ripple_Bw);
//Lowpass_Proto_Filt->DumpBiquads(DebugFile);
Lowpass_Proto_Filt->FilterFrequencyResponse();
}
return;
}
static SIM_RC
sim_model_init (SIM_DESC sd)
{
SIM_CPU *cpu;
/* If both cpu model and state architecture are set, ensure they're
compatible. If only one is set, set the other. If neither are set,
use the default model. STATE_ARCHITECTURE is the bfd_arch_info data
for the selected "mach" (bfd terminology). */
/* Only check cpu 0. STATE_ARCHITECTURE is for that one only. */
/* ??? At present this only supports homogeneous multiprocessors. */
cpu = STATE_CPU (sd, 0);
if (! STATE_ARCHITECTURE (sd)
&& ! CPU_MACH (cpu))
{
/* Set the default model. */
const MODEL *model = sim_model_lookup (WITH_DEFAULT_MODEL);
sim_model_set (sd, NULL, model);
}
if (STATE_ARCHITECTURE (sd)
&& CPU_MACH (cpu))
{
if (strcmp (STATE_ARCHITECTURE (sd)->printable_name,
MACH_BFD_NAME (CPU_MACH (cpu))) != 0)
{
sim_io_eprintf (sd, "invalid model `%s' for `%s'\n",
MODEL_NAME (CPU_MODEL (cpu)),
STATE_ARCHITECTURE (sd)->printable_name);
return SIM_RC_FAIL;
}
}
else if (STATE_ARCHITECTURE (sd))
{
/* Use the default model for the selected machine.
The default model is the first one in the list. */
const MACH *mach = sim_mach_lookup_bfd_name (STATE_ARCHITECTURE (sd)->printable_name);
if (mach == NULL)
{
sim_io_eprintf (sd, "unsupported machine `%s'\n",
STATE_ARCHITECTURE (sd)->printable_name);
return SIM_RC_FAIL;
}
sim_model_set (sd, NULL, MACH_MODELS (mach));
}
else
{
STATE_ARCHITECTURE (sd) = bfd_scan_arch (MACH_BFD_NAME (CPU_MACH (cpu)));
}
return SIM_RC_OK;
}
static SIM_RC
model_option_handler (SIM_DESC sd, sim_cpu *cpu, int opt,
char *arg, int is_command)
{
switch (opt)
{
case OPTION_MODEL :
{
const MODEL *model = sim_model_lookup (arg);
if (! model)
{
sim_io_eprintf (sd, "unknown model `%s'\n", arg);
return SIM_RC_FAIL;
}
sim_model_set (sd, cpu, model);
break;
}
case OPTION_MODEL_INFO :
{
const MACH **machp;
const MODEL *model;
for (machp = & sim_machs[0]; *machp != NULL; ++machp)
{
sim_io_printf (sd, "Models for architecture `%s':\n",
MACH_NAME (*machp));
for (model = MACH_MODELS (*machp); MODEL_NAME (model) != NULL;
++model)
sim_io_printf (sd, " %s", MODEL_NAME (model));
sim_io_printf (sd, "\n");
}
break;
}
}
return SIM_RC_OK;
}
//====================================================
SignalAnchor::SignalAnchor( char* instance_name,
PracSimModel* outer_model,
Signal<int>* int_signal,
double samp_intvl,
int block_size )
:PracSimModel(instance_name,
outer_model)
{
MODEL_NAME(SignalAnchor);
Int_Signal = int_signal;
MAKE_INPUT(Int_Signal);
SET_SAMP_INTVL(Int_Signal, samp_intvl);
SET_BLOCK_SIZE(Int_Signal, block_size);
}
SignalAnchor::SignalAnchor( char* instance_name,
PracSimModel* outer_model,
Signal< std::complex<float> >* complex_signal,
double samp_intvl,
int block_size )
:PracSimModel(instance_name,
outer_model)
{
MODEL_NAME(SignalAnchor);
Complex_Signal = complex_signal;
MAKE_INPUT(Complex_Signal);
SET_SAMP_INTVL(Complex_Signal, samp_intvl);
SET_BLOCK_SIZE(Complex_Signal, block_size);
}
QpskOptimalBitDemod::QpskOptimalBitDemod( char* instance_name,
PracSimModel* outer_model,
Signal< std::complex< float > >* in_sig,
Signal< std::complex< float > >* carrier_ref_sig,
Signal< bit_t >* symb_clock_in,
Signal< bit_t >* i_decis_out,
Signal< bit_t >* q_decis_out )
:PracSimModel(instance_name,
outer_model)
{
MODEL_NAME(QpskOptimalBitDemod);
ENABLE_MULTIRATE;
//-----------------------------------------
// Read model config parms
OPEN_PARM_BLOCK;
GET_INT_PARM(Samps_Per_Symb);
GET_BOOL_PARM(Constel_Offset_Enabled);
//--------------------------------------
// Connect input and output signals
I_Decis_Out = i_decis_out;
Q_Decis_Out = q_decis_out;
Symb_Clock_In = symb_clock_in;
Carrier_Ref_Sig = carrier_ref_sig;
In_Sig = in_sig;
MAKE_OUTPUT( I_Decis_Out );
MAKE_OUTPUT( Q_Decis_Out );
MAKE_INPUT( Symb_Clock_In );
MAKE_INPUT( Carrier_Ref_Sig );
MAKE_INPUT( In_Sig );
double resamp_rate = 1.0/double(Samps_Per_Symb);
CHANGE_RATE( In_Sig, I_Decis_Out, resamp_rate );
CHANGE_RATE( In_Sig, Q_Decis_Out, resamp_rate );
CHANGE_RATE( Carrier_Ref_Sig, I_Decis_Out, resamp_rate );
CHANGE_RATE( Carrier_Ref_Sig, Q_Decis_Out, resamp_rate );
CHANGE_RATE( Symb_Clock_In, I_Decis_Out, resamp_rate );
}
QpskModulator::QpskModulator( char* instance_name,
PracSimModel* outer_model,
Signal<float>* i_in_sig,
Signal<float>* q_in_sig,
Signal< std::complex<float> >* cmpx_out_sig,
Signal<float>* mag_out_sig,
Signal<float>* phase_out_sig )
:PracSimModel(instance_name,
outer_model)
{
MODEL_NAME(QpskModulator);
//----------------------------------------
// Read model config parms
OPEN_PARM_BLOCK;
GET_DOUBLE_PARM(Phase_Unbal);
GET_DOUBLE_PARM(Amp_Unbal);
//GET_INT_PARM("block_size\0");
//GET_DOUBLE_PARM("samp_intvl\0");
//-------------------------------------
// Connect input and output signals
I_In_Sig = i_in_sig;
Q_In_Sig = q_in_sig;
Cmpx_Out_Sig = cmpx_out_sig;
Mag_Out_Sig = mag_out_sig;
Phase_Out_Sig = phase_out_sig;
MAKE_OUTPUT( Cmpx_Out_Sig );
MAKE_OUTPUT( Mag_Out_Sig );
MAKE_OUTPUT( Phase_Out_Sig );
MAKE_INPUT( I_In_Sig );
MAKE_INPUT( Q_In_Sig );
//-----------------------------------------
// Set up derived parms
double phase_unbal_rad = PI * Phase_Unbal / 180.0;
Real_Unbal = float(cos(phase_unbal_rad) * Amp_Unbal);
Imag_Unbal = float(sin(phase_unbal_rad) * Amp_Unbal);
}
LevelGener::LevelGener( char* instance_name,
PracSimModel* outer_model,
Signal<float>* out_sig )
:PracSimModel( instance_name,
outer_model )
{
MODEL_NAME(LevelGener);
Out_Sig = out_sig;
OPEN_PARM_BLOCK;
//GET_LONG_PARM(Initial_Seed);
//Seed = Initial_Seed;
//GET_LONG_PARM(Block_Size);
GET_FLOAT_PARM(Const_Level);
MAKE_OUTPUT(Out_Sig);
}
PolarFreqDomainFilter::PolarFreqDomainFilter( char* instance_name,
PracSimModel* outer_model,
Signal< std::complex<float> >* in_sig,
Signal< std::complex<float> >* out_sig)
:PracSimModel(instance_name,
outer_model)
{
MODEL_NAME(PolarFreqDomainFilter);
ENABLE_MULTIRATE;
In_Sig = in_sig;
Out_Sig = out_sig;
OPEN_PARM_BLOCK;
GET_INT_PARM(Fft_Size);
GET_DOUBLE_PARM(Dt_For_Fft);
GET_FLOAT_PARM(Overlap_Save_Mem);
GET_BOOL_PARM(Bypass_Enabled);
Magnitude_Data_Fname = new char[64];
strcpy(Magnitude_Data_Fname, "\0");
GET_STRING_PARM(Magnitude_Data_Fname);
GET_DOUBLE_PARM(Mag_Freq_Scaling_Factor);
Phase_Data_Fname = new char[64];
strcpy(Phase_Data_Fname, "\0");
GET_STRING_PARM(Phase_Data_Fname);
GET_DOUBLE_PARM(Phase_Freq_Scaling_Factor);
Num_Saved_Samps = int(Overlap_Save_Mem/Dt_For_Fft + 0.5);
Block_Size = Fft_Size - Num_Saved_Samps;
MAKE_OUTPUT(Out_Sig);
MAKE_INPUT(In_Sig);
SET_SAMP_INTVL(In_Sig, Dt_For_Fft);
SET_BLOCK_SIZE(In_Sig, Block_Size);
SET_SAMP_INTVL(Out_Sig, Dt_For_Fft);
SET_BLOCK_SIZE(Out_Sig, Block_Size);
//SET_DELAY( In_Sig, Out_Sig, Group_Delay_Offset);
}
GaussianNoiseGenerator::GaussianNoiseGenerator( char* instance_name,
PracSimModel* outer_model,
Signal<float>* noise_sig)
:PracSimModel(instance_name,
outer_model)
{
MODEL_NAME(GaussianNoiseGenerator);
Noise_Sig = noise_sig;
OPEN_PARM_BLOCK;
GET_INT_PARM(Seed);
GET_DOUBLE_PARM(Noise_Sigma);
//----------------------------------------------
MAKE_OUTPUT(Noise_Sig);
}
//====================================================
// Dual float signal
SignalAnchor::SignalAnchor( char* instance_name,
PracSimModel* outer_model,
Signal<float>* float_signal,
Signal<float>* float_signal_2,
double samp_intvl,
int block_size )
:PracSimModel(instance_name,
outer_model)
{
MODEL_NAME(SignalAnchor);
Float_Signal = float_signal;
Float_Signal_2 = float_signal_2;
MAKE_INPUT(Float_Signal);
MAKE_INPUT(Float_Signal_2);
SET_SAMP_INTVL(Float_Signal, samp_intvl);
SET_BLOCK_SIZE(Float_Signal, block_size);
SET_SAMP_INTVL(Float_Signal_2, samp_intvl);
SET_BLOCK_SIZE(Float_Signal_2, block_size);
}
BartlettPeriodogram<T>::
BartlettPeriodogram( char* instance_name,
PracSimModel* outer_model,
Signal<T>* in_sig )
:PracSimModel( instance_name,
outer_model )
{
MODEL_NAME(BartlettPeriodogram);
OPEN_PARM_BLOCK;
GET_INT_PARM(Seg_Len);
GET_INT_PARM(Fft_Len);
GET_INT_PARM(Hold_Off);
GET_INT_PARM(Num_Segs_To_Avg);
Psd_File_Name = new char[64];
strcpy(Psd_File_Name, "\0");
GET_STRING_PARM(Psd_File_Name);
GET_DOUBLE_PARM(Freq_Norm_Factor);
GET_BOOL_PARM(Output_In_Decibels);
GET_BOOL_PARM(Plot_Two_Sided);
GET_BOOL_PARM(Halt_When_Completed);
In_Sig = in_sig;
MAKE_INPUT(In_Sig);
Time_Seg = new T[Seg_Len];
Sample_Spectrum = new double[Fft_Len];
Freq_Seg = new std::complex<double>[Fft_Len];
for(int is=0; is<Fft_Len; is++) {
Sample_Spectrum[is] = 0.0;
}
Psd_File = new ofstream(Psd_File_Name, ios::out);
Processing_Completed = false;
}
BartlettPeriodogramWindowed<T>::
BartlettPeriodogramWindowed(
char* instance_name,
PracSimModel* outer_model,
Signal<T>* in_sig )
:PracSimModel( instance_name,
outer_model )
{
int is;
MODEL_NAME(BartlettPeriodogram);
OPEN_PARM_BLOCK;
GET_INT_PARM(Seg_Len);
GET_INT_PARM(Fft_Len);
GET_INT_PARM(Hold_Off);
GET_INT_PARM(Num_Segs_To_Avg);
GET_DOUBLE_PARM(Freq_Norm_Factor);
GET_BOOL_PARM(Output_In_Decibels);
GET_BOOL_PARM(Plot_Two_Sided);
GET_BOOL_PARM(Halt_When_Completed);
GET_BOOL_PARM(Using_Window);
Psd_File_Name = new char[64];
strcpy(Psd_File_Name, "\0");
GET_STRING_PARM(Psd_File_Name);
if(Using_Window){
Window_Shape =
GetWindowShapeParm("Window_Shape\0");
switch(Window_Shape){
case WINDOW_SHAPE_TRIANGULAR:
Data_Window = new TriangularWindow( Seg_Len,
_NO_ZERO_ENDS );
break;
case WINDOW_SHAPE_HAMMING:
Data_Window = new HammingWindow( Seg_Len );
break;
case WINDOW_SHAPE_HANN:
Data_Window = new HannWindow( Seg_Len,
_NO_ZERO_ENDS );
break;
}
Window_Taps = Data_Window->GetDataWindow();
Window_Power = 0.0;
for(is=0; is<Seg_Len; is++){
Window_Power +=Window_Taps[is]*Window_Taps[is];
}
Window_Power /= double(Seg_Len);
double window_scale = sqrt(Window_Power);
for(is=0; is<Seg_Len; is++){
Window_Taps[is] /= window_scale;
}
}
In_Sig = in_sig;
MAKE_INPUT(In_Sig);
Time_Seg = new T[Seg_Len];
Win_Time_Seg = new T[Seg_Len];
Sample_Spectrum = new double[Fft_Len];
Freq_Seg = new std::complex<double>[Fft_Len];
for(is=0; is<Fft_Len; is++){
Sample_Spectrum[is] = 0.0;
}
Psd_File = new ofstream(Psd_File_Name, ios::out);
Processing_Completed = false;
}
