📄 reg0299.c
字号:
return CalcDerotatorFrequency(FieldGetVal(handle,DEROTATORFREQUENCYMSB),
FieldGetVal(handle,DEROTATORFREQUENCYLSB),
RegGetMasterFreq(handle));
}
/*****************************************************
**FUNCTION :: CalcAuxClkFrequency
**ACTION :: Compute Auxiliary clock frequency
**PARAMS IN :: NONE
**PARAMS OUT:: NONE
**RETURN :: Auxiliary Clock frequency
*****************************************************/
long CalcAuxClkFrequency(DEMOD_HANDLE handle,INT32 k, INT32 m, INT32 acr)
{
long aclk,factor;
INT32 function,value;
function = acr>>5;
value = acr & 0x1F;
switch(function)
{
case 0:
aclk = 0;
break;
case 1:
if(value)
aclk = CalcVCOFrequency(handle,k,m)/8/value;
else
aclk = CalcVCOFrequency(handle,k,m)/8;
break;
default:
factor = 8192L*PowOf2(function-2);
aclk = CalcVCOFrequency(handle,k,m)/factor/(32+value);
break;
}
return aclk;
}
/*****************************************************
**FUNCTION :: RegGetAuxFreq
**ACTION :: Read registers and compute Auxiliary clock frequency
**PARAMS IN :: NONE
**PARAMS OUT:: NONE
**RETURN :: Auxiliary Clock frequency
*****************************************************/
long RegGetAuxFreq(DEMOD_HANDLE handle)
{
/* Read registers */
RegGetOneRegister(handle,R_RCR);
RegGetOneRegister(handle,R_ACR);
return CalcAuxClkFrequency(handle,FieldGetVal(handle,K),
FieldGetVal(handle,M),
FieldGetVal(handle,ACR)); /* Compute auxiliary clock freq */
}
int RegGetErrorCount(DEMOD_HANDLE handle)
{
int lsb,msb;
//Do not modified the read order (lsb first)
lsb = RegGetField(handle,ERRCNTLSB);
msb = RegGetField(handle,ERRCNTMSB);
return (MAKEWORD(msb,lsb));
}
void RegSetErrorCount(DEMOD_HANDLE handle, int Value)
{
RegSetField(handle,ERRCNTMSB,MSB(Value));
RegSetField(handle,ERRCNTLSB,LSB(Value));
}
/*
**
**------------------------------------------------------------------------------
**
** INT32 GetRollOff(void)
**
** Simple function whichs read the register 00h bit bit1 and which sets
** corresponding Nyquist filter roll-off value.
**------------------------------------------------------------------------------
**
*/
int RegGetRollOff(DEMOD_HANDLE handle)
{
if ( RegGetField(handle,NYQUISTFILTER)==1 )
return 20;
else
return 35;
}
/*
**
*/
void RegSetRollOff(DEMOD_HANDLE handle, INT32 _Value)
{
if(_Value == 35)
RegSetField(handle,NYQUISTFILTER,0);
else
RegSetField(handle,NYQUISTFILTER,1);
}
long BinaryFloatDiv(long n1, long n2, INT32 precision)
{
INT32 i=0;
long result=0;
/* division de N1 par N2 avec N1<N2 */
while(i<=precision) /* n1>0 */
{
if(n1<n2)
{
result*=2;
n1*=2;
}
else
{
result=result*2+1;
n1=(n1-n2)*2;
}
i++;
}
return result;
}
/*****************************************************
**FUNCTION :: CalcSymbolRate
**ACTION :: Compute symbol frequency
**PARAMS IN :: Hbyte -> High order byte
** Mbyte -> Mid byte
** Lbyte -> Low order byte
**PARAMS OUT:: NONE
**RETURN :: Symbol frequency
*****************************************************/
long CalcSymbolRate(DEMOD_HANDLE handle, INT32 Hbyte,INT32 Mbyte,INT32 Lbyte)
{
long Ltmp,Ltmp2;
long Mclk;
Mclk = RegGetMasterFreq(handle) / 4096L; /* Fm_clk*10/2^20 */
Ltmp = (((long)Hbyte<<12)+((long)Mbyte<<4))/16;
Ltmp *= Mclk;
Ltmp /=16;
Ltmp2=((long)Lbyte*Mclk)/256;
Ltmp+=Ltmp2;
return Ltmp;
}
long RegSetSymbolRate(DEMOD_HANDLE handle, long SymbolRate)
{
unsigned long Result;
long MasterClock;
/*
** 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 )
*/
MasterClock=RegGetMasterFreq(handle);
Result = BinaryFloatDiv(SymbolRate,MasterClock,20);
FieldSetVal(handle,SYMB_FREQH,(int)((Result>>12)&0xFF));
FieldSetVal(handle,SYMB_FREQM,(int)((Result>>4)&0xFF));
FieldSetVal(handle,SYMB_FREQL,(int)(Result&0x0F));
RegSetRegisters(handle,R_SFRH,3);
return(SymbolRate) ;
}
/*****************************************************
**FUNCTION :: RegGetSymbolRate
**ACTION :: Return the symbol rate
**PARAMS IN :: NONE
**PARAMS OUT:: NONE
**RETURN :: Symbol rate
*****************************************************/
long RegGetSymbolRate(DEMOD_HANDLE handle)
{
RegGetRegisters(handle,R_SFRH,3);
return CalcSymbolRate(handle,FieldGetVal(handle,SYMB_FREQH),
FieldGetVal(handle,SYMB_FREQM),
FieldGetVal(handle,SYMB_FREQL));
}
/*****************************************************
**FUNCTION :: RegIncrSymbolRate
**ACTION :: add a correction to the symbol rate
**PARAMS IN :: correction -> correction
**PARAMS OUT:: NONE
**RETURN :: New symbol rate
*****************************************************/
long RegIncrSymbolRate(DEMOD_HANDLE handle, long correction)
{
long Ltmp;
RegGetRegisters(handle,R_SFRH,3);
Ltmp = (long)FieldGetVal(handle,SYMB_FREQH)<<12;
Ltmp += (long)FieldGetVal(handle,SYMB_FREQM)<<4;
Ltmp += FieldGetVal(handle,SYMB_FREQL);
Ltmp += correction;
FieldSetVal(handle,SYMB_FREQH,(INT16)((Ltmp>>12)&0xFF));
FieldSetVal(handle,SYMB_FREQM,(INT16)((Ltmp>>4)&0xFF));
FieldSetVal(handle,SYMB_FREQL,(INT16)(Ltmp&0x0F));
RegSetRegisters(handle,R_SFRH,3);
return RegGetSymbolRate(handle);
}
/*****************************************************
**FUNCTION :: CalcAGC1TimeConstant
**ACTION :: compute AGC1 time constant
**PARAMS IN :: m1 -> AGC1 reference value
** fm -> Master clock frequency (MHz)
** betaagc1 -> BeatAgc1
**PARAMS OUT:: NONE
**RETURN :: AGC1 time constant (us)
*****************************************************/
long CalcAGC1TimeConstant(INT32 m1,long fm,INT32 betaagc1)
{
long Tagc1;
if((m1==0)||(fm==0))
return(0);
Tagc1 = 67108864L; /* 2^26 */
Tagc1 /= PowOf2(betaagc1); /* 2^betaagc1 */
Tagc1 /= m1;
Tagc1 /= (fm/10000); /* Result is in mS*10 */
return Tagc1;
}
/*****************************************************
**FUNCTION :: RegGetAGC1TimeConstant
**ACTION :: compute AGC1 time constant
**PARAMS IN :: NONE
**PARAMS OUT:: NONE
**RETURN :: AGC2 time constant
*****************************************************/
long RegGetAGC1TimeConstant(DEMOD_HANDLE handle)
{
long fm;
RegGetOneRegister(handle,R_AGC1C);
RegGetOneRegister(handle,R_AGC1R);
RegGetRegisters(handle,R_RCR,2); /* RCR,MCR */
fm=CalcMasterClkFrequency(handle,FieldGetVal(handle,STDBY),
FieldGetVal(handle,DIRCLK),
FieldGetVal(handle,K),
FieldGetVal(handle,M),
FieldGetVal(handle,P));
return CalcAGC1TimeConstant(FieldGetVal(handle,AGC1_REF),
fm,
FieldGetVal(handle,BETA_AGC1));
}
/****************************************************
**FUNCTION :: CalcAGC2TimeConstant
**ACTION :: compute AGC2 time constant
**PARAMS IN :: agc2coef -> AGC2 coeficient
** m1 -> AGC1 reference value
** fm -> Master clock frequency (MHz)
**PARAMS OUT:: NONE
**RETURN :: AGC2 time constant (ns)
*****************************************************/
long CalcAGC2TimeConstant(long agc2coef, long m1, long fm)
{
long BetaAgc2,
Tagc2=0;
if((m1!=0) && (fm!=0))
{
BetaAgc2=PowOf2((agc2coef-1)*2);
Tagc2=60000L*10000L;
Tagc2/=(fm/1000);
Tagc2/=m1*BetaAgc2;
Tagc2*=100;
}
return Tagc2;
}
/*****************************************************
**FUNCTION :: RegGetAGC2TimeConstant
**ACTION :: compute AGC2 time constant
**PARAMS IN :: agc2coef -> AGC2 coeficient
** m1 -> AGC1 reference value
** fm -> Master clock frequency
**PARAMS OUT:: NONE
**RETURN :: AGC2 time constant
*****************************************************/
long RegGetAGC2TimeConstant(DEMOD_HANDLE handle)
{
long fm;
RegGetOneRegister(handle,R_AGC1R);
RegGetOneRegister(handle,R_AGC2O);
RegGetOneRegister(handle,R_RCR);
RegGetOneRegister(handle,R_MCR);
fm=CalcMasterClkFrequency(handle,FieldGetVal(handle,STDBY),
FieldGetVal(handle,DIRCLK),
FieldGetVal(handle,K),
FieldGetVal(handle,M),
FieldGetVal(handle,P));
return CalcAGC2TimeConstant(FieldGetVal(handle,AGC2COEF),
FieldGetVal(handle,AGC1_REF),
fm);
}
/*****************************************************
**FUNCTION :: RegGetTimingLocked
**ACTION :: Check the state of the timing loop
**PARAMS IN :: agc2coef -> AGC2 coeficient
** m1 -> AGC1 reference value
** fm -> Master clock frequency
**PARAMS OUT:: NONE
**RETURN :: Boolean ->true if timing loop is locked
*****************************************************/
INT32 RegGetTimingLocked(DEMOD_HANDLE handle)
{
INT32 locked;
long TimingFreq;
unsigned char Sr[3];
locked=RegGetField(handle,TLIR);
if(locked>42)
{
if(locked>48)
locked = 1;
else
{
RegGetRegisters(handle,R_SFRH,3); /* Read symbol rate registers */
Sr[0] = FieldGetVal(handle,SYMB_FREQH); /* Save symbol rate registers */
Sr[1] = FieldGetVal(handle,SYMB_FREQM);
Sr[2] = FieldGetVal(handle,SYMB_FREQL);
TimingFreq = CalcSymbolRate(handle,Sr[0],Sr[1],Sr[2]);
RegSetSymbolRate(handle,TimingFreq-(TimingFreq/100));
if(RegGetField(handle,TLIR) < locked)
locked = 1;
else
locked = 0;
FieldSetVal(handle,SYMB_FREQH,Sr[0]);
FieldSetVal(handle,SYMB_FREQM,Sr[1]);
FieldSetVal(handle,SYMB_FREQL,Sr[2]);
RegSetRegisters(handle,R_SFRH,3); /* Write symbol rate registers */
}
}
else locked = 0;
return locked;
}
/*=====================================================
**=====================================================
**|||| ||||
**|||| F22 GENERATION FACILITIES ||||
**|||| ||||
**=====================================================
**===================================================*/
void RegF22On(void)
{
/*RegSetField(F22OUTPUT,1); */
}
void RegF22Off(void)
{
/*RegSetField(F22OUTPUT,0); */
}
/*=====================================================
**=====================================================
**|||| ||||
**|||| TRIGGER FACILITIES ||||
**|||| ||||
**=====================================================
**===================================================*/
void RegTriggerOn(DEMOD_HANDLE handle)
{
DEMOD_SAT_DATA *sDemodData = (DEMOD_SAT_DATA*)handle;
if(sDemodData->RegTrigger == YES)
/* I/O = 1 */
RegSetField(handle,DACMODE,1);
}
void RegTriggerOff(DEMOD_HANDLE handle)
{
DEMOD_SAT_DATA *sDemodData = (DEMOD_SAT_DATA*)handle;
if(sDemodData->RegTrigger == YES)
/* I/O = 0 */
RegSetField(handle,DACMODE,0);
}
FLAG_ RegGetTrigger(DEMOD_HANDLE handle)
{
DEMOD_SAT_DATA *sDemodData = (DEMOD_SAT_DATA*)handle;
return(sDemodData->RegTrigger);
}
void RegSetTrigger(DEMOD_HANDLE handle,FLAG_ _Trigger)
{
DEMOD_SAT_DATA *sDemodData = (DEMOD_SAT_DATA*)handle;
sDemodData->RegTrigger = _Trigger;
}
#endif // SATELLITE_299
#endif // FTA_SUPPORT⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -