generate the 66.5 inside the pll via the pilot

lib/filters.c

@@ -1,55 +1,59 @@
 #include "filters.h"
 
 void init_preemphasis(ResistorCapacitor *filter, float tau, float sample_rate) {
-    filter->prev_sample = 0.0f;
-    filter->alpha = exp(-1 / (tau*sample_rate));
+	filter->prev_sample = 0.0f;
+	filter->alpha = exp(-1 / (tau*sample_rate));
 }
 float apply_preemphasis(ResistorCapacitor *filter, float sample) {
-    float out = sample-filter->alpha*filter->prev_sample;
-    filter->prev_sample = sample;
-    return out;
+	float out = sample-filter->alpha*filter->prev_sample;
+	filter->prev_sample = sample;
+	return out;
 }
 
 float hard_clip(float sample, float threshold) {
-    return fmaxf(-threshold, fminf(threshold, sample));
+	return fmaxf(-threshold, fminf(threshold, sample));
 }
 
-void init_pll(PLL *pll, float output_freq, float reference_freq, float loop_filter_bandwidth, int quadrature_mode, int sample_rate) {
-    pll->phase = 0.0f;
-    pll->freq = output_freq;
-    pll->ref_freq = reference_freq;
-    pll->loop_filter_state = 0.0f;
-    pll->kp = 2.0f * M_PI * loop_filter_bandwidth;
-    pll->ki = 0.25f * pll->kp * pll->kp;
-    pll->sample_rate = sample_rate;
-    pll->quadrature_mode = quadrature_mode;
+void init_pll(PLL *pll, int interpolation, int decimation, float freq, float loop_filter_bandwidth, int quadrature_mode, int sample_rate) {
+	pll->phase = 0.0f;
+	pll->freq = freq;
+	pll->loop_filter_state = 0.0f;
+	pll->kp = M_2PI * loop_filter_bandwidth;
+	pll->ki = 0.25f * pll->kp * pll->kp;
+	pll->sample_rate = sample_rate;
+	pll->quadrature_mode = quadrature_mode;
+	pll->last_output = 0.0f;
+	pll->interpolation = interpolation;
+	pll->decimation = decimation;
 }
 
-float apply_pll(PLL *pll, float ref_sample, float input_sample) {
-    float phase_error;
-    
-    float output = sinf(pll->phase);
-    
-    if (pll->quadrature_mode) {
-        output = sinf(pll->phase + (M_PI / 2.0f));
-    }
-    
-    phase_error = ref_sample * input_sample;
-    
-    pll->loop_filter_state += pll->ki * phase_error / pll->sample_rate;
-    float loop_output = pll->loop_filter_state + pll->kp * phase_error;
-    
-    float freq_adjustment = loop_output / (2.0f * M_PI);
-    float instantaneous_freq = pll->freq + freq_adjustment;
-    
-    pll->phase += 2.0f * M_PI * instantaneous_freq / pll->sample_rate;
-    
-    while (pll->phase >= 2.0f * M_PI) {
-        pll->phase -= 2.0f * M_PI;
-    }
-    while (pll->phase < 0.0f) {
-        pll->phase += 2.0f * M_PI;
-    }
-    
-    return output;
+float apply_pll(PLL *pll, float ref_sample) {
+	float phase_error;
+
+	float vco_phase = pll->phase;
+	if(pll->quadrature_mode) vco_phase += M_PI/2.0f;
+
+	float vco_output = sinf(pll->phase);
+	if (pll->quadrature_mode) vco_output = sinf(pll->phase + (M_PI / 2.0f)); // 90 degrees
+
+	phase_error = ref_sample * pll->last_output;
+
+	pll->loop_filter_state += pll->ki * phase_error / pll->sample_rate;
+	float loop_output = pll->loop_filter_state + pll->kp * phase_error;
+
+	float freq_adjustment = loop_output / M_2PI;
+	float instantaneous_freq = pll->freq + freq_adjustment;
+
+	pll->phase += M_2PI * instantaneous_freq / pll->sample_rate;
+
+	while (pll->phase >= M_2PI) {
+		pll->phase -= M_2PI;
+	}
+	while (pll->phase < 0.0f) {
+		pll->phase += M_2PI;
+	}
+
+	pll->last_output = sinf((vco_phase*pll->interpolation)/pll->decimation);
+
+	return pll->last_output;
 }

lib/filters.h

@@ -7,8 +7,8 @@
 
 typedef struct
 {
-    float alpha;
-    float prev_sample;
+	float alpha;
+	float prev_sample;
 } ResistorCapacitor;
 
 void init_preemphasis(ResistorCapacitor *filter, float tau, float sample_rate);
@@ -17,14 +17,16 @@ float apply_preemphasis(ResistorCapacitor *filter, float sample);
 float hard_clip(float sample, float threshold);
 
 typedef struct {
-    float phase;
-    float freq;
-    float ref_freq;
-    float loop_filter_state;
-    float kp;
-    float ki;
-    int sample_rate;
-    int quadrature_mode;
+	float phase;
+	float freq;
+	float loop_filter_state;
+	float kp;
+	float ki;
+	float last_output;
+	int interpolation;
+	int decimation;
+	int sample_rate;
+	int quadrature_mode;
 } PLL;
-void init_pll(PLL *pll, float output_freq, float refrence_freq, float loop_filter_bandwidth, int quadrature_mode, int sample_rate);
-float apply_pll(PLL *pll, float ref_sample, float input_sample);
+void init_pll(PLL *pll, int interpolation, int decimation, float freq, float loop_filter_bandwidth, int quadrature_mode, int sample_rate);
+float apply_pll(PLL *pll, float ref_sample);

lib/fm_modulator.c

@@ -1,16 +1,16 @@
 #include "fm_modulator.h"
 
 void init_fm_modulator(FMModulator *fm, float frequency, float deviation, float sample_rate) {
-    fm->frequency = frequency;
-    fm->deviation = deviation;
-    fm->sample_rate = sample_rate;
-    fm->osc_phase = 0.0f;
+	fm->frequency = frequency;
+	fm->deviation = deviation;
+	fm->sample_rate = sample_rate;
+	fm->osc_phase = 0.0f;
 }
 
 float modulate_fm(FMModulator *fm, float sample) {
-    float inst_freq = fm->frequency+(sample*fm->deviation);
-    if (inst_freq < 0.0f) inst_freq = 0.0f;
-    float out = sinf(fm->osc_phase);
-    fm->osc_phase = fmodf(fm->osc_phase + ((M_2PI * inst_freq) / fm->sample_rate), M_2PI);
-    return out;
+	float inst_freq = fm->frequency+(sample*fm->deviation);
+	if (inst_freq < 0.0f) inst_freq = 0.0f;
+	float out = sinf(fm->osc_phase);
+	fm->osc_phase = fmodf(fm->osc_phase + ((M_2PI * inst_freq) / fm->sample_rate), M_2PI);
+	return out;
 }

lib/fm_modulator.h

@@ -4,10 +4,10 @@
 
 typedef struct
 {
-    float frequency;
-    float deviation;
-    float osc_phase;
-    float sample_rate;
+	float frequency;
+	float deviation;
+	float osc_phase;
+	float sample_rate;
 } FMModulator;
 
 void init_fm_modulator(FMModulator *fm, float frequency, float deviation, float sample_rate);

lib/oscillator.c

@@ -1,37 +1,37 @@
 #include "oscillator.h"
 
 void init_oscillator(Oscillator *osc, float frequency, float sample_rate) {
-    osc->phase = 0.0f;
-    osc->phase_increment = (M_2PI * frequency) / sample_rate;
-    osc->sample_rate = sample_rate;
+	osc->phase = 0.0f;
+	osc->phase_increment = (M_2PI * frequency) / sample_rate;
+	osc->sample_rate = sample_rate;
 }
 
 void change_oscillator_frequency(Oscillator *osc, float frequency) {
-    osc->phase_increment = (M_2PI * frequency) / osc->sample_rate;
+	osc->phase_increment = (M_2PI * frequency) / osc->sample_rate;
 }
 
 float get_oscillator_sin_sample(Oscillator *osc) {
-    float sample = sinf(osc->phase);
-    advance_oscillator(osc);
-    return sample;
+	float sample = sinf(osc->phase);
+	advance_oscillator(osc);
+	return sample;
 }
 
 float get_oscillator_cos_sample(Oscillator *osc) {
-    float sample = cosf(osc->phase);
-    advance_oscillator(osc);
-    return sample;
+	float sample = cosf(osc->phase);
+	advance_oscillator(osc);
+	return sample;
 }
 
 float get_oscillator_sin_multiplier_ni(Oscillator *osc, float multiplier) { // ni = No Increment
-    return sinf(fmodf(osc->phase * multiplier, M_2PI));
+	return sinf(fmodf(osc->phase * multiplier, M_2PI));
 }
 float get_oscillator_cos_multiplier_ni(Oscillator *osc, float multiplier) {
-    return cosf(fmodf(osc->phase * multiplier, M_2PI));
+	return cosf(fmodf(osc->phase * multiplier, M_2PI));
 }
 
 void advance_oscillator(Oscillator *osc) {
-    osc->phase += osc->phase_increment;
-    if (osc->phase >= M_2PI) {
-        osc->phase -= M_2PI;
-    }    
+	osc->phase += osc->phase_increment;
+	if (osc->phase >= M_2PI) {
+		osc->phase -= M_2PI;
+	}
 }

lib/oscillator.h

@@ -4,9 +4,9 @@
 #include "math.h"
 
 typedef struct {
-    float phase;
-    float phase_increment;
-    float sample_rate;
+	float phase;
+	float phase_increment;
+	float sample_rate;
 } Oscillator;
 
 void init_oscillator(Oscillator *osc, float frequency, float sample_rate);