def probeData(settings):
print "Probing data", settings.fileName
samplesPerCode = int(
round(settings.samplingFreq /
(settings.codeFreqBasis / settings.codeLength)))
samples = getSamples.int8(settings.fileName, 10 * samplesPerCode,
settings.skipNumberOfBytes)
#Initialize figure
fig = pylab.figure()
pylab.clf()
#X axis
timeScale = [x*(1/settings.samplingFreq) for x in \
range(0,int(round((5e-3 + 1/settings.samplingFreq)*settings.samplingFreq)))]
#Time domain plot
pylab.subplot(2, 2, 1)
plot_max = int(round(samplesPerCode / 50))
pylab.plot([1000 * i for i in timeScale[0:plot_max]], samples[0:plot_max])
pylab.title('Time domain plot')
pylab.xlabel('Time (ms)')
pylab.ylabel('Amplitude')
#Frequency domain plot
(Pxx,freqs) = matplotlib.mlab.psd(x = samples-numpy.mean(samples),\
noverlap = 1024,\
NFFT = 2048,\
Fs = settings.samplingFreq/1e6)
pylab.subplot(2, 2, 2)
pylab.semilogy(freqs, Pxx)
pylab.title('Frequency Domain Plot')
pylab.xlabel('Frequency (MHz)')
pylab.ylabel('Magnitude')
#Histogram
pylab.subplot(2, 2, 3)
xticks = pylab.unique(samples)
pylab.hist(samples, len(xticks))
axis = pylab.axis()
pylab.axis([min(samples), max(samples), axis[2], axis[3]])
xticks = pylab.unique(pylab.round_(xticks))
pylab.xticks(xticks)
pylab.title('Histogram')
return fig
def probeData(settings):
print "Probing data", settings.fileName
samplesPerCode = int(round(settings.samplingFreq / (settings.codeFreqBasis / settings.codeLength)))
samples = getSamples.int8(settings.fileName,10*samplesPerCode,settings.skipNumberOfBytes)
#Initialize figure
fig = pylab.figure()
pylab.clf()
#X axis
timeScale = [x*(1/settings.samplingFreq) for x in \
range(0,int(round((5e-3 + 1/settings.samplingFreq)*settings.samplingFreq)))]
#Time domain plot
pylab.subplot(2,2,1)
plot_max = int(round(samplesPerCode/50))
pylab.plot([1000*i for i in timeScale[0:plot_max]],samples[0:plot_max])
pylab.title('Time domain plot')
pylab.xlabel('Time (ms)')
pylab.ylabel('Amplitude')
#Frequency domain plot
(Pxx,freqs) = matplotlib.mlab.psd(x = samples-numpy.mean(samples),\
noverlap = 1024,\
NFFT = 2048,\
Fs = settings.samplingFreq/1e6)
pylab.subplot(2,2,2)
pylab.semilogy(freqs,Pxx)
pylab.title('Frequency Domain Plot')
pylab.xlabel('Frequency (MHz)')
pylab.ylabel('Magnitude')
#Histogram
pylab.subplot(2,2,3)
xticks = pylab.unique(samples)
pylab.hist(samples,len(xticks))
axis = pylab.axis()
pylab.axis([min(samples),max(samples),axis[2],axis[3]])
xticks = pylab.unique(pylab.round_(xticks))
pylab.xticks(xticks)
pylab.title('Histogram');
return fig
#Initialize constants, settings
settings = initSettings()
#Generate plot of raw data
if settings.plotSignal:
print "Plotting data", settings.fileName
probeFigure = probeData(settings)
pylab.draw()
#Do acquisition
#Get 11ms of acquisition samples for fine frequency estimation
samplesPerCode = int(
round(settings.samplingFreq /
(settings.codeFreqBasis / settings.codeLength)))
acqSamples = getSamples.int8(settings.fileName, 11 * samplesPerCode,
settings.skipNumberOfBytes)
if settings.skipAcquisition:
print "\nLoading old acquisition results ...",
acqResults = pickle.load(open("acqResults.pickle", "rb"))
print "done"
else:
print "\nAcquiring satellites ...",
acqResults = acquisition(acqSamples, settings)
pickle.dump(acqResults, open("acqResults.pickle", "wb"))
# print "done"
if settings.plotAcquisition:
acqFigure = plotAcquisition(acqResults, settings)
pylab.draw()
#Do tracking
#Find if any satellites were acquired
def track(samples, channel, settings):
#Create list of tracking channels results (correlations, freqs, etc)
trackResults = [trackResults_class(settings) for i in range(len(channel))]
#Initialize tracking variables
codePeriods = settings.msToProcess
##DLL Variables##
#Define early-late offset
earlyLateSpc = settings.dllCorrelatorSpacing
#Summation interval
PDIcode = 0.001
#Filter coefficient values
(tau1code, tau2code) = calcLoopCoef(settings.dllNoiseBandwidth,settings.dllDampingRatio,1.0)
##PLL Variables##
PDIcarr = 0.001
(tau1carr,tau2carr) = calcLoopCoef(settings.pllNoiseBandwidth,settings.pllDampingRatio,0.25)
progbar = Waitbar(True)
#Do tracking for each channel
for channelNr in range(len(channel)):
trackResults[channelNr].PRN = channel[channelNr].PRN
#Get a vector with the C/A code sampled 1x/chip
caCode = np.array(generateCAcode(channel[channelNr].PRN))
#Add wrapping to either end to be able to do early/late
caCode = np.concatenate(([caCode[1022]],caCode,[caCode[0]]))
#Initialize phases and frequencies
codeFreq = settings.codeFreqBasis
remCodePhase = 0.0 #residual code phase
carrFreq = channel[channelNr].acquiredFreq
carrFreqBasis = channel[channelNr].acquiredFreq
remCarrPhase = 0.0 #residual carrier phase
#code tracking loop parameters
oldCodeNco = 0.0
oldCodeError = 0.0
#carrier/Costas loop parameters
oldCarrNco = 0.0
oldCarrError = 0.0
#number of samples to seek ahead in file
numSamplesToSkip = settings.skipNumberOfBytes + channel[channelNr].codePhase
#Process the specified number of ms
for loopCnt in range(settings.msToProcess):
#Update progress every 50 loops
if (np.remainder(loopCnt,50)==0):
progbar.updated(float(loopCnt + channelNr*settings.msToProcess)\
/ float(len(channel)*settings.msToProcess))
# print "Channel %d/%d, %d/%d ms" % (channelNr+1,len(channel),loopCnt, settings.msToProcess)
#Update the code phase rate based on code freq and sampling freq
codePhaseStep = codeFreq/settings.samplingFreq
codePhaseStep = codePhaseStep*(10**12) #round it in the same way we are in octave
codePhaseStep = round(codePhaseStep)
codePhaseStep = codePhaseStep*(10**(-12))
blksize = int(np.ceil((settings.codeLength - remCodePhase)/codePhaseStep))
#Read samples for this integration period
rawSignal = np.array(getSamples.int8(settings.fileName,blksize,numSamplesToSkip))
numSamplesToSkip = numSamplesToSkip + blksize
#Define index into early code vector
tcode = np.r_[(remCodePhase-earlyLateSpc) : \
(blksize*codePhaseStep+remCodePhase-earlyLateSpc) : \
codePhaseStep]
earlyCode = caCode[np.int_(np.ceil(tcode))]
#Define index into late code vector
tcode = np.r_[(remCodePhase+earlyLateSpc) : \
(blksize*codePhaseStep+remCodePhase+earlyLateSpc) : \
codePhaseStep]
lateCode = caCode[np.int_(np.ceil(tcode))]
#Define index into prompt code vector
tcode = np.r_[(remCodePhase) : \
(blksize*codePhaseStep+remCodePhase) : \
codePhaseStep]
promptCode = caCode[np.int_(np.ceil(tcode))]
remCodePhase = (tcode[blksize-1] + codePhaseStep) - 1023
#Generate the carrier frequency to mix the signal to baseband
time = np.r_[0:blksize+1] / settings.samplingFreq #(seconds)
#Get the argument to sin/cos functions
trigarg = (carrFreq * 2.0 * math.pi)*time + remCarrPhase
remCarrPhase = np.remainder(trigarg[blksize],(2*math.pi))
#Finally compute the signal to mix the collected data to baseband
carrCos = np.cos(trigarg[0:blksize])
carrSin = np.sin(trigarg[0:blksize])
#Mix signals to baseband
qBasebandSignal = carrCos*rawSignal
iBasebandSignal = carrSin*rawSignal
#Get early, prompt, and late I/Q correlations
I_E = np.sum(earlyCode * iBasebandSignal)
Q_E = np.sum(earlyCode * qBasebandSignal)
I_P = np.sum(promptCode * iBasebandSignal)
Q_P = np.sum(promptCode * qBasebandSignal)
I_L = np.sum(lateCode * iBasebandSignal)
Q_L = np.sum(lateCode * qBasebandSignal)
#Find PLL error and update carrier NCO
#Carrier loop discriminator (phase detector)
carrError = math.atan(Q_P/I_P) / (2.0 * math.pi)
#Carrier loop filter and NCO
carrNco = oldCarrNco + (tau2carr/tau1carr) * \
(carrError-oldCarrError) + carrError*(PDIcarr/tau1carr)
oldCarrNco = carrNco
oldCarrError = carrError
#Modify carrier freq based on NCO
carrFreq = carrFreqBasis + carrNco
trackResults[channelNr].carrFreq[loopCnt] = carrFreq
#Find DLL error and update code NCO
codeError = (math.sqrt(I_E*I_E + Q_E*Q_E) - math.sqrt(I_L*I_L + Q_L*Q_L)) / \
(math.sqrt(I_E*I_E + Q_E*Q_E) + math.sqrt(I_L*I_L + Q_L*Q_L))
codeNco = oldCodeNco + (tau2code/tau1code)*(codeError-oldCodeError) \
+ codeError*(PDIcode/tau1code)
oldCodeNco = codeNco
oldCodeError = codeError
#Code freq based on NCO
codeFreq = settings.codeFreqBasis - codeNco
trackResults[channelNr].codeFreq[loopCnt] = codeFreq
#Record stuff for postprocessing
trackResults[channelNr].absoluteSample[loopCnt] = numSamplesToSkip
trackResults[channelNr].dllDiscr[loopCnt] = codeError
trackResults[channelNr].dllDiscrFilt[loopCnt] = codeNco
trackResults[channelNr].pllDiscr[loopCnt] = carrError
trackResults[channelNr].pllDiscrFilt[loopCnt] = carrNco
trackResults[channelNr].I_E[loopCnt] = I_E
trackResults[channelNr].I_P[loopCnt] = I_P
trackResults[channelNr].I_L[loopCnt] = I_L
trackResults[channelNr].Q_E[loopCnt] = Q_E
trackResults[channelNr].Q_P[loopCnt] = Q_P
trackResults[channelNr].Q_L[loopCnt] = Q_L
# print ("tR[%d].absoluteSample[%d] = %d" % (channelNr,loopCnt,trackResults[channelNr].absoluteSample[loopCnt]))
#
# print ("tR[%d].dllDiscr[%d] = %f" % (channelNr,loopCnt,trackResults[channelNr].dllDiscr[loopCnt]))
# print ("tR[%d].dllDiscrFilt[%d] = %f" % (channelNr,loopCnt,trackResults[channelNr].dllDiscrFilt[loopCnt]))
# print ("tR[%d].codeFreq[%d] = %f" % (channelNr,loopCnt,trackResults[channelNr].codeFreq[loopCnt]))
# print ("tR[%d].pllDiscr[%d] = %f" % (channelNr,loopCnt,trackResults[channelNr].pllDiscr[loopCnt]))
# print ("tR[%d].pllDiscrFilt[%d] = %f" % (channelNr,loopCnt,trackResults[channelNr].pllDiscrFilt[loopCnt]))
# print ("tR[%d].carrFreq[%d] = %f" % (channelNr,loopCnt,trackResults[channelNr].carrFreq[loopCnt]))
#
# print ("tR[%d].I_E[%d] = %f" % (channelNr,loopCnt,trackResults[channelNr].I_E[loopCnt]))
# print ("tR[%d].I_P[%d] = %f" % (channelNr,loopCnt,trackResults[channelNr].I_P[loopCnt]))
# print ("tR[%d].I_L[%d] = %f" % (channelNr,loopCnt,trackResults[channelNr].I_L[loopCnt]))
# print ("tR[%d].Q_E[%d] = %f" % (channelNr,loopCnt,trackResults[channelNr].Q_E[loopCnt]))
# print ("tR[%d].Q_P[%d] = %f" % (channelNr,loopCnt,trackResults[channelNr].Q_P[loopCnt]))
# print ("tR[%d].Q_L[%d] = %f" % (channelNr,loopCnt,trackResults[channelNr].Q_L[loopCnt]))
# print ""
#Possibility for lock-detection later
trackResults[channelNr].status = 'T'
print ""
return (trackResults,channel)
print 'is free software you are welcome to redistribute it under'
print 'the terms described in the license.'
#Initialize constants, settings
settings = initSettings()
#Generate plot of raw data
if settings.plotSignal:
print "Plotting data", settings.fileName
probeFigure = probeData(settings)
pylab.draw()
#Do acquisition
#Get 11ms of acquisition samples for fine frequency estimation
samplesPerCode = int(round(settings.samplingFreq / (settings.codeFreqBasis / settings.codeLength)))
acqSamples = getSamples.int8(settings.fileName,11*samplesPerCode,settings.skipNumberOfBytes)
if settings.skipAcquisition:
print "\nLoading old acquisition results ...",
acqResults = pickle.load(open("acqResults.pickle","rb"))
print "done"
else:
print "\nAcquiring satellites ...",
acqResults = acquisition(acqSamples,settings)
pickle.dump(acqResults,open("acqResults.pickle","wb"))
# print "done"
if settings.plotAcquisition:
acqFigure = plotAcquisition(acqResults,settings)
pylab.draw()
#Do tracking
#Find if any satellites were acquired
else:
print ".",
sys.stdout.flush()
for i in range(32): #Add PRN number to each result
acqResults[i].append(i)
#Acquisition is over
print ")"
return acqResults
if __name__ == "__main__":
from initSettings import initSettings
import getSamples
from showChannelStatus import showChannelStatus
from preRun import preRun
from plotAcquisition import plotAcquisition
settings = initSettings()
#11 ms of samples
samplesPerCode = int(round(settings.samplingFreq / (settings.codeFreqBasis / settings.codeLength)))
acqSamples = getSamples.int8(settings.fileName,11*samplesPerCode,settings.skipNumberOfBytes)
print "Acquiring satellites ...",
acqResults = acquisition(acqSamples,settings)
acqFigure = plotAcquisition(acqResults,settings)
#if satellite wasn't found, pop it off the list
for i in range(32-1,-1,-1):
if acqResults[i][0] > settings.acqThreshold:
acqSuccessful = True
else:
acqResults.pop(i)
showChannelStatus(preRun(acqResults,settings),settings)
pylab.show()
return acqResults
if __name__ == "__main__":
from initSettings import initSettings
import getSamples
from showChannelStatus import showChannelStatus
from preRun import preRun
from plotAcquisition import plotAcquisition
settings = initSettings()
settings.fileName = '../gnss_signal_records/v2_3_samples.dat'
settings.IF = 4.092e6
settings.samplingFreq = 16.368e6
#11 ms of samples
samplesPerCode = int(
round(settings.samplingFreq /
(settings.codeFreqBasis / settings.codeLength)))
acqSamples = getSamples.int8(settings.fileName, 11 * samplesPerCode,
settings.skipNumberOfBytes)
print "Acquiring satellites ...",
acqResults = acquisition(acqSamples, settings)
acqFigure = plotAcquisition(acqResults, settings)
#if satellite wasn't found, pop it off the list
for i in range(32 - 1, -1, -1):
if acqResults[i][0] > settings.acqThreshold:
acqSuccessful = True
else:
acqResults.pop(i)
showChannelStatus(preRun(acqResults, settings), settings)
pylab.show()
