frequencyscanner.cpp

QAM module to use in Java with an easy interface and powerful performance

                                        //posible 4f
                                        double dj=((double)j)+(outinternalave[j-1]-outinternalave[j+1])/(2*(outinternalave[j+1]+outinternalave[j-1]-2*outinternalave[j]));
                                        double dk=((double)k)+(outinternalave[k-1]-outinternalave[k+1])/(2*(outinternalave[k+1]+outinternalave[k-1]-2*outinternalave[k]));
                                        double pf=((dk)/4.0)*(gSettings.Common.Samplerate)/((double)N);
                                        double pg=pf/((dj)*(gSettings.Common.Samplerate)/((double)N));;


                                        PosibleFrequencySettings[PosibleFrequencySettingsPtr].Gamma=SimpleRoundTo(pg,-2);//pg;



                                        PosibleFrequencySettings[PosibleFrequencySettingsPtr].SignalPower=(outinternalave[j]+outinternalave[k]);//af+as;



                                        double arem=fabs(PosibleFrequencySettings[PosibleFrequencySettingsPtr].Gamma-pg);

                                        // if gammga looks good freq is above a min and power is above the lowest entry and power good then add to the list
                                        if(
                                                (pf>=MIN_FREQ_TO_SEARCH_FOR)&&(arem<0.001)
                                                &&
                                                (PosibleFrequencySettings[PosibleFrequencySettingsPtr].SignalPower>20.0)
                                                &&
                                                (PosibleFrequencySettings[PosibleFrequencySettingsPtr].Gamma>0.5)
                                          )
                                        {
                                                PosibleFrequencySettings[PosibleFrequencySettingsPtr].Freq=SimpleRoundTo(pf,-3);//pf;

                                                if(
                                                (SimpleRoundTo(PosibleFrequencySettings[PosibleFrequencySettingsPtr].Freq,0)==SimpleRoundTo(WorkingSettings.Freq,0))
                                                &&
                                                (PosibleFrequencySettings[PosibleFrequencySettingsPtr].Gamma==WorkingSettings.Gamma)
                                                  )
                                                {
                                                        TmpWorkingSettingStillValid=true;
                                                }

                                                //-- order from most likely to least likely
                                                for(int l=PosibleFrequencySettingsPtr;l>=1;l--)
                                                {
                                                        if(PosibleFrequencySettings[l].SignalPower>PosibleFrequencySettings[l-1].SignalPower)
                                                        {
                                                                FrequencySetting TmpSetting;
                                                                TmpSetting.Gamma=PosibleFrequencySettings[l].Gamma;
                                                                TmpSetting.Freq=PosibleFrequencySettings[l].Freq;
                                                                TmpSetting.SignalPower=PosibleFrequencySettings[l].SignalPower;
                                                                PosibleFrequencySettings[l].Gamma=PosibleFrequencySettings[l-1].Gamma;
                                                                PosibleFrequencySettings[l].Freq=PosibleFrequencySettings[l-1].Freq;
                                                                PosibleFrequencySettings[l].SignalPower=PosibleFrequencySettings[l-1].SignalPower;
                                                                PosibleFrequencySettings[l-1].Gamma=TmpSetting.Gamma;
                                                                PosibleFrequencySettings[l-1].Freq=TmpSetting.Freq;
                                                                PosibleFrequencySettings[l-1].SignalPower=TmpSetting.SignalPower;
                                                        }
                                                         else break;
                                                }
                                                //--
                                                if(PosibleFrequencySettingsPtr<MAX_NUMBER_OF_POSIBLE_FREQS_TO_TRY)PosibleFrequencySettingsPtr++;
                                        }
                                }
                        }
                }
        }

        NoteForMain=true;

        WorkingSettingStillValid=TmpWorkingSettingStillValid;
}

bool __fastcall FrequencyScanner::GetNextSetting()
{
        for(;CopyOfPosibleFrequencySettingsPtr<CopyOfPosibleFrequencySettingsSize;CopyOfPosibleFrequencySettingsPtr++)
        {
                WorkingSettings.Freq=CopyOfPosibleFrequencySettings[CopyOfPosibleFrequencySettingsPtr].Freq;
                WorkingSettings.Gamma=CopyOfPosibleFrequencySettings[CopyOfPosibleFrequencySettingsPtr].Gamma;
                WorkingSettings.SignalPower=CopyOfPosibleFrequencySettings[CopyOfPosibleFrequencySettingsPtr].SignalPower;
                if(CheckIfWorkingIsStillValid())
                {
                        CopyOfPosibleFrequencySettingsPtr++;
                        return true;
                }
        }

       if(PosibleFrequencySettingsPtr>0)
        {
                CopyPosibleFreqSettings();
                WorkingSettings.Freq=CopyOfPosibleFrequencySettings[0].Freq;
                WorkingSettings.Gamma=CopyOfPosibleFrequencySettings[0].Gamma;
                WorkingSettings.SignalPower=CopyOfPosibleFrequencySettings[0].SignalPower;
                WorkingSettingStillValid=true;
                CopyOfPosibleFrequencySettingsPtr++;
                return true;
        }
         else WorkingSettingStillValid=false;


        return false;
}

void __fastcall FrequencyScanner::CopyPosibleFreqSettings()
{
        for(int i=0;i<PosibleFrequencySettingsPtr;i++)
        {
                CopyOfPosibleFrequencySettings[i].Freq=PosibleFrequencySettings[i].Freq;
                CopyOfPosibleFrequencySettings[i].Gamma=PosibleFrequencySettings[i].Gamma;
                CopyOfPosibleFrequencySettings[i].SignalPower=PosibleFrequencySettings[i].SignalPower;
        }
        CopyOfPosibleFrequencySettingsSize=PosibleFrequencySettingsPtr;
        CopyOfPosibleFrequencySettingsPtr=0;
}

void __fastcall FrequencyScanner::Update(short * Data, int size)
{
        if(invest->Working)
        {
                return;
        }
        for(int i=0;i<size;i+=2)
        {
                double sig=(((double)Data[i])+((double)Data[i+1]));
                SigLevel=SigLevel*0.99999+0.00001*sig*sig*0.000001;
                in[NPtr]=sqrt((fabs(sig)));
                NPtr++;NPtr%=N;
                if(NPtr==0)
                {
                        invest->ThreadTheXForm();
                        //where is this bug test below and above
                        //DoTheXform();
                        break;
                }
        }
}


__fastcall FrequencyScanner::DoTheXform(void)
{
                        fftw_execute(p);
                        //----------
                        outinternalavepos++;
                        if(((!gSettings.DemodMinor.SlowLock)&&(outinternalavepos>=FREQ_SCANNER_INTERNAL_AVE_NUMBER))||((gSettings.DemodMinor.SlowLock)&&(outinternalavepos>=(2*FREQ_SCANNER_INTERNAL_AVE_NUMBER))))
                        {
                                outinternalavepos=0;
                                outinternalaveworking[0]=0.0;
                                for(int j=0;j<(N_2);j++)
                                {
                                        MASum-=MABuf[MAPtr];
                                        MABuf[MAPtr]=outinternalaveworking[j];
                                        MASum+=MABuf[MAPtr];
                                        MAPtr++;MAPtr%=MABuf.size();

                                        if((j-20)>=0)
                                        {

                                                outinternalave[j-20]=outinternalaveworking[j-20]-MASum/MABuf.size();
                                                outinternalaveworking[j-20]=0.0;

                                                MASum2-=MABuf2[MAPtr2];
                                                MABuf2[MAPtr2]=fabs(outinternalave[j-20]);
                                                MASum2+=MABuf2[MAPtr2];
                                                MAPtr2++;MAPtr2%=MABuf2.size();

                                                if((j-70)>=0) if(MASum2>0.0)outinternalave[j-70]/=(MASum2/MABuf2.size());
                                        }

                                }
                                for(int j=0;j<20;j++)
                                {
                                        outinternalaveworking[j]=0.0;
                                        outinternalave[j]=0.0;
                                }
                                for(int j=N_2-70;j<(N_2);j++)
                                {
                                        outinternalave[j]=0.0;
                                }
                                LoadPosibleFrequencys();
                        }
                        for(register int j=1;j<(N_2);j++)outinternalaveworking[j]+=(out[j]*out[j]+out[N-j]*out[N-j]);//fabs(out[j])+fabs(out[N-j]);//
                        //----------
}

bool __fastcall FrequencyScanner::CheckIfWorkingIsStillValid()
{
        for(int i=0;i<PosibleFrequencySettingsPtr;i++)
        {
                if(
                (SimpleRoundTo(PosibleFrequencySettings[i].Freq,0)==SimpleRoundTo(WorkingSettings.Freq,0))
                &&
                (PosibleFrequencySettings[i].Gamma==WorkingSettings.Gamma)
                )
                {
                        WorkingSettingStillValid=true;
                        return true;
                }
        }
        WorkingSettingStillValid=false;
        return false;
}