void get_adc_offset()
{
int LoopCtrl;
Uint32 RunTimeMsec,StartTimeMsec;
double u_offset_in, v_offset_in;
double R_offset_in, S_offset_in;
double u_offset_out, v_offset_out;
double R_offset_out, S_offset_out;
UNION32 u32data;
load_sci_tx_mail_box( "\n***********************"); delay_msecs(10);
load_sci_tx_mail_box( "\n Start ADC Offset Calc "); delay_msecs(10);
load_sci_tx_mail_box( "\n***********************"); delay_msecs(10);
gfRunTime=0.0;
LoopCtrl = 1;
while(LoopCtrl == 1)
{
if( gfRunTime >= 5.0 ) LoopCtrl = 0;
RunTimeMsec = ulGetTime_mSec( StartTimeMsec);
if(RunTimeMsec > 1){
StartTimeMsec = ulGetNow_mSec( );
u_offset_in = (double)giAdcUphase;
v_offset_in = (double)giAdcVphase;
R_offset_in = (double)giAdcRphase;
S_offset_in = (double)giAdcSphase;
LPF1(0.002,10.0,u_offset_in, & u_offset_out);
LPF1(0.002,10.0,v_offset_in, & v_offset_out);
LPF1(0.002,10.0,R_offset_in, & R_offset_out);
LPF1(0.002,10.0,S_offset_in, & S_offset_out);
}
}
if( gfRunTime >= 5.0 ){
adc_u_offset = (int)u_offset_out;
adc_v_offset = (int)v_offset_out;
adc_R_offset = (int)R_offset_out;
adc_S_offset = (int)S_offset_out;
u32data.word.word0 = adc_u_offset; write_code_2_eeprom(CODE_adc_u_offset,u32data);
u32data.word.word0 = adc_v_offset; write_code_2_eeprom(CODE_adc_v_offset,u32data);
u32data.word.word0 = adc_R_offset; write_code_2_eeprom(CODE_adc_R_offset,u32data);
u32data.word.word0 = adc_S_offset; write_code_2_eeprom(CODE_adc_S_offset,u32data);
load_sci_tx_mail_box("\n*********************");delay_msecs(10);
load_sci_tx_mail_box("\n OK Adc offset Saved ");delay_msecs(10);
load_sci_tx_mail_box("\n*********************");delay_msecs(10);
}
}
void get_adc_vdc_high()
{
int LoopCtrl;
Uint32 RunTimeMsec,StartTimeMsec;
double adc_Vdc_in, adc_Vdc_out;
UNION32 u32data;
load_sci_tx_mail_box( "Start ADC at Vdc high"); delay_msecs(10);
gfRunTime=0.0;
LoopCtrl = 1;
gMachineState = STATE_READY;
while(LoopCtrl == 1)
{
if( gfRunTime >= 1.0 ) LoopCtrl = 0;
RunTimeMsec = ulGetTime_mSec( StartTimeMsec);
if(RunTimeMsec > 1){
StartTimeMsec = ulGetNow_mSec( );
adc_Vdc_in = (double)giAdcVdc;
LPF1(0.002,10.0,adc_Vdc_in, & adc_Vdc_out);
}
}
if( gfRunTime >= 1.0 ){
code_adc_vdc_high = adc_Vdc_out;
u32data.dword = code_adc_vdc_high; write_code_2_eeprom(CODE_adc_vdc_high,u32data);
load_sci_tx_mail_box("OK adc_vdc_high Saved");delay_msecs(10);
}
}
void VVVF_Control()
{
float Es_m;
float Slip;
float sgn_freq;
float Det_slip; // sqrt()안의 부호검사
float Det_emf;
// 전압 추정시 시간지연(Ts)을 보상
CosDeltaTheta=cos(we*Ts);
SinDeltaTheta=sin(we*Ts);
Us_dq[ds]=Vs_dq[ds]*CosDeltaTheta + Vs_dq[qs]*SinDeltaTheta;
Us_dq[qs]=-Vs_dq[ds]*SinDeltaTheta + Vs_dq[qs]*CosDeltaTheta;
Vs_dq[ds]=Us_dq[ds];
Vs_dq[qs]=Us_dq[qs];
// 주파수 명령
// if ( gfRunTime < gExcitationTime) // DC 여자 ==> Flux Setup
if( gMachineState == STATE_INIT_RUN)
{
Freq_ref=0.0;
Freq_out=0.0;
reference=0.0;
we=0.0;
theta=0.0;
SinTheta=0.0;
CosTheta=1.0;
Vs_ref=VF_Vs_Coeff_TrqBoost*Vs_rat;
}
else
{
// RefProc(reference_in, &reference);
Freq_ref = Freq_rat*reference;
if (Freq_ref > VF_Freq_TrqBoost)
{
// 주파수의 부호
if (Freq_ref >= 0.0) sgn_freq = 1.0;
else sgn_freq = -1.0;
// 슬립 보상
Slip = fabs(Freq_slip)*inv_Freq_rat;
Power_core_rat = gMotorRatePower*(1.0-gMotorRateEffiency/(1.0-S_rat))-1.5*Is_rat*Is_rat*VF_Rs;
Power_core=0.5*( (1.0+Slip)/(1+S_rat)*(Freq_out*inv_Freq_rat) + (1.0+Slip*Slip)/(1.0+S_rat*S_rat)*(Freq_out*inv_Freq_rat)*(Freq_out*inv_Freq_rat) )*Power_core_rat;
LPF1(Ts,VF_Slip_Comp_FilterPole,1.5*(Vs_dq[ds]*Is_dq[ds]+Vs_dq[qs]*Is_dq[qs]- VF_Rs_ThermalCoeff*VF_Rs*Is_mag*Is_mag)-Power_core,&Power_gap);
Det_slip = Freq_ref*Freq_ref + S_lin*Power_gap;
if (Det_slip < 0.0)
LPF1(Ts,VF_Slip_Comp_FilterPole,-0.5*sqrt(fabs(S_lin*Power_gap)),&Freq_slip);
else LPF1(Ts,VF_Slip_Comp_FilterPole,0.5*(sqrt(Det_slip)-fabs(Freq_ref)),&Freq_slip);
// 슬립 제한
if (Freq_slip>2.0*Freq_slip_rat) Freq_slip=2.0*Freq_slip_rat;
else if (Freq_slip<-2.0*Freq_slip_rat) Freq_slip=-2.0*Freq_slip_rat;
Freq_out=Freq_ref + sgn_freq*Freq_slip;
}
else
{
Freq_out=Freq_ref;
Power_gap=0.0;
Freq_slip=0.0;
}
// 각도 계산 : 주파수 명령 + 슬립 ==> 새로운 주파수 명령
we=PI_2*Freq_out;
theta+=we*Ts;
if (theta>PI) theta-=PI_2;
else if (theta<-PI) theta+=PI_2;
SinTheta=sin(theta); CosTheta=cos(theta);
Vs_max=0.57735*Vdc;
Es_m=VF_Fs_Coeff*fabs(Freq_out)*inv_Freq_rat*Vs_rat;
if (Es_m>Vs_max) Es_m=Vs_max;
Is_DQ[DS]= CosTheta*Is_dq[ds] + SinTheta*Is_dq[qs];
Is_DQ[QS]=-SinTheta*Is_dq[ds] + CosTheta*Is_dq[qs];
Det_emf=(Es_m*Es_m)-(VF_Rs*Is_DQ[QS])*(VF_Rs*Is_DQ[QS]); //sqrt안의 음수여부조사
if ( (Det_emf>0.0) && (fabs(Freq_out)>VF_Freq_TrqBoost) )
LPF1(Ts,VF_IR_Comp_FilterPole,0.9*(VF_Rs*Is_DQ[DS]+sqrt(Det_emf)-Es_m),&Vs_IR_comp);
else LPF1(Ts,VF_IR_Comp_FilterPole,VF_Vs_Coeff_TrqBoost*Vs_rat,&Vs_IR_comp);
// 전류 제한기
if (Is_mag>Is_max)
{
del_Vs_comp=(2.0*Vs_rat*inv_Is_rat)*(Is_mag-Is_max);
if (del_Vs_comp>0.2*Vs_rat) del_Vs_comp=0.2*Vs_rat;
else if (del_Vs_comp<-0.2*Vs_rat) del_Vs_comp=-0.2*Vs_rat;
}
else del_Vs_comp=0.0;
// 최종 전압 명령
Vs_ref = Es_m + Vs_IR_comp - del_Vs_comp; // IR보상, 전류크기 제한
if (Vs_ref>Vs_max) Vs_ref=Vs_max;
}
// 출력 전압
Vs_dq_ref[ds]=Vs_ref*CosTheta + VF_DeadTimeGain*(Vs_dq_ref[ds]-Vs_dq[ds]);
Vs_dq_ref[qs]=Vs_ref*SinTheta + VF_DeadTimeGain*(Vs_dq_ref[qs]-Vs_dq[qs]);
rpm = 60 * Freq_out * inv_P_pair ;
}
void VVVF_Control()
{
double Es_m;
double Vs_gain;
double Slip;
double sgn_freq;
double Det_slip; // sqrt()안의 부호검사
double Det_emf;
Is_mag=sqrt(Is_dq[ds]*Is_dq[ds]+Is_dq[qs]*Is_dq[qs]);
// 전압 추정시 시간지연(Ts)을 보상
CosDeltaTheta=cos(we*Ts);
SinDeltaTheta=sin(we*Ts);
Us_dq[ds]=Vs_dq[ds]*CosDeltaTheta + Vs_dq[qs]*SinDeltaTheta;
Us_dq[qs]=-Vs_dq[ds]*SinDeltaTheta + Vs_dq[qs]*CosDeltaTheta;
Vs_dq[ds]=Us_dq[ds];
Vs_dq[qs]=Us_dq[qs];
// 주파수 명령
if (t<VF_ExcitationTime) // DC 여자 ==> Flux Setup
{
Freq_ref=0.0;
Freq_out=0.0;
reference=0.0;
we=0.0;
theta=0.0;
SinTheta=0.0;
CosTheta=1.0;
// 초기 고정자 저항 추정 ==> IR 보상
Re_Power=(Vs_dq[ds]*Is_dq[ds]+Vs_dq[qs]*Is_dq[qs]);
if ( (Is_mag>0.1*Is_rat) && (t>0.1) )
LPF1(Ts,5.0,Re_Power/(Is_mag*Is_mag),&VF_Rs);
Vs_ref=VF_Vs_Coeff_TrqBoost*Vs_rat;
}
else
{
Freq_ref=Freq_rat*reference;
// 주파수의 부호
if (Freq_ref>=0.0) sgn_freq=1.0;
else sgn_freq=-1.0;
// 슬립 보상
Slip=fabs(Freq_slip)*inv_Freq_rat;
Power_core_rat=Po_rat*(1.0-Effiency_Coeff/(1.0-S_rat))-1.5*Is_rat*Is_rat*VF_Rs;
Power_core=0.5*( (1.0+Slip)/(1+S_rat)*(Freq_out*inv_Freq_rat) + (1.0+Slip*Slip)/(1.0+S_rat*S_rat)*(Freq_out*inv_Freq_rat)*(Freq_out*inv_Freq_rat) )*Power_core_rat;
LPF1(Ts,VF_Slip_Comp_FilterPole,1.5*(Vs_dq[ds]*Is_dq[ds]+Vs_dq[qs]*Is_dq[qs] - VF_Rs_ThermalCoeff*VF_Rs*Is_mag*Is_mag)-Power_core,&Power_gap);
Det_slip=Freq_ref*Freq_ref + S_lin*Power_gap;
if (Det_slip<0.0)
LPF1(Ts,VF_Slip_Comp_FilterPole,-0.5*sqrt(fabs(S_lin*Power_gap)),&Freq_slip);
else LPF1(Ts,VF_Slip_Comp_FilterPole,0.5*(sqrt(Det_slip)-fabs(Freq_ref)),&Freq_slip);
// 슬립 제한
if (Freq_slip>2.0*Freq_slip_rat)
Freq_slip=2.0*Freq_slip_rat;
else if (Freq_slip<-2.0*Freq_slip_rat)
Freq_slip=-2.0*Freq_slip_rat;
Freq_out=Freq_ref + sgn_freq*Freq_slip;
// 각도 계산 : 주파수 명령 + 슬립 ==> 새로운 주파수 명령
we=PI_2*Freq_out;
theta+=we*Ts;
if (theta>PI) theta-=PI_2;
else if (theta<-PI) theta+=PI_2;
SinTheta=sin(theta);
CosTheta=cos(theta);
// 저항에 걸리는 전압강하를 보상하기위해서는
// Phase lag(low pass filter)가 반드시 포함되어야 한다.
// 이는본질적으로 IR보상식은 불안정하기 때문에
// 강제로 phase delay를 주기위함이며, 이로인해
// 보상을 안정되게 하기 위함이다.
// 따라서 VF_IR_Comp_FilterPole은 너무 큰 값을 가질수 없다.
Vs_max=0.57735*Vdc;
Es_m=VF_Fs_Coeff*fabs(Freq_out)*inv_Freq_rat*Vs_rat;
if (Es_m>Vs_max) Es_m=Vs_max;
Is_DQ[DS]= CosTheta*Is_dq[ds] + SinTheta*Is_dq[qs];
Is_DQ[QS]=-SinTheta*Is_dq[ds] + CosTheta*Is_dq[qs];
Det_emf=(Es_m*Es_m)-(VF_Rs*Is_DQ[QS])*(VF_Rs*Is_DQ[QS]); //sqrt안의 음수여부조사
if ( (Det_emf>0.0)&&(fabs(Freq_out)>VF_Freq_TrqBoost) )
LPF1(Ts,VF_IR_Comp_FilterPole,VF_Rs*Is_DQ[DS]+sqrt(Det_emf)-Es_m,&Vs_IR_comp);
else LPF1(Ts,VF_IR_Comp_FilterPole,VF_Vs_Coeff_TrqBoost*Vs_rat,&Vs_IR_comp);
// 전류 제한기
if (Is_mag>Is_max)
{
del_Vs_comp=(2.0*Vs_rat*inv_Is_rat)*(Is_mag-Is_max);
if (del_Vs_comp>0.1*Vs_rat)
del_Vs_comp=0.1*Vs_rat;
else if (del_Vs_comp<-0.1*Vs_rat)
del_Vs_comp=-0.1*Vs_rat;
}
else del_Vs_comp=0.0;
// 최종 전압 명령
Vs_ref = Es_m + Vs_IR_comp - del_Vs_comp; // IR보상, 전류크기 제한
if (Vs_ref>Vs_max)
Vs_ref=Vs_max;
}
// 출력 전압
Vs_dq_ref[ds]=Vs_ref*CosTheta + VF_DeadTimeGain*(Vs_dq_ref[ds]-Vs_dq[ds]);
Vs_dq_ref[qs]=Vs_ref*SinTheta + VF_DeadTimeGain*(Vs_dq_ref[qs]-Vs_dq[qs]);
}
// 역방향 운전시에 사용된다. : 미리 추정된 고정자 저항값이 사용되며,
// 저항값을 찾지 않으므로 여자시간은 길지 않다.
// 전류 리밋값이 미리 주어져야 한다.
// 정방향 운전에는 벡터제어가 사용됨.
void ReverseDirection_VVVF_Control()
{
double Es_m;
double Vs_gain;
double Slip;
double sgn_freq;
double Det_slip; // sqrt()안의 부호검사
double Det_emf;
Is_mag=sqrt(Is_dq[ds]*Is_dq[ds]+Is_dq[qs]*Is_dq[qs]);
// 전압 추정시 시간지연(Ts)을 보상
CosDeltaTheta=cos(we*Ts);
SinDeltaTheta=sin(we*Ts);
Us_dq[ds]=Vs_dq[ds]*CosDeltaTheta + Vs_dq[qs]*SinDeltaTheta;
Us_dq[qs]=-Vs_dq[ds]*SinDeltaTheta + Vs_dq[qs]*CosDeltaTheta;
Vs_dq[ds]=Us_dq[ds];
Vs_dq[qs]=Us_dq[qs];
// DC 여자 ==> Flux Setup : 벡터제어에서와 연동하기 위해서 같은 여자시간을 사용한다.
if (t<ExcitationTime)
{
Freq_ref=0.0;
Freq_out=0.0;
reference=0.0;
we=0.0;
theta=0.0;
SinTheta=0.0;
CosTheta=1.0;
//DC여자 동안 전압 명령
Vs_ref=Rs*(VF_ExcitationCurrentCoeff*Is_rat);
}
else
{
// 주파수 명령
// 1차 모터가 대차를 당기고 있을 경우
// 2차 모터는 적절한 힘으로 당겨줘야한다.
// 따라서 2차 모터는 설정된 슬립 만큼 주파수를 낮게 인가하면
// 회생영역에서 동작하게 되며 대차를 당기는 힘을 발생시킨다.
// 따라서 주파수 명령은 속도제어를 하고 있는 1차 인버터의 속도명령보다 작아져야 한다.
if (reference>=0.0)
{
Freq_ref=(wr_rat*inv_PI_2)*reference - Rev_SlipFreq_ref;
if (Freq_ref<0.0) Freq_ref=0.0;
}
else
{
Freq_ref=(wr_rat*inv_PI_2)*reference + Rev_SlipFreq_ref;
if (Freq_ref>0.0) Freq_ref=0.0;
}
Freq_out=Freq_ref;
// 각도 계산 : 주파수 명령 + 슬립 ==> 새로운 주파수 명령
we=PI_2*Freq_out;
theta+=we*Ts;
if (theta>PI) theta-=PI_2;
else if (theta<-PI) theta+=PI_2;
SinTheta=sin(theta);
CosTheta=cos(theta);
// 저항에 걸리는 전압강하를 보상하기위해서는
// Phase lag(low pass filter)가 반드시 포함되어야 한다.
// 이는본질적으로 IR보상식은 불안정하기 때문에
// 강제로 phase delay를 주기위함이며, 이로인해
// 보상을 안정되게 하기 위함이다.
// 따라서 VF_IR_Comp_FilterPole은 너무 큰 값을 가질수 없다.
if (t<0.1)
Vs_max=0.57735*Vdc;
else Vs_max+=20.0*(0.57735*Vdc-Vs_max)*Ts;
Es_m=VF_Fs_Coeff*fabs(Freq_out)*inv_Freq_rat*Vs_rat;
if (Es_m>Vs_max) Es_m=Vs_max;
Is_DQ[DS]= CosTheta*Is_dq[ds] + SinTheta*Is_dq[qs];
Is_DQ[QS]=-SinTheta*Is_dq[ds] + CosTheta*Is_dq[qs];
Det_emf=(Es_m*Es_m)-(Rs*Is_DQ[QS])*(Rs*Is_DQ[QS]); //sqrt안의 음수여부조사
if ( (Det_emf>0.0)&&(fabs(Freq_out)>VF_Freq_TrqBoost) )
LPF1(Ts,VF_IR_Comp_FilterPole,Rs*Is_DQ[DS]+sqrt(Det_emf)-Es_m,&Vs_IR_comp);
else LPF1(Ts,VF_IR_Comp_FilterPole,VF_Vs_Coeff_TrqBoost*Vs_rat,&Vs_IR_comp);
// 전류 제한기 => (VF_CurLimitCoeff*Is_max)
if (Is_mag>(VF_CurLimitCoeff*Is_max))
{
del_Vs_comp=(3.0*Vs_rat*inv_Is_rat)*(Is_mag-(VF_CurLimitCoeff*Is_max));
if (del_Vs_comp>0.1*Vs_rat)
del_Vs_comp=0.1*Vs_rat;
else if (del_Vs_comp<-0.1*Vs_rat)
del_Vs_comp=-0.1*Vs_rat;
}
else del_Vs_comp=0.0;
// 최종 전압 명령
Vs_ref = Es_m + Vs_IR_comp - del_Vs_comp; // IR보상, 전류크기 제한
if (Vs_ref>Vs_max)
Vs_ref=Vs_max;
}
// 출력 전압
Vs_dq_ref[ds]=Vs_ref*CosTheta + VF_DeadTimeGain*(Vs_dq_ref[ds]-Vs_dq[ds]);
Vs_dq_ref[qs]=Vs_ref*SinTheta + VF_DeadTimeGain*(Vs_dq_ref[qs]-Vs_dq[qs]);
}
void CrossOver::run(LV2_Handle instance, uint32_t n_samples)
{
CrossOver *plugin;
plugin = (CrossOver *) instance;
double f_before_1 = plugin->f_1;
double f_before_2 = plugin->f_2;
float Order;
plugin->f_1 = (float)(*(plugin->freq_1));
plugin->f_2 = (float)(*(plugin->freq_2));
double fc = sqrt( plugin->f_1 * plugin->f_2);
double fc_before = sqrt( f_before_1 * f_before_2);
double BW = abs(plugin->f_2 - plugin->f_1);
double BW_before = abs(f_before_2 - f_before_1);
Order = (float)(*(plugin->order));
Order = round(Order)+1;
for (uint32_t i=0; i<= n_samples-1;i++)
{
plugin->u[i] = plugin->in[i];
}
/*********************************************************/
switch (int(Order))
{
case 1:
LPF1(plugin->u, plugin->y1, n_samples, f_before_1, plugin->f_1, plugin->T, &plugin->y1_1, &plugin->u1_1, &plugin->y1_2, &plugin->u1_2, &plugin->y1_3, &plugin->u1_3 );
break;
case 2:
LPF2(plugin->u, plugin->y1, n_samples, f_before_1, plugin->f_1, plugin->T, &plugin->y1_1, &plugin->u1_1, &plugin->y1_2, &plugin->u1_2, &plugin->y1_3, &plugin->u1_3 );
break;
case 3:
LPF3(plugin->u, plugin->y1, n_samples, f_before_1, plugin->f_1, plugin->T, &plugin->y1_1, &plugin->u1_1, &plugin->y1_2, &plugin->u1_2, &plugin->y1_3, &plugin->u1_3 );
break;
default:
LPF1(plugin->u, plugin->y1, n_samples, f_before_1, plugin->f_1, plugin->T, &plugin->y1_1, &plugin->u1_1, &plugin->y1_2, &plugin->u1_2, &plugin->y1_3, &plugin->u1_3 );
}
for (uint32_t i=0; i<= n_samples-1;i++)
{
plugin->out_1[i] = plugin->y1[i];
}
/*********************************************************/
double g_before_1 = plugin->g_1;
plugin->g_1 = pow(10, (float)(*(plugin->gain_1))/20.0);
for (uint32_t i=1; i<=n_samples; i++)
{
plugin->out_1[i-1] = (g_before_1 + ((plugin->g_1 - g_before_1)/(n_samples - 1))*(i-1) )*(float)plugin->out_1[i-1];
}
/*********************************************************//*********************************************************/
switch (int(Order))
{
case 1:
BPF1(plugin->u, plugin->y2, n_samples, fc_before, fc, BW_before, BW, plugin->T, &plugin->y2_1, &plugin->u2_1, &plugin->y2_2, &plugin->u2_2, &plugin->y2_3, &plugin->u2_3, &plugin->y2_4, &plugin->u2_4, &plugin->y2_5, &plugin->u2_5, &plugin->y2_6, &plugin->u2_6 );
break;
case 2:
BPF2(plugin->u, plugin->y2, n_samples, fc_before, fc, BW_before, BW, plugin->T, &plugin->y2_1, &plugin->u2_1, &plugin->y2_2, &plugin->u2_2, &plugin->y2_3, &plugin->u2_3, &plugin->y2_4, &plugin->u2_4, &plugin->y2_5, &plugin->u2_5, &plugin->y2_6, &plugin->u2_6 );
break;
case 3:
BPF3(plugin->u, plugin->y2, n_samples, fc_before, fc, BW_before, BW, plugin->T, &plugin->y2_1, &plugin->u2_1, &plugin->y2_2, &plugin->u2_2, &plugin->y2_3, &plugin->u2_3, &plugin->y2_4, &plugin->u2_4, &plugin->y2_5, &plugin->u2_5, &plugin->y2_6, &plugin->u2_6 );
break;
default:
BPF1(plugin->u, plugin->y2, n_samples, fc_before, fc, BW_before, BW, plugin->T, &plugin->y2_1, &plugin->u2_1, &plugin->y2_2, &plugin->u2_2, &plugin->y2_3, &plugin->u2_3, &plugin->y2_4, &plugin->u2_4, &plugin->y2_5, &plugin->u2_5, &plugin->y2_6, &plugin->u2_6 );
}
for (uint32_t i=0; i<= n_samples-1;i++)
{
plugin->out_2[i] = plugin->y2[i];
}
/*********************************************************/
double g_before_2 = plugin->g_2;
plugin->g_2 = pow(10, (float)(*(plugin->gain_2))/20.0);
for (uint32_t i=1; i<=n_samples; i++)
{
plugin->out_2[i-1] = (g_before_2 + ((plugin->g_2 - g_before_2)/(n_samples - 1))*(i-1) )*(float)plugin->out_2[i-1];
}
/*********************************************************//*********************************************************/
switch (int(Order))
{
case 1:
HPF1(plugin->u, plugin->y3, n_samples, f_before_2, plugin->f_2, plugin->T, &plugin->y3_1, &plugin->u3_1, &plugin->y3_2, &plugin->u3_2, &plugin->y3_3, &plugin->u3_3 );
break;
case 2:
HPF2(plugin->u, plugin->y3, n_samples, f_before_2, plugin->f_2, plugin->T, &plugin->y3_1, &plugin->u3_1, &plugin->y3_2, &plugin->u3_2, &plugin->y3_3, &plugin->u3_3 );
break;
case 3:
HPF3(plugin->u, plugin->y3, n_samples, f_before_2, plugin->f_2, plugin->T, &plugin->y3_1, &plugin->u3_1, &plugin->y3_2, &plugin->u3_2, &plugin->y3_3, &plugin->u3_3 );
break;
default:
HPF1(plugin->u, plugin->y3, n_samples, f_before_2, plugin->f_2, plugin->T, &plugin->y3_1, &plugin->u3_1, &plugin->y3_2, &plugin->u3_2, &plugin->y3_3, &plugin->u3_3 );
}
for (uint32_t i=0; i<= n_samples-1;i++)
{
plugin->out_3[i] = plugin->y3[i];
}
/*********************************************************/
double g_before_3 = plugin->g_3;
plugin->g_3 = pow(10, (float)(*(plugin->gain_3))/20.0);
for (uint32_t i=1; i<=n_samples; i++)
{
plugin->out_3[i-1] = (g_before_3 + ((plugin->g_3 - g_before_3)/(n_samples - 1))*(i-1) )*(float)plugin->out_3[i-1];
}
}
