📄 qpsk0299.c
字号:
if ( i2c_write ( i2c_ssc0,
( unsigned char ) I2C_SLAVE_ADDR_FOR_STV0299,
aucData,
2,
&iActualLength ) )
{
do_report ( severity_info, "WRITE=> Failed to write STv0299 Reg[%02X] Data[%02X]\n",
aucData [ 0 ],
aucData [ 1 ] );
return FALSE;
}
do_report ( severity_info, "WRITE=> Reg[%02X] Data[%02X]\n",
aucData [ 0 ],
aucData [ 1 ] );
#endif /* ENABLE_STAPI_ENVIRONMENT */
return FALSE;
}
/*}}}*/
#endif
#ifndef ENABLE_STAPI_ENVIRONMENT
/*
* CODE : link_read
* TYPE : subroutine
* PROTOTYPE : BOOLEAN link_read ( BYTE reg, BYTE *value_p );
*
* PURPOSE : to access the specified LINK_IC register over the specified I2C bus.
*
*/
BOOLEAN link_read ( BYTE reg, BYTE *value_p )
{
/* low level I2C interface for link I/O used by tuning process */
BOOLEAN error = FALSE;
BYTE i2c_buffer [ I2C_COMMAND_LEN ];
int actlen = 1;
semaphore_wait (psemLinkIcAccess);
i2c_buffer [ 0 ] = reg;
while ( TRUE )
{
/* retry until success */
error = i2c_write ( i2c_ssc0, LINKIC_DEV, i2c_buffer, 1, &actlen );
if (!error)
{
error = i2c_read ( i2c_ssc0, LINKIC_DEV, i2c_buffer, 1, &actlen );
*value_p = i2c_buffer[0];
if ( !error )
break;
i2c_buffer [ 0 ] = reg;
TUNER_I2C_ERROR ( do_report ( severity_info, "link_read->I2C_read error\n" ) );
}
else
{
i2c_errors++;
TUNER_I2C_ERROR( do_report ( severity_info, "link_read->I2C_write error (%d) \n",i2c_errors) );
MILLI_DELAY(30);
}
}
semaphore_signal (psemLinkIcAccess);
return(error);
}
#define MAX_I2C_WRITE_VERIFY_FAIL_COUNT 5
/*
* CODE : link_write
* TYPE : subroutine
* PROTOTYPE : BOOLEAN link_write ( BYTE reg, BYTE value, BOOLEAN verify );
*
* PURPOSE : to write the given data into the specified LINK_IC register
* over the specified I2C bus.
*/
/*{{{ link_write ()*/
BOOLEAN link_write(BYTE reg, BYTE value, BOOLEAN verify )
{
/* low level I2C interface for link I/O used by tuning process */
BOOLEAN error = FALSE;
BYTE i2c_buffer [ I2C_COMMAND_LEN ];
int actlen;
int iTimeOutCount;
semaphore_wait (psemLinkIcAccess);
iTimeOutCount = 0;
while ( TRUE )
{
i2c_buffer[0] = reg;
i2c_buffer[1] = value;
error = i2c_write(i2c_ssc0, LINKIC_DEV, i2c_buffer, 2, &actlen);
if (!error)
{
if ( verify )
{
i2c_buffer [ 0 ] = 0xFF;
/* read back from same register to validate write */
if ( i2c_read ( i2c_ssc0, LINKIC_DEV, i2c_buffer, 1, &actlen ) )
{
TUNER_I2C_ERROR ( do_report ( severity_info, "link_write->I2C read error in verify mode\n" ) );
/*
* give 1mSec delay before making next access
*/
MILLI_DELAY ( 1 );
}
if ( i2c_buffer [ 0 ] == value )
break;
TUNER_I2C_ERROR ( do_report ( severity_info, "Write to LinkIC failed (address = 0x%02X, read data = %02x and should be = %02x\n", reg, i2c_buffer [ 0 ], value ) );
if ( ++iTimeOutCount > MAX_I2C_WRITE_VERIFY_FAIL_COUNT )
break;
}
else
break;
}
else
{
i2c_errors++;
TUNER_I2C_ERROR ( do_report ( severity_info, "link_write->I2C error (%d)\n",i2c_errors ) );
}
}
semaphore_signal (psemLinkIcAccess);
return(error);
}
/*}}}*/
/*
* CODE : tuner_write
* TYPE : subroutine
* PROTOTYPE : BOOLEAN tuner_write ( int value );
*
* PURPOSE : to write the given data into the TUNER_IC for the PLL setup.
*/
BOOLEAN tuner_write ( int value )
{
/* low level I2C interface for tuner I/O */
BOOLEAN error = FALSE;
BYTE i2c_buffer [ I2C_COMMAND_LEN ];
int actlen;
semaphore_wait (psemLinkIcAccess);
i2c_buffer[0] = ( BYTE ) ( ( value >> 8 ) & 0x7F); /* MSB */
i2c_buffer[1] = ( BYTE ) ( value & 0xFF ); /* LSB */
i2c_buffer[2] = ( BYTE ) 0x8E; /* control data */
i2c_buffer[3] = ( BYTE ) 0xC1; /* I/O port */
TUNER_DEBUG ( do_report ( severity_info, "tuner_write->%d ( %ld KHz )\n", value, ( long ) ( ( long ) value * TUNER_STEP - TUNER_IF ) ) );
while ( TRUE )
{
error = i2c_write ( i2c_ssc0, TUNER_DEV, i2c_buffer, 4, &actlen );
if ( error )
{
i2c_errors++;
TUNER_I2C_ERROR ( do_report ( severity_info, "tuner_write->I2C error (%d)\n", i2c_errors ) );
MILLI_DELAY ( 30 );
}
else
break;
}
semaphore_signal (psemLinkIcAccess);
return (error);
}
/*
* CODE : tuner_read
* TYPE : subroutine
* PROTOTYPE : BOOLEAN link_read ( BYTE *value_p );
*
* PURPOSE : to read the status reg of TUNER
*/
/*{{{ tuner_read ()*/
BOOLEAN tuner_read ( BYTE *value_p )
{
/* low level I2C interface for tuner I/O */
BOOLEAN error = FALSE;
BYTE i2c_buffer [ I2C_COMMAND_LEN ];
int actlen = 0;
semaphore_wait (psemLinkIcAccess);
error = i2c_read ( i2c_ssc0, TUNER_DEV, i2c_buffer, 1, &actlen );
*value_p = i2c_buffer [ 0 ];
semaphore_signal (psemLinkIcAccess);
return(error);
}
/*}}}*/
#endif /* ENABLE_STAPI_ENVIRONMENT */
/*
* CODE : tuner_process
* TYPE : process, low_priority (200)
* PROTOTYPE : void tuner_process ( void );
* STACK : 2048 bytes
* INPUT : nothing
* OUTPUT : nothing
*
* GLOBAL VARIABLES USED :
* a. iCurTunerTaskState int ENUM_TUNER_TASK_STATES ( R/W )
*
* FUNCTIONS CALLED :
* a. link_read
* b. link_write
* c. tuner_write
*
* CALLERS :
* a. tuner_init - resident call
*
* PURPOSE : tuning algorithm
*/
/*{{{ tuner_process ()*/
static void tuner_process ( void *pvParam )
{
SEARCHPARAMS *pParams;
SEARCHRESULT *pResult;
int iTunerPeriodicReportCnt = 0;
int iLnbOffsetRegistered;
signed short int sDerotatorFreqRead;
signed short int sDerotatorFreqWritten;
signed short int sDerotatorLimit;
int iTemp;
BYTE ucStatusRead;
pParams = &Params;
pResult = &Result;
while ( TRUE )
{
switch ( iCurTunerTaskState )
{
case TUNER_IDLE:
semaphore_signal ( psemTunerIdleStateEntered );
/*
TUNER_TUNER_CRITICAL ( do_report ( severity_info, "TIDLE => psemTunerIdleStateReleased (%d)\n", psemTunerIdleStateReleased -> semaphore_count ) );
*/
semaphore_wait ( psemTunerIdleStateReleased );
TUNER_TUNER_CRITICAL ( do_report ( severity_info, "TIDLE => TO[%d] FS_Offset[%d]\n",
iTunerOffset,
iCurFsRegOffset ) );
iLnbOffsetRegistered = iTunerOffset / iTunerStepSize;
Params . TunerOffset = iTunerOffset;
TUNER_TUNER_CRITICAL ( do_report ( severity_info, "\n\n***> New Tune Req => XpdrFreq[%d] LO[%d] TO[%d] Symb[%d]\n",
iRequestedTransponderFreq,
iInitialTunedFreq,
iTunerOffset,
iRequestedSymbolRate ) );
iTunerPeriodicReportCnt = 0;
break;
case TUNER_SETUP_PARAMS:
sDerotatorFreqRead = 0;
sDerotatorFreqWritten = 0;
iSavedTunerTaskState = iCurTunerTaskState;
Result . SignalType = NOAGC1;
Result . Frequency = 0;
Result . SymbolRate = 0;
InitSearch ( iInitialTunedFreq,
iRequestedSymbolRate,
iMaxLnbDrift,
DEROTATOR_STEP, /*6*/
DRV_SEARCH );
#if 0
/* VICKY - 290200 - modify the beta_car depending on the i/p symb rate */
{
iTemp = RegGetField ( BETA_CAR );
if ( pParams -> SymbolRate > 15000000L )
{
iTemp = 0x15;
}
else
{
if ( pParams -> SymbolRate > 5000000L )
{
iTemp = 0x0F;
}
else
{
if ( pParams -> SymbolRate > 2000000L )
{
iTemp = 0x09;
}
else
{
iTemp = 0x06;
}
}
}
RegSetField ( BETA_CAR, iTemp );
}
#endif
{
int errorrate,sn,to,hy;
RegGetOneRegister(R_PR);
RegGetOneRegister(R_VSEARCH);
/* Get fields value */
sn=FieldGetVal(SN);
to=FieldGetVal(TO);
hy=FieldGetVal(H);
errorrate=FieldGetVal(RATE);
RegTriggerOff(); /*______________________________________TRIGGER____________________________________________*/
/* Initial calculations */
pParams->DerotStep = pParams->DerotPercent*(pParams->SymbolRate/1000L)/pParams->Mclk; /* saut de DerotStep/1000 * Fsymbol */
pParams->Ttiming = CalcTimingTimeConstant(pParams->SymbolRate);
pParams->Tderot = 2 + CalcDerotTimeConstant(pParams->SymbolRate);
pParams->Tdata = 2 + CalcDataTimeConstant(errorrate,sn,to,hy,pParams->SymbolRate);
TUNER_TUNER_CRITICAL ( do_report ( severity_info, "TSP => iMaxLnbDrift[%d]\n",iMaxLnbDrift));
TUNER_TUNER_CRITICAL ( do_report ( severity_info, "TSP => WaitTime ( AGC1[%d] AGC2[%d] TimeLoop[%d] )\n",
pParams -> Tagc1,
pParams -> Tagc2,
pParams -> Ttiming ) );
TUNER_TUNER_CRITICAL ( do_report ( severity_info, "TSP => DerotStep[%d] WaitTime ( Derot[%d] Data[%d])\n",
pParams -> DerotStep,
pParams -> Tderot,
pParams -> Tdata ) );
}
pParams -> Frequency = iCurTunedFreq;
pParams -> Direction = 1;
sDerotatorLimit = ( iMaxLnbDrift * 1000 ) / pParams -> Mclk;
TUNER_TUNER_CRITICAL ( do_report ( severity_info, "TSP => DerotLimit[%d] MasterClock[%d] Mclk[%d]\n",
sDerotatorLimit,
pParams -> MasterClock,
pParams -> Mclk ) );
UPDATE_TUNER_STATE ( TUNER_SETUP_PARAMS, TUNER_SIGNAL_DETECTION );
break;
case TUNER_SIGNAL_DETECTION:
/* Move the tuner */
pParams -> Frequency = TunerSetFrequency ( pParams -> Frequency );
sDerotatorFreqWritten = 0;
RegSetField ( CFD_ALGO, 1 );
FieldSetVal ( DEROTATORFREQUENCYMSB, MSB ( sDerotatorFreqWritten ) );
FieldSetVal ( DEROTATORFREQUENCYLSB, LSB ( sDerotatorFreqWritten ) );
RegSetRegisters(R_CFRM,2); /* Reset the derotator frequency */
/* Wait for agc1,agc2 and timing loop */
MILLI_DELAY ( pParams -> Tagc1 + pParams -> Tagc2 + pParams -> Ttiming );
WaitTuner ( 100 ); /* Is tuner Locked ? (wait 100 ms maxi) */
if ( CheckAgc1 ( pParams ) < AGC1SATURATION )
{
/* find next offset to the tuner */
iTunerOffset = 0;
pParams -> TunerOffset = 0;
pParams -> Frequency = TunerSetFrequency ( pParams -> BaseFreq );
MILLI_DELAY ( 20 );
break;
}
UPDATE_TUNER_STATE ( TUNER_SIGNAL_DETECTION, TUNER_TIMING_DETECTION );
StillLocked = false;
break;
case TUNER_TIMING_DETECTION:
TUNER_TUNER_CRITICAL ( do_report ( severity_info, "TTD => TUNER_TIMING_DETECTION entered\n"));
if ( pParams -> SymbolRate <= ( pParams -> TunerBW / 2L ) )
{
SearchTiming ( pParams, pResult ); /* For low rates (SCPC) */
}
else
{
/* LP 101100 - Oblige SearchTiming whatever MCPC/SCPC */
SearchTiming ( pParams, pResult ); /* CheckTiming ( pParams ); */ /* For high rates (MCPC) */
}
if ( pParams -> State == TIMINGOK )
{
DEMOD_CenterTimingLoop ( pParams );
UPDATE_TUNER_STATE ( TUNER_TIMING_DETECTION,
TUNER_CARRIER_DETECTION );
}
else
{
UPDATE_TUNER_STATE ( TUNER_TIMING_DETECTION,
TUNER_SIGNAL_DETECTION );
}
break;
case TUNER_CARRIER_DETECTION:
/* Search carrier */
iTunerPeriodicReportCnt = 0;
bImageTried = FALSE;
#ifdef CENTER_TUNER_AT_STARTUP
/* center TUNER_FREQ before doing Zig-Zag scan */
DEMOD_TunerCentering ( pParams );
#endif
RegSetField ( CFD_ALGO, 1 );
while ( iCurTunerTaskState == TUNER_CARRIER_DETECTION )
{
/*
* start Zig-Zag scan
*/
sDerotatorFreqWritten = 0;
while ( sDerotatorFreqWritten < sDerotatorLimit )
{
/*
* test whether carrier is there or not
*/
if ( CheckCarrier ( pParams ) == CARRIEROK )
{
/* read the derotator frequency */
RegGetRegisters ( R_CFRM, 2 );
sDerotatorFreqRead = MAKEWORD ( FieldGetVal ( DEROTATORFREQUENCYMSB ),
FieldGetVal ( DEROTATORFREQUENCYLSB ) );
ucStatusRead = ( BYTE ) RegGetOneRegister ( R_VSTATUS );
TUNER_TUNER_CRITICAL ( do_report ( severity_info, "TCC => Carrier found [%X] at Derot R[%d] W[%d] TF[%d] TO[%d]\n",
ucStatusRead,
sDerotatorFreqRead,
sDerotatorFreqWritten,
pParams -> Frequency,
iTunerOffset ) );
if ( DEMOD_SearchData ( pParams ) == DATAOK )
{
/* read the derotator frequency */
RegGetRegisters ( R_CFRM, 2 );
sDerotatorFreqRead = MAKEWORD ( FieldGetVal ( DEROTATORFREQUENCYMSB ),
FieldGetVal ( DEROTATORFREQUENCYLSB ) );
ucStatusRead = ( BYTE ) RegGetOneRegister ( R_VSTATUS );
TUNER_TUNER_CRITICAL ( do_report ( severity_info, "TCC => Data found [%X] at Derotator [%d]\n",
ucStatusRead,
sDerotatorFreqRead ) );
if ( DEMOD_TunerCentering ( pParams ) == DATAOK )
{
/*
* tuner is in locked state goto TCF state
*/
UPDATE_TUNER_STATE ( TUNER_CARRIER_DETECTION,
TUNER_MONITOR_TUNING );
break;
}
}
/* If data is found already then break this Zig-Zag loop */
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -