tmbsl10086scanauto.c

卫星接收机器卫星 自动搜索, 包括优化处理

    {
        SEND_TRACEAUTOSR1(0x0006, 0);
        if((psObject->puRegion[uCounter].uDelta <= psObject->sConfig.uDeltaThreshold) ||
           (psObject->puRegion[uCounter].uMax - psObject->puRegion[uCounter].uMin <= MAX_MIN_THRESHOLD) ||
//           (psObject->puRegion[uCounter].uTriangle > MIN_TRIANGLE) ||
           (psObject->puRegion[uCounter].uSrMin >= MAX_SR_SCAN) ||
           (psObject->puRegion[uCounter].uSrMax - psObject->puRegion[uCounter].uSrMin == 0) ||
           (psObject->puRegion[uCounter].uSrMax <  MIN_SR_SCAN) )
        {
            // Remove region
            SEND_TRACEAUTOSR1(0x8029, uCounter);
            SEND_TRACEAUTOSR1(0x8027,psObject->puRegion[uCounter].uRfMin/2 + psObject->puRegion[uCounter].uRfMax/2);
            if (psObject->puRegion[uCounter].uDelta <= psObject->sConfig.uDeltaThreshold)
            {
                SEND_TRACEAUTOSR1(0x8012, psObject->puRegion[uCounter].uDelta);
            }
            if ((psObject->puRegion[uCounter].uMax - psObject->puRegion[uCounter].uMin) <= MAX_MIN_THRESHOLD)           
            {
                SEND_TRACEAUTOSR1(0x8017, psObject->puRegion[uCounter].uMax - psObject->puRegion[uCounter].uMin);
            }
            if (psObject->puRegion[uCounter].uSrMin >= MAX_SR_SCAN);
            {
                SEND_TRACEAUTOSR1(0x8003, psObject->puRegion[uCounter].uSrMin);
            }
            if (psObject->puRegion[uCounter].uTriangle < MIN_TRIANGLE)
            {
                SEND_TRACEAUTOSR1(0x8034, psObject->puRegion[uCounter].uTriangle);
            }
            if (psObject->puRegion[uCounter].uSrMax - psObject->puRegion[uCounter].uSrMin == 0);
            {
                SEND_TRACEAUTOSR1(0x8013, psObject->puRegion[uCounter].uSrMin);
            }
            if (psObject->puRegion[uCounter].uSrMax < MIN_SR_SCAN);
            {
                SEND_TRACEAUTOSR1(0x8004, psObject->puRegion[uCounter].uSrMax);
            }
        }
        else
        {
            psObject->puRegion[uLastValidRegion] = psObject->puRegion[uCounter];
            SEND_TRACEAUTOSR1(0x802A, uLastValidRegion);
            uLastValidRegion++;
            SEND_TRACEAUTOSR1(0x8027, psObject->puRegion[uCounter].uRfMin/2 + psObject->puRegion[uCounter].uRfMax/2);
            SEND_TRACEAUTOSR1(0x8001, psObject->puRegion[uCounter].uRfMin);
            SEND_TRACEAUTOSR1(0x8002, psObject->puRegion[uCounter].uRfMax);
            SEND_TRACEAUTOSR1(0x8004, psObject->puRegion[uCounter].uSrMax);
            SEND_TRACEAUTOSR1(0x8003, psObject->puRegion[uCounter].uSrMin);
            SEND_TRACEAUTOSR1(0x800c, psObject->puRegion[uCounter].uDelta);
            SEND_TRACEAUTOSR1(0x8017, psObject->puRegion[uCounter].uMax - psObject->puRegion[uCounter].uMin);
            #ifdef BSL_DEBUG_GREEN_TRACE
            {
                if (psObject->puRegion[uCounter].uDelta >= psObject->sConfig.uDeltaThreshold)
                {
                    UInt32 uFreq;

                    for (uFreq = psObject->puRegion[uCounter].uRfMin; uFreq <= psObject->puRegion[uCounter].uRfMax; uFreq += DISPLAY_STEP)
                    {
//                        SEND_TRACESPECTRUM(TRACE_GREEN, DEBUG_XY, FREQ2INDEX(uFreq), psObject->puRegion[uCounter].uMax);
                    }
                }
            }
            #endif
        }
    }

    psObject->uNbRegion = uLastValidRegion;

    SEND_TRACEAUTOSR1(0x0006,0);
    SEND_TRACEAUTOSR1(0x0006,0);
    SEND_TRACEAUTOSR1(0x8006,uLastValidRegion);
    SEND_TRACEAUTOSR1(0x0006,0);
    SEND_TRACEAUTOSR1(0x0006,0);

    return True;
}

int comp(const int *px, const int *py)
{
    if(*px < *py)
        return(-1);
    else if(*px == *py)
        return(0);
    else
        return(1);
}


//-----------------------------------------------------------------------------
// FUNCTION:    Tda10086PreAnalyzer
//
// DESCRIPTION: 
//
// RETURN:      TDA10086_ALGO_SUCCESS_RET
//              TDA10086_ALGO_FAILED_RET
//              TDA10086_ALGO_NOT_FINISHED_RET
//
// NOTES:       psObject->bStateSpectrum is used to control the State 
//              of the algorithm
//-----------------------------------------------------------------------------
//
tmErrorCode_t
Tda10086PreAnalyzer(
    tm10086object_t *psObject
)
{
    UInt32 uSweepRange = 22000;
    UInt32 uScanStep = 25000;

    static Int32  iVagcN_Offset = 0;
    static UInt32 uVagcN = 0;
    UInt32 uAFS = 1;
    UInt32 uAFG = 5;
    UInt32 uDFN = 4;
    UInt32 uNYQG = 2;
    UInt32 uGSEL = 0;

    double lFTUNStep;
    Int32  iFTUNStep;
    static Int32  iFTUNStepLoop = 0;
    double lFTUNRange;
    static Int32  iMinFTUN = 0;
    static Int32  iMaxFTUN = 0;

    static UInt32 uStepRF = 0;
    static UInt32 uStartRF = 0;
    static UInt32 uStopRF = 0;

    Int32  iFTUN;
    UInt32 uByte, puByte[2];
    Int32  iFTUN_MSB, iFTUN_LSB;
    double lOffset;
    UInt32 uRF2;

    UInt32 uNewVagcN;
//    Int32  iVagcNMod;
    UInt32    uGauto;

//    UInt32 uNEST;

    double lFreqRange;

    SEND_TRACE_CALLS(0x003C,0);

    if (psObject->bStateSpectrum == 2)
    {
        return TDA10086_ALGO_SUCCESS_RET;
    }
    else if (psObject->bStateSpectrum == 0)
    {

        lFTUNStep  = (double)(uScanStep);
        lFTUNStep *= 1000;
        lFTUNStep *= (1 << 16);
        lFTUNStep /= (double)(psObject->uSysClk);
        iFTUNStep  = (Int32)lFTUNStep;

        iFTUNStepLoop = -iFTUNStep;

        lFTUNRange  = (double)(uSweepRange);
        lFTUNRange *= 1000;
        lFTUNRange *= (1<<16);
        lFTUNRange /= (double)(psObject->uSysClk);

        iMinFTUN = (Int32)lFTUNRange;
        iMaxFTUN = (Int32)(-lFTUNRange);

        lFreqRange  = lFTUNRange;
        lFreqRange *= (double)(psObject->uSysClk);
        lFreqRange /= (1<<16);

        uStepRF = (UInt32)(2 * lFreqRange);
        uStartRF = psObject->uStartFrequency + (UInt32)(lFreqRange);
        uStopRF = psObject->uStopFrequency;



        // set SR to 1Mbauds
        psObject->sCurrentChannel.uSR = 1000000;
        Tda10086WriteSR(psObject,&psObject->sCurrentChannel.uSR);
        psObject->sCurrentChannel.uSR = 1000000;

        // set RF to start frequency
        psObject->sCurrentChannel.uRF = psObject->uStartFrequency;
        Tda10086WriteRF(psObject,&psObject->sCurrentChannel.uRF);

        // Set Auto Spectral inversion
        psObject->systemFunc.SY_WriteBit(
            psObject->uDemodHwAdd, 
            TDA10086_CONF_IND, 
            TDA10086_CONF_SPECINV_MSK, 
            TDA10086_CONF_AUTOSPECINV_VAL);

        // Set Auto viterbi
        psObject->systemFunc.SY_WriteBit(
            psObject->uDemodHwAdd,
            TDA10086_RATE_IND,
            TDA10086_RATE_RAUTO_MSK, 
            TDA10086_RATE_RAUTO_BIT);


        // Write FCONF: AFS,AFG,DFN
        uByte = (uAFS << 7) | (uAFG << 3) | (uDFN);
        psObject->systemFunc.SY_Write(
            psObject->uDemodHwAdd, 
            TDA10086_FCONF_IND, 
            1, 
            &uByte);

        // Write GSEL = 0
        uGSEL=0;
        psObject->systemFunc.SY_WriteBit(
            psObject->uDemodHwAdd, 
            TDA10086_AGCRA_IND, 
            TDA10086_AGCRA_GSEL_MSK, 
            uGSEL<<6);

        // Write NYQG
        psObject->systemFunc.SY_WriteBit(
            psObject->uDemodHwAdd, 
            TDA10086_AGCRN_IND, 
            TDA10086_AGCRN_NYQG_MSK, 
            uNYQG << 6);


        psObject->sCurrentChannel.uRF = uStartRF;

        psObject->bStateSpectrum++;

        return TDA10086_ALGO_NOT_FINISHED_RET;

    }
    else if (psObject->bStateSpectrum == 1)
    {

        // open the IIC BUS for the Tuner
        psObject->systemFunc.SY_WriteBit(
                psObject->uDemodHwAdd, 
                TDA10086_CLEAR_IND, 
                TDA10086_CLEAR_IICTRL_MSK, 
                TDA10086_CLEAR_IICTRL_MSK);    

        // call the tuner function
        psObject->tunerFunc.setRfFunc(psObject->eTunerUnit, psObject->sCurrentChannel.uRF);
//        SEND_TRACESPECTRUM(TRACE_RED, DEBUG_XY, FREQ2INDEX(psObject->sCurrentChannel.uRF), 25);
    
        // close the IIC BUS
        psObject->systemFunc.SY_WriteBit(
                psObject->uDemodHwAdd, 
                TDA10086_CLEAR_IND, 
                TDA10086_CLEAR_IICTRL_MSK, 
                0);

        psObject->tunerFunc.getRfFunc(psObject->eTunerUnit, &(psObject->sCurrentChannel.uRF));


        // CLBCAR = 0: Clear the carrier recovery loop
        psObject->systemFunc.SY_WriteBit(
            psObject->uDemodHwAdd, 
            TDA10086_CARINIT_IND, 
            TDA10086_CARINIT_CLBCAR_MSK, 
            0x00);


        for(iFTUN = iMinFTUN; iFTUN >= iMaxFTUN ; iFTUN += iFTUNStepLoop)
        {
            lOffset  = (double)iFTUN;
            lOffset *= psObject->uSysClk;
            lOffset /= (1 << 16);
            uRF2 = psObject->sCurrentChannel.uRF - (Int32)lOffset;

            if(uRF2 > uStopRF)
                break;

            iFTUN_MSB = iFTUN >> 8;
            iFTUN_LSB = iFTUN & 0xFF;

            puByte[0] = 0x80 | (iFTUN_MSB & 0x7F);    //POSMUL
            puByte[1] = iFTUN_LSB;


            psObject->systemFunc.SY_Write(
                psObject->uDemodHwAdd, 
                TDA10086_FTUNMSB_IND, 
                2, 
                puByte);

            if(iFTUN == iMinFTUN)
            {
                Tda10086InitTick(psObject, 20);
                while (Tda10086WaitTick(psObject) == False);
            }

            psObject->systemFunc.SY_Read(
                psObject->uDemodHwAdd, 
                TDA10086_VAGCN_IND, 
                1, 
                &uNewVagcN);

            psObject->systemFunc.SY_Read(
                psObject->uDemodHwAdd, 
                TDA10086_GAUTO_IND, 
                1, 
                &uGauto);

            uGFARA = uGauto & TDA10086_GAUTO_GFARA_MSK;
            uGNYQA = (uGauto & TDA10086_GAUTO_GNYQA_MSK) >> 4;

            AverageGFARA = (AverageGFARA*NbSamples + uGFARA*1000)/(NbSamples+1);
            AverageGNYQA = (AverageGNYQA*NbSamples + uGNYQA*1000)/(NbSamples+1);
            NbSamples++;

//            SEND_TRACEAUTOSR2(0x803F,uGauto);

//            SEND_TRACEAUTOSR2(0x803D,uGFARA);

//            SEND_TRACEAUTOSR2(0x803E,uGNYQA);

//            SEND_TRACEAUTOSR2(0x8040,NbSamples);
//            SEND_TRACEAUTOSR2(0x8041,AverageGFARA);
//            SEND_TRACEAUTOSR2(0x8042,AverageGNYQA);


        }

        psObject->sCurrentChannel.uRF += uStepRF;


        if(psObject->sCurrentChannel.uRF >= (uStopRF+uStepRF))
        {
            psObject->bStateSpectrum++;

            // Write GSEL
            uGSEL = 0;
            psObject->systemFunc.SY_WriteBit(
                psObject->uDemodHwAdd, 
                TDA10086_AGCRA_IND, 
                TDA10086_AGCRA_GSEL_MSK, 
                uGSEL<<6);

            iVagcN_Offset = 0;
            uVagcN = 0;

            SEND_TRACEAUTOSR2(0x8041,AverageGFARA);
            SEND_TRACEAUTOSR2(0x8042,AverageGNYQA);
            uGFARA = (AverageGFARA + 500)/1000;
            uGNYQA = (AverageGNYQA + 500)/1000;

            SEND_TRACEAUTOSR2(0x8040,NbSamples);
            SEND_TRACEAUTOSR2(0x803D,uGFARA);
            SEND_TRACEAUTOSR2(0x803E,uGNYQA);

            psObject->bStateSpectrum = 0;

            return TDA10086_ALGO_SUCCESS_RET;
        }
    }
    return TM_OK;
}



//-----------------------------------------------------------------------------
// FUNCTION:    Tda10086SpectrumAnalyzer
//
// DESCRIPTION: 
//
// RETURN:      TDA10086_ALGO_SUCCESS_RET
//              TDA10086_ALGO_FAILED_RET
//              TDA10086_ALGO_NOT_FINISHED_RET
//
// NOTES:       psObject->bStateSpectrum is used to control the State 
//              of the algorithm
//-----------------------------------------------------------------------------
//
tmErrorCode_t
Tda10086SpectrumAnalyzer(
    tm10086object_t *psObject
)
{
    UInt32 uSweepRange = 22000;
    UInt32 uScanStep = 250;

    static Int32  iVagcN_Offset = 0;
    static UInt32 uVagcN = 0;
    UInt32 uAFS = 1;
    UInt32 uAFG = uGFARA;
//    UInt32 uAFG = 7;
    UInt32 uDFN = 4;
    UInt32 uNYQG = uGNYQA;
//    UInt32 uNYQG = 1;
    UInt32 uGSEL = 1;