📄 demod.cpp
字号:
/* ( Set maximum tuner bandwidth ) TunerSetBandwidth(hTuner,50000000)*/
t.Format("SEARCH>> FE_288_Algo::Kt=%d",kt); message(t);
/* Setup of non-modified parameters */
F288_ALPHA=7;
F288_BETA=28;
address=0x16;
register_[address]&=0xF0;
register_[address]|=F288_ALPHA;
demod_setdata(address,register_[address]); //F288_ALPHA
address+=1;
register_[address]&=0xC0;
register_[address]|=F288_BETA;
demod_setdata(address,register_[address]); //F288_BETA
if(direcTV) {
F288_SYM=0;
address=0x30;
register_[address]&=0xFE;
register_[address]|=F288_SYM;
demod_setdata(address,register_[address]); /* force IQ normal */
}
/* Set Kt value */
address=0x51;
register_[address]=kt;
demod_setdata(address,register_[address]);
demod_288_froze_lock(1,register_);
F288_IND1_ACC=0;
F288_IND2_ACC=0xFF;
address=0x5E;
register_[address]=F288_IND1_ACC;
demod_setdata(address,register_[address]);
address+=1;
register_[address]=F288_IND2_ACC;
demod_setdata(address,register_[address]);
demod_288_set_symbolrate(1000000,register_); //sps /* Set symbolrate to 1.000MBps (minimum symbol rate) */
demod_288_set_derot_freq(coarseOffset_Khz*1000,register_); //Hz /* Set carrier loop offset to 0KHz or previous iteration value */
demod_288_set_frequency_offset_detector(1,register_); /* Frequency offset detector on */
coarseSymbolRate_Bds=demod_288_coarse(register_,&coarseOffset_Khz);/* Symbolrate coarse search */
coarseOffset_Khz *= tunerIQ;
t.Format("SEARCH>> FE_288_Algo::dF=%ld",demod_288_get_derot_freq(register_)); message(t);
//V0.05[061204] [TILT2]
//in manual search mode,
//move coarseOffset_Khz value as Fs/4, if coarseOffset_Khz is out of range(+/-5MHz)
if(1){
if(known){ //manual search mode
t.Format(" [061201_test_tilt] coarseOffset_Khz=%ld",coarseOffset_Khz); message(t);
if(coarseOffset_Khz<MinOffset_Khz)
{
t.Format(" [061201_test_tilt] %ld + [ %ld]",coarseOffset_Khz,SymbolRate_Bds/4000); message(t);
coarseOffset_Khz+=SymbolRate_Bds/4000;
}
else if(MaxOffset_Khz<coarseOffset_Khz){
t.Format(" [061201_test_tilt] %ld - [ %ld]",coarseOffset_Khz,SymbolRate_Bds/4000); message(t);
coarseOffset_Khz-=SymbolRate_Bds/4000;
}
t.Format(" [061201_test_tilt] coarseOffset_Khz=%ld",coarseOffset_Khz); message(t);
// //set the derot value with moved "coarseOffset_Khz" value
// demod_288_set_derot_freq(coarseOffset_Khz*1000,register_); //Hz /* Set carrier loop offset to 0KHz or previous iteration value */
// demod_288_set_frequency_offset_detector(1,register_); /* Frequency offset detector on */
// Sleep(50);
}
}
t.Format("SEARCH>> FE_288_Algo::dF=%ld",demod_288_get_derot_freq(register_)); message(t);
if(known) /* symbol rate is already known, so keep only the offset and force the symbol rate */
demod_288_set_symbolrate(SymbolRate_Bds,register_);
else /* take into account the symbol rate returned by the coarse algorithm */
SymbolRate_Bds=coarseSymbolRate_Bds;
//t.Format("SEARCH>> FE_288_Algo::SymbolRate=%d Kbds, Offset=%d KHz",SymbolRate_Bds/1000,coarseOffset_Khz); message(t);
t.Format("SEARCH>> FE_288_Algo::SymbolRate=%d Kbds",SymbolRate_Bds/1000); message(t);
t.Format("SEARCH>> FE_288_Algo::Offset=%d KHz",coarseOffset_Khz); message(t);
MasterClock_Hz=demod_288_get_mclk_freq(register_);
if(SymbolRate_Bds>1000) {
symbolrate_ok = (MasterClock_Hz/(SymbolRate_Bds/1000))>2100; /* to avoid a divide by zero error */
}
else {
symbolrate_ok = TRUE;
}
if( (SymbolRate_Bds >= 1000000) /* Check min symbolrate value */ //<--for 1Msps [060529]
//if( (SymbolRate_Bds > 1000000) /* Check min symbolrate value */
&& (coarseOffset_Khz>=MinOffset_Khz) /* Check minimum derotator offset criteria */
&& (coarseOffset_Khz<MaxOffset_Khz) /* Check maximum derotator offset criteria */
&& (symbolrate_ok)) /* Check shannon criteria */
{
//V0.05[061204] [TILT5]
//search with false lock loop
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
int iii=0;
long lambda_4;
lambda_4=SymbolRate_Bds/4; //sps
long offset;
do{
message(" ");
//t.Format("[061201_test_tilt] False Lock Loop [ %d ] ",iii); message(t);
t.Format(" "); message(t);
t.Format("[ %d ] ",iii); message(t);
//[
//false lock search loop setting.
//if carrier/timing lock and FEC unlock -> junm to the next false lock point(+/- Fs/4)
if(iii==0)
offset=coarseOffset_Khz*1000; //Hz
if(iii==1)
offset=coarseOffset_Khz*1000 + lambda_4; //Hz
if(iii==2)
offset=coarseOffset_Khz*1000 - lambda_4; //Hz
demod_288_set_derot_freq(offset,register_); //Hz
demod_288_set_frequency_offset_detector(1,register_); /* Frequency offset detector on */
Sleep(50);
t.Format("[061201_test_tilt] coarseOffset_Khz*1000 = %.3lf [MHz]",coarseOffset_Khz/1000.); message(t);
t.Format("[061201_test_tilt] lambda_4 = %.3lf [MHz] ",lambda_4/1000000.); message(t);
t.Format("[061201_test_tilt] DEROT = %.3lf [MHz] ",offset/1000000.); message(t);
//________________________________________________________________________________
//ORIGINAL ORIGINAL ORIGINAL ORIGINAL ORIGINAL ORIGINAL ORIGINAL ORIGINAL ORIGINAL
// if(known)
// TunerSetBandwidth(hTuner,(SymbolRate_Bds*1.4)+4000000); /* Change tuner bandwidth */
// else
// TunerSetBandwidth(hTuner,SymbolRate_Bds*3); /* Change tuner bandwidth */
//仼僽儔僀儞僪僒乕僠帪丄BW寁嶼昁梫両両
/* Adjust carrier loop setting */
if(SymbolRate_Bds < 5000000)
{
F288_ALPHA=8;
F288_BETA=17;
}
else if(SymbolRate_Bds > 35000000)
{
F288_ALPHA=8;
F288_BETA=36;
}
address=0x16;
register_[address]&=0xF0;
register_[address]|=F288_ALPHA;
demod_setdata(address,register_[address]);
address+=1;
register_[address]&=0xC0;
register_[address]|=F288_BETA;
demod_setdata(address,register_[address]);
demod_288_froze_lock(0,register_);
demod_288_fine(SymbolRate_Bds,known,register_);
//V0.05[061204] [TILT3]
//need wait time?? (CARRIER : UNLOCK -> LOCK)
Sleep(50);
int F288_TMG_LOCK,F288_CF;
demod_getdata(0x1E,&F288_TMG_LOCK); F288_TMG_LOCK&=0x80;
demod_getdata(0x24,&F288_CF); F288_CF&=0x80;
//V0.05[061204] [TILT6]
//if timing and carrier OK, lock or false lock.
// -> memorize the demod_288_get_derot_freq() into coarseOffset_Khz .
if(F288_TMG_LOCK&&F288_CF) coarseOffset_Khz = demod_288_get_derot_freq(register_);
t.Format("SEARCH>> FE_288_Algo::Timing=%s,Carrier=%s",F288_TMG_LOCK?"LOCK":"UNLOCK",F288_CF?"LOCK":"UNLOCK"); message(t);
t.Format("SEARCH>> FE_288_Algo::dF=%ld",demod_288_get_derot_freq(register_)); message(t);
demod_288_set_frequency_offset_detector(0,register_); /* Frequency offset detector off */
timing=demod_288_autocenter(register_);
if( !demod_288_get_cf(register_) && (SymbolRate_Bds>18000000))
{
demod_288_set_symbolrate(SymbolRate_Bds,register_);
demod_288_set_frequency_offset_detector(1,register_);
demod_288_set_derot_freq(0,register_);
demod_288_set_frequency_offset_detector(0,register_);
timing=demod_288_autocenter(register_);
}
t.Format("SEARCH>> FE_288_Algo::Timing offset=%d(%.2X)",ABS(timing),ABS(timing)); message(t);
if(ABS(timing)<=300)
{
pIntResults_SymbolRate_Bds=demod_288_get_symbolrate(register_);
tdata=10+(2*demod_288_data_timing_constant(pIntResults_SymbolRate_Bds,register_));
lock=demod_288_waitlock(tdata,register_);
if(lock)
{
pIntResults_PunctureRate=FE_288_Rate_t( 1<<demod_288_get_pr(register_) );
}
if(direcTV)
{
}
// if(direcTV)
// {
// /* workaround for IQ invertion in DIRECTV mode */
// WAIT_N_MS(4);
// nbErr = FE_288_GetErrorCount(hDemod,COUNTER2);
// maxPckError = 0x01<<(11+2*ChipGetField(hDemod,F288_NOE2)); /* packet error rate = 50% */
// if((!lock) || (lock && (pIntResults->PunctureRate == FE_6_7) && (nbErr>maxPckError)))
// {
// /* more than 50% packet errors rate ==> swap I and Q */
//
// #if defined(DBG_SEARCHALGO) && !defined(NO_GUI)
// ReportInsertMessage(text);
// #endif
//
// ChipSetField(hDemod,F288_SYM,1);
// lock=FE_288_WaitLock(hDemod,tdata);
// }
// }
//
t.Format("SEARCH>> FE_288_Algo::FEC=%s",lock?"LOCK":"UNLOCK"); message(t);
if(lock)
{
//V0.02[060613] invert the polarity
/* update results */
pIntResults_Frequency_Khz=tun_getfreq(byte_)-(tunerIQ*demod_288_get_derot_freq(register_));
// pIntResults_Frequency_Khz=tun_getfreq(byte_)+(tunerIQ*demod_288_get_derot_freq(register_));
t.Format("SEARCH>> FE_288_Algo::Transponder freq=%f MHz",(double)(pIntResults_Frequency_Khz)/1000.0); message(t);
if(ABS(SearchFreq_Khz-pIntResults_Frequency_Khz)>ABS(MaxOffset_Khz))
{
signalType = OUTOFRANGE;
}
else{
signalType = RANGEOK;
//V0.04[061109] [STB0288+ix2410]
//set lock status for retrun value
flag=1;
//
}
pIntResults_SignalType = signalType;
//____________________________________________________________
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
((Cnim*)m_pParent)->nim_status.signal_type=signalType;
((Cnim*)m_pParent)->nim_status.symbolrate=pIntResults_SymbolRate_Bds;
((Cnim*)m_pParent)->nim_status.freq=pIntResults_Frequency_Khz;
((Cnim*)m_pParent)->nim_status.lock_up_time=get_elapsed_time();
//____________________________________________________________
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
}
}
//ORIGINAL ORIGINAL ORIGINAL ORIGINAL ORIGINAL ORIGINAL ORIGINAL ORIGINAL ORIGINAL
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
t.Format("[061201_test_tilt] lock,TMG,CF = %d ",lock,demod_288_check_TMG_LOCK(),democd_288_check_CF() ); message(t);
if(known) iii+=1; //manual search : false lock loop, next derot.
else iii=3; //blind search mode : loop finish
}while( (lock==0) && demod_288_check_TMG_LOCK() && democd_288_check_CF() && (iii<=2) );
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
}
else {
demod_288_froze_lock(0,register_);
t.Format(" ( FE_288_Algo:: ABS(timing)<=300:NG )"); message(t);
}
kt-=10; /* decrease Kt for next trial */
message(" ");
}while((signalType != RANGEOK) && (signalType != OUTOFRANGE) && (symbolrate_ok) && (kt>=46));
message("SEARCH>> FE_288_Algo::End");
return flag;
}
BOOL Cdemod::tun_setfreq(long freq_, long baud_, int *byte_)//kHz
{
message("<tun_setfreq>");
BOOL flag=0;
((Cnim*)m_pParent)->tun_setfreq(freq_,baud_,byte_);
return flag;
}
long Cdemod::tun_getfreq(int *byte_)
{
return ((Cnim*)m_pParent)->tun_getfreq(byte_);
}
//S32 FE_288_CalcDerotFreq()
long Cdemod::demod_288_calc_derot_freq(int *register_)
{
long derotmsb;
long derotlsb;
long fm;
long dfreq;
long Itmp;
int address;
address=0x2B;
demod_getdata(address,®ister_[address]);
address+=1;
demod_getdata(address,®ister_[address]);
derotmsb=register_[0x2B];
derotlsb=register_[0x2C];
fm=demod_288_get_mclk_freq(register_);
Itmp = (derotmsb<<8)+derotlsb;
if(Itmp>0x10000/2) { //2's complement
Itmp=0x10000-Itmp;
Itmp*=-1;
}
dfreq = Itmp*(fm/10000L);
dfreq = dfreq / 65536L;
dfreq *= 10;
return dfreq;
}
long Cdemod::demod_288_get_mclk_freq(int *register_) //Hz
{
long mclk_Hz; /* master clock frequency (Hz) */
long pll_divider; /* pll divider */
long pll_selratio; /* 4 or 6 ratio */
long pll_bypass; /* pll bypass */
long ExtClk_Hz;
ExtClk_Hz=demod_xtal();
pll_divider=register_[0x40]+1;
pll_selratio=( ((register_[0x41]>>2)&0x01)?4:6);
pll_bypass=register_[0x41]&0x01;
if(pll_bypass) mclk_Hz=ExtClk_Hz;
else mclk_Hz=(ExtClk_Hz*pll_divider)/pll_selratio;
return mclk_Hz;
}
long Cdemod::demod_xtal()
{
return ((Cnim*)m_pParent)->demod.xtal; //Hz(4MHz)
}
int Cdemod::get_iq_wiring()
{
int iq_wiring=1; // (1):I/Q , (-1):I/-Q
iq_wiring=((Cnim*)m_pParent)->tuner.iq_wiring;
if(iq_wiring!=1) iq_wiring=-1;
return iq_wiring;
}
long Cdemod::demod_288_set_symbolrate(long SymbolRate, int *register_)//Hz
{
long MasterClock_Hz;
long temp;
int address;
MasterClock_Hz=demod_288_get_mclk_freq(register_); //Hz
// /*
// ** in order to have the maximum precision, the symbol rate entered into
// ** the chip is computed as the closest value of the "true value".
// ** In this purpose, the symbol rate value is rounded (1 is added on the bit
// ** below the LSB )
// */
temp=BinaryFloatDiv(SymbolRate,MasterClock_Hz,20);
/* warning : symbol rate is set to Masterclock/2 before setting the real value !!!!! */
int F288_SYMB_FREQ_HSB=0x80;
int F288_SYMB_FREQ_MSB=0x00;
int F288_SYMB_FREQ_LSB=0x00;
address=0x28;
register_[address]=F288_SYMB_FREQ_HSB;
demod_setdata(address,register_[address]);
address+=1;
register_[address]=F288_SYMB_FREQ_MSB;
demod_setdata(address,register_[address]);
address+=1;
register_[address]=F288_SYMB_FREQ_LSB;
demod_setdata(address,register_[address]);
F288_SYMB_FREQ_HSB=(temp>>12)&0xFF;
F288_SYMB_FREQ_MSB=(temp>>4)&0xFF;
F288_SYMB_FREQ_LSB=(temp)&0xFF;
address=0x28; register_[address]=F288_SYMB_FREQ_HSB;
demod_setdata(address,register_[address]);
address+=1; register_[address]=F288_SYMB_FREQ_MSB;
demod_setdata(address,register_[address]);
address+=1; register_[address]=F288_SYMB_FREQ_LSB;
demod_setdata(address,register_[address]);
address=0x22; register_[address]=0;
demod_setdata(address,register_[address]);
address+=1; register_[address]=0;
demod_setdata(address,register_[address]);
return SymbolRate;
}
long Cdemod::BinaryFloatDiv(long n1, long n2, int precision)
{
int i=0;
long result=0;
/* division de N1 par N2 avec N1<N2 */
while(i<=precision) /* n1>0 */
{
if(n1<n2)
{
result<<=1;
n1<<=1;
}
else
{
result=(result<<1)+1;
n1=(n1-n2)<<1;
}
i++;
}
return result;
}
void Cdemod::demod_288_set_derot_freq(long DerotFreq_Hz, int *register_)
{
int address;
long temp;
long MasterClock_Hz;
MasterClock_Hz=demod_288_get_mclk_freq(register_); //Hz
temp=long(DerotFreq_Hz/long(MasterClock_Hz/65536L));
int F288_CARRIER_FREQUENCY_MSB;
int F288_CARRIER_FREQUENCY_LSB;
F288_CARRIER_FREQUENCY_MSB=(temp>>8)&0xFF;
F288_CARRIER_FREQUENCY_LSB=temp&0xFF;
address=0x2B;
register_[address]=F288_CARRIER_FREQUENCY_MSB;
demod_setdata(address,register_[address]);
address+=1;
register_[address]=F288_CARRIER_FREQUENCY_LSB;
demod_setdata(address,register_[address]);
}
void Cdemod::demod_288_set_frequency_offset_detector(int flag,int *register_)
{
int address=0x15;
if(flag) register_[address]|=0x80;
else register_[address]&=0x7F;
demod_setdata(address,register_[address]);
}
long Cdemod::demod_288_coarse(int *register_, long *Offset_Khz)
{
CString t;
long symbolrate_Bds = 0;
int F288_AUTOCENTRE=1;
int F288_FINE=0;
int F288_COARSE=1;
int address=0x50;
register_[address]&=0xF8;
register_[address]|=(F288_AUTOCENTRE<<2);
register_[address]|=(F288_FINE<<1);
register_[address]|=(F288_COARSE<<0);
demod_setdata(address,register_[address]);
WAIT_N_MS(50);
message("WAIT_N_MS(50)");
symbolrate_Bds=demod_288_get_symbolrate(register_);
//symbolrate_Bds=27500000;
*Offset_Khz=demod_288_get_derot_freq(register_);
demod_288_start_coarse_algorithm(0,register_); /* stop coarse algorithm */
// t.Format(" (demod_288_coarse: symbolrate_Bds=%ld / *Offset_Khz=%ld)",symbolrate_Bds,*Offset_Khz); message(t);
t.Format(" (demod_288_coarse: symbolrate_Bds=%ld )",symbolrate_Bds); message(t);
t.Format(" (demod_288_coarse: *Offset_Khz=%ld)",*Offset_Khz); message(t);
// demod_288_start_coarse_algorithm(0,register_); /* stop coarse algorithm */
return symbolrate_Bds;
}
long Cdemod::demod_288_get_derot_freq(int *register_)
{
int address=0x2B;
demod_getdata(address,®ister_[address]);
return demod_288_calc_derot_freq(register_);
}
long Cdemod::demod_288_get_symbolrate(int *register_) //[sps]
{
//original
int address=0x2A;
demod_getdata(address,®ister_[address]);
address-=1;
demod_getdata(address,®ister_[address]);
address-=1;
demod_getdata(address,®ister_[address]);
return demod_288_calc_symbolrate(register_);
// int address=0x28;
// demod_getdata(address,®ister_[address]);
// address+=1;
// demod_getdata(address,®ister_[address]);
// address+=1;
// demod_getdata(address,®ister_[address]);
// return demod_288_calc_symbolrate(register_);
}
long Cdemod::demod_288_calc_symbolrate(int *register_)
{
long Ltmp;
long Ltmp2;
long Mclk;
long Hbyte;
long Mbyte;
long Lbyte;
int address=0x28;
Mclk=long(demod_288_get_mclk_freq(register_)/4096L);/* MasterClock*10/2^20 */
Hbyte=register_[address];
Mbyte=register_[address+1];
Lbyte=register_[address+2];
Ltmp=((Hbyte<<12)+(Mbyte<<4))/16;
Ltmp *= Mclk;
Ltmp /=16;
// Ltmp2=long(Lbyte*Mclk)/256;
Ltmp2=long(Lbyte*Mclk)/256/16; //V0.03[xxxxxx]
Ltmp+=Ltmp2;
return Ltmp;
}
void Cdemod::demod_288_froze_lock(int flag, int *register_)
{
//CString t;
//t.Format("::demod_288_froze_lock/flag=%d",flag); message(t);
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -