mirror of
https://github.com/gnss-sdr/gnss-sdr
synced 2025-10-25 04:27:39 +00:00
Remove build and data folders, move tests and utils to the base of the source tree
This commit is contained in:
Carles Fernandez
80
utils/matlab/dll_pll_veml_plot_sample.m
Normal file
80
utils/matlab/dll_pll_veml_plot_sample.m
Normal file
@@ -0,0 +1,80 @@
|
||||
% Reads GNSS-SDR Tracking dump binary file using the provided
|
||||
% function and plots some internal variables
|
||||
|
||||
% Javier Arribas, 2011. jarribas(at)cttc.es
|
||||
% Antonio Ramos, 2018. antonio.ramos(at)cttc.es
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% Copyright (C) 2010-2019 (see AUTHORS file for a list of contributors)
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
|
||||
close all;
|
||||
clear all;
|
||||
|
||||
if ~exist('dll_pll_veml_read_tracking_dump.m', 'file')
|
||||
addpath('./libs')
|
||||
end
|
||||
|
||||
samplingFreq = 3000000; %[Hz]
|
||||
plot_last_outputs=0;%1000;
|
||||
|
||||
channels = 1; % Number of channels
|
||||
first_channel = 0; % Number of the first channel
|
||||
|
||||
path = '/home/javier/git/gnss-sdr/install/test_inta/'; %% CHANGE THIS PATH
|
||||
|
||||
for N=1:1:channels
|
||||
tracking_log_path = [path 'tracking_ch_' num2str(N+first_channel-1) '.dat']; %% CHANGE track_ch_ BY YOUR dump_filename
|
||||
GNSS_tracking(N) = dll_pll_veml_read_tracking_dump(tracking_log_path);
|
||||
end
|
||||
|
||||
% GNSS-SDR format conversion to MATLAB GPS receiver
|
||||
|
||||
for N=1:1:channels
|
||||
trackResults(N).status = 'T'; %fake track
|
||||
if plot_last_outputs>0 && plot_last_outputs<length(GNSS_tracking(N).code_freq_hz)
|
||||
|
||||
start_sample=length(GNSS_tracking(N).code_freq_hz)-plot_last_outputs;
|
||||
else
|
||||
start_sample=1;
|
||||
end
|
||||
trackResults(N).codeFreq = GNSS_tracking(N).code_freq_hz(start_sample:end).';
|
||||
trackResults(N).carrFreq = GNSS_tracking(N).carrier_doppler_hz(start_sample:end).';
|
||||
trackResults(N).dllDiscr = GNSS_tracking(N).code_error(start_sample:end).';
|
||||
trackResults(N).dllDiscrFilt = GNSS_tracking(N).code_nco(start_sample:end).';
|
||||
trackResults(N).pllDiscr = GNSS_tracking(N).carr_error(start_sample:end).';
|
||||
trackResults(N).pllDiscrFilt = GNSS_tracking(N).carr_nco(start_sample:end).';
|
||||
|
||||
trackResults(N).I_P = GNSS_tracking(N).P(start_sample:end).';
|
||||
trackResults(N).Q_P = zeros(1,length(GNSS_tracking(N).P(start_sample:end)));
|
||||
|
||||
trackResults(N).I_VE = GNSS_tracking(N).VE(start_sample:end).';
|
||||
trackResults(N).I_E = GNSS_tracking(N).E(start_sample:end).';
|
||||
trackResults(N).I_L = GNSS_tracking(N).L(start_sample:end).';
|
||||
trackResults(N).I_VL = GNSS_tracking(N).VL(start_sample:end).';
|
||||
trackResults(N).Q_VE = zeros(1,length(GNSS_tracking(N).VE(start_sample:end)));
|
||||
trackResults(N).Q_E = zeros(1,length(GNSS_tracking(N).E(start_sample:end)));
|
||||
trackResults(N).Q_L = zeros(1,length(GNSS_tracking(N).L(start_sample:end)));
|
||||
trackResults(N).Q_VL = zeros(1,length(GNSS_tracking(N).VL(start_sample:end)));
|
||||
trackResults(N).data_I = GNSS_tracking(N).prompt_I(start_sample:end).';
|
||||
trackResults(N).data_Q = GNSS_tracking(N).prompt_Q(start_sample:end).';
|
||||
trackResults(N).PRN = GNSS_tracking(N).PRN(start_sample:end).';
|
||||
trackResults(N).CNo = GNSS_tracking(N).CN0_SNV_dB_Hz(start_sample:end).';
|
||||
trackResults(N).prn_start_time_s = GNSS_tracking(N).PRN_start_sample(start_sample:end)/samplingFreq;
|
||||
% Use original MATLAB tracking plot function
|
||||
settings.numberOfChannels = channels;
|
||||
plotVEMLTracking(N, trackResults, settings)
|
||||
end
|
||||
|
||||
%Doppler plot (optional)
|
||||
% for N=1:1:channels
|
||||
% figure;
|
||||
% plot(trackResults(N).prn_start_time_s , GNSS_tracking(N).carrier_doppler_hz(start_sample:end).' / 1000);
|
||||
% xlabel('Time(s)'); ylabel('Doppler(KHz)'); title(['Doppler frequency channel ' num2str(N)]);
|
||||
% end
|
||||
77
utils/matlab/gps_l1_ca_kf_plot_sample.m
Normal file
77
utils/matlab/gps_l1_ca_kf_plot_sample.m
Normal file
@@ -0,0 +1,77 @@
|
||||
% Reads GNSS-SDR Tracking dump binary file using the provided
|
||||
% function and plots some internal variables
|
||||
% Javier Arribas, 2011. jarribas(at)cttc.es
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% Copyright (C) 2010-2019 (see AUTHORS file for a list of contributors)
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
|
||||
close all;
|
||||
clear all;
|
||||
|
||||
if ~exist('dll_pll_veml_read_tracking_dump.m', 'file')
|
||||
addpath('./libs')
|
||||
end
|
||||
|
||||
|
||||
samplingFreq = 6625000; %[Hz]
|
||||
channels = 8;
|
||||
first_channel = 0;
|
||||
code_period = 0.001;
|
||||
|
||||
path = '/archive/'; %% CHANGE THIS PATH
|
||||
figpath = [path];
|
||||
|
||||
for N=1:1:channels
|
||||
tracking_log_path = [path 'epl_tracking_ch_' num2str(N+first_channel-1) '.dat']; %% CHANGE epl_tracking_ch_ BY YOUR dump_filename
|
||||
GNSS_tracking(N) = gps_l1_ca_kf_read_tracking_dump(tracking_log_path);
|
||||
end
|
||||
|
||||
% GNSS-SDR format conversion to MATLAB GPS receiver
|
||||
|
||||
for N=1:1:channels
|
||||
trackResults(N).status = 'T'; %fake track
|
||||
trackResults(N).codeFreq = GNSS_tracking(N).code_freq_hz.';
|
||||
trackResults(N).carrFreq = GNSS_tracking(N).carrier_doppler_hz.';
|
||||
trackResults(N).carrFreqRate = GNSS_tracking(N).carrier_dopplerrate_hz2.';
|
||||
trackResults(N).dllDiscr = GNSS_tracking(N).code_error.';
|
||||
trackResults(N).dllDiscrFilt = GNSS_tracking(N).code_nco.';
|
||||
trackResults(N).pllDiscr = GNSS_tracking(N).carr_error.';
|
||||
trackResults(N).pllDiscrFilt = GNSS_tracking(N).carr_nco.';
|
||||
|
||||
trackResults(N).I_P = GNSS_tracking(N).prompt_I.';
|
||||
trackResults(N).Q_P = GNSS_tracking(N).prompt_Q.';
|
||||
|
||||
trackResults(N).I_E = GNSS_tracking(N).E.';
|
||||
trackResults(N).I_L = GNSS_tracking(N).L.';
|
||||
trackResults(N).Q_E = zeros(1,length(GNSS_tracking(N).E));
|
||||
trackResults(N).Q_L = zeros(1,length(GNSS_tracking(N).E));
|
||||
trackResults(N).PRN = GNSS_tracking(N).PRN.';
|
||||
trackResults(N).CNo = GNSS_tracking(N).CN0_SNV_dB_Hz.';
|
||||
|
||||
|
||||
kalmanResults(N).PRN = GNSS_tracking(N).PRN.';
|
||||
kalmanResults(N).innovation = GNSS_tracking(N).carr_error.';
|
||||
kalmanResults(N).state1 = GNSS_tracking(N).carr_nco.';
|
||||
kalmanResults(N).state2 = GNSS_tracking(N).carrier_doppler_hz.';
|
||||
kalmanResults(N).state3 = GNSS_tracking(N).carrier_dopplerrate_hz2.';
|
||||
kalmanResults(N).r_noise_cov = GNSS_tracking(N).carr_noise_sigma2.';
|
||||
kalmanResults(N).CNo = GNSS_tracking(N).CN0_SNV_dB_Hz.';
|
||||
|
||||
% Use original MATLAB tracking plot function
|
||||
settings.numberOfChannels = channels;
|
||||
settings.msToProcess = length(GNSS_tracking(N).E);
|
||||
settings.codePeriod = code_period;
|
||||
settings.timeStartInSeconds = 20;
|
||||
|
||||
%plotTracking(N, trackResults, settings)
|
||||
plotKalman(N, kalmanResults, settings)
|
||||
|
||||
saveas(gcf, [figpath 'epl_tracking_ch_' num2str(N) '_PRN_' num2str(trackResults(N).PRN(end)) '.png'], 'png')
|
||||
end
|
||||
64
utils/matlab/gps_l1_ca_pvt_plot_sample_agilent_cap2.m
Normal file
64
utils/matlab/gps_l1_ca_pvt_plot_sample_agilent_cap2.m
Normal file
@@ -0,0 +1,64 @@
|
||||
% Reads GNSS-SDR PVT dump binary file using the provided
|
||||
% function and plots some internal variables
|
||||
% Javier Arribas, 2011. jarribas(at)cttc.es
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% Copyright (C) 2010-2019 (see AUTHORS file for a list of contributors)
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
|
||||
close all;
|
||||
clear all;
|
||||
|
||||
% True position of the antenna in UTM system (if known). Otherwise enter
|
||||
% all NaN's and mean position will be used as a reference .
|
||||
settings.truePosition.E = nan;
|
||||
settings.truePosition.N = nan;
|
||||
settings.truePosition.U = nan;
|
||||
|
||||
settings.navSolPeriod=100; %[ms]
|
||||
|
||||
filename='/home/javier/workspace/gnss-sdr/trunk/install/PVT.dat';
|
||||
|
||||
navSolutions = gps_l1_ca_pvt_read_pvt_dump (filename);
|
||||
|
||||
% Reference position for Agilent cap2.dat (San Francisco static scenario)
|
||||
% Scenario latitude is 37.8194388888889 N37 49 9.98
|
||||
% Scenario longitude is -122.4784944 W122 28 42.58
|
||||
% Scenario elevation is 35 meters.
|
||||
lat=[37 49 9.98];
|
||||
long=[-122 -28 -42.58];
|
||||
|
||||
lat_deg=dms2deg(lat);
|
||||
long_deg=dms2deg(long);
|
||||
|
||||
h=35;
|
||||
%Choices i of Reference Ellipsoid
|
||||
% 1. International Ellipsoid 1924
|
||||
% 2. International Ellipsoid 1967
|
||||
% 3. World Geodetic System 1972
|
||||
% 4. Geodetic Reference System 1980
|
||||
% 5. World Geodetic System 1984
|
||||
[X, Y, Z]=geo2cart(lat, long, h, 5); % geographical to cartesian conversion
|
||||
|
||||
%=== Convert to UTM coordinate system =============================
|
||||
utmZone = findUtmZone(lat_deg, long_deg);
|
||||
|
||||
[settings.truePosition.E, ...
|
||||
settings.truePosition.N, ...
|
||||
settings.truePosition.U] = cart2utm(X, Y, Z, utmZone);
|
||||
|
||||
|
||||
for k=1:1:length(navSolutions.X)
|
||||
[navSolutions.E(k), ...
|
||||
navSolutions.N(k), ...
|
||||
navSolutions.U(k)]=cart2utm(navSolutions.X(k), navSolutions.Y(k), navSolutions.Z(k), utmZone);
|
||||
end
|
||||
|
||||
plot_skyplot=0;
|
||||
plotNavigation(navSolutions,settings,plot_skyplot);
|
||||
19
utils/matlab/gps_l1_ca_pvt_raw_plot_sample.m
Normal file
19
utils/matlab/gps_l1_ca_pvt_raw_plot_sample.m
Normal file
@@ -0,0 +1,19 @@
|
||||
% Read PVG raw dump
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% Copyright (C) 2010-2019 (see AUTHORS file for a list of contributors)
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
|
||||
%clear all;
|
||||
|
||||
samplingFreq = 64e6/16; %[Hz]
|
||||
channels=4;
|
||||
path='/home/javier/workspace/gnss-sdr-ref/trunk/install/';
|
||||
pvt_raw_log_path=[path 'PVT_raw.dat'];
|
||||
GNSS_PVT_raw= gps_l1_ca_read_pvt_raw_dump(channels,pvt_raw_log_path);
|
||||
51
utils/matlab/gps_l1_ca_telemetry_plot_sample.m
Normal file
51
utils/matlab/gps_l1_ca_telemetry_plot_sample.m
Normal file
@@ -0,0 +1,51 @@
|
||||
% Reads GNSS-SDR Tracking dump binary file using the provided
|
||||
% function and plots some internal variables
|
||||
% Javier Arribas, 2011. jarribas(at)cttc.es
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% Copyright (C) 2010-2019 (see AUTHORS file for a list of contributors)
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
|
||||
close all;clear;
|
||||
samplingFreq = 10000000; %[Hz]
|
||||
channels=[0:17];
|
||||
path='/home/dmiralles/Documents/gnss-sdr/build/';
|
||||
addpath('libs/');
|
||||
clear PRN_absolute_sample_start;
|
||||
for N=1:1:length(channels)
|
||||
telemetry_log_path=[path 'telemetry' num2str(channels(N)) '.dat'];
|
||||
GNSS_telemetry(N)= gps_l1_ca_read_telemetry_dump(telemetry_log_path);
|
||||
end
|
||||
|
||||
%% Plotting values
|
||||
%--- Configurations
|
||||
chn_num_a = 11;
|
||||
chn_num_b = 3;
|
||||
%--- Plot results
|
||||
figure;
|
||||
plot(GNSS_telemetry(chn_num_a).tracking_sample_counter, ...
|
||||
GNSS_telemetry(chn_num_a).tow_current_symbol_ms/1000, 'b+');
|
||||
hold on;
|
||||
grid on;
|
||||
plot(GNSS_telemetry(chn_num_b).tracking_sample_counter, ...
|
||||
GNSS_telemetry(chn_num_b).tow_current_symbol_ms, 'ro');
|
||||
xlabel('TRK Sampling Counter');
|
||||
ylabel('Current Symbol TOW');
|
||||
legend(['CHN-',num2str(chn_num_a-1)], ['CHN-',num2str(chn_num_b-1)]);
|
||||
|
||||
figure;
|
||||
plot(GNSS_telemetry(chn_num_a).tracking_sample_counter, ...
|
||||
GNSS_telemetry(chn_num_a).tow, 'b+');
|
||||
hold on;
|
||||
grid on;
|
||||
plot(GNSS_telemetry(chn_num_b).tracking_sample_counter, ...
|
||||
GNSS_telemetry(chn_num_b).tow, 'ro');
|
||||
xlabel('TRK Sampling Counter');
|
||||
ylabel('Decoded Nav TOW');
|
||||
legend(['CHN-',num2str(chn_num_a-1)], ['CHN-',num2str(chn_num_b-1)]);
|
||||
44
utils/matlab/help_script1.m
Normal file
44
utils/matlab/help_script1.m
Normal file
@@ -0,0 +1,44 @@
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% Copyright (C) 2010-2019 (see AUTHORS file for a list of contributors)
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
|
||||
%help script to compare GNSS-SDR Preambles starts
|
||||
channel=3;
|
||||
% From GNSS_SDR telemetry decoder
|
||||
|
||||
% 1 find preambles indexes
|
||||
preambles_index=find(GNSS_telemetry(channel).Preamble_symbol_counter==0);
|
||||
|
||||
% 2 Get associated timestamp ms
|
||||
|
||||
preambles_timestamp_sdr_ms=GNSS_telemetry(channel).prn_delay_ms(preambles_index);
|
||||
|
||||
|
||||
% From Matlab receiver
|
||||
|
||||
[firstSubFrame, activeChnList, javi_subFrameStart_sample] = findPreambles(trackResults_sdr,settings);
|
||||
|
||||
preambles_timestamp_matlab_ms=trackResults_sdr(channel).prn_delay_ms(javi_subFrameStart_sample(channel,1:6));
|
||||
|
||||
|
||||
%Compare
|
||||
|
||||
common_start_index=max(find(abs(preambles_timestamp_sdr_ms-preambles_timestamp_matlab_ms(1))<2000));
|
||||
|
||||
error_ms=preambles_timestamp_sdr_ms(common_start_index:(common_start_index+length(preambles_timestamp_matlab_ms)-1))-preambles_timestamp_matlab_ms.'
|
||||
|
||||
% figure
|
||||
% stem(tracking_loop_start+javi_subFrameStart_sample(channel,:),1000*trackResults_sdr(channel).absoluteSample(javi_subFrameStart_sample(channel,:))/settings.samplingFreq);
|
||||
%
|
||||
% hold on;
|
||||
%
|
||||
% plot(GNSS_observables.preamble_delay_ms(channel,:));
|
||||
%
|
||||
% plot(GNSS_observables.prn_delay_ms(channel,:),'r')
|
||||
20
utils/matlab/help_script2.m
Normal file
20
utils/matlab/help_script2.m
Normal file
@@ -0,0 +1,20 @@
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% Copyright (C) 2010-2019 (see AUTHORS file for a list of contributors)
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
|
||||
% compare pseudoranges
|
||||
|
||||
close all;
|
||||
% GNSS SDR
|
||||
plot(GNSS_PVT_raw.tx_time(1,1:300).'-200/settings.samplingFreq,GNSS_PVT_raw.Pseudorange_m(1,1:300).')
|
||||
|
||||
% MATLAB
|
||||
hold on;
|
||||
plot(navSolutions.transmitTime,navSolutions.channel.rawP(1,:),'g')
|
||||
125
utils/matlab/hybrid_observables_plot_sample.m
Normal file
125
utils/matlab/hybrid_observables_plot_sample.m
Normal file
@@ -0,0 +1,125 @@
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% Copyright (C) 2010-2019 (see AUTHORS file for a list of contributors)
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
|
||||
%% Read Hibrid Observables Dump
|
||||
clearvars;
|
||||
close all;
|
||||
addpath('./libs');
|
||||
samplingFreq = 25000000; %[Hz]
|
||||
channels=10;
|
||||
path='/home/dmiralles/Documents/gnss-sdr/';
|
||||
observables_log_path=[path 'observables.dat'];
|
||||
GNSS_observables= read_hybrid_observables_dump(channels,observables_log_path);
|
||||
|
||||
%% Plo data
|
||||
%--- optional: search all channels having good satellite simultaneously
|
||||
min_tow_idx=1;
|
||||
obs_idx=1;
|
||||
for n=1:1:channels
|
||||
idx=find(GNSS_observables.valid(n,:)>0,1,'first');
|
||||
if min_tow_idx<idx
|
||||
min_tow_idx=idx;
|
||||
obs_idx = n;
|
||||
end
|
||||
end
|
||||
|
||||
%--- plot observables from that index
|
||||
figure;
|
||||
plot(GNSS_observables.RX_time(obs_idx,min_tow_idx+1:end),GNSS_observables.Pseudorange_m(:,min_tow_idx+1:end)');
|
||||
grid on;
|
||||
xlabel('TOW [s]')
|
||||
ylabel('Pseudorange [m]');
|
||||
|
||||
figure;
|
||||
plot(GNSS_observables.RX_time(obs_idx,min_tow_idx+1:end),GNSS_observables.Carrier_phase_hz(:,min_tow_idx+1:end)');
|
||||
xlabel('TOW [s]')
|
||||
ylabel('Accumulated Carrier Phase [cycles]');
|
||||
grid on;
|
||||
|
||||
figure;
|
||||
plot(GNSS_observables.RX_time(obs_idx,min_tow_idx+1:end),GNSS_observables.Carrier_Doppler_hz(:,min_tow_idx+1:end)');
|
||||
xlabel('TOW [s]');
|
||||
ylabel('Doppler Frequency [Hz]');
|
||||
grid on;
|
||||
|
||||
%% Deprecated Code
|
||||
% %read true obs from simulator (optional)
|
||||
% GPS_STARTOFFSET_s = 68.802e-3;
|
||||
%
|
||||
% true_observables_log_path='/home/javier/git/gnss-sdr/build/obs_out.bin';
|
||||
% GNSS_true_observables= read_true_sim_observables_dump(true_observables_log_path);
|
||||
%
|
||||
% %correct the clock error using true values (it is not possible for a receiver to correct
|
||||
% %the receiver clock offset error at the observables level because it is required the
|
||||
% %decoding of the ephemeris data and solve the PVT equations)
|
||||
%
|
||||
% SPEED_OF_LIGHT_M_S = 299792458.0;
|
||||
%
|
||||
% %find the reference satellite
|
||||
% [~,ref_sat_ch]=min(GNSS_observables.Pseudorange_m(:,min_idx+1));
|
||||
% shift_time_s=GNSS_true_observables.Pseudorange_m(ref_sat_ch,:)/SPEED_OF_LIGHT_M_S-GPS_STARTOFFSET_s;
|
||||
%
|
||||
%
|
||||
% %Compute deltas if required and interpolate to measurement time
|
||||
% delta_true_psudorange_m=GNSS_true_observables.Pseudorange_m(1,:)-GNSS_true_observables.Pseudorange_m(2,:);
|
||||
% delta_true_interp_psudorange_m=interp1(GNSS_true_observables.RX_time(1,:)-shift_time_s, ...
|
||||
% delta_true_psudorange_m,GNSS_observables.RX_time(1,min_idx+1:end),'lineal','extrap');
|
||||
% true_interp_acc_carrier_phase_ch1_hz=interp1(GNSS_true_observables.RX_time(1,:)-shift_time_s, ...
|
||||
% GNSS_true_observables.Carrier_phase_hz(1,:),GNSS_observables.RX_time(1,min_idx+1:end),'lineal','extrap');
|
||||
% true_interp_acc_carrier_phase_ch2_hz=interp1(GNSS_true_observables.RX_time(1,:)-shift_time_s, ...
|
||||
% GNSS_true_observables.Carrier_phase_hz(2,:),GNSS_observables.RX_time(2,min_idx+1:end),'lineal','extrap');
|
||||
%
|
||||
% %Compute measurement errors
|
||||
%
|
||||
% delta_measured_psudorange_m=GNSS_observables.Pseudorange_m(1,min_idx+1:end)-GNSS_observables.Pseudorange_m(2,min_idx+1:end);
|
||||
% psudorange_error_m=delta_measured_psudorange_m-delta_true_interp_psudorange_m;
|
||||
% psudorange_rms_m=sqrt(sum(psudorange_error_m.^2)/length(psudorange_error_m))
|
||||
%
|
||||
% acc_carrier_error_ch1_hz=GNSS_observables.Carrier_phase_hz(1,min_idx+1:end)-true_interp_acc_carrier_phase_ch1_hz...
|
||||
% -GNSS_observables.Carrier_phase_hz(1,min_idx+1)+true_interp_acc_carrier_phase_ch1_hz(1);
|
||||
%
|
||||
% acc_phase_rms_ch1_hz=sqrt(sum(acc_carrier_error_ch1_hz.^2)/length(acc_carrier_error_ch1_hz))
|
||||
%
|
||||
% acc_carrier_error_ch2_hz=GNSS_observables.Carrier_phase_hz(2,min_idx+1:end)-true_interp_acc_carrier_phase_ch2_hz...
|
||||
% -GNSS_observables.Carrier_phase_hz(2,min_idx+1)+true_interp_acc_carrier_phase_ch2_hz(1);
|
||||
% acc_phase_rms_ch2_hz=sqrt(sum(acc_carrier_error_ch2_hz.^2)/length(acc_carrier_error_ch2_hz))
|
||||
%
|
||||
%
|
||||
% %plot results
|
||||
% figure;
|
||||
% plot(GNSS_true_observables.RX_time(1,:),delta_true_psudorange_m,'g');
|
||||
% hold on;
|
||||
% plot(GNSS_observables.RX_time(1,min_idx+1:end),delta_measured_psudorange_m,'b');
|
||||
% title('TRUE vs. measured Pseudoranges [m]')
|
||||
% xlabel('TOW [s]')
|
||||
% ylabel('[m]');
|
||||
%
|
||||
% figure;
|
||||
% plot(GNSS_observables.RX_time(1,min_idx+1:end),psudorange_error_m)
|
||||
% title('Pseudoranges error [m]')
|
||||
% xlabel('TOW [s]')
|
||||
% ylabel('[m]');
|
||||
%
|
||||
% figure;
|
||||
% plot(GNSS_observables.RX_time(1,min_idx+1:end),acc_carrier_error_ch1_hz)
|
||||
% title('Accumulated carrier phase error CH1 [hz]')
|
||||
% xlabel('TOW [s]')
|
||||
% ylabel('[hz]');
|
||||
%
|
||||
% figure;
|
||||
% plot(GNSS_observables.RX_time(1,min_idx+1:end),acc_carrier_error_ch2_hz)
|
||||
% title('Accumulated carrier phase error CH2 [hz]')
|
||||
% xlabel('TOW [s]')
|
||||
% ylabel('[hz]');
|
||||
%
|
||||
%
|
||||
%
|
||||
%
|
||||
146
utils/matlab/libs/dll_pll_veml_read_tracking_dump.m
Normal file
146
utils/matlab/libs/dll_pll_veml_read_tracking_dump.m
Normal file
@@ -0,0 +1,146 @@
|
||||
% Usage: dll_pll_veml_read_tracking_dump (filename, [count])
|
||||
%
|
||||
% Read GNSS-SDR Tracking dump binary file into MATLAB.
|
||||
% Opens GNSS-SDR tracking binary log file .dat and returns the contents
|
||||
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Luis Esteve, 2012. luis(at)epsilon-formacion.com
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%
|
||||
% -------------------------------------------------------------------------
|
||||
|
||||
function [GNSS_tracking] = dll_pll_veml_read_tracking_dump (filename, count)
|
||||
|
||||
m = nargchk (1,2,nargin);
|
||||
|
||||
num_float_vars = 19;
|
||||
num_unsigned_long_int_vars = 1;
|
||||
num_double_vars = 1;
|
||||
num_unsigned_int_vars = 1;
|
||||
|
||||
if(~isempty(strfind(computer('arch'), '64')))
|
||||
% 64-bit computer
|
||||
double_size_bytes = 8;
|
||||
unsigned_long_int_size_bytes = 8;
|
||||
float_size_bytes = 4;
|
||||
unsigned_int_size_bytes = 4;
|
||||
else
|
||||
double_size_bytes = 8;
|
||||
unsigned_long_int_size_bytes = 4;
|
||||
float_size_bytes = 4;
|
||||
unsigned_int_size_bytes = 4;
|
||||
end
|
||||
|
||||
skip_bytes_each_read = float_size_bytes * num_float_vars + unsigned_long_int_size_bytes * num_unsigned_long_int_vars + ...
|
||||
double_size_bytes * num_double_vars + num_unsigned_int_vars*unsigned_int_size_bytes;
|
||||
|
||||
bytes_shift = 0;
|
||||
|
||||
if (m)
|
||||
usage (m);
|
||||
end
|
||||
|
||||
if (nargin < 2)
|
||||
count = Inf;
|
||||
end
|
||||
%loops_counter = fread (f, count, 'uint32',4*12);
|
||||
f = fopen (filename, 'rb');
|
||||
if (f < 0)
|
||||
else
|
||||
v1 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v2 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v3 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v4 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v5 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v6 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v7 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved float
|
||||
if unsigned_long_int_size_bytes==8
|
||||
v8 = fread (f, count, 'uint64', skip_bytes_each_read - unsigned_long_int_size_bytes);
|
||||
else
|
||||
v8 = fread (f, count, 'uint32', skip_bytes_each_read - unsigned_long_int_size_bytes);
|
||||
end
|
||||
bytes_shift = bytes_shift + unsigned_long_int_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v9 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v10 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v11 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v12 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v13 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v14 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v15 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v16 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v17 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v18 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved float
|
||||
v19 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v20 = fread (f, count, 'float', skip_bytes_each_read-float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next double
|
||||
v21 = fread (f, count, 'double', skip_bytes_each_read - double_size_bytes);
|
||||
bytes_shift = bytes_shift + double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next unsigned int
|
||||
v22 = fread (f, count, 'uint', skip_bytes_each_read - unsigned_int_size_bytes);
|
||||
fclose (f);
|
||||
|
||||
GNSS_tracking.VE = v1;
|
||||
GNSS_tracking.E = v2;
|
||||
GNSS_tracking.P = v3;
|
||||
GNSS_tracking.L = v4;
|
||||
GNSS_tracking.VL = v5;
|
||||
GNSS_tracking.prompt_I = v6;
|
||||
GNSS_tracking.prompt_Q = v7;
|
||||
GNSS_tracking.PRN_start_sample = v8;
|
||||
GNSS_tracking.acc_carrier_phase_rad = v9;
|
||||
GNSS_tracking.carrier_doppler_hz = v10;
|
||||
GNSS_tracking.carrier_doppler_rate_hz_s = v11;
|
||||
GNSS_tracking.code_freq_hz = v12;
|
||||
GNSS_tracking.code_freq_rate_hz_s = v13;
|
||||
GNSS_tracking.carr_error = v14;
|
||||
GNSS_tracking.carr_nco = v15;
|
||||
GNSS_tracking.code_error = v16;
|
||||
GNSS_tracking.code_nco = v17;
|
||||
GNSS_tracking.CN0_SNV_dB_Hz = v18;
|
||||
GNSS_tracking.carrier_lock_test = v19;
|
||||
GNSS_tracking.var1 = v20;
|
||||
GNSS_tracking.var2 = v21;
|
||||
GNSS_tracking.PRN = v22;
|
||||
end
|
||||
60
utils/matlab/libs/geoFunctions/cart2geo.m
Normal file
60
utils/matlab/libs/geoFunctions/cart2geo.m
Normal file
@@ -0,0 +1,60 @@
|
||||
function [phi, lambda, h] = cart2geo(X, Y, Z, i)
|
||||
% CART2GEO Conversion of Cartesian coordinates (X,Y,Z) to geographical
|
||||
% coordinates (phi, lambda, h) on a selected reference ellipsoid.
|
||||
%
|
||||
% [phi, lambda, h] = cart2geo(X, Y, Z, i);
|
||||
%
|
||||
% Choices i of Reference Ellipsoid for Geographical Coordinates
|
||||
% 1. International Ellipsoid 1924
|
||||
% 2. International Ellipsoid 1967
|
||||
% 3. World Geodetic System 1972
|
||||
% 4. Geodetic Reference System 1980
|
||||
% 5. World Geodetic System 1984
|
||||
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Kai Borre
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%==========================================================================
|
||||
|
||||
a = [6378388 6378160 6378135 6378137 6378137];
|
||||
f = [1/297 1/298.247 1/298.26 1/298.257222101 1/298.257223563];
|
||||
|
||||
lambda = atan2(Y,X);
|
||||
ex2 = (2-f(i))*f(i)/((1-f(i))^2);
|
||||
c = a(i)*sqrt(1+ex2);
|
||||
phi = atan(Z/((sqrt(X^2+Y^2)*(1-(2-f(i)))*f(i))));
|
||||
|
||||
h = 0.1; oldh = 0;
|
||||
iterations = 0;
|
||||
while abs(h-oldh) > 1.e-12
|
||||
oldh = h;
|
||||
N = c/sqrt(1+ex2*cos(phi)^2);
|
||||
phi = atan(Z/((sqrt(X^2+Y^2)*(1-(2-f(i))*f(i)*N/(N+h)))));
|
||||
h = sqrt(X^2+Y^2)/cos(phi)-N;
|
||||
|
||||
iterations = iterations + 1;
|
||||
if iterations > 100
|
||||
fprintf('Failed to approximate h with desired precision. h-oldh: %e.\n', h-oldh);
|
||||
break;
|
||||
end
|
||||
end
|
||||
|
||||
phi = phi*180/pi;
|
||||
% b = zeros(1,3);
|
||||
% b(1,1) = fix(phi);
|
||||
% b(2,1) = fix(rem(phi,b(1,1))*60);
|
||||
% b(3,1) = (phi-b(1,1)-b(1,2)/60)*3600;
|
||||
|
||||
lambda = lambda*180/pi;
|
||||
% l = zeros(1,3);
|
||||
% l(1,1) = fix(lambda);
|
||||
% l(2,1) = fix(rem(lambda,l(1,1))*60);
|
||||
% l(3,1) = (lambda-l(1,1)-l(1,2)/60)*3600;
|
||||
|
||||
%fprintf('\n phi =%3.0f %3.0f %8.5f',b(1),b(2),b(3))
|
||||
%fprintf('\n lambda =%3.0f %3.0f %8.5f',l(1),l(2),l(3))
|
||||
%fprintf('\n h =%14.3f\n',h)
|
||||
|
||||
%%%%%%%%%%%%%% end cart2geo.m %%%%%%%%%%%%%%%%%%%
|
||||
176
utils/matlab/libs/geoFunctions/cart2utm.m
Normal file
176
utils/matlab/libs/geoFunctions/cart2utm.m
Normal file
@@ -0,0 +1,176 @@
|
||||
function [E, N, U] = cart2utm(X, Y, Z, zone)
|
||||
% CART2UTM Transformation of (X,Y,Z) to (N,E,U) in UTM, zone 'zone'.
|
||||
%
|
||||
% [E, N, U] = cart2utm(X, Y, Z, zone);
|
||||
%
|
||||
% Inputs:
|
||||
% X,Y,Z - Cartesian coordinates. Coordinates are referenced
|
||||
% with respect to the International Terrestrial Reference
|
||||
% Frame 1996 (ITRF96)
|
||||
% zone - UTM zone of the given position
|
||||
%
|
||||
% Outputs:
|
||||
% E, N, U - UTM coordinates (Easting, Northing, Uping)
|
||||
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Kai Borre
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
% This implementation is based upon
|
||||
% O. Andersson & K. Poder (1981) Koordinattransformationer
|
||||
% ved Geod\ae{}tisk Institut. Landinspekt\oe{}ren
|
||||
% Vol. 30: 552--571 and Vol. 31: 76
|
||||
%
|
||||
% An excellent, general reference (KW) is
|
||||
% R. Koenig & K.H. Weise (1951) Mathematische Grundlagen der
|
||||
% h\"oheren Geod\"asie und Kartographie.
|
||||
% Erster Band, Springer Verlag
|
||||
|
||||
% Explanation of variables used:
|
||||
% f flattening of ellipsoid
|
||||
% a semi major axis in m
|
||||
% m0 1 - scale at central meridian; for UTM 0.0004
|
||||
% Q_n normalized meridian quadrant
|
||||
% E0 Easting of central meridian
|
||||
% L0 Longitude of central meridian
|
||||
% bg constants for ellipsoidal geogr. to spherical geogr.
|
||||
% gb constants for spherical geogr. to ellipsoidal geogr.
|
||||
% gtu constants for ellipsoidal N, E to spherical N, E
|
||||
% utg constants for spherical N, E to ellipoidal N, E
|
||||
% tolutm tolerance for utm, 1.2E-10*meridian quadrant
|
||||
% tolgeo tolerance for geographical, 0.00040 second of arc
|
||||
|
||||
% B, L refer to latitude and longitude. Southern latitude is negative
|
||||
% International ellipsoid of 1924, valid for ED50
|
||||
|
||||
a = 6378388;
|
||||
f = 1/297;
|
||||
ex2 = (2-f)*f / ((1-f)^2);
|
||||
c = a * sqrt(1+ex2);
|
||||
vec = [X; Y; Z-4.5];
|
||||
alpha = .756e-6;
|
||||
R = [ 1 -alpha 0;
|
||||
alpha 1 0;
|
||||
0 0 1];
|
||||
trans = [89.5; 93.8; 127.6];
|
||||
scale = 0.9999988;
|
||||
v = scale*R*vec + trans; % coordinate vector in ED50
|
||||
L = atan2(v(2), v(1));
|
||||
N1 = 6395000; % preliminary value
|
||||
B = atan2(v(3)/((1-f)^2*N1), norm(v(1:2))/N1); % preliminary value
|
||||
U = 0.1; oldU = 0;
|
||||
|
||||
iterations = 0;
|
||||
while abs(U-oldU) > 1.e-4
|
||||
oldU = U;
|
||||
N1 = c/sqrt(1+ex2*(cos(B))^2);
|
||||
B = atan2(v(3)/((1-f)^2*N1+U), norm(v(1:2))/(N1+U) );
|
||||
U = norm(v(1:2))/cos(B)-N1;
|
||||
|
||||
iterations = iterations + 1;
|
||||
if iterations > 100
|
||||
fprintf('Failed to approximate U with desired precision. U-oldU: %e.\n', U-oldU);
|
||||
break;
|
||||
end
|
||||
end
|
||||
|
||||
% Normalized meridian quadrant, KW p. 50 (96), p. 19 (38b), p. 5 (21)
|
||||
m0 = 0.0004;
|
||||
n = f / (2-f);
|
||||
m = n^2 * (1/4 + n*n/64);
|
||||
w = (a*(-n-m0+m*(1-m0))) / (1+n);
|
||||
Q_n = a + w;
|
||||
|
||||
% Easting and longitude of central meridian
|
||||
E0 = 500000;
|
||||
L0 = (zone-30)*6 - 3;
|
||||
|
||||
% Check tolerance for reverse transformation
|
||||
tolutm = pi/2 * 1.2e-10 * Q_n;
|
||||
tolgeo = 0.000040;
|
||||
|
||||
% Coefficients of trigonometric series
|
||||
|
||||
% ellipsoidal to spherical geographical, KW p. 186--187, (51)-(52)
|
||||
% bg[1] = n*(-2 + n*(2/3 + n*(4/3 + n*(-82/45))));
|
||||
% bg[2] = n^2*(5/3 + n*(-16/15 + n*(-13/9)));
|
||||
% bg[3] = n^3*(-26/15 + n*34/21);
|
||||
% bg[4] = n^4*1237/630;
|
||||
|
||||
% spherical to ellipsoidal geographical, KW p. 190--191, (61)-(62)
|
||||
% gb[1] = n*(2 + n*(-2/3 + n*(-2 + n*116/45)));
|
||||
% gb[2] = n^2*(7/3 + n*(-8/5 + n*(-227/45)));
|
||||
% gb[3] = n^3*(56/15 + n*(-136/35));
|
||||
% gb[4] = n^4*4279/630;
|
||||
|
||||
% spherical to ellipsoidal N, E, KW p. 196, (69)
|
||||
% gtu[1] = n*(1/2 + n*(-2/3 + n*(5/16 + n*41/180)));
|
||||
% gtu[2] = n^2*(13/48 + n*(-3/5 + n*557/1440));
|
||||
% gtu[3] = n^3*(61/240 + n*(-103/140));
|
||||
% gtu[4] = n^4*49561/161280;
|
||||
|
||||
% ellipsoidal to spherical N, E, KW p. 194, (65)
|
||||
% utg[1] = n*(-1/2 + n*(2/3 + n*(-37/96 + n*1/360)));
|
||||
% utg[2] = n^2*(-1/48 + n*(-1/15 + n*437/1440));
|
||||
% utg[3] = n^3*(-17/480 + n*37/840);
|
||||
% utg[4] = n^4*(-4397/161280);
|
||||
|
||||
% With f = 1/297 we get
|
||||
|
||||
bg = [-3.37077907e-3;
|
||||
4.73444769e-6;
|
||||
-8.29914570e-9;
|
||||
1.58785330e-11];
|
||||
|
||||
gb = [ 3.37077588e-3;
|
||||
6.62769080e-6;
|
||||
1.78718601e-8;
|
||||
5.49266312e-11];
|
||||
|
||||
gtu = [ 8.41275991e-4;
|
||||
7.67306686e-7;
|
||||
1.21291230e-9;
|
||||
2.48508228e-12];
|
||||
|
||||
utg = [-8.41276339e-4;
|
||||
-5.95619298e-8;
|
||||
-1.69485209e-10;
|
||||
-2.20473896e-13];
|
||||
|
||||
% Ellipsoidal latitude, longitude to spherical latitude, longitude
|
||||
neg_geo = 'FALSE';
|
||||
|
||||
if B < 0
|
||||
neg_geo = 'TRUE ';
|
||||
end
|
||||
|
||||
Bg_r = abs(B);
|
||||
[res_clensin] = clsin(bg, 4, 2*Bg_r);
|
||||
Bg_r = Bg_r + res_clensin;
|
||||
L0 = L0*pi / 180;
|
||||
Lg_r = L - L0;
|
||||
|
||||
% Spherical latitude, longitude to complementary spherical latitude
|
||||
% i.e. spherical N, E
|
||||
cos_BN = cos(Bg_r);
|
||||
Np = atan2(sin(Bg_r), cos(Lg_r)*cos_BN);
|
||||
Ep = atanh(sin(Lg_r) * cos_BN);
|
||||
|
||||
%Spherical normalized N, E to ellipsoidal N, E
|
||||
Np = 2 * Np;
|
||||
Ep = 2 * Ep;
|
||||
[dN, dE] = clksin(gtu, 4, Np, Ep);
|
||||
Np = Np/2;
|
||||
Ep = Ep/2;
|
||||
Np = Np + dN;
|
||||
Ep = Ep + dE;
|
||||
N = Q_n * Np;
|
||||
E = Q_n*Ep + E0;
|
||||
|
||||
if neg_geo == 'TRUE '
|
||||
N = -N + 20000000;
|
||||
end;
|
||||
|
||||
%%%%%%%%%%%%%%%%%%%% end cart2utm.m %%%%%%%%%%%%%%%%%%%%
|
||||
29
utils/matlab/libs/geoFunctions/check_t.m
Normal file
29
utils/matlab/libs/geoFunctions/check_t.m
Normal file
@@ -0,0 +1,29 @@
|
||||
function corrTime = check_t(time)
|
||||
% CHECK_T accounting for beginning or end of week crossover.
|
||||
%
|
||||
% corrTime = check_t(time);
|
||||
%
|
||||
% Inputs:
|
||||
% time - time in seconds
|
||||
%
|
||||
% Outputs:
|
||||
% corrTime - corrected time (seconds)
|
||||
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Kai Borre
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%==========================================================================
|
||||
|
||||
half_week = 302400; % seconds
|
||||
|
||||
corrTime = time;
|
||||
|
||||
if time > half_week
|
||||
corrTime = time - 2*half_week;
|
||||
elseif time < -half_week
|
||||
corrTime = time + 2*half_week;
|
||||
end
|
||||
|
||||
%%%%%%% end check_t.m %%%%%%%%%%%%%%%%%
|
||||
36
utils/matlab/libs/geoFunctions/clksin.m
Normal file
36
utils/matlab/libs/geoFunctions/clksin.m
Normal file
@@ -0,0 +1,36 @@
|
||||
function [re, im] = clksin(ar, degree, arg_real, arg_imag)
|
||||
% Clenshaw summation of sinus with complex argument
|
||||
% [re, im] = clksin(ar, degree, arg_real, arg_imag);
|
||||
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Kai Borre
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%==========================================================================
|
||||
|
||||
sin_arg_r = sin(arg_real);
|
||||
cos_arg_r = cos(arg_real);
|
||||
sinh_arg_i = sinh(arg_imag);
|
||||
cosh_arg_i = cosh(arg_imag);
|
||||
|
||||
r = 2 * cos_arg_r * cosh_arg_i;
|
||||
i =-2 * sin_arg_r * sinh_arg_i;
|
||||
|
||||
hr1 = 0; hr = 0; hi1 = 0; hi = 0;
|
||||
|
||||
for t = degree : -1 : 1
|
||||
hr2 = hr1;
|
||||
hr1 = hr;
|
||||
hi2 = hi1;
|
||||
hi1 = hi;
|
||||
z = ar(t) + r*hr1 - i*hi - hr2;
|
||||
hi = i*hr1 + r*hi1 - hi2;
|
||||
hr = z;
|
||||
end
|
||||
|
||||
r = sin_arg_r * cosh_arg_i;
|
||||
i = cos_arg_r * sinh_arg_i;
|
||||
|
||||
re = r*hr - i*hi;
|
||||
im = r*hi + i*hr;
|
||||
25
utils/matlab/libs/geoFunctions/clsin.m
Normal file
25
utils/matlab/libs/geoFunctions/clsin.m
Normal file
@@ -0,0 +1,25 @@
|
||||
function result = clsin(ar, degree, argument)
|
||||
% Clenshaw summation of sinus of argument.
|
||||
%
|
||||
% result = clsin(ar, degree, argument);
|
||||
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Kai Borre
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%==========================================================================
|
||||
|
||||
cos_arg = 2 * cos(argument);
|
||||
hr1 = 0;
|
||||
hr = 0;
|
||||
|
||||
for t = degree : -1 : 1
|
||||
hr2 = hr1;
|
||||
hr1 = hr;
|
||||
hr = ar(t) + cos_arg*hr1 - hr2;
|
||||
end
|
||||
|
||||
result = hr * sin(argument);
|
||||
|
||||
%%%%%%%%%%%%%%%%%%%%%%% end clsin.m %%%%%%%%%%%%%%%%%%%%%
|
||||
48
utils/matlab/libs/geoFunctions/deg2dms.m
Normal file
48
utils/matlab/libs/geoFunctions/deg2dms.m
Normal file
@@ -0,0 +1,48 @@
|
||||
function dmsOutput = deg2dms(deg)
|
||||
% DEG2DMS Conversion of degrees to degrees, minutes, and seconds.
|
||||
% The output format (dms format) is: (degrees*100 + minutes + seconds/100)
|
||||
|
||||
% February 7, 2001
|
||||
% Updated by Darius Plausinaitis
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Kai Borre
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
%%% Save the sign for later processing
|
||||
neg_arg = false;
|
||||
if deg < 0
|
||||
% Only positive numbers should be used while splitting into deg/min/sec
|
||||
deg = -deg;
|
||||
neg_arg = true;
|
||||
end
|
||||
|
||||
%%% Split degrees minutes and seconds
|
||||
int_deg = floor(deg);
|
||||
decimal = deg - int_deg;
|
||||
min_part = decimal*60;
|
||||
min = floor(min_part);
|
||||
sec_part = min_part - floor(min_part);
|
||||
sec = sec_part*60;
|
||||
|
||||
%%% Check for overflow
|
||||
if sec == 60
|
||||
min = min + 1;
|
||||
sec = 0;
|
||||
end
|
||||
if min == 60
|
||||
int_deg = int_deg + 1;
|
||||
min = 0;
|
||||
end
|
||||
|
||||
%%% Construct the output
|
||||
dmsOutput = int_deg * 100 + min + sec/100;
|
||||
|
||||
%%% Correct the sign
|
||||
if neg_arg == true
|
||||
dmsOutput = -dmsOutput;
|
||||
end
|
||||
|
||||
%%%%%%%%%%%%%%%%%%% end deg2dms.m %%%%%%%%%%%%%%%%
|
||||
15
utils/matlab/libs/geoFunctions/dms2deg.m
Normal file
15
utils/matlab/libs/geoFunctions/dms2deg.m
Normal file
@@ -0,0 +1,15 @@
|
||||
function deg = dms2deg(dms)
|
||||
% DMS2DEG Conversion of degrees, minutes, and seconds to degrees.
|
||||
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Javier Arribas 2011
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
|
||||
%if (dms(1)>=0)
|
||||
deg=dms(1)+dms(2)/60+dms(3)/3600;
|
||||
%else
|
||||
%deg=dms(1)-dms(2)/60-dms(3)/3600;
|
||||
%end
|
||||
109
utils/matlab/libs/geoFunctions/dms2mat.m
Normal file
109
utils/matlab/libs/geoFunctions/dms2mat.m
Normal file
@@ -0,0 +1,109 @@
|
||||
function [dout,mout,sout] = dms2mat(dms,n)
|
||||
|
||||
% DMS2MAT Converts a dms vector format to a [deg min sec] matrix
|
||||
%
|
||||
% [d,m,s] = DMS2MAT(dms) converts a dms vector format to a
|
||||
% deg:min:sec matrix. The vector format is dms = 100*deg + min + sec/100.
|
||||
% This allows compressed dms data to be expanded to a d,m,s triple,
|
||||
% for easier reporting and viewing of the data.
|
||||
%
|
||||
% [d,m,s] = DMS2MAT(dms,n) uses n digits in the accuracy of the
|
||||
% seconds calculation. n = -2 uses accuracy in the hundredths position,
|
||||
% n = 0 uses accuracy in the units position. Default is n = -5.
|
||||
% For further discussion of the input n, see ROUNDN.
|
||||
%
|
||||
% mat = DMS2MAT(...) returns a single output argument of mat = [d m s].
|
||||
% This is useful only if the input dms is a single column vector.
|
||||
%
|
||||
% See also MAT2DMS
|
||||
|
||||
% Written by: E. Byrns, E. Brown
|
||||
% Revision: 1.10 $Date: 2002/03/20 21:25:06
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: 1996-2002 Systems Planning and Analysis, Inc. and The MathWorks, Inc.
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
|
||||
|
||||
if nargin == 0
|
||||
error('Incorrect number of arguments')
|
||||
elseif nargin == 1
|
||||
n = -5;
|
||||
end
|
||||
|
||||
% Test for empty arguments
|
||||
|
||||
if isempty(dms); dout = []; mout = []; sout = []; return; end
|
||||
|
||||
% Test for complex arguments
|
||||
|
||||
if ~isreal(dms)
|
||||
warning('Imaginary parts of complex ANGLE argument ignored')
|
||||
dms = real(dms);
|
||||
end
|
||||
|
||||
% Don't let seconds be rounded beyond the tens place.
|
||||
% If you did, then 55 seconds rounds to 100, which is not good.
|
||||
|
||||
if n == 2; n = 1; end
|
||||
|
||||
% Construct a sign vector which has +1 when dms >= 0 and -1 when dms < 0.
|
||||
|
||||
signvec = sign(dms);
|
||||
signvec = signvec + (signvec == 0); % Ensure +1 when dms = 0
|
||||
|
||||
% Decompress the dms data vector
|
||||
|
||||
dms = abs(dms);
|
||||
d = fix(dms/100); % Degrees
|
||||
m = fix(dms) - abs(100*d); % Minutes
|
||||
[s,msg] = roundn(100*rem(dms,1),n); % Seconds: Truncate to roundoff error
|
||||
if ~isempty(msg); error(msg); end
|
||||
|
||||
% Adjust for 60 seconds or 60 minutes.
|
||||
% Test for seconds > 60 to allow for round-off from roundn,
|
||||
% Test for minutes > 60 as a ripple effect from seconds > 60
|
||||
|
||||
|
||||
indx = find(s >= 60);
|
||||
if ~isempty(indx); m(indx) = m(indx) + 1; s(indx) = s(indx) - 60; end
|
||||
indx = find(m >= 60);
|
||||
if ~isempty(indx); d(indx) = d(indx) + 1; m(indx) = m(indx) - 60; end
|
||||
|
||||
% Data consistency checks
|
||||
|
||||
if any(m > 59) | any (m < 0)
|
||||
error('Minutes must be >= 0 and <= 59')
|
||||
|
||||
elseif any(s >= 60) | any( s < 0)
|
||||
error('Seconds must be >= 0 and < 60')
|
||||
end
|
||||
|
||||
% Determine where to store the sign of the angle. It should be
|
||||
% associated with the largest nonzero component of d:m:s.
|
||||
|
||||
dsign = signvec .* (d~=0);
|
||||
msign = signvec .* (d==0 & m~=0);
|
||||
ssign = signvec .* (d==0 & m==0 & s~=0);
|
||||
|
||||
% In the application of signs below, the comparison with 0 is used so that
|
||||
% the sign vector contains only +1 and -1. Any zero occurrences causes
|
||||
% data to be lost when the sign has been applied to a higher component
|
||||
% of d:m:s. Use fix function to eliminate potential round-off errors.
|
||||
|
||||
d = ((dsign==0) + dsign).*fix(d); % Apply signs to the degrees
|
||||
m = ((msign==0) + msign).*fix(m); % Apply signs to minutes
|
||||
s = ((ssign==0) + ssign).*s; % Apply signs to seconds
|
||||
|
||||
% Set the output arguments
|
||||
|
||||
if nargout <= 1
|
||||
dout = [d m s];
|
||||
elseif nargout == 3
|
||||
dout = d; mout = m; sout = s;
|
||||
else
|
||||
error('Invalid number of output arguments')
|
||||
end
|
||||
34
utils/matlab/libs/geoFunctions/e_r_corr.m
Normal file
34
utils/matlab/libs/geoFunctions/e_r_corr.m
Normal file
@@ -0,0 +1,34 @@
|
||||
function X_sat_rot = e_r_corr(traveltime, X_sat)
|
||||
% E_R_CORR Returns rotated satellite ECEF coordinates due to Earth
|
||||
% rotation during signal travel time
|
||||
%
|
||||
% X_sat_rot = e_r_corr(traveltime, X_sat);
|
||||
%
|
||||
% Inputs:
|
||||
% travelTime - signal travel time
|
||||
% X_sat - satellite's ECEF coordinates
|
||||
%
|
||||
% Outputs:
|
||||
% X_sat_rot - rotated satellite's coordinates (ECEF)
|
||||
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Kai Borre
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%==========================================================================
|
||||
|
||||
Omegae_dot = 7.292115147e-5; % rad/sec
|
||||
|
||||
%--- Find rotation angle --------------------------------------------------
|
||||
omegatau = Omegae_dot * traveltime;
|
||||
|
||||
%--- Make a rotation matrix -----------------------------------------------
|
||||
R3 = [ cos(omegatau) sin(omegatau) 0;
|
||||
-sin(omegatau) cos(omegatau) 0;
|
||||
0 0 1];
|
||||
|
||||
%--- Do the rotation ------------------------------------------------------
|
||||
X_sat_rot = R3 * X_sat;
|
||||
|
||||
%%%%%%%% end e_r_corr.m %%%%%%%%%%%%%%%%%%%%
|
||||
59
utils/matlab/libs/geoFunctions/findUtmZone.m
Normal file
59
utils/matlab/libs/geoFunctions/findUtmZone.m
Normal file
@@ -0,0 +1,59 @@
|
||||
function utmZone = findUtmZone(latitude, longitude)
|
||||
% Function finds the UTM zone number for given longitude and latitude.
|
||||
% The longitude value must be between -180 (180 degree West) and 180 (180
|
||||
% degree East) degree. The latitude must be within -80 (80 degree South) and
|
||||
% 84 (84 degree North).
|
||||
%
|
||||
% utmZone = findUtmZone(latitude, longitude);
|
||||
%
|
||||
% Latitude and longitude must be in decimal degrees (e.g. 15.5 degrees not
|
||||
% 15 deg 30 min).
|
||||
|
||||
%--------------------------------------------------------------------------
|
||||
% SoftGNSS v3.0
|
||||
%
|
||||
% Written by Darius Plausinaitis
|
||||
%--------------------------------------------------------------------------
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Darius Plausinaitis
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%==========================================================================
|
||||
|
||||
%% Check value bounds =====================================================
|
||||
|
||||
if ((longitude > 180) || (longitude < -180))
|
||||
error('Longitude value exceeds limits (-180:180).');
|
||||
end
|
||||
|
||||
if ((latitude > 84) || (latitude < -80))
|
||||
error('Latitude value exceeds limits (-80:84).');
|
||||
end
|
||||
|
||||
%% Find zone ==============================================================
|
||||
|
||||
% Start at 180 deg west = -180 deg
|
||||
|
||||
utmZone = fix((180 + longitude)/ 6) + 1;
|
||||
|
||||
%% Correct zone numbers for particular areas ==============================
|
||||
|
||||
if (latitude > 72)
|
||||
% Corrections for zones 31 33 35 37
|
||||
if ((longitude >= 0) && (longitude < 9))
|
||||
utmZone = 31;
|
||||
elseif ((longitude >= 9) && (longitude < 21))
|
||||
utmZone = 33;
|
||||
elseif ((longitude >= 21) && (longitude < 33))
|
||||
utmZone = 35;
|
||||
elseif ((longitude >= 33) && (longitude < 42))
|
||||
utmZone = 37;
|
||||
end
|
||||
|
||||
elseif ((latitude >= 56) && (latitude < 64))
|
||||
% Correction for zone 32
|
||||
if ((longitude >= 3) && (longitude < 12))
|
||||
utmZone = 32;
|
||||
end
|
||||
end
|
||||
50
utils/matlab/libs/geoFunctions/geo2cart.m
Normal file
50
utils/matlab/libs/geoFunctions/geo2cart.m
Normal file
@@ -0,0 +1,50 @@
|
||||
function [X, Y, Z] = geo2cart(phi, lambda, h, i)
|
||||
% GEO2CART Conversion of geographical coordinates (phi, lambda, h) to
|
||||
% Cartesian coordinates (X, Y, Z).
|
||||
%
|
||||
% [X, Y, Z] = geo2cart(phi, lambda, h, i);
|
||||
%
|
||||
% Format for phi and lambda: [degrees minutes seconds].
|
||||
% h, X, Y, and Z are in meters.
|
||||
%
|
||||
% Choices i of Reference Ellipsoid
|
||||
% 1. International Ellipsoid 1924
|
||||
% 2. International Ellipsoid 1967
|
||||
% 3. World Geodetic System 1972
|
||||
% 4. Geodetic Reference System 1980
|
||||
% 5. World Geodetic System 1984
|
||||
%
|
||||
% Inputs:
|
||||
% phi - geocentric latitude (format [degrees minutes seconds])
|
||||
% lambda - geocentric longitude (format [degrees minutes seconds])
|
||||
% h - height
|
||||
% i - reference ellipsoid type
|
||||
%
|
||||
% Outputs:
|
||||
% X, Y, Z - Cartesian coordinates (meters)
|
||||
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Kai Borre, 1998
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
%==========================================================================
|
||||
|
||||
b = phi(1) + phi(2)/60 + phi(3)/3600;
|
||||
b = b*pi / 180;
|
||||
l = lambda(1) + lambda(2)/60 + lambda(3)/3600;
|
||||
l = l*pi / 180;
|
||||
|
||||
a = [6378388 6378160 6378135 6378137 6378137];
|
||||
f = [1/297 1/298.247 1/298.26 1/298.257222101 1/298.257223563];
|
||||
|
||||
ex2 = (2-f(i))*f(i) / ((1-f(i))^2);
|
||||
c = a(i) * sqrt(1+ex2);
|
||||
N = c / sqrt(1 + ex2*cos(b)^2);
|
||||
|
||||
X = (N+h) * cos(b) * cos(l);
|
||||
Y = (N+h) * cos(b) * sin(l);
|
||||
Z = ((1-f(i))^2*N + h) * sin(b);
|
||||
|
||||
%%%%%%%%%%%%%% end geo2cart.m %%%%%%%%%%%%%%%%%%%%%%%%
|
||||
116
utils/matlab/libs/geoFunctions/leastSquarePos.m
Normal file
116
utils/matlab/libs/geoFunctions/leastSquarePos.m
Normal file
@@ -0,0 +1,116 @@
|
||||
function [pos, el, az, dop] = leastSquarePos(satpos, obs, settings)
|
||||
% Function calculates the Least Square Solution.
|
||||
%
|
||||
% [pos, el, az, dop] = leastSquarePos(satpos, obs, settings);
|
||||
%
|
||||
% Inputs:
|
||||
% satpos - Satellites positions (in ECEF system: [X; Y; Z;] -
|
||||
% one column per satellite)
|
||||
% obs - Observations - the pseudorange measurements to each
|
||||
% satellite:
|
||||
% (e.g. [20000000 21000000 .... .... .... .... ....])
|
||||
% settings - receiver settings
|
||||
%
|
||||
% Outputs:
|
||||
% pos - receiver position and receiver clock error
|
||||
% (in ECEF system: [X, Y, Z, dt])
|
||||
% el - Satellites elevation angles (degrees)
|
||||
% az - Satellites azimuth angles (degrees)
|
||||
% dop - Dilutions Of Precision ([GDOP PDOP HDOP VDOP TDOP])
|
||||
|
||||
%--------------------------------------------------------------------------
|
||||
% SoftGNSS v3.0
|
||||
%--------------------------------------------------------------------------
|
||||
% Based on Kai Borre
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Kai Borre
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
%==========================================================================
|
||||
|
||||
%=== Initialization =======================================================
|
||||
nmbOfIterations = 7;
|
||||
|
||||
dtr = pi/180;
|
||||
pos = zeros(4, 1);
|
||||
X = satpos;
|
||||
nmbOfSatellites = size(satpos, 2);
|
||||
|
||||
A = zeros(nmbOfSatellites, 4);
|
||||
omc = zeros(nmbOfSatellites, 1);
|
||||
az = zeros(1, nmbOfSatellites);
|
||||
el = az;
|
||||
|
||||
%=== Iteratively find receiver position ===================================
|
||||
for iter = 1:nmbOfIterations
|
||||
|
||||
for i = 1:nmbOfSatellites
|
||||
if iter == 1
|
||||
%--- Initialize variables at the first iteration --------------
|
||||
Rot_X = X(:, i);
|
||||
trop = 2;
|
||||
else
|
||||
%--- Update equations -----------------------------------------
|
||||
rho2 = (X(1, i) - pos(1))^2 + (X(2, i) - pos(2))^2 + ...
|
||||
(X(3, i) - pos(3))^2;
|
||||
traveltime = sqrt(rho2) / settings.c ;
|
||||
|
||||
%--- Correct satellite position (do to earth rotation) --------
|
||||
Rot_X = e_r_corr(traveltime, X(:, i));
|
||||
|
||||
%--- Find the elevation angel of the satellite ----------------
|
||||
[az(i), el(i), dist] = topocent(pos(1:3, :), Rot_X - pos(1:3, :));
|
||||
|
||||
if (settings.useTropCorr == 1)
|
||||
%--- Calculate tropospheric correction --------------------
|
||||
trop = tropo(sin(el(i) * dtr), ...
|
||||
0.0, 1013.0, 293.0, 50.0, 0.0, 0.0, 0.0);
|
||||
else
|
||||
% Do not calculate or apply the tropospheric corrections
|
||||
trop = 0;
|
||||
end
|
||||
end % if iter == 1 ... ... else
|
||||
|
||||
%--- Apply the corrections ----------------------------------------
|
||||
omc(i) = (obs(i) - norm(Rot_X - pos(1:3), 'fro') - pos(4) - trop);
|
||||
|
||||
%--- Construct the A matrix ---------------------------------------
|
||||
A(i, :) = [ (-(Rot_X(1) - pos(1))) / obs(i) ...
|
||||
(-(Rot_X(2) - pos(2))) / obs(i) ...
|
||||
(-(Rot_X(3) - pos(3))) / obs(i) ...
|
||||
1 ];
|
||||
end % for i = 1:nmbOfSatellites
|
||||
|
||||
% These lines allow the code to exit gracefully in case of any errors
|
||||
if rank(A) ~= 4
|
||||
pos = zeros(1, 4);
|
||||
return
|
||||
end
|
||||
|
||||
%--- Find position update ---------------------------------------------
|
||||
x = A \ omc;
|
||||
|
||||
%--- Apply position update --------------------------------------------
|
||||
pos = pos + x;
|
||||
|
||||
end % for iter = 1:nmbOfIterations
|
||||
|
||||
pos = pos';
|
||||
|
||||
%=== Calculate Dilution Of Precision ======================================
|
||||
if nargout == 4
|
||||
%--- Initialize output ------------------------------------------------
|
||||
dop = zeros(1, 5);
|
||||
|
||||
%--- Calculate DOP ----------------------------------------------------
|
||||
Q = inv(A'*A);
|
||||
|
||||
dop(1) = sqrt(trace(Q)); % GDOP
|
||||
dop(2) = sqrt(Q(1,1) + Q(2,2) + Q(3,3)); % PDOP
|
||||
dop(3) = sqrt(Q(1,1) + Q(2,2)); % HDOP
|
||||
dop(4) = sqrt(Q(3,3)); % VDOP
|
||||
dop(5) = sqrt(Q(4,4)); % TDOP
|
||||
end
|
||||
129
utils/matlab/libs/geoFunctions/mat2dms.m
Normal file
129
utils/matlab/libs/geoFunctions/mat2dms.m
Normal file
@@ -0,0 +1,129 @@
|
||||
function dmsvec = mat2dms(d,m,s,n)
|
||||
% MAT2DMS Converts a [deg min sec] matrix to vector format
|
||||
%
|
||||
% dms = MAT2DMS(d,m,s) converts a deg:min:sec matrix into a vector
|
||||
% format. The vector format is dms = 100*deg + min + sec/100.
|
||||
% This allows d,m,s triple to be compressed into a single value,
|
||||
% which can then be employed similar to a degree or radian vector.
|
||||
% The inputs d, m and s must be of equal size. Minutes and
|
||||
% second must be between 0 and 60.
|
||||
%
|
||||
% dms = MAT2DMS(mat) assumes and input matrix of [d m s]. This is
|
||||
% useful only for single column vectors for d, m and s.
|
||||
%
|
||||
% dms = MAT2DMS(d,m) and dms = MAT2DMS([d m]) assume that seconds
|
||||
% are zero, s = 0.
|
||||
%
|
||||
% dms = MAT2DMS(d,m,s,n) uses n as the accuracy of the seconds
|
||||
% calculation. n = -2 uses accuracy in the hundredths position,
|
||||
% n = 0 uses accuracy in the units position. Default is n = -5.
|
||||
% For further discussion of the input n, see ROUNDN.
|
||||
%
|
||||
% See also DMS2MAT
|
||||
|
||||
% Written by: E. Byrns, E. Brown
|
||||
% Revision: 1.10 Date: 2002/03/20 21:25:51
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: 1996-2002 Systems Planning and Analysis, Inc. and The MathWorks, Inc.
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
|
||||
if nargin == 0
|
||||
error('Incorrect number of arguments')
|
||||
|
||||
elseif nargin==1
|
||||
if size(d,2)== 3
|
||||
s = d(:,3); m = d(:,2); d = d(:,1);
|
||||
elseif size(d,2)== 2
|
||||
m = d(:,2); d = d(:,1); s = zeros(size(d));
|
||||
elseif size(d,2) == 0
|
||||
d = []; m = []; s = [];
|
||||
else
|
||||
error('Single input matrices must be n-by-2 or n-by-3.');
|
||||
end
|
||||
n = -5;
|
||||
|
||||
elseif nargin == 2
|
||||
s = zeros(size(d));
|
||||
n = -5;
|
||||
|
||||
elseif nargin == 3
|
||||
n = -5;
|
||||
end
|
||||
|
||||
% Test for empty arguments
|
||||
|
||||
if isempty(d) & isempty(m) & isempty(s); dmsvec = []; return; end
|
||||
|
||||
% Don't let seconds be rounded beyond the tens place.
|
||||
% If you did, then 55 seconds rounds to 100, which is not good.
|
||||
|
||||
if n == 2; n = 1; end
|
||||
|
||||
% Complex argument tests
|
||||
|
||||
if any([~isreal(d) ~isreal(m) ~isreal(s)])
|
||||
warning('Imaginary parts of complex ANGLE argument ignored')
|
||||
d = real(d); m = real(m); s = real(s);
|
||||
end
|
||||
|
||||
% Dimension and value tests
|
||||
|
||||
if ~isequal(size(d),size(m),size(s))
|
||||
error('Inconsistent dimensions for input arguments')
|
||||
elseif any(rem(d(~isnan(d)),1) ~= 0 | rem(m(~isnan(m)),1) ~= 0)
|
||||
error('Degrees and minutes must be integers')
|
||||
end
|
||||
|
||||
if any(abs(m) > 60) | any (abs(m) < 0) % Actually algorithm allows for
|
||||
error('Minutes must be >= 0 and < 60') % up to exactly 60 seconds or
|
||||
% 60 minutes, but the error message
|
||||
elseif any(abs(s) > 60) | any(abs(s) < 0) % doesn't reflect this so that angst
|
||||
error('Seconds must be >= 0 and < 60') % is minimized in the user docs
|
||||
end
|
||||
|
||||
% Ensure that only one negative sign is present and at the correct location
|
||||
|
||||
if any((s<0 & m<0) | (s<0 & d<0) | (m<0 & d<0) )
|
||||
error('Multiple negative entries in a DMS specification')
|
||||
elseif any((s<0 & (m~=0 | d~= 0)) | (m<0 & d~=0))
|
||||
error('Incorrect negative DMS specification')
|
||||
end
|
||||
|
||||
% Construct a sign vector which has +1 when
|
||||
% angle >= 0 and -1 when angle < 0. Note that the sign of the
|
||||
% angle is associated with the largest nonzero component of d:m:s
|
||||
|
||||
negvec = (d<0) | (m<0) | (s<0);
|
||||
signvec = ~negvec - negvec;
|
||||
|
||||
% Convert to all positive numbers. Allows for easier
|
||||
% adjusting at 60 seconds and 60 minutes
|
||||
|
||||
d = abs(d); m = abs(m); s = abs(s);
|
||||
|
||||
% Truncate seconds to a specified accuracy to eliminate round-off errors
|
||||
|
||||
[s,msg] = roundn(s,n);
|
||||
if ~isempty(msg); error(msg); end
|
||||
|
||||
% Adjust for 60 seconds or 60 minutes. If s > 60, this can only be
|
||||
% from round-off during roundn since s > 60 is already tested above.
|
||||
% This round-off effect has happened though.
|
||||
|
||||
indx = find(s >= 60);
|
||||
if ~isempty(indx); m(indx) = m(indx) + 1; s(indx) = 0; end
|
||||
|
||||
% The user can not put minutes > 60 as input. However, the line
|
||||
% above may create minutes > 60 (since the user can put in m == 60),
|
||||
% thus, the test below includes the greater than condition.
|
||||
|
||||
indx = find(m >= 60);
|
||||
if ~isempty(indx); d(indx) = d(indx) + 1; m(indx) = m(indx)-60; end
|
||||
|
||||
% Construct the dms vector format
|
||||
|
||||
dmsvec = signvec .* (100*d + m + s/100);
|
||||
51
utils/matlab/libs/geoFunctions/roundn.m
Normal file
51
utils/matlab/libs/geoFunctions/roundn.m
Normal file
@@ -0,0 +1,51 @@
|
||||
function [x,msg] = roundn(x,n)
|
||||
|
||||
% ROUNDN Rounds input data at specified power of 10
|
||||
%
|
||||
% y = ROUNDN(x) rounds the input data x to the nearest hundredth.
|
||||
%
|
||||
% y = ROUNDN(x,n) rounds the input data x at the specified power
|
||||
% of tens position. For example, n = -2 rounds the input data to
|
||||
% the 10E-2 (hundredths) position.
|
||||
%
|
||||
% [y,msg] = ROUNDN(...) returns the text of any error condition
|
||||
% encountered in the output variable msg.
|
||||
%
|
||||
% See also ROUND
|
||||
|
||||
% Written by: E. Byrns, E. Brown
|
||||
% Revision: 1.9 Date: 2002/03/20 21:26:19
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: 1996-2002 Systems Planning and Analysis, Inc. and The MathWorks, Inc.
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
msg = []; % Initialize output
|
||||
|
||||
if nargin == 0
|
||||
error('Incorrect number of arguments')
|
||||
elseif nargin == 1
|
||||
n = -2;
|
||||
end
|
||||
|
||||
% Test for scalar n
|
||||
|
||||
if max(size(n)) ~= 1
|
||||
msg = 'Scalar accuracy required';
|
||||
if nargout < 2; error(msg); end
|
||||
return
|
||||
elseif ~isreal(n)
|
||||
warning('Imaginary part of complex N argument ignored')
|
||||
n = real(n);
|
||||
end
|
||||
|
||||
% Compute the exponential factors for rounding at specified
|
||||
% power of 10. Ensure that n is an integer.
|
||||
|
||||
factors = 10 ^ (fix(-n));
|
||||
|
||||
% Set the significant digits for the input data
|
||||
|
||||
x = round(x * factors) / factors;
|
||||
143
utils/matlab/libs/geoFunctions/satpos.m
Normal file
143
utils/matlab/libs/geoFunctions/satpos.m
Normal file
@@ -0,0 +1,143 @@
|
||||
function [satPositions, satClkCorr] = satpos(transmitTime, prnList, ...
|
||||
eph, settings)
|
||||
% SATPOS Computation of satellite coordinates X,Y,Z at TRANSMITTIME for
|
||||
% given ephemeris EPH. Coordinates are computed for each satellite in the
|
||||
% list PRNLIST.
|
||||
%[ satPositions, satClkCorr] = satpos(transmitTime, prnList, eph, settings);
|
||||
%
|
||||
% Inputs:
|
||||
% transmitTime - transmission time
|
||||
% prnList - list of PRN-s to be processed
|
||||
% eph - ephemerides of satellites
|
||||
% settings - receiver settings
|
||||
%
|
||||
% Outputs:
|
||||
% satPositions - position of satellites (in ECEF system [X; Y; Z;])
|
||||
% satClkCorr - correction of satellite clocks
|
||||
|
||||
%--------------------------------------------------------------------------
|
||||
% SoftGNSS v3.0
|
||||
%--------------------------------------------------------------------------
|
||||
% Based on Kai Borre 04-09-96
|
||||
% Updated by Darius Plausinaitis, Peter Rinder and Nicolaj Bertelsen
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Kai Borre
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
%% Initialize constants ===================================================
|
||||
numOfSatellites = size(prnList, 2);
|
||||
|
||||
% GPS constatns
|
||||
|
||||
gpsPi = 3.1415926535898; % Pi used in the GPS coordinate
|
||||
% system
|
||||
|
||||
%--- Constants for satellite position calculation -------------------------
|
||||
Omegae_dot = 7.2921151467e-5; % Earth rotation rate, [rad/s]
|
||||
GM = 3.986005e14; % Universal gravitational constant times
|
||||
% the mass of the Earth, [m^3/s^2]
|
||||
F = -4.442807633e-10; % Constant, [sec/(meter)^(1/2)]
|
||||
|
||||
%% Initialize results =====================================================
|
||||
satClkCorr = zeros(1, numOfSatellites);
|
||||
satPositions = zeros(3, numOfSatellites);
|
||||
|
||||
%% Process each satellite =================================================
|
||||
|
||||
for satNr = 1 : numOfSatellites
|
||||
|
||||
prn = prnList(satNr);
|
||||
|
||||
%% Find initial satellite clock correction --------------------------------
|
||||
|
||||
%--- Find time difference ---------------------------------------------
|
||||
dt = check_t(transmitTime - eph(prn).t_oc);
|
||||
|
||||
%--- Calculate clock correction ---------------------------------------
|
||||
satClkCorr(satNr) = (eph(prn).a_f2 * dt + eph(prn).a_f1) * dt + ...
|
||||
eph(prn).a_f0 - ...
|
||||
eph(prn).T_GD;
|
||||
|
||||
time = transmitTime - satClkCorr(satNr);
|
||||
|
||||
%% Find satellite's position ----------------------------------------------
|
||||
|
||||
%Restore semi-major axis
|
||||
a = eph(prn).sqrtA * eph(prn).sqrtA;
|
||||
|
||||
%Time correction
|
||||
tk = check_t(time - eph(prn).t_oe);
|
||||
|
||||
%Initial mean motion
|
||||
n0 = sqrt(GM / a^3);
|
||||
%Mean motion
|
||||
n = n0 + eph(prn).deltan;
|
||||
|
||||
%Mean anomaly
|
||||
M = eph(prn).M_0 + n * tk;
|
||||
%Reduce mean anomaly to between 0 and 360 deg
|
||||
M = rem(M + 2*gpsPi, 2*gpsPi);
|
||||
|
||||
%Initial guess of eccentric anomaly
|
||||
E = M;
|
||||
|
||||
%--- Iteratively compute eccentric anomaly ----------------------------
|
||||
for ii = 1:10
|
||||
E_old = E;
|
||||
E = M + eph(prn).e * sin(E);
|
||||
dE = rem(E - E_old, 2*gpsPi);
|
||||
|
||||
if abs(dE) < 1.e-12
|
||||
% Necessary precision is reached, exit from the loop
|
||||
break;
|
||||
end
|
||||
end
|
||||
|
||||
%Reduce eccentric anomaly to between 0 and 360 deg
|
||||
E = rem(E + 2*gpsPi, 2*gpsPi);
|
||||
|
||||
%Compute relativistic correction term
|
||||
dtr = F * eph(prn).e * eph(prn).sqrtA * sin(E);
|
||||
|
||||
%Calculate the true anomaly
|
||||
nu = atan2(sqrt(1 - eph(prn).e^2) * sin(E), cos(E)-eph(prn).e);
|
||||
|
||||
%Compute angle phi
|
||||
phi = nu + eph(prn).omega;
|
||||
%Reduce phi to between 0 and 360 deg
|
||||
phi = rem(phi, 2*gpsPi);
|
||||
|
||||
%Correct argument of latitude
|
||||
u = phi + ...
|
||||
eph(prn).C_uc * cos(2*phi) + ...
|
||||
eph(prn).C_us * sin(2*phi);
|
||||
%Correct radius
|
||||
r = a * (1 - eph(prn).e*cos(E)) + ...
|
||||
eph(prn).C_rc * cos(2*phi) + ...
|
||||
eph(prn).C_rs * sin(2*phi);
|
||||
%Correct inclination
|
||||
i = eph(prn).i_0 + eph(prn).iDot * tk + ...
|
||||
eph(prn).C_ic * cos(2*phi) + ...
|
||||
eph(prn).C_is * sin(2*phi);
|
||||
|
||||
%Compute the angle between the ascending node and the Greenwich meridian
|
||||
Omega = eph(prn).omega_0 + (eph(prn).omegaDot - Omegae_dot)*tk - ...
|
||||
Omegae_dot * eph(prn).t_oe;
|
||||
%Reduce to between 0 and 360 deg
|
||||
Omega = rem(Omega + 2*gpsPi, 2*gpsPi);
|
||||
|
||||
%--- Compute satellite coordinates ------------------------------------
|
||||
satPositions(1, satNr) = cos(u)*r * cos(Omega) - sin(u)*r * cos(i)*sin(Omega);
|
||||
satPositions(2, satNr) = cos(u)*r * sin(Omega) + sin(u)*r * cos(i)*cos(Omega);
|
||||
satPositions(3, satNr) = sin(u)*r * sin(i);
|
||||
|
||||
|
||||
%% Include relativistic correction in clock correction --------------------
|
||||
satClkCorr(satNr) = (eph(prn).a_f2 * dt + eph(prn).a_f1) * dt + ...
|
||||
eph(prn).a_f0 - ...
|
||||
eph(prn).T_GD + dtr;
|
||||
|
||||
end % for satNr = 1 : numOfSatellites
|
||||
110
utils/matlab/libs/geoFunctions/togeod.m
Normal file
110
utils/matlab/libs/geoFunctions/togeod.m
Normal file
@@ -0,0 +1,110 @@
|
||||
function [dphi, dlambda, h] = togeod(a, finv, X, Y, Z)
|
||||
% TOGEOD Subroutine to calculate geodetic coordinates latitude, longitude,
|
||||
% height given Cartesian coordinates X,Y,Z, and reference ellipsoid
|
||||
% values semi-major axis (a) and the inverse of flattening (finv).
|
||||
%
|
||||
% [dphi, dlambda, h] = togeod(a, finv, X, Y, Z);
|
||||
%
|
||||
% The units of linear parameters X,Y,Z,a must all agree (m,km,mi,ft,..etc)
|
||||
% The output units of angular quantities will be in decimal degrees
|
||||
% (15.5 degrees not 15 deg 30 min). The output units of h will be the
|
||||
% same as the units of X,Y,Z,a.
|
||||
%
|
||||
% Inputs:
|
||||
% a - semi-major axis of the reference ellipsoid
|
||||
% finv - inverse of flattening of the reference ellipsoid
|
||||
% X,Y,Z - Cartesian coordinates
|
||||
%
|
||||
% Outputs:
|
||||
% dphi - latitude
|
||||
% dlambda - longitude
|
||||
% h - height above reference ellipsoid
|
||||
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: 1987 C. Goad, 1996 Kai Borre
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%==========================================================================
|
||||
|
||||
h = 0;
|
||||
tolsq = 1.e-10;
|
||||
maxit = 10;
|
||||
|
||||
% compute radians-to-degree factor
|
||||
rtd = 180/pi;
|
||||
|
||||
% compute square of eccentricity
|
||||
if finv < 1.e-20
|
||||
esq = 0;
|
||||
else
|
||||
esq = (2 - 1/finv) / finv;
|
||||
end
|
||||
|
||||
oneesq = 1 - esq;
|
||||
|
||||
% first guess
|
||||
% P is distance from spin axis
|
||||
P = sqrt(X^2+Y^2);
|
||||
% direct calculation of longitude
|
||||
|
||||
if P > 1.e-20
|
||||
dlambda = atan2(Y,X) * rtd;
|
||||
else
|
||||
dlambda = 0;
|
||||
end
|
||||
|
||||
if (dlambda < 0)
|
||||
dlambda = dlambda + 360;
|
||||
end
|
||||
|
||||
% r is distance from origin (0,0,0)
|
||||
r = sqrt(P^2 + Z^2);
|
||||
|
||||
if r > 1.e-20
|
||||
sinphi = Z/r;
|
||||
else
|
||||
sinphi = 0;
|
||||
end
|
||||
|
||||
dphi = asin(sinphi);
|
||||
|
||||
% initial value of height = distance from origin minus
|
||||
% approximate distance from origin to surface of ellipsoid
|
||||
if r < 1.e-20
|
||||
h = 0;
|
||||
return
|
||||
end
|
||||
|
||||
h = r - a*(1-sinphi*sinphi/finv);
|
||||
|
||||
% iterate
|
||||
for i = 1:maxit
|
||||
sinphi = sin(dphi);
|
||||
cosphi = cos(dphi);
|
||||
|
||||
% compute radius of curvature in prime vertical direction
|
||||
N_phi = a/sqrt(1-esq*sinphi*sinphi);
|
||||
|
||||
% compute residuals in P and Z
|
||||
dP = P - (N_phi + h) * cosphi;
|
||||
dZ = Z - (N_phi*oneesq + h) * sinphi;
|
||||
|
||||
% update height and latitude
|
||||
h = h + (sinphi*dZ + cosphi*dP);
|
||||
dphi = dphi + (cosphi*dZ - sinphi*dP)/(N_phi + h);
|
||||
|
||||
% test for convergence
|
||||
if (dP*dP + dZ*dZ < tolsq)
|
||||
break;
|
||||
end
|
||||
|
||||
% Not Converged--Warn user
|
||||
if i == maxit
|
||||
fprintf([' Problem in TOGEOD, did not converge in %2.0f',...
|
||||
' iterations\n'], i);
|
||||
end
|
||||
end % for i = 1:maxit
|
||||
|
||||
dphi = dphi * rtd;
|
||||
%%%%%%%% end togeod.m %%%%%%%%%%%%%%%%%%%%%%
|
||||
58
utils/matlab/libs/geoFunctions/topocent.m
Normal file
58
utils/matlab/libs/geoFunctions/topocent.m
Normal file
@@ -0,0 +1,58 @@
|
||||
function [Az, El, D] = topocent(X, dx)
|
||||
% TOPOCENT Transformation of vector dx into topocentric coordinate
|
||||
% system with origin at X.
|
||||
% Both parameters are 3 by 1 vectors.
|
||||
%
|
||||
% [Az, El, D] = topocent(X, dx);
|
||||
%
|
||||
% Inputs:
|
||||
% X - vector origin coordinates (in ECEF system [X; Y; Z;])
|
||||
% dx - vector ([dX; dY; dZ;]).
|
||||
%
|
||||
% Outputs:
|
||||
% D - vector length. Units like units of the input
|
||||
% Az - azimuth from north positive clockwise, degrees
|
||||
% El - elevation angle, degrees
|
||||
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Kai Borre 11-24-96
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
%==========================================================================
|
||||
|
||||
dtr = pi/180;
|
||||
|
||||
[phi, lambda, h] = togeod(6378137, 298.257223563, X(1), X(2), X(3));
|
||||
|
||||
cl = cos(lambda * dtr);
|
||||
sl = sin(lambda * dtr);
|
||||
cb = cos(phi * dtr);
|
||||
sb = sin(phi * dtr);
|
||||
|
||||
F = [-sl -sb*cl cb*cl;
|
||||
cl -sb*sl cb*sl;
|
||||
0 cb sb];
|
||||
|
||||
local_vector = F' * dx;
|
||||
E = local_vector(1);
|
||||
N = local_vector(2);
|
||||
U = local_vector(3);
|
||||
|
||||
hor_dis = sqrt(E^2 + N^2);
|
||||
|
||||
if hor_dis < 1.e-20
|
||||
Az = 0;
|
||||
El = 90;
|
||||
else
|
||||
Az = atan2(E, N)/dtr;
|
||||
El = atan2(U, hor_dis)/dtr;
|
||||
end
|
||||
|
||||
if Az < 0
|
||||
Az = Az + 360;
|
||||
end
|
||||
|
||||
D = sqrt(dx(1)^2 + dx(2)^2 + dx(3)^2);
|
||||
%%%%%%%%% end topocent.m %%%%%%%%%
|
||||
100
utils/matlab/libs/geoFunctions/tropo.m
Normal file
100
utils/matlab/libs/geoFunctions/tropo.m
Normal file
@@ -0,0 +1,100 @@
|
||||
function ddr = tropo(sinel, hsta, p, tkel, hum, hp, htkel, hhum)
|
||||
% TROPO Calculation of tropospheric correction.
|
||||
% The range correction ddr in m is to be subtracted from
|
||||
% pseudo-ranges and carrier phases
|
||||
%
|
||||
% ddr = tropo(sinel, hsta, p, tkel, hum, hp, htkel, hhum);
|
||||
%
|
||||
% Inputs:
|
||||
% sinel - sin of elevation angle of satellite
|
||||
% hsta - height of station in km
|
||||
% p - atmospheric pressure in mb at height hp
|
||||
% tkel - surface temperature in degrees Kelvin at height htkel
|
||||
% hum - humidity in % at height hhum
|
||||
% hp - height of pressure measurement in km
|
||||
% htkel - height of temperature measurement in km
|
||||
% hhum - height of humidity measurement in km
|
||||
%
|
||||
% Outputs:
|
||||
% ddr - range correction (meters)
|
||||
%
|
||||
% Reference
|
||||
% Goad, C.C. & Goodman, L. (1974) A Modified Tropospheric
|
||||
% Refraction Correction Model. Paper presented at the
|
||||
% American Geophysical Union Annual Fall Meeting, San
|
||||
% Francisco, December 12-17
|
||||
|
||||
% A Matlab reimplementation of a C code from driver.
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Kai Borre 06-28-95
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%==========================================================================
|
||||
|
||||
a_e = 6378.137; % semi-major axis of earth ellipsoid
|
||||
b0 = 7.839257e-5;
|
||||
tlapse = -6.5;
|
||||
tkhum = tkel + tlapse*(hhum-htkel);
|
||||
atkel = 7.5*(tkhum-273.15) / (237.3+tkhum-273.15);
|
||||
e0 = 0.0611 * hum * 10^atkel;
|
||||
tksea = tkel - tlapse*htkel;
|
||||
em = -978.77 / (2.8704e6*tlapse*1.0e-5);
|
||||
tkelh = tksea + tlapse*hhum;
|
||||
e0sea = e0 * (tksea/tkelh)^(4*em);
|
||||
tkelp = tksea + tlapse*hp;
|
||||
psea = p * (tksea/tkelp)^em;
|
||||
|
||||
if sinel < 0
|
||||
sinel = 0;
|
||||
end
|
||||
|
||||
tropo = 0;
|
||||
done = 'FALSE';
|
||||
refsea = 77.624e-6 / tksea;
|
||||
htop = 1.1385e-5 / refsea;
|
||||
refsea = refsea * psea;
|
||||
ref = refsea * ((htop-hsta)/htop)^4;
|
||||
|
||||
while 1
|
||||
rtop = (a_e+htop)^2 - (a_e+hsta)^2*(1-sinel^2);
|
||||
|
||||
% check to see if geometry is crazy
|
||||
if rtop < 0
|
||||
rtop = 0;
|
||||
end
|
||||
|
||||
rtop = sqrt(rtop) - (a_e+hsta)*sinel;
|
||||
a = -sinel/(htop-hsta);
|
||||
b = -b0*(1-sinel^2) / (htop-hsta);
|
||||
rn = zeros(8,1);
|
||||
|
||||
for i = 1:8
|
||||
rn(i) = rtop^(i+1);
|
||||
end
|
||||
|
||||
alpha = [2*a, 2*a^2+4*b/3, a*(a^2+3*b),...
|
||||
a^4/5+2.4*a^2*b+1.2*b^2, 2*a*b*(a^2+3*b)/3,...
|
||||
b^2*(6*a^2+4*b)*1.428571e-1, 0, 0];
|
||||
|
||||
if b^2 > 1.0e-35
|
||||
alpha(7) = a*b^3/2;
|
||||
alpha(8) = b^4/9;
|
||||
end
|
||||
|
||||
dr = rtop;
|
||||
dr = dr + alpha*rn;
|
||||
tropo = tropo + dr*ref*1000;
|
||||
|
||||
if done == 'TRUE '
|
||||
ddr = tropo;
|
||||
break;
|
||||
end
|
||||
|
||||
done = 'TRUE ';
|
||||
refsea = (371900.0e-6/tksea-12.92e-6)/tksea;
|
||||
htop = 1.1385e-5 * (1255/tksea+0.05)/refsea;
|
||||
ref = refsea * e0sea * ((htop-hsta)/htop)^4;
|
||||
end;
|
||||
%%%%%%%%% end tropo.m %%%%%%%%%%%%%%%%%%%
|
||||
176
utils/matlab/libs/gps_l1_ca_dll_pll_read_tracking_dump.m
Normal file
176
utils/matlab/libs/gps_l1_ca_dll_pll_read_tracking_dump.m
Normal file
@@ -0,0 +1,176 @@
|
||||
% Usage: gps_l1_ca_dll_pll_read_tracking_dump (filename, [count])
|
||||
%
|
||||
% Read GNSS-SDR Tracking dump binary file into MATLAB.
|
||||
% Opens GNSS-SDR tracking binary log file .dat and returns the contents
|
||||
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Javier Arribas 2011
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%
|
||||
% -------------------------------------------------------------------------
|
||||
|
||||
|
||||
function [GNSS_tracking] = gps_l1_ca_dll_pll_read_tracking_dump (filename, count)
|
||||
|
||||
m = nargchk (1,2,nargin);
|
||||
num_float_vars=5;
|
||||
num_unsigned_long_int_vars=1;
|
||||
num_double_vars=11;
|
||||
num_unsigned_int_vars=1;
|
||||
double_size_bytes=8;
|
||||
unsigned_long_int_size_bytes=8;
|
||||
float_size_bytes=4;
|
||||
long_int_size_bytes=4;
|
||||
|
||||
skip_bytes_each_read=float_size_bytes*num_float_vars+unsigned_long_int_size_bytes*num_unsigned_long_int_vars+double_size_bytes*num_double_vars+long_int_size_bytes*num_unsigned_int_vars;
|
||||
bytes_shift=0;
|
||||
if (m)
|
||||
usage (m);
|
||||
end
|
||||
|
||||
if (nargin < 2)
|
||||
%count = Inf;
|
||||
file_stats = dir(filename);
|
||||
%round num bytes to read to integer number of samples (to protect the script from binary
|
||||
%dump end file transitory)
|
||||
count = (file_stats.bytes - mod(file_stats.bytes,skip_bytes_each_read))/skip_bytes_each_read;
|
||||
end
|
||||
%loops_counter = fread (f, count, 'uint32',4*12);
|
||||
f = fopen (filename, 'rb');
|
||||
if (f < 0)
|
||||
else
|
||||
v1 = fread (f, count, 'float',skip_bytes_each_read-float_size_bytes);
|
||||
bytes_shift=bytes_shift+float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved float
|
||||
v2 = fread (f, count, 'float',skip_bytes_each_read-float_size_bytes);
|
||||
bytes_shift=bytes_shift+float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved float
|
||||
v3 = fread (f, count, 'float',skip_bytes_each_read-float_size_bytes);
|
||||
bytes_shift=bytes_shift+float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved float
|
||||
v4 = fread (f, count, 'float',skip_bytes_each_read-float_size_bytes);
|
||||
bytes_shift=bytes_shift+float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved float
|
||||
v5 = fread (f, count, 'float',skip_bytes_each_read-float_size_bytes);
|
||||
bytes_shift=bytes_shift+float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved unsigned_long_int
|
||||
v6 = fread (f, count, 'uint64',skip_bytes_each_read-unsigned_long_int_size_bytes);
|
||||
bytes_shift=bytes_shift+unsigned_long_int_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved double
|
||||
v7 = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved double
|
||||
v8 = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved double
|
||||
v9 = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved double
|
||||
v10 = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved double
|
||||
v11 = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved double
|
||||
v12 = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved double
|
||||
v13 = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved double
|
||||
v14 = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved double
|
||||
v15 = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved double
|
||||
v16 = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved double
|
||||
v17 = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved double
|
||||
v18 = fread (f, count, 'uint32',skip_bytes_each_read-double_size_bytes);
|
||||
fclose (f);
|
||||
|
||||
%%%%%%%% output vars %%%%%%%%
|
||||
|
||||
% // EPR
|
||||
% d_dump_file.write(reinterpret_cast<char*>(&tmp_E), sizeof(float));
|
||||
% d_dump_file.write(reinterpret_cast<char*>(&tmp_P), sizeof(float));
|
||||
% d_dump_file.write(reinterpret_cast<char*>(&tmp_L), sizeof(float));
|
||||
% // PROMPT I and Q (to analyze navigation symbols)
|
||||
% d_dump_file.write(reinterpret_cast<char*>(&prompt_I), sizeof(float));
|
||||
% d_dump_file.write(reinterpret_cast<char*>(&prompt_Q), sizeof(float));
|
||||
% // PRN start sample stamp
|
||||
% //tmp_float=(float)d_sample_counter;
|
||||
% d_dump_file.write(reinterpret_cast<char*>(&d_sample_counter), sizeof(unsigned long int));
|
||||
% // accumulated carrier phase
|
||||
% d_dump_file.write(reinterpret_cast<char*>(&d_acc_carrier_phase_rad), sizeof(double));
|
||||
%
|
||||
% // carrier and code frequency
|
||||
% d_dump_file.write(reinterpret_cast<char*>(&d_carrier_doppler_hz), sizeof(double));
|
||||
% d_dump_file.write(reinterpret_cast<char*>(&d_code_freq_chips), sizeof(double));
|
||||
%
|
||||
% //PLL commands
|
||||
% d_dump_file.write(reinterpret_cast<char*>(&carr_phase_error_secs_Ti), sizeof(double));
|
||||
% d_dump_file.write(reinterpret_cast<char*>(&d_carrier_doppler_hz), sizeof(double));
|
||||
%
|
||||
% //DLL commands
|
||||
% d_dump_file.write(reinterpret_cast<char*>(&code_error_chips_Ti), sizeof(double));
|
||||
% d_dump_file.write(reinterpret_cast<char*>(&code_error_filt_chips), sizeof(double));
|
||||
%
|
||||
% // CN0 and carrier lock test
|
||||
% d_dump_file.write(reinterpret_cast<char*>(&d_CN0_SNV_dB_Hz), sizeof(double));
|
||||
% d_dump_file.write(reinterpret_cast<char*>(&d_carrier_lock_test), sizeof(double));
|
||||
%
|
||||
% // AUX vars (for debug purposes)
|
||||
% tmp_double = d_rem_code_phase_samples;
|
||||
% d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
|
||||
% tmp_double = static_cast<double>(d_sample_counter + d_current_prn_length_samples);
|
||||
% d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
|
||||
% // PRN
|
||||
% unsigned int prn_ = d_acquisition_gnss_synchro->PRN;
|
||||
% d_dump_file.write(reinterpret_cast<char*>(&prn_), sizeof(unsigned int));
|
||||
E=v1;
|
||||
P=v2;
|
||||
L=v3;
|
||||
prompt_I=v4;
|
||||
prompt_Q=v5;
|
||||
PRN_start_sample=v6;
|
||||
acc_carrier_phase_rad=v7;
|
||||
carrier_doppler_hz=v8;
|
||||
code_freq_hz=v9;
|
||||
carr_error=v10;
|
||||
carr_nco=v11;
|
||||
code_error=v12;
|
||||
code_nco=v13;
|
||||
CN0_SNV_dB_Hz=v14;
|
||||
carrier_lock_test=v15;
|
||||
var1=v16;
|
||||
var2=v17;
|
||||
PRN=v18;
|
||||
|
||||
GNSS_tracking.E=E;
|
||||
GNSS_tracking.P=P;
|
||||
GNSS_tracking.L=L;
|
||||
GNSS_tracking.prompt_I=prompt_I;
|
||||
GNSS_tracking.prompt_Q=prompt_Q;
|
||||
GNSS_tracking.PRN_start_sample=PRN_start_sample;
|
||||
GNSS_tracking.acc_carrier_phase_rad=acc_carrier_phase_rad;
|
||||
GNSS_tracking.carrier_doppler_hz=carrier_doppler_hz;
|
||||
GNSS_tracking.code_freq_hz=code_freq_hz;
|
||||
GNSS_tracking.carr_error=carr_error;
|
||||
GNSS_tracking.carr_nco=carr_nco;
|
||||
GNSS_tracking.code_error=code_error
|
||||
GNSS_tracking.code_nco=code_nco;
|
||||
GNSS_tracking.CN0_SNV_dB_Hz=CN0_SNV_dB_Hz;
|
||||
GNSS_tracking.carrier_lock_test=carrier_lock_test;
|
||||
GNSS_tracking.d_rem_code_phase_samples=var1;
|
||||
GNSS_tracking.var2=var2;
|
||||
GNSS_tracking.PRN=PRN;
|
||||
end
|
||||
143
utils/matlab/libs/gps_l1_ca_kf_read_tracking_dump.m
Normal file
143
utils/matlab/libs/gps_l1_ca_kf_read_tracking_dump.m
Normal file
@@ -0,0 +1,143 @@
|
||||
% Usage: gps_l1_ca_kf_read_tracking_dump (filename, [count])
|
||||
%
|
||||
% Read GNSS-SDR Tracking dump binary file into MATLAB.
|
||||
% Opens GNSS-SDR tracking binary log file .dat and returns the contents
|
||||
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Javier Arribas 2011
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%
|
||||
% -------------------------------------------------------------------------
|
||||
|
||||
|
||||
function [GNSS_tracking] = gps_l1_ca_kf_read_tracking_dump (filename, count)
|
||||
|
||||
m = nargchk (1,2,nargin);
|
||||
|
||||
num_float_vars = 19;
|
||||
num_unsigned_long_int_vars = 1;
|
||||
num_double_vars = 1;
|
||||
num_unsigned_int_vars = 1;
|
||||
|
||||
if(~isempty(strfind(computer('arch'), '64')))
|
||||
% 64-bit computer
|
||||
double_size_bytes = 8;
|
||||
unsigned_long_int_size_bytes = 8;
|
||||
float_size_bytes = 4;
|
||||
unsigned_int_size_bytes = 4;
|
||||
else
|
||||
double_size_bytes = 8;
|
||||
unsigned_long_int_size_bytes = 4;
|
||||
float_size_bytes = 4;
|
||||
unsigned_int_size_bytes = 4;
|
||||
end
|
||||
|
||||
skip_bytes_each_read = float_size_bytes * num_float_vars + unsigned_long_int_size_bytes * num_unsigned_long_int_vars + ...
|
||||
double_size_bytes * num_double_vars + num_unsigned_int_vars*unsigned_int_size_bytes;
|
||||
|
||||
bytes_shift = 0;
|
||||
|
||||
if (m)
|
||||
usage (m);
|
||||
end
|
||||
|
||||
if (nargin < 2)
|
||||
count = Inf;
|
||||
end
|
||||
%loops_counter = fread (f, count, 'uint32',4*12);
|
||||
f = fopen (filename, 'rb');
|
||||
if (f < 0)
|
||||
else
|
||||
v1 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v2 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v3 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v4 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v5 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v6 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v7 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved float
|
||||
v8 = fread (f, count, 'long', skip_bytes_each_read - unsigned_long_int_size_bytes);
|
||||
bytes_shift = bytes_shift + unsigned_long_int_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v9 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v10 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v11 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v12 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v13 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v14 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v15 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v16 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v17 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v18 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved float
|
||||
v19 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next float
|
||||
v20 = fread (f, count, 'float', skip_bytes_each_read-float_size_bytes);
|
||||
bytes_shift = bytes_shift + float_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next double
|
||||
v21 = fread (f, count, 'double', skip_bytes_each_read - double_size_bytes);
|
||||
bytes_shift = bytes_shift + double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next unsigned int
|
||||
v22 = fread (f, count, 'uint', skip_bytes_each_read - unsigned_int_size_bytes);
|
||||
fclose (f);
|
||||
|
||||
GNSS_tracking.VE = v1;
|
||||
GNSS_tracking.E = v2;
|
||||
GNSS_tracking.P = v3;
|
||||
GNSS_tracking.L = v4;
|
||||
GNSS_tracking.VL = v5;
|
||||
GNSS_tracking.prompt_I = v6;
|
||||
GNSS_tracking.prompt_Q = v7;
|
||||
GNSS_tracking.PRN_start_sample = v8;
|
||||
GNSS_tracking.acc_carrier_phase_rad = v9;
|
||||
GNSS_tracking.carrier_doppler_hz = v10;
|
||||
GNSS_tracking.carrier_dopplerrate_hz2 = v11;
|
||||
GNSS_tracking.code_freq_hz = v12;
|
||||
GNSS_tracking.carr_error = v13;
|
||||
GNSS_tracking.carr_noise_sigma2 = v14;
|
||||
GNSS_tracking.carr_nco = v15;
|
||||
GNSS_tracking.code_error = v16;
|
||||
GNSS_tracking.code_nco = v17;
|
||||
GNSS_tracking.CN0_SNV_dB_Hz = v18;
|
||||
GNSS_tracking.carrier_lock_test = v19;
|
||||
GNSS_tracking.var1 = v20;
|
||||
GNSS_tracking.var2 = v21;
|
||||
GNSS_tracking.PRN = v22;
|
||||
end
|
||||
97
utils/matlab/libs/gps_l1_ca_pvt_read_pvt_dump.m
Normal file
97
utils/matlab/libs/gps_l1_ca_pvt_read_pvt_dump.m
Normal file
@@ -0,0 +1,97 @@
|
||||
% Read GNSS-SDR PVT lib dump binary file into MATLAB. The resulting
|
||||
% structure is compatible with the K.Borre MATLAB-based receiver.
|
||||
%
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Javier Arribas 2011
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
|
||||
function [navSolutions] = gps_l1_ca_pvt_read_pvt_dump (filename, count)
|
||||
|
||||
%% usage: gps_l1_ca_pvt_read_pvt_dump (filename, [count])
|
||||
%%
|
||||
%% open GNSS-SDR PVT binary log file .dat and return the contents
|
||||
%%
|
||||
%
|
||||
% // PVT GPS time
|
||||
% tmp_double=GPS_current_time;
|
||||
% d_dump_file.write((char*)&tmp_double, sizeof(double));
|
||||
% // ECEF User Position East [m]
|
||||
% tmp_double=mypos(0);
|
||||
% d_dump_file.write((char*)&tmp_double, sizeof(double));
|
||||
% // ECEF User Position North [m]
|
||||
% tmp_double=mypos(1);
|
||||
% d_dump_file.write((char*)&tmp_double, sizeof(double));
|
||||
% // ECEF User Position Up [m]
|
||||
% tmp_double=mypos(2);
|
||||
% d_dump_file.write((char*)&tmp_double, sizeof(double));
|
||||
% // User clock offset [s]
|
||||
% tmp_double=mypos(3);
|
||||
% d_dump_file.write((char*)&tmp_double, sizeof(double));
|
||||
% // GEO user position Latitude [deg]
|
||||
% tmp_double=d_latitude_d;
|
||||
% d_dump_file.write((char*)&tmp_double, sizeof(double));
|
||||
% // GEO user position Longitude [deg]
|
||||
% tmp_double=d_longitude_d;
|
||||
% d_dump_file.write((char*)&tmp_double, sizeof(double));
|
||||
% // GEO user position Height [m]
|
||||
% tmp_double=d_height_m;
|
||||
% d_dump_file.write((char*)&tmp_double, sizeof(double));
|
||||
|
||||
m = nargchk (1,2,nargin);
|
||||
num_double_vars=8;
|
||||
double_size_bytes=8;
|
||||
skip_bytes_each_read=double_size_bytes*num_double_vars;
|
||||
bytes_shift=0;
|
||||
if (m)
|
||||
usage (m);
|
||||
end
|
||||
|
||||
if (nargin < 3)
|
||||
count = Inf;
|
||||
end
|
||||
%loops_counter = fread (f, count, 'uint32',4*12);
|
||||
f = fopen (filename, 'rb');
|
||||
if (f < 0)
|
||||
else
|
||||
GPS_current_time = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
ECEF_X = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
ECEF_Y = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
ECEF_Z = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
Clock_Offset = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
Lat = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
Long = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
Height = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
fclose (f);
|
||||
end
|
||||
|
||||
navSolutions.X=ECEF_X.';
|
||||
navSolutions.Y=ECEF_Y.';
|
||||
navSolutions.Z=ECEF_Z.';
|
||||
navSolutions.dt=Clock_Offset.';
|
||||
navSolutions.latitude=Lat.';
|
||||
navSolutions.longitude=Long.';
|
||||
navSolutions.height=Height.';
|
||||
navSolutions.TransmitTime=GPS_current_time.';
|
||||
57
utils/matlab/libs/gps_l1_ca_read_pvt_raw_dump.m
Normal file
57
utils/matlab/libs/gps_l1_ca_read_pvt_raw_dump.m
Normal file
@@ -0,0 +1,57 @@
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Javier Arribas 2011
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%
|
||||
% -------------------------------------------------------------------------
|
||||
|
||||
function [pvt_raw] = gps_l1_ca_read_pvt_raw_dump (channels, filename, count)
|
||||
|
||||
%% usage: read_tracking_dat (filename, [count])
|
||||
%%
|
||||
%% open GNSS-SDR pvt binary log file .dat and return the contents
|
||||
%%
|
||||
|
||||
m = nargchk (1,2,nargin);
|
||||
num_double_vars=3;
|
||||
double_size_bytes=8;
|
||||
skip_bytes_each_read=double_size_bytes*num_double_vars*channels;
|
||||
bytes_shift=0;
|
||||
if (m)
|
||||
usage (m);
|
||||
end
|
||||
|
||||
if (nargin < 3)
|
||||
count = Inf;
|
||||
end
|
||||
%loops_counter = fread (f, count, 'uint32',4*12);
|
||||
f = fopen (filename, 'rb');
|
||||
if (f < 0)
|
||||
else
|
||||
for N=1:1:channels
|
||||
pvt_raw.Pseudorange_m(N,:) = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
pvt_raw.Pseudorange_symbol_shift(N,:) = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
pvt_raw.tx_time(N,:) = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
end
|
||||
|
||||
fclose (f);
|
||||
|
||||
%%%%%%%% output vars %%%%%%%%
|
||||
% for (unsigned int i=0; i<d_nchannels ; i++)
|
||||
% {
|
||||
% tmp_double = in[i][0].Pseudorange_m;
|
||||
% d_dump_file.write((char*)&tmp_double, sizeof(double));
|
||||
% tmp_double = in[i][0].Pseudorange_symbol_shift;
|
||||
% d_dump_file.write((char*)&tmp_double, sizeof(double));
|
||||
% d_dump_file.write((char*)&d_tx_time, sizeof(double));
|
||||
% }
|
||||
end
|
||||
54
utils/matlab/libs/gps_l1_ca_read_telemetry_dump.m
Normal file
54
utils/matlab/libs/gps_l1_ca_read_telemetry_dump.m
Normal file
@@ -0,0 +1,54 @@
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Javier Arribas 2011
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%
|
||||
% -------------------------------------------------------------------------
|
||||
|
||||
function [telemetry] = gps_l1_ca_read_telemetry_dump (filename, count)
|
||||
|
||||
%%
|
||||
%% open GNSS-SDR tracking binary log file .dat and return the contents
|
||||
%%
|
||||
|
||||
m = nargchk (1,2,nargin);
|
||||
num_double_vars=3;
|
||||
double_size_bytes=8;
|
||||
num_int_vars=2;
|
||||
int_size_bytes=4;
|
||||
skip_bytes_each_read=double_size_bytes*num_double_vars+num_int_vars*int_size_bytes;
|
||||
bytes_shift=0;
|
||||
if (m)
|
||||
usage (m);
|
||||
end
|
||||
|
||||
if (nargin < 3)
|
||||
count = Inf;
|
||||
end
|
||||
f = fopen (filename, 'rb');
|
||||
if (f < 0)
|
||||
else
|
||||
[x, loops_counter] = fread (f,skip_bytes_each_read);
|
||||
fseek(f,0,-1);
|
||||
for i=1:min(count, loops_counter),
|
||||
telemetry(i).tow_current_symbol_ms = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
telemetry(i).tracking_sample_counter = fread (f, count, 'uint64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
telemetry(i).tow = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
telemetry(i).nav_simbols = fread (f, count, 'int32',skip_bytes_each_read-int_size_bytes);
|
||||
bytes_shift=bytes_shift+int_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
telemetry(i).prn = fread (f, count, 'int32',skip_bytes_each_read-int_size_bytes);
|
||||
bytes_shift=bytes_shift+int_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
end
|
||||
fclose (f);
|
||||
end
|
||||
125
utils/matlab/libs/plotKalman.m
Normal file
125
utils/matlab/libs/plotKalman.m
Normal file
@@ -0,0 +1,125 @@
|
||||
function plotKalman(channelList, trackResults, settings)
|
||||
% This function plots the tracking results for the given channel list.
|
||||
%
|
||||
% plotTracking(channelList, trackResults, settings)
|
||||
%
|
||||
% Inputs:
|
||||
% channelList - list of channels to be plotted.
|
||||
% trackResults - tracking results from the tracking function.
|
||||
% settings - receiver settings.
|
||||
|
||||
%--------------------------------------------------------------------------
|
||||
% SoftGNSS v3.0
|
||||
%
|
||||
% Written by Darius Plausinaitis
|
||||
%--------------------------------------------------------------------------
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Darius Plausinaitis
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%--------------------------------------------------------------------------
|
||||
|
||||
% Protection - if the list contains incorrect channel numbers
|
||||
channelList = intersect(channelList, 1:settings.numberOfChannels);
|
||||
|
||||
%=== For all listed channels ==============================================
|
||||
for channelNr = channelList
|
||||
|
||||
%% Select (or create) and clear the figure ================================
|
||||
% The number 200 is added just for more convenient handling of the open
|
||||
% figure windows, when many figures are closed and reopened.
|
||||
% Figures drawn or opened by the user, will not be "overwritten" by
|
||||
% this function.
|
||||
|
||||
figure(channelNr +200);
|
||||
clf(channelNr +200);
|
||||
set(channelNr +200, 'Name', ['Channel ', num2str(channelNr), ...
|
||||
' (PRN ', ...
|
||||
num2str(trackResults(channelNr).PRN(end-1)), ...
|
||||
') results']);
|
||||
|
||||
timeStart = settings.timeStartInSeconds;
|
||||
|
||||
%% Draw axes ==============================================================
|
||||
% Row 1
|
||||
handles(1, 1) = subplot(4, 2, 1);
|
||||
handles(1, 2) = subplot(4, 2, 2);
|
||||
% Row 2
|
||||
handles(2, 1) = subplot(4, 2, 3);
|
||||
handles(2, 2) = subplot(4, 2, 4);
|
||||
% Row 3
|
||||
handles(3, 1) = subplot(4, 2, [5 6]);
|
||||
% Row 4
|
||||
handles(4, 1) = subplot(4, 2, [7 8]);
|
||||
|
||||
%% Plot all figures =======================================================
|
||||
|
||||
timeAxisInSeconds = (1:settings.msToProcess)/1000;
|
||||
|
||||
%----- CNo for signal----------------------------------
|
||||
plot (handles(1, 1), timeAxisInSeconds, ...
|
||||
trackResults(channelNr).CNo(1:settings.msToProcess), 'b');
|
||||
|
||||
grid (handles(1, 1));
|
||||
axis (handles(1, 1), 'tight');
|
||||
xlabel(handles(1, 1), 'Time (s)');
|
||||
ylabel(handles(1, 1), 'CNo (dB-Hz)');
|
||||
title (handles(1, 1), 'Carrier to Noise Ratio');
|
||||
|
||||
%----- PLL discriminator filtered----------------------------------
|
||||
plot (handles(1, 2), timeAxisInSeconds, ...
|
||||
trackResults(channelNr).state1(1:settings.msToProcess), 'b');
|
||||
|
||||
grid (handles(1, 2));
|
||||
axis (handles(1, 2), 'tight');
|
||||
xlim (handles(1, 2), [timeStart, timeAxisInSeconds(end)]);
|
||||
xlabel(handles(1, 2), 'Time (s)');
|
||||
ylabel(handles(1, 2), 'Phase Amplitude');
|
||||
title (handles(1, 2), 'Filtered Carrier Phase');
|
||||
|
||||
%----- Carrier Frequency --------------------------------
|
||||
plot (handles(2, 1), timeAxisInSeconds(2:end), ...
|
||||
trackResults(channelNr).state2(2:settings.msToProcess), 'Color',[0.42 0.25 0.39]);
|
||||
|
||||
grid (handles(2, 1));
|
||||
axis (handles(2, 1));
|
||||
xlim (handles(2, 1), [timeStart, timeAxisInSeconds(end)]);
|
||||
xlabel(handles(2, 1), 'Time (s)');
|
||||
ylabel(handles(2, 1), 'Freq (hz)');
|
||||
title (handles(2, 1), 'Filtered Doppler Frequency');
|
||||
|
||||
%----- Carrier Frequency Rate --------------------------------
|
||||
plot (handles(2, 2), timeAxisInSeconds(2:end), ...
|
||||
trackResults(channelNr).state3(2:settings.msToProcess), 'Color',[0.42 0.25 0.39]);
|
||||
|
||||
grid (handles(2, 2));
|
||||
axis (handles(2, 2));
|
||||
xlim (handles(2, 2), [timeStart, timeAxisInSeconds(end)]);
|
||||
xlabel(handles(2, 2), 'Time (s)');
|
||||
ylabel(handles(2, 2), 'Freq (hz)');
|
||||
title (handles(2, 2), 'Filtered Doppler Frequency Rate');
|
||||
|
||||
%----- PLL discriminator unfiltered--------------------------------
|
||||
plot (handles(3, 1), timeAxisInSeconds, ...
|
||||
trackResults(channelNr).innovation, 'r');
|
||||
|
||||
grid (handles(3, 1));
|
||||
axis (handles(3, 1), 'auto');
|
||||
xlim (handles(3, 1), [timeStart, timeAxisInSeconds(end)]);
|
||||
xlabel(handles(3, 1), 'Time (s)');
|
||||
ylabel(handles(3, 1), 'Amplitude');
|
||||
title (handles(3, 1), 'Raw PLL discriminator (Innovation)');
|
||||
|
||||
|
||||
%----- PLL discriminator covariance --------------------------------
|
||||
plot (handles(4, 1), timeAxisInSeconds, ...
|
||||
trackResults(channelNr).r_noise_cov, 'r');
|
||||
|
||||
grid (handles(4, 1));
|
||||
axis (handles(4, 1), 'auto');
|
||||
xlim (handles(4, 1), [timeStart, timeAxisInSeconds(end)]);
|
||||
xlabel(handles(4, 1), 'Time (s)');
|
||||
ylabel(handles(4, 1), 'Variance');
|
||||
title (handles(4, 1), 'Estimated Noise Variance');
|
||||
end % for channelNr = channelList
|
||||
152
utils/matlab/libs/plotNavigation.m
Normal file
152
utils/matlab/libs/plotNavigation.m
Normal file
@@ -0,0 +1,152 @@
|
||||
% Function plots variations of coordinates over time and a 3D position
|
||||
% plot. It plots receiver coordinates in UTM system or coordinate offsets if
|
||||
% the true UTM receiver coordinates are provided.
|
||||
%
|
||||
% plotNavigation(navSolutions, settings)
|
||||
%
|
||||
% Inputs:
|
||||
% navSolutions - Results from navigation solution function. It
|
||||
% contains measured pseudoranges and receiver
|
||||
% coordinates.
|
||||
% settings - Receiver settings. The true receiver coordinates
|
||||
% are contained in this structure.
|
||||
% plot_skyplot - If ==1 then use satellite coordinates to plot the
|
||||
% the satellite positions
|
||||
|
||||
% Darius Plausinaitis
|
||||
% Modified by Javier Arribas, 2011. jarribas(at)cttc.es
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% Copyright (C) 2010-2019 (see AUTHORS file for a list of contributors)
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
|
||||
function plotNavigation(navSolutions, settings,plot_skyplot)
|
||||
|
||||
|
||||
%% Plot results in the necessary data exists ==============================
|
||||
if (~isempty(navSolutions))
|
||||
|
||||
%% If reference position is not provided, then set reference position
|
||||
%% to the average position
|
||||
if isnan(settings.truePosition.E) || isnan(settings.truePosition.N) ...
|
||||
|| isnan(settings.truePosition.U)
|
||||
|
||||
%=== Compute mean values ==========================================
|
||||
% Remove NaN-s or the output of the function MEAN will be NaN.
|
||||
refCoord.E = mean(navSolutions.E(~isnan(navSolutions.E)));
|
||||
refCoord.N = mean(navSolutions.N(~isnan(navSolutions.N)));
|
||||
refCoord.U = mean(navSolutions.U(~isnan(navSolutions.U)));
|
||||
|
||||
%Also convert geodetic coordinates to deg:min:sec vector format
|
||||
meanLongitude = dms2mat(deg2dms(...
|
||||
mean(navSolutions.longitude(~isnan(navSolutions.longitude)))), -5);
|
||||
meanLatitude = dms2mat(deg2dms(...
|
||||
mean(navSolutions.latitude(~isnan(navSolutions.latitude)))), -5);
|
||||
|
||||
LatLong_str=[num2str(meanLatitude(1)), '??', ...
|
||||
num2str(meanLatitude(2)), '''', ...
|
||||
num2str(meanLatitude(3)), '''''', ...
|
||||
',', ...
|
||||
num2str(meanLongitude(1)), '??', ...
|
||||
num2str(meanLongitude(2)), '''', ...
|
||||
num2str(meanLongitude(3)), '''''']
|
||||
|
||||
|
||||
|
||||
refPointLgText = ['Mean Position\newline Lat: ', ...
|
||||
num2str(meanLatitude(1)), '{\circ}', ...
|
||||
num2str(meanLatitude(2)), '{\prime}', ...
|
||||
num2str(meanLatitude(3)), '{\prime}{\prime}', ...
|
||||
'\newline Lng: ', ...
|
||||
num2str(meanLongitude(1)), '{\circ}', ...
|
||||
num2str(meanLongitude(2)), '{\prime}', ...
|
||||
num2str(meanLongitude(3)), '{\prime}{\prime}', ...
|
||||
'\newline Hgt: ', ...
|
||||
num2str(mean(navSolutions.height(~isnan(navSolutions.height))), '%+6.1f')];
|
||||
|
||||
else
|
||||
% compute the mean error for static receiver
|
||||
mean_position.E = mean(navSolutions.E(~isnan(navSolutions.E)));
|
||||
mean_position.N = mean(navSolutions.N(~isnan(navSolutions.N)));
|
||||
mean_position.U = mean(navSolutions.U(~isnan(navSolutions.U)));
|
||||
refCoord.E = settings.truePosition.E;
|
||||
refCoord.N = settings.truePosition.N;
|
||||
refCoord.U = settings.truePosition.U;
|
||||
|
||||
error_meters=sqrt((mean_position.E-refCoord.E)^2+(mean_position.N-refCoord.N)^2+(mean_position.U-refCoord.U)^2);
|
||||
|
||||
refPointLgText = ['Reference Position, Mean 3D error = ' num2str(error_meters) ' [m]'];
|
||||
end
|
||||
|
||||
figureNumber = 300;
|
||||
% The 300 is chosen for more convenient handling of the open
|
||||
% figure windows, when many figures are closed and reopened. Figures
|
||||
% drawn or opened by the user, will not be "overwritten" by this
|
||||
% function if the auto numbering is not used.
|
||||
|
||||
%=== Select (or create) and clear the figure ==========================
|
||||
figure(figureNumber);
|
||||
clf (figureNumber);
|
||||
set (figureNumber, 'Name', 'Navigation solutions');
|
||||
|
||||
%--- Draw axes --------------------------------------------------------
|
||||
handles(1, 1) = subplot(4, 2, 1 : 4);
|
||||
handles(3, 1) = subplot(4, 2, [5, 7]);
|
||||
handles(3, 2) = subplot(4, 2, [6, 8]);
|
||||
|
||||
%% Plot all figures =======================================================
|
||||
|
||||
%--- Coordinate differences in UTM system -----------------------------
|
||||
plot(handles(1, 1), [(navSolutions.E - refCoord.E)', ...
|
||||
(navSolutions.N - refCoord.N)',...
|
||||
(navSolutions.U - refCoord.U)']);
|
||||
|
||||
title (handles(1, 1), 'Coordinates variations in UTM system');
|
||||
legend(handles(1, 1), 'E', 'N', 'U');
|
||||
xlabel(handles(1, 1), ['Measurement period: ', ...
|
||||
num2str(settings.navSolPeriod), 'ms']);
|
||||
ylabel(handles(1, 1), 'Variations (m)');
|
||||
grid (handles(1, 1));
|
||||
axis (handles(1, 1), 'tight');
|
||||
|
||||
%--- Position plot in UTM system --------------------------------------
|
||||
plot3 (handles(3, 1), navSolutions.E - refCoord.E, ...
|
||||
navSolutions.N - refCoord.N, ...
|
||||
navSolutions.U - refCoord.U, '+');
|
||||
hold (handles(3, 1), 'on');
|
||||
|
||||
%Plot the reference point
|
||||
plot3 (handles(3, 1), 0, 0, 0, 'r+', 'LineWidth', 1.5, 'MarkerSize', 10);
|
||||
hold (handles(3, 1), 'off');
|
||||
|
||||
view (handles(3, 1), 0, 90);
|
||||
axis (handles(3, 1), 'equal');
|
||||
grid (handles(3, 1), 'minor');
|
||||
|
||||
legend(handles(3, 1), 'Measurements', refPointLgText);
|
||||
|
||||
title (handles(3, 1), 'Positions in UTM system (3D plot)');
|
||||
xlabel(handles(3, 1), 'East (m)');
|
||||
ylabel(handles(3, 1), 'North (m)');
|
||||
zlabel(handles(3, 1), 'Upping (m)');
|
||||
|
||||
if (plot_skyplot==1)
|
||||
%--- Satellite sky plot -----------------------------------------------
|
||||
skyPlot(handles(3, 2), ...
|
||||
navSolutions.channel.az, ...
|
||||
navSolutions.channel.el, ...
|
||||
navSolutions.channel.PRN(:, 1));
|
||||
|
||||
title (handles(3, 2), ['Sky plot (mean PDOP: ', ...
|
||||
num2str(mean(navSolutions.DOP(2,:))), ')']);
|
||||
end
|
||||
|
||||
else
|
||||
disp('plotNavigation: No navigation data to plot.');
|
||||
end % if (~isempty(navSolutions))
|
||||
177
utils/matlab/libs/plotTracking.m
Normal file
177
utils/matlab/libs/plotTracking.m
Normal file
@@ -0,0 +1,177 @@
|
||||
function plotTracking(channelList, trackResults, settings)
|
||||
% This function plots the tracking results for the given channel list.
|
||||
%
|
||||
% plotTracking(channelList, trackResults, settings)
|
||||
%
|
||||
% Inputs:
|
||||
% channelList - list of channels to be plotted.
|
||||
% trackResults - tracking results from the tracking function.
|
||||
% settings - receiver settings.
|
||||
|
||||
%--------------------------------------------------------------------------
|
||||
% SoftGNSS v3.0
|
||||
%
|
||||
% Written by Darius Plausinaitis
|
||||
%--------------------------------------------------------------------------
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Darius Plausinaitis
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%--------------------------------------------------------------------------
|
||||
|
||||
|
||||
% Protection - if the list contains incorrect channel numbers
|
||||
channelList = intersect(channelList, 1:settings.numberOfChannels);
|
||||
|
||||
%=== For all listed channels ==============================================
|
||||
for channelNr = channelList
|
||||
|
||||
%% Select (or create) and clear the figure ================================
|
||||
% The number 200 is added just for more convenient handling of the open
|
||||
% figure windows, when many figures are closed and reopened.
|
||||
% Figures drawn or opened by the user, will not be "overwritten" by
|
||||
% this function.
|
||||
|
||||
figure(channelNr +200);
|
||||
clf(channelNr +200);
|
||||
set(channelNr +200, 'Name', ['Channel ', num2str(channelNr), ...
|
||||
' (PRN ', ...
|
||||
num2str(trackResults(channelNr).PRN(end-1)), ...
|
||||
') results']);
|
||||
|
||||
%% Draw axes ==============================================================
|
||||
% Row 1
|
||||
handles(1, 1) = subplot(4, 3, 1);
|
||||
handles(1, 2) = subplot(4, 3, [2 3]);
|
||||
% Row 2
|
||||
handles(2, 1) = subplot(4, 3, 4);
|
||||
handles(2, 2) = subplot(4, 3, [5 6]);
|
||||
% Row 3
|
||||
handles(3, 1) = subplot(4, 3, 7);
|
||||
handles(3, 2) = subplot(4, 3, 8);
|
||||
handles(3, 3) = subplot(4, 3, 9);
|
||||
% Row 4
|
||||
handles(4, 1) = subplot(4, 3, 10);
|
||||
handles(4, 2) = subplot(4, 3, 11);
|
||||
handles(4, 3) = subplot(4, 3, 12);
|
||||
|
||||
|
||||
%% Plot all figures =======================================================
|
||||
|
||||
timeAxisInSeconds = (1:settings.msToProcess)/1000;
|
||||
|
||||
%----- Discrete-Time Scatter Plot ---------------------------------
|
||||
plot(handles(1, 1), trackResults(channelNr).I_P,...
|
||||
trackResults(channelNr).Q_P, ...
|
||||
'.');
|
||||
|
||||
grid (handles(1, 1));
|
||||
axis (handles(1, 1), 'equal');
|
||||
title (handles(1, 1), 'Discrete-Time Scatter Plot');
|
||||
xlabel(handles(1, 1), 'I prompt');
|
||||
ylabel(handles(1, 1), 'Q prompt');
|
||||
|
||||
%----- Nav bits ---------------------------------------------------
|
||||
plot (handles(1, 2), timeAxisInSeconds, ...
|
||||
trackResults(channelNr).I_P);
|
||||
|
||||
grid (handles(1, 2));
|
||||
title (handles(1, 2), 'Bits of the navigation message');
|
||||
xlabel(handles(1, 2), 'Time (s)');
|
||||
axis (handles(1, 2), 'tight');
|
||||
|
||||
%----- PLL discriminator unfiltered--------------------------------
|
||||
plot (handles(2, 1), timeAxisInSeconds, ...
|
||||
trackResults(channelNr).pllDiscr, 'r');
|
||||
|
||||
grid (handles(2, 1));
|
||||
axis (handles(2, 1), 'tight');
|
||||
xlabel(handles(2, 1), 'Time (s)');
|
||||
ylabel(handles(2, 1), 'Amplitude');
|
||||
title (handles(2, 1), 'Raw PLL discriminator');
|
||||
|
||||
%----- Correlation ------------------------------------------------
|
||||
plot(handles(2, 2), timeAxisInSeconds, ...
|
||||
[sqrt(trackResults(channelNr).I_E.^2 + ...
|
||||
trackResults(channelNr).Q_E.^2)', ...
|
||||
sqrt(trackResults(channelNr).I_P.^2 + ...
|
||||
trackResults(channelNr).Q_P.^2)', ...
|
||||
sqrt(trackResults(channelNr).I_L.^2 + ...
|
||||
trackResults(channelNr).Q_L.^2)'], ...
|
||||
'-*');
|
||||
|
||||
grid (handles(2, 2));
|
||||
title (handles(2, 2), 'Correlation results');
|
||||
xlabel(handles(2, 2), 'Time (s)');
|
||||
axis (handles(2, 2), 'tight');
|
||||
|
||||
hLegend = legend(handles(2, 2), '$\sqrt{I_{E}^2 + Q_{E}^2}$', ...
|
||||
'$\sqrt{I_{P}^2 + Q_{P}^2}$', ...
|
||||
'$\sqrt{I_{L}^2 + Q_{L}^2}$');
|
||||
|
||||
%set interpreter from tex to latex. This will draw \sqrt correctly
|
||||
set(hLegend, 'Interpreter', 'Latex');
|
||||
|
||||
%----- PLL discriminator filtered----------------------------------
|
||||
plot (handles(3, 1), timeAxisInSeconds, ...
|
||||
trackResults(channelNr).pllDiscrFilt(1:settings.msToProcess), 'b');
|
||||
|
||||
grid (handles(3, 1));
|
||||
axis (handles(3, 1), 'tight');
|
||||
xlabel(handles(3, 1), 'Time (s)');
|
||||
ylabel(handles(3, 1), 'Amplitude');
|
||||
title (handles(3, 1), 'Filtered PLL discriminator');
|
||||
|
||||
%----- DLL discriminator unfiltered--------------------------------
|
||||
plot (handles(3, 2), timeAxisInSeconds, ...
|
||||
trackResults(channelNr).dllDiscr, 'r');
|
||||
|
||||
grid (handles(3, 2));
|
||||
axis (handles(3, 2), 'tight');
|
||||
xlabel(handles(3, 2), 'Time (s)');
|
||||
ylabel(handles(3, 2), 'Amplitude');
|
||||
title (handles(3, 2), 'Raw DLL discriminator');
|
||||
|
||||
%----- DLL discriminator filtered----------------------------------
|
||||
plot (handles(3, 3), timeAxisInSeconds, ...
|
||||
trackResults(channelNr).dllDiscrFilt, 'b');
|
||||
|
||||
grid (handles(3, 3));
|
||||
axis (handles(3, 3), 'tight');
|
||||
xlabel(handles(3, 3), 'Time (s)');
|
||||
ylabel(handles(3, 3), 'Amplitude');
|
||||
title (handles(3, 3), 'Filtered DLL discriminator');
|
||||
|
||||
%----- CNo for signal----------------------------------
|
||||
plot (handles(4, 1), timeAxisInSeconds, ...
|
||||
trackResults(channelNr).CNo(1:settings.msToProcess), 'b');
|
||||
|
||||
grid (handles(4, 1));
|
||||
axis (handles(4, 1), 'tight');
|
||||
xlabel(handles(4, 1), 'Time (s)');
|
||||
ylabel(handles(4, 1), 'CNo (dB-Hz)');
|
||||
title (handles(4, 1), 'Carrier to Noise Ratio');
|
||||
|
||||
%----- Carrier Frequency --------------------------------
|
||||
plot (handles(4, 2), timeAxisInSeconds(2:end), ...
|
||||
trackResults(channelNr).carrFreq(2:settings.msToProcess), 'Color',[0.42 0.25 0.39]);
|
||||
|
||||
grid (handles(4, 2));
|
||||
axis (handles(4, 2));
|
||||
xlabel(handles(4, 2), 'Time (s)');
|
||||
ylabel(handles(4, 2), 'Freq (hz)');
|
||||
title (handles(4, 2), 'Carrier Freq');
|
||||
|
||||
%----- Code Frequency----------------------------------
|
||||
%--- Skip sample 0 to help with results display
|
||||
plot (handles(4, 3), timeAxisInSeconds(2:end), ...
|
||||
trackResults(channelNr).codeFreq(2:settings.msToProcess), 'Color',[0.2 0.3 0.49]);
|
||||
|
||||
grid (handles(4, 3));
|
||||
axis (handles(4, 3), 'tight');
|
||||
xlabel(handles(4, 3), 'Time (s)');
|
||||
ylabel(handles(4, 3), 'Freq (Hz)');
|
||||
title (handles(4, 3), 'Code Freq');
|
||||
|
||||
end % for channelNr = channelList
|
||||
152
utils/matlab/libs/plotVEMLTracking.m
Normal file
152
utils/matlab/libs/plotVEMLTracking.m
Normal file
@@ -0,0 +1,152 @@
|
||||
function plotVEMLTracking(channelList, trackResults, settings)
|
||||
% This function plots the tracking results for the given channel list.
|
||||
%
|
||||
% plotTracking(channelList, trackResults, settings)
|
||||
%
|
||||
% Inputs:
|
||||
% channelList - list of channels to be plotted.
|
||||
% trackResults - tracking results from the tracking function.
|
||||
% settings - receiver settings.
|
||||
|
||||
%--------------------------------------------------------------------------
|
||||
% SoftGNSS v3.0
|
||||
%
|
||||
% Written by Darius Plausinaitis
|
||||
%--------------------------------------------------------------------------
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Darius Plausinaitis
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%--------------------------------------------------------------------------
|
||||
|
||||
% Protection - if the list contains incorrect channel numbers
|
||||
channelList = intersect(channelList, 1:settings.numberOfChannels);
|
||||
|
||||
%=== For all listed channels ==============================================
|
||||
for channelNr = channelList
|
||||
|
||||
%% Select (or create) and clear the figure ================================
|
||||
% The number 200 is added just for more convenient handling of the open
|
||||
% figure windows, when many figures are closed and reopened.
|
||||
% Figures drawn or opened by the user, will not be "overwritten" by
|
||||
% this function.
|
||||
|
||||
figure(channelNr +200);
|
||||
clf(channelNr +200);
|
||||
set(channelNr +200, 'Name', ['Channel ', num2str(channelNr), ...
|
||||
' (PRN ', ...
|
||||
num2str(trackResults(channelNr).PRN(end-1)), ...
|
||||
') results']);
|
||||
|
||||
%% Draw axes ==============================================================
|
||||
% Row 1
|
||||
handles(1, 1) = subplot(3, 3, 1);
|
||||
handles(1, 2) = subplot(3, 3, [2 3]);
|
||||
% Row 2
|
||||
handles(2, 1) = subplot(3, 3, 4);
|
||||
handles(2, 2) = subplot(3, 3, [5 6]);
|
||||
% Row 3
|
||||
handles(3, 1) = subplot(3, 3, 7);
|
||||
handles(3, 2) = subplot(3, 3, 8);
|
||||
handles(3, 3) = subplot(3, 3, 9);
|
||||
|
||||
%% Plot all figures =======================================================
|
||||
|
||||
if isfield(trackResults(channelNr), 'prn_start_time_s')
|
||||
timeAxis=trackResults(channelNr).prn_start_time_s;
|
||||
time_label='RX Time (s)';
|
||||
else
|
||||
timeAxis = (1:length(trackResults(channelNr).PRN));
|
||||
time_label='Epoch';
|
||||
end
|
||||
|
||||
%----- Discrete-Time Scatter Plot ---------------------------------
|
||||
plot(handles(1, 1), trackResults(channelNr).data_I,...
|
||||
trackResults(channelNr).data_Q, ...
|
||||
'.');
|
||||
|
||||
grid (handles(1, 1));
|
||||
axis (handles(1, 1), 'equal');
|
||||
title (handles(1, 1), 'Discrete-Time Scatter Plot');
|
||||
xlabel(handles(1, 1), 'I prompt');
|
||||
ylabel(handles(1, 1), 'Q prompt');
|
||||
|
||||
%----- Nav bits ---------------------------------------------------
|
||||
plot (handles(1, 2), timeAxis, ...
|
||||
trackResults(channelNr).data_I);
|
||||
|
||||
grid (handles(1, 2));
|
||||
title (handles(1, 2), 'Bits of the navigation message');
|
||||
xlabel(handles(1, 2), time_label);
|
||||
axis (handles(1, 2), 'tight');
|
||||
|
||||
%----- PLL discriminator unfiltered--------------------------------
|
||||
plot (handles(2, 1), timeAxis, ...
|
||||
trackResults(channelNr).pllDiscr, 'r');
|
||||
|
||||
grid (handles(2, 1));
|
||||
axis (handles(2, 1), 'tight');
|
||||
xlabel(handles(2, 1), time_label);
|
||||
ylabel(handles(2, 1), 'Amplitude');
|
||||
title (handles(2, 1), 'Raw PLL discriminator');
|
||||
|
||||
%----- Correlation ------------------------------------------------
|
||||
plot(handles(2, 2), timeAxis, ...
|
||||
[sqrt(trackResults(channelNr).I_VE.^2 + ...
|
||||
trackResults(channelNr).Q_VE.^2)', ...
|
||||
sqrt(trackResults(channelNr).I_E.^2 + ...
|
||||
trackResults(channelNr).Q_E.^2)', ...
|
||||
sqrt(trackResults(channelNr).I_P.^2 + ...
|
||||
trackResults(channelNr).Q_P.^2)', ...
|
||||
sqrt(trackResults(channelNr).I_L.^2 + ...
|
||||
trackResults(channelNr).Q_L.^2)', ...
|
||||
sqrt(trackResults(channelNr).I_VL.^2 + ...
|
||||
trackResults(channelNr).Q_VL.^2)'], ...
|
||||
'-*');
|
||||
|
||||
grid (handles(2, 2));
|
||||
title (handles(2, 2), 'Correlation results');
|
||||
xlabel(handles(2, 2), time_label);
|
||||
axis (handles(2, 2), 'tight');
|
||||
|
||||
hLegend = legend(handles(2, 2), '$\sqrt{I_{VE}^2 + Q_{VE}^2}$', ...
|
||||
'$\sqrt{I_{E}^2 + Q_{E}^2}$', ...
|
||||
'$\sqrt{I_{P}^2 + Q_{P}^2}$', ...
|
||||
'$\sqrt{I_{L}^2 + Q_{L}^2}$', ...
|
||||
'$\sqrt{I_{VL}^2 + Q_{VL}^2}$');
|
||||
|
||||
%set interpreter from tex to latex. This will draw \sqrt correctly
|
||||
set(hLegend, 'Interpreter', 'Latex');
|
||||
|
||||
%----- PLL discriminator filtered----------------------------------
|
||||
plot (handles(3, 1), timeAxis, ...
|
||||
trackResults(channelNr).pllDiscrFilt, 'b');
|
||||
|
||||
grid (handles(3, 1));
|
||||
axis (handles(3, 1), 'tight');
|
||||
xlabel(handles(3, 1), time_label);
|
||||
ylabel(handles(3, 1), 'Amplitude');
|
||||
title (handles(3, 1), 'Filtered PLL discriminator');
|
||||
|
||||
%----- DLL discriminator unfiltered--------------------------------
|
||||
plot (handles(3, 2), timeAxis, ...
|
||||
trackResults(channelNr).dllDiscr, 'r');
|
||||
|
||||
grid (handles(3, 2));
|
||||
axis (handles(3, 2), 'tight');
|
||||
xlabel(handles(3, 2), time_label);
|
||||
ylabel(handles(3, 2), 'Amplitude');
|
||||
title (handles(3, 2), 'Raw DLL discriminator');
|
||||
|
||||
%----- DLL discriminator filtered----------------------------------
|
||||
plot (handles(3, 3), timeAxis, ...
|
||||
trackResults(channelNr).dllDiscrFilt, 'b');
|
||||
|
||||
grid (handles(3, 3));
|
||||
axis (handles(3, 3), 'tight');
|
||||
xlabel(handles(3, 3), time_label);
|
||||
ylabel(handles(3, 3), 'Amplitude');
|
||||
title (handles(3, 3), 'Filtered DLL discriminator');
|
||||
|
||||
end % for channelNr = channelList
|
||||
80
utils/matlab/libs/quantize_signal.m
Normal file
80
utils/matlab/libs/quantize_signal.m
Normal file
@@ -0,0 +1,80 @@
|
||||
% This function opens a binary file using the ibyte format, reads and
|
||||
% quantizes the signal using the most significant nbits, and stores the
|
||||
% quantized signal into an output file. The output file also uses the
|
||||
% ibyte format.
|
||||
%
|
||||
% Usage: quantize_signal (infile, outfile, nbits)
|
||||
%
|
||||
% Inputs:
|
||||
% infile - Input file name
|
||||
% outfile - Output file name
|
||||
% nbits - number of quantization bits
|
||||
%
|
||||
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Marc Majoral, 2020. mmajoral(at)cttc.es
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
|
||||
function quantize_signal (infile, outfile, nbits)
|
||||
|
||||
%% usage: quantize_signal (infile, outfile, nbits)
|
||||
%%
|
||||
%% open input signal file infile, quantize the signal using the most
|
||||
%% significant nbits and write the quantized signal to outfile
|
||||
%%
|
||||
|
||||
fileID = fopen(infile, 'rb');
|
||||
fileID2 = fopen(outfile, 'wb');
|
||||
|
||||
% initialize loop
|
||||
BlockSize = 20000000; % processing block size
|
||||
NumBitsPerSample = 8; % num. bits per sample ibyte format.
|
||||
NumBitsSHift = NumBitsPerSample - nbits;
|
||||
DivVal = 2^NumBitsSHift;
|
||||
Lim2sCompl = 2^(NumBitsPerSample - 1) - 1;
|
||||
Base2sCompl = 2^NumBitsPerSample;
|
||||
do = true;
|
||||
data_bytes = fread(fileID, BlockSize);
|
||||
|
||||
while do
|
||||
|
||||
% 2's complement
|
||||
for k=1:length(data_bytes)
|
||||
if (data_bytes(k) > Lim2sCompl)
|
||||
data_bytes(k) = -Base2sCompl + data_bytes(k);
|
||||
end
|
||||
end
|
||||
|
||||
% take the nbits most significant bits
|
||||
data_bytes = floor(data_bytes/DivVal);
|
||||
|
||||
% quantization correction
|
||||
data_bytes = data_bytes*2 + 1;
|
||||
|
||||
% 2's complement
|
||||
for k=1:length(data_bytes)
|
||||
if (data_bytes(k) < 0)
|
||||
data_bytes(k) = Base2sCompl + data_bytes(k);
|
||||
end
|
||||
end
|
||||
|
||||
% write result
|
||||
fwrite(fileID2, data_bytes);
|
||||
|
||||
if (size(data_bytes) < BlockSize)
|
||||
do = false;
|
||||
else
|
||||
data_bytes = fread(fileID,BlockSize);
|
||||
end
|
||||
end
|
||||
|
||||
% close files
|
||||
fclose(fileID);
|
||||
fclose(fileID2);
|
||||
47
utils/matlab/libs/read_complex_binary.m
Normal file
47
utils/matlab/libs/read_complex_binary.m
Normal file
@@ -0,0 +1,47 @@
|
||||
% Usage: read_complex_binary (filename, [count], [start_sample])
|
||||
%
|
||||
% Opens filename and returns the contents as a column vector,
|
||||
% treating them as 32 bit complex numbers
|
||||
%
|
||||
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% Copyright (C) 2010-2019 (see AUTHORS file for a list of contributors)
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
|
||||
function v = read_complex_binary (filename, count, start_sample)
|
||||
|
||||
m = nargchk (1,2,nargin);
|
||||
if (m)
|
||||
%usage (m);
|
||||
end
|
||||
|
||||
if (nargin < 2)
|
||||
count = Inf;
|
||||
start_sample=0;
|
||||
end
|
||||
|
||||
if (nargin < 3)
|
||||
start_sample=0;
|
||||
end
|
||||
|
||||
f = fopen (filename, 'rb');
|
||||
if (f < 0)
|
||||
v = 0;
|
||||
else
|
||||
if (start_sample>0)
|
||||
bytes_per_sample=4;
|
||||
fseek(f,start_sample*bytes_per_sample,'bof');
|
||||
end
|
||||
t = fread (f, [2, count], 'float');
|
||||
fclose (f);
|
||||
v = t(1,:) + t(2,:)*i;
|
||||
[r, c] = size (v);
|
||||
v = reshape (v, c, r);
|
||||
end
|
||||
38
utils/matlab/libs/read_complex_char_binary.m
Normal file
38
utils/matlab/libs/read_complex_char_binary.m
Normal file
@@ -0,0 +1,38 @@
|
||||
% Usage: read_complex_binary (filename, [count])
|
||||
%
|
||||
% Opens filename and returns the contents as a column vector,
|
||||
% treating them as 32 bit complex numbers
|
||||
%
|
||||
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% Copyright (C) 2010-2019 (see AUTHORS file for a list of contributors)
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
|
||||
function v = read_complex_char_binary (filename, count)
|
||||
|
||||
m = nargchk (1,2,nargin);
|
||||
if (m)
|
||||
usage (m);
|
||||
end
|
||||
|
||||
if (nargin < 2)
|
||||
count = Inf;
|
||||
end
|
||||
|
||||
f = fopen (filename, 'rb');
|
||||
if (f < 0)
|
||||
v = 0;
|
||||
else
|
||||
t = fread (f, [2, count], 'int8');
|
||||
fclose (f);
|
||||
v = t(1,:) + t(2,:)*i;
|
||||
[r, c] = size (v);
|
||||
v = reshape (v, c, r);
|
||||
end
|
||||
38
utils/matlab/libs/read_complex_short_binary.m
Normal file
38
utils/matlab/libs/read_complex_short_binary.m
Normal file
@@ -0,0 +1,38 @@
|
||||
% Usage: read_complex_binary (filename, [count])
|
||||
%
|
||||
% Opens filename and returns the contents as a column vector,
|
||||
% treating them as 32 bit complex numbers
|
||||
%
|
||||
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% Copyright (C) 2010-2019 (see AUTHORS file for a list of contributors)
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
|
||||
function v = read_complex_short_binary (filename, count)
|
||||
|
||||
m = nargchk (1,2,nargin);
|
||||
if (m)
|
||||
usage (m);
|
||||
end
|
||||
|
||||
if (nargin < 2)
|
||||
count = Inf;
|
||||
end
|
||||
|
||||
f = fopen (filename, 'rb');
|
||||
if (f < 0)
|
||||
v = 0;
|
||||
else
|
||||
t = fread (f, [2, count], 'short');
|
||||
fclose (f);
|
||||
v = t(1,:) + t(2,:)*i;
|
||||
[r, c] = size (v);
|
||||
v = reshape (v, c, r);
|
||||
end
|
||||
77
utils/matlab/libs/read_hybrid_observables_dump.m
Normal file
77
utils/matlab/libs/read_hybrid_observables_dump.m
Normal file
@@ -0,0 +1,77 @@
|
||||
% Opens GNSS-SDR tracking binary log file .dat and returns the contents
|
||||
%
|
||||
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Javier Arribas 2011
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%
|
||||
% -------------------------------------------------------------------------
|
||||
|
||||
function [observables] = read_hybrid_observables_dump (channels, filename, count)
|
||||
|
||||
m = nargchk (1,2,nargin);
|
||||
num_double_vars=7;
|
||||
double_size_bytes=8;
|
||||
skip_bytes_each_read=double_size_bytes*num_double_vars*channels;
|
||||
bytes_shift=0;
|
||||
if (m)
|
||||
usage (m);
|
||||
end
|
||||
|
||||
if (nargin < 3)
|
||||
count = Inf;
|
||||
end
|
||||
%loops_counter = fread (f, count, 'uint32',4*12);
|
||||
f = fopen (filename, 'rb');
|
||||
if (f < 0)
|
||||
else
|
||||
for N=1:1:channels
|
||||
observables.RX_time(N,:) = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
observables.d_TOW_at_current_symbol(N,:) = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
observables.Carrier_Doppler_hz(N,:) = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
observables.Carrier_phase_hz(N,:) = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
observables.Pseudorange_m(N,:) = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
observables.PRN(N,:) = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
observables.valid(N,:) = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
end
|
||||
|
||||
fclose (f);
|
||||
|
||||
%%%%%%%% output vars %%%%%%%%
|
||||
% double tmp_double;
|
||||
% for (unsigned int i = 0; i < d_nchannels; i++)
|
||||
% {
|
||||
% tmp_double = current_gnss_synchro[i].RX_time;
|
||||
% d_dump_file.write((char*)&tmp_double, sizeof(double));
|
||||
% tmp_double = current_gnss_synchro[i].TOW_at_current_symbol_ms;
|
||||
% d_dump_file.write((char*)&tmp_double, sizeof(double));
|
||||
% tmp_double = current_gnss_synchro[i].Carrier_Doppler_hz;
|
||||
% d_dump_file.write((char*)&tmp_double, sizeof(double));
|
||||
% tmp_double = current_gnss_synchro[i].Carrier_phase_rads/GPS_TWO_PI;
|
||||
% d_dump_file.write((char*)&tmp_double, sizeof(double));
|
||||
% tmp_double = current_gnss_synchro[i].Pseudorange_m;
|
||||
% d_dump_file.write((char*)&tmp_double, sizeof(double));
|
||||
% tmp_double = current_gnss_synchro[i].PRN;
|
||||
% d_dump_file.write((char*)&tmp_double, sizeof(double));
|
||||
% tmp_double = current_gnss_synchro[i].Flag_valid_pseudorange;
|
||||
% d_dump_file.write((char*)&tmp_double, sizeof(double));
|
||||
% }
|
||||
end
|
||||
74
utils/matlab/libs/read_true_sim_observables_dump.m
Normal file
74
utils/matlab/libs/read_true_sim_observables_dump.m
Normal file
@@ -0,0 +1,74 @@
|
||||
% Usage: read_true_sim_observables_dump (filename, [count])
|
||||
%
|
||||
% Opens gnss-sdr-sim observables dump and reads all chennels
|
||||
%
|
||||
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Javier Arribas 2011
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%
|
||||
% -------------------------------------------------------------------------
|
||||
|
||||
|
||||
function [observables] = read_true_sim_observables_dump (filename, count)
|
||||
|
||||
m = nargchk (1,2,nargin);
|
||||
channels=12; %Simulator always use 12 channels
|
||||
num_double_vars=7;
|
||||
double_size_bytes=8;
|
||||
skip_bytes_each_read=double_size_bytes*num_double_vars*channels;
|
||||
bytes_shift=0;
|
||||
|
||||
if (m)
|
||||
usage (m);
|
||||
end
|
||||
|
||||
if (nargin < 2)
|
||||
count = Inf;
|
||||
end
|
||||
%loops_counter = fread (f, count, 'uint32',4*12);
|
||||
f = fopen (filename, 'rb');
|
||||
if (f < 0)
|
||||
else
|
||||
for N=1:1:channels
|
||||
observables.RX_time(N,:) = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
observables.Carrier_Doppler_hz(N,:) = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
observables.Carrier_phase_hz(N,:) = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
observables.Pseudorange_m(N,:) = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
observables.True_range_m(N,:) = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
observables.Carrier_phase_hz_v2(N,:) = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
observables.PRN(N,:) = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
|
||||
bytes_shift=bytes_shift+double_size_bytes;
|
||||
fseek(f,bytes_shift,'bof'); % move to next interleaved
|
||||
end
|
||||
|
||||
fclose (f);
|
||||
|
||||
% %%%%%%%% output vars %%%%%%%%
|
||||
% for(int i=0;i<12;i++)
|
||||
% {
|
||||
% d_dump_file.read((char *) &gps_time_sec[i], sizeof(double));
|
||||
% d_dump_file.read((char *) &doppler_l1_hz, sizeof(double));
|
||||
% d_dump_file.read((char *) &acc_carrier_phase_l1_cycles[i], sizeof(double));
|
||||
% d_dump_file.read((char *) &dist_m[i], sizeof(double));
|
||||
% d_dump_file.read((char *) &true_dist_m[i], sizeof(double));
|
||||
% d_dump_file.read((char *) &carrier_phase_l1_cycles[i], sizeof(double));
|
||||
% d_dump_file.read((char *) &prn[i], sizeof(double));
|
||||
% }
|
||||
end
|
||||
140
utils/matlab/plotTrackingE5a.m
Normal file
140
utils/matlab/plotTrackingE5a.m
Normal file
@@ -0,0 +1,140 @@
|
||||
function plotTracking(channelList, trackResults, settings)
|
||||
% This function plots the tracking results for the given channel list.
|
||||
%
|
||||
% plotTracking(channelList, trackResults, settings)
|
||||
%
|
||||
% Inputs:
|
||||
% channelList - list of channels to be plotted.
|
||||
% trackResults - tracking results from the tracking function.
|
||||
% settings - receiver settings.
|
||||
|
||||
%--------------------------------------------------------------------------
|
||||
% SoftGNSS v3.0
|
||||
%
|
||||
% Written by Darius Plausinaitis
|
||||
%--------------------------------------------------------------------------
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Darius Plausinaitis
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%--------------------------------------------------------------------------
|
||||
|
||||
% Protection - if the list contains incorrect channel numbers
|
||||
channelList = intersect(channelList, 1:settings.numberOfChannels);
|
||||
|
||||
%=== For all listed channels ==============================================
|
||||
for channelNr = channelList
|
||||
|
||||
%% Select (or create) and clear the figure ================================
|
||||
% The number 200 is added just for more convenient handling of the open
|
||||
% figure windows, when many figures are closed and reopened.
|
||||
% Figures drawn or opened by the user, will not be "overwritten" by
|
||||
% this function.
|
||||
|
||||
figure(channelNr +200);
|
||||
clf(channelNr +200);
|
||||
set(channelNr +200, 'Name', ['Channel ', num2str(channelNr), ...
|
||||
' (PRN ', ...
|
||||
num2str(trackResults(channelNr).PRN), ...
|
||||
') results']);
|
||||
|
||||
%% Draw axes ==============================================================
|
||||
% Row 1
|
||||
handles(1, 1) = subplot(3, 3, 1);
|
||||
handles(1, 2) = subplot(3, 3, [2 3]);
|
||||
% Row 2
|
||||
handles(2, 1) = subplot(3, 3, 4);
|
||||
handles(2, 2) = subplot(3, 3, [5 6]);
|
||||
% Row 3
|
||||
handles(3, 1) = subplot(3, 3, 7);
|
||||
handles(3, 2) = subplot(3, 3, 8);
|
||||
handles(3, 3) = subplot(3, 3, 9);
|
||||
|
||||
%% Plot all figures =======================================================
|
||||
|
||||
timeAxisInSeconds = (1:settings.msToProcess-1)/1000;
|
||||
|
||||
%----- Discrete-Time Scatter Plot ---------------------------------
|
||||
plot(handles(1, 1), trackResults(channelNr).I_PN,...
|
||||
trackResults(channelNr).Q_PN, ...
|
||||
'.');
|
||||
|
||||
grid (handles(1, 1));
|
||||
axis (handles(1, 1), 'equal');
|
||||
title (handles(1, 1), 'Discrete-Time Scatter Plot');
|
||||
xlabel(handles(1, 1), 'I prompt');
|
||||
ylabel(handles(1, 1), 'Q prompt');
|
||||
|
||||
%----- Nav bits ---------------------------------------------------
|
||||
plot (handles(1, 2), timeAxisInSeconds, ...
|
||||
trackResults(channelNr).I_PN(1:settings.msToProcess-1));
|
||||
|
||||
grid (handles(1, 2));
|
||||
title (handles(1, 2), 'Bits of the navigation message');
|
||||
xlabel(handles(1, 2), 'Time (s)');
|
||||
axis (handles(1, 2), 'tight');
|
||||
|
||||
%----- PLL discriminator unfiltered--------------------------------
|
||||
plot (handles(2, 1), timeAxisInSeconds, ...
|
||||
trackResults(channelNr).pllDiscr(1:settings.msToProcess-1), 'r');
|
||||
|
||||
grid (handles(2, 1));
|
||||
axis (handles(2, 1), 'tight');
|
||||
xlabel(handles(2, 1), 'Time (s)');
|
||||
ylabel(handles(2, 1), 'Amplitude');
|
||||
title (handles(2, 1), 'Raw PLL discriminator');
|
||||
|
||||
%----- Correlation ------------------------------------------------
|
||||
plot(handles(2, 2), timeAxisInSeconds, ...
|
||||
[sqrt(trackResults(channelNr).I_E(1:settings.msToProcess-1).^2 + ...
|
||||
trackResults(channelNr).Q_E(1:settings.msToProcess-1).^2)', ...
|
||||
sqrt(trackResults(channelNr).I_P(1:settings.msToProcess-1).^2 + ...
|
||||
trackResults(channelNr).Q_P(1:settings.msToProcess-1).^2)', ...
|
||||
sqrt(trackResults(channelNr).I_L(1:settings.msToProcess-1).^2 + ...
|
||||
trackResults(channelNr).Q_L(1:settings.msToProcess-1).^2)'], ...
|
||||
'-*');
|
||||
|
||||
grid (handles(2, 2));
|
||||
title (handles(2, 2), 'Correlation results');
|
||||
xlabel(handles(2, 2), 'Time (s)');
|
||||
axis (handles(2, 2), 'tight');
|
||||
|
||||
hLegend = legend(handles(2, 2), '$\sqrt{I_{E}^2 + Q_{E}^2}$', ...
|
||||
'$\sqrt{I_{P}^2 + Q_{P}^2}$', ...
|
||||
'$\sqrt{I_{L}^2 + Q_{L}^2}$');
|
||||
|
||||
%set interpreter from tex to latex. This will draw \sqrt correctly
|
||||
set(hLegend, 'Interpreter', 'Latex');
|
||||
|
||||
%----- PLL discriminator filtered----------------------------------
|
||||
plot (handles(3, 1), timeAxisInSeconds, ...
|
||||
trackResults(channelNr).pllDiscrFilt(1:settings.msToProcess-1), 'b');
|
||||
|
||||
grid (handles(3, 1));
|
||||
axis (handles(3, 1), 'tight');
|
||||
xlabel(handles(3, 1), 'Time (s)');
|
||||
ylabel(handles(3, 1), 'Amplitude');
|
||||
title (handles(3, 1), 'Filtered PLL discriminator');
|
||||
|
||||
%----- DLL discriminator unfiltered--------------------------------
|
||||
plot (handles(3, 2), timeAxisInSeconds, ...
|
||||
trackResults(channelNr).dllDiscr(1:settings.msToProcess-1), 'r');
|
||||
|
||||
grid (handles(3, 2));
|
||||
axis (handles(3, 2), 'tight');
|
||||
xlabel(handles(3, 2), 'Time (s)');
|
||||
ylabel(handles(3, 2), 'Amplitude');
|
||||
title (handles(3, 2), 'Raw DLL discriminator');
|
||||
|
||||
%----- DLL discriminator filtered----------------------------------
|
||||
plot (handles(3, 3), timeAxisInSeconds, ...
|
||||
trackResults(channelNr).dllDiscrFilt(1:settings.msToProcess-1), 'b');
|
||||
|
||||
grid (handles(3, 3));
|
||||
axis (handles(3, 3), 'tight');
|
||||
xlabel(handles(3, 3), 'Time (s)');
|
||||
ylabel(handles(3, 3), 'Amplitude');
|
||||
title (handles(3, 3), 'Filtered DLL discriminator');
|
||||
|
||||
end % for channelNr = channelList
|
||||
125
utils/matlab/plot_acq_grid.m
Normal file
125
utils/matlab/plot_acq_grid.m
Normal file
@@ -0,0 +1,125 @@
|
||||
% Reads GNSS-SDR Acquisition dump .mat file using the provided
|
||||
% function and plots acquisition grid of acquisition statistic of PRN sat
|
||||
% Antonio Ramos, 2017. antonio.ramos(at)cttc.es
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% Copyright (C) 2010-2019 (see AUTHORS file for a list of contributors)
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
|
||||
%% Configuration
|
||||
path = '/home/dmiralles/Documents/gnss-sdr/';
|
||||
file = 'bds_acq';
|
||||
sat = 6;
|
||||
channel = 0;
|
||||
execution = 4;
|
||||
% Signal:
|
||||
% 1 GPS L1
|
||||
% 2 GPS L2M
|
||||
% 3 GPS L5
|
||||
% 4 Gal. E1B
|
||||
% 5 Gal. E5
|
||||
% 6 Glo. 1G
|
||||
% 7 Glo. 2G
|
||||
% 8 BDS. B1
|
||||
% 9 BDS. B3
|
||||
% 10 BDS. B2a
|
||||
|
||||
signal_type = 8;
|
||||
|
||||
%%% True for light grid representation
|
||||
lite_view = true;
|
||||
|
||||
%%% If lite_view, it sets the number of samples per chip in the graphical representation
|
||||
n_samples_per_chip = 3;
|
||||
d_samples_per_code = 25000;
|
||||
|
||||
%% Load data
|
||||
|
||||
switch(signal_type)
|
||||
case 1
|
||||
n_chips = 1023;
|
||||
system = 'G';
|
||||
signal = '1C';
|
||||
case 2
|
||||
n_chips = 10230;
|
||||
system = 'G';
|
||||
signal = '2S';
|
||||
case 3
|
||||
n_chips = 10230;
|
||||
system = 'G';
|
||||
signal = 'L5';
|
||||
case 4
|
||||
n_chips = 4092;
|
||||
system = 'E';
|
||||
signal = '1B';
|
||||
case 5
|
||||
n_chips = 10230;
|
||||
system = 'E';
|
||||
signal = '5X';
|
||||
case 6
|
||||
n_chips = 511;
|
||||
system = 'R';
|
||||
signal = '1G';
|
||||
case 7
|
||||
n_chips = 511;
|
||||
system = 'R';
|
||||
signal = '2G';
|
||||
case 8
|
||||
n_chips = 2048;
|
||||
system = 'C';
|
||||
signal = 'B1';
|
||||
case 9
|
||||
n_chips = 10230;
|
||||
system = 'C';
|
||||
signal = 'B3';
|
||||
case 10
|
||||
n_chips = 10230;
|
||||
system = 'C';
|
||||
signal = '5C';
|
||||
end
|
||||
filename = [path file '_' system '_' signal '_ch_' num2str(channel) '_' num2str(execution) '_sat_' num2str(sat) '.mat'];
|
||||
load(filename);
|
||||
[n_fft, n_dop_bins] = size(acq_grid);
|
||||
[d_max, f_max] = find(acq_grid == max(max(acq_grid)));
|
||||
freq = (0 : n_dop_bins - 1) * double(doppler_step) - double(doppler_max);
|
||||
delay = (0 : n_fft - 1) / n_fft * n_chips;
|
||||
|
||||
|
||||
%% Plot data
|
||||
%--- Acquisition grid (3D)
|
||||
figure(1)
|
||||
if(lite_view == false)
|
||||
surf(freq, delay, acq_grid, 'FaceColor', 'interp', 'LineStyle', 'none')
|
||||
ylim([min(delay) max(delay)])
|
||||
else
|
||||
delay_interp = (0 : n_samples_per_chip * n_chips - 1) / n_samples_per_chip;
|
||||
grid_interp = spline(delay, acq_grid', delay_interp)';
|
||||
surf(freq, delay_interp, grid_interp, 'FaceColor', 'interp', 'LineStyle', 'none')
|
||||
ylim([min(delay_interp) max(delay_interp)])
|
||||
end
|
||||
xlabel('Doppler shift (Hz)')
|
||||
xlim([min(freq) max(freq)])
|
||||
ylabel('Code delay (chips)')
|
||||
zlabel('Test Statistics')
|
||||
|
||||
%--- Acquisition grid (2D)
|
||||
figure(2)
|
||||
subplot(2,1,1)
|
||||
plot(freq, acq_grid(d_max, :))
|
||||
xlim([min(freq) max(freq)])
|
||||
xlabel('Doppler shift (Hz)')
|
||||
ylabel('Test statistics')
|
||||
title(['Fixed code delay to ' num2str((d_max - 1) / n_fft * n_chips) ' chips'])
|
||||
subplot(2,1,2)
|
||||
normalization = (d_samples_per_code^4) * input_power;
|
||||
plot(delay, acq_grid(:, f_max)./normalization)
|
||||
xlim([min(delay) max(delay)])
|
||||
xlabel('Code delay (chips)')
|
||||
ylabel('Test statistics')
|
||||
title(['Doppler wipe-off = ' num2str((f_max - 1) * doppler_step - doppler_max) ' Hz'])
|
||||
80
utils/matlab/plot_acq_grid_gsoc.m
Normal file
80
utils/matlab/plot_acq_grid_gsoc.m
Normal file
@@ -0,0 +1,80 @@
|
||||
% Reads GNSS-SDR Acquisition dump binary file using the provided
|
||||
% function and plots acquisition grid of acquisition statistic of PRN sat
|
||||
%
|
||||
% This function analyzes a experiment performed by Luis Esteve in the framework
|
||||
% of the Google Summer of Code (GSoC) 2012, with the collaboration of Javier Arribas
|
||||
% and Carles Fern??ndez, related to the extension of GNSS-SDR to Galileo.
|
||||
%
|
||||
% Luis Esteve, 2012. luis(at)epsilon-formacion.com
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% Copyright (C) 2010-2019 (see AUTHORS file for a list of contributors)
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
|
||||
function plot_acq_grid_gsoc(sat)
|
||||
|
||||
file=['test_statistics_E_1C_sat_' num2str(sat) '_doppler_0.dat'];
|
||||
|
||||
sampling_freq_Hz=4E6
|
||||
Doppler_max_Hz = 9875
|
||||
Doppler_min_Hz = -10000
|
||||
Doppler_step_Hz = 125
|
||||
|
||||
|
||||
% read files
|
||||
|
||||
x=read_complex_binary (file);
|
||||
|
||||
l_y=length(x);
|
||||
|
||||
Doppler_axes=Doppler_min_Hz:Doppler_step_Hz:Doppler_max_Hz;
|
||||
|
||||
l_x=length(Doppler_axes);
|
||||
|
||||
acq_grid = zeros(l_x,l_y);
|
||||
|
||||
index=0;
|
||||
|
||||
for k=Doppler_min_Hz:Doppler_step_Hz:Doppler_max_Hz
|
||||
index=index+1;
|
||||
filename=['test_statistics_E_1C_sat_' num2str(sat) '_doppler_' num2str(k) '.dat'];
|
||||
acq_grid(index,:)=abs(read_complex_binary (filename));
|
||||
end
|
||||
|
||||
maximum_correlation_peak = max(max(acq_grid))
|
||||
|
||||
[fila,col]=find(acq_grid==max(max(acq_grid)));
|
||||
|
||||
delay_error_sps = col -1
|
||||
|
||||
Doppler_error_Hz = Doppler_axes(fila)
|
||||
|
||||
noise_grid=acq_grid;
|
||||
delay_span=floor(3*sampling_freq_Hz/(1.023e6));
|
||||
Doppler_span=floor(500/Doppler_step_Hz);
|
||||
noise_grid(fila-Doppler_span:fila+Doppler_span,col-delay_span:col+delay_span)=0;
|
||||
|
||||
n=numel(noise_grid)-(2*delay_span+1)*(2*Doppler_span+1);
|
||||
|
||||
noise_floor= sum(sum(noise_grid))/n
|
||||
|
||||
Gain_dbs = 10*log10(maximum_correlation_peak/noise_floor)
|
||||
|
||||
|
||||
%% Plot 3D FULL RESOLUTION
|
||||
|
||||
|
||||
[X,Y] = meshgrid(Doppler_axes,1:1:l_y);
|
||||
figure;
|
||||
surf(X,Y,acq_grid');
|
||||
|
||||
xlabel('Doppler(Hz)');ylabel('Code Delay(samples)');title(['GLRT statistic of Galileo Parallel Code Phase Search Acquisition. Local replica: E1C cboc PRN ' num2str(sat)]);
|
||||
|
||||
|
||||
end
|
||||
121
utils/matlab/plot_acq_grid_gsoc_e5.m
Normal file
121
utils/matlab/plot_acq_grid_gsoc_e5.m
Normal file
@@ -0,0 +1,121 @@
|
||||
% Reads GNSS-SDR Acquisition dump binary file using the provided
|
||||
% function and plot acquisition grid of acquisition statistic of PRN sat.
|
||||
% CAF input must be 0 or 1 depending if the user desires to read the file
|
||||
% that resolves doppler ambiguity or not.
|
||||
%
|
||||
% This function analyzes a experiment performed by Marc Sales in the framework
|
||||
% of the Google Summer of Code (GSoC) 2014, with the collaboration of Luis Esteve, Javier Arribas
|
||||
% and Carles Fernandez, related to the extension of GNSS-SDR to Galileo.
|
||||
%
|
||||
% Marc Sales marcsales92(at)gmail.com,
|
||||
% Luis Esteve, 2014. luis(at)epsilon-formacion.com
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% Copyright (C) 2010-2019 (see AUTHORS file for a list of contributors)
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
|
||||
function plot_acq_grid_gsoc_e5(sat,CAF)
|
||||
|
||||
path='/home/marc/git/gnss-sdr/data/';
|
||||
file=[path 'test_statistics_E5a_sat_' num2str(sat) '_doppler_0.dat'];
|
||||
|
||||
sampling_freq_Hz=32E6
|
||||
%Doppler_max_Hz = 14875
|
||||
%Doppler_min_Hz = -15000
|
||||
%Doppler_step_Hz = 125
|
||||
Doppler_max_Hz = 10000
|
||||
Doppler_min_Hz = -10000
|
||||
Doppler_step_Hz = 250
|
||||
|
||||
|
||||
|
||||
% read files
|
||||
|
||||
%x=read_complex_binary (file);
|
||||
%x=load_complex_data(file); % complex
|
||||
%l_y=length(x);
|
||||
myFile = java.io.File(file);
|
||||
flen = length(myFile);
|
||||
l_y=flen/4;% float
|
||||
|
||||
|
||||
Doppler_axes=Doppler_min_Hz:Doppler_step_Hz:Doppler_max_Hz;
|
||||
|
||||
l_x=length(Doppler_axes);
|
||||
|
||||
acq_grid = zeros(l_x,l_y);
|
||||
|
||||
index=0;
|
||||
|
||||
for k=Doppler_min_Hz:Doppler_step_Hz:Doppler_max_Hz
|
||||
index=index+1;
|
||||
filename=[path 'test_statistics_E5a_sat_' num2str(sat) '_doppler_' num2str(k) '.dat'];
|
||||
fid=fopen(filename,'r');
|
||||
xx=fread(fid,'float');%floats from squared correlation
|
||||
%xx=load_complex_data (filename); %complex
|
||||
acq_grid(index,:)=abs(xx);
|
||||
end
|
||||
|
||||
[fila,col]=find(acq_grid==max(max(acq_grid)));
|
||||
|
||||
if (CAF > 0)
|
||||
filename=[path 'test_statistics_E5a_sat_' num2str(sat) '_CAF.dat'];
|
||||
fid=fopen(filename,'r');
|
||||
xx=fread(fid,'float');%floats from squared correlation
|
||||
acq_grid(:,col(1))=abs(xx);
|
||||
Doppler_error_Hz = Doppler_axes(xx==max(xx))
|
||||
maximum_correlation_peak = max(xx)
|
||||
else
|
||||
Doppler_error_Hz = Doppler_axes(fila)
|
||||
maximum_correlation_peak = max(max(acq_grid))
|
||||
end
|
||||
|
||||
delay_error_sps = col -1
|
||||
|
||||
|
||||
|
||||
noise_grid=acq_grid;
|
||||
delay_span=floor(3*sampling_freq_Hz/(1.023e7));
|
||||
Doppler_span=floor(500/Doppler_step_Hz);
|
||||
noise_grid(fila-Doppler_span:fila+Doppler_span,col-delay_span:col+delay_span)=0;
|
||||
|
||||
n=numel(noise_grid)-(2*delay_span+1)*(2*Doppler_span+1);
|
||||
|
||||
noise_floor= sum(sum(noise_grid))/n
|
||||
|
||||
Gain_dbs = 10*log10(maximum_correlation_peak/noise_floor)
|
||||
|
||||
|
||||
%% Plot 3D FULL RESOLUTION
|
||||
|
||||
|
||||
[X,Y] = meshgrid(Doppler_axes,1:1:l_y);
|
||||
figure;
|
||||
surf(X,Y,acq_grid');
|
||||
|
||||
xlabel('Doppler(Hz)');ylabel('Code Delay(samples)');title(['GLRT statistic of Galileo Parallel Code Phase Search Acquisition. PRN ' num2str(sat)]);
|
||||
|
||||
|
||||
end
|
||||
|
||||
function x=load_complex_data(file)
|
||||
fid = fopen(file,'r');
|
||||
%fid = fopen('signal_source.dat','r');
|
||||
|
||||
myFile = java.io.File(file);
|
||||
flen = length(myFile);
|
||||
num_samples=flen/8; % 8 bytes (2 single floats) per complex sample
|
||||
|
||||
for k=1:num_samples
|
||||
a(1:2) = fread(fid, 2, 'float');
|
||||
x(k) = a(1) + a(2)*1i;
|
||||
k=k+1;
|
||||
end
|
||||
|
||||
end
|
||||
82
utils/matlab/plot_acq_grid_gsoc_glonass.m
Normal file
82
utils/matlab/plot_acq_grid_gsoc_glonass.m
Normal file
@@ -0,0 +1,82 @@
|
||||
% Reads GNSS-SDR Acquisition dump binary file using the provided
|
||||
% function and plots acquisition grid of acquisition statistic of PRN sat
|
||||
%
|
||||
% This function analyzes a experiment performed by Luis Esteve in the framework
|
||||
% of the Google Summer of Code (GSoC) 2012, with the collaboration of Javier Arribas
|
||||
% and Carles Fernandez, related to the extension of GNSS-SDR to Galileo.
|
||||
%
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% Copyright (C) 2010-2019 (see AUTHORS file for a list of contributors)
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
%
|
||||
% -------------------------------------------------------------------------
|
||||
%
|
||||
|
||||
function plot_acq_grid_gsoc_glonass(sat)
|
||||
|
||||
file=['/archive/acquisition_R_1G_sat_' num2str(sat) '_doppler_0.dat'];
|
||||
|
||||
% sampling_freq_Hz=62316000
|
||||
sampling_freq_Hz=6.625e6
|
||||
Doppler_max_Hz = 10000
|
||||
Doppler_min_Hz = -10000
|
||||
Doppler_step_Hz = 250
|
||||
|
||||
|
||||
% read files
|
||||
|
||||
x=read_complex_binary (file);
|
||||
|
||||
l_y=length(x);
|
||||
|
||||
Doppler_axes=Doppler_min_Hz:Doppler_step_Hz:Doppler_max_Hz;
|
||||
|
||||
l_x=length(Doppler_axes);
|
||||
|
||||
acq_grid = zeros(l_x,l_y);
|
||||
|
||||
index=0;
|
||||
|
||||
for k=Doppler_min_Hz:Doppler_step_Hz:Doppler_max_Hz
|
||||
index=index+1;
|
||||
filename=['acquisition_R_1G_sat_' num2str(sat) '_doppler_' num2str(k) '.dat'];
|
||||
acq_grid(index,:)=abs(read_complex_binary (filename));
|
||||
end
|
||||
|
||||
acq_grid = acq_grid.^2;
|
||||
|
||||
maximum_correlation_peak = max(max(acq_grid))
|
||||
|
||||
[fila,col]=find(acq_grid==max(max(acq_grid)));
|
||||
|
||||
delay_error_sps = col -1
|
||||
|
||||
Doppler_error_Hz = Doppler_axes(fila)
|
||||
|
||||
noise_grid=acq_grid;
|
||||
delay_span=floor(3*sampling_freq_Hz/(0.511e6));
|
||||
Doppler_span=floor(500/Doppler_step_Hz);
|
||||
noise_grid(fila-Doppler_span:fila+Doppler_span,col-delay_span:col+delay_span)=0;
|
||||
|
||||
n=numel(noise_grid)-(2*delay_span+1)*(2*Doppler_span+1);
|
||||
|
||||
noise_floor= sum(sum(noise_grid))/n
|
||||
|
||||
Gain_dbs = 10*log10(maximum_correlation_peak/noise_floor)
|
||||
|
||||
|
||||
%% Plot 3D FULL RESOLUTION
|
||||
|
||||
|
||||
[X,Y] = meshgrid(Doppler_axes,1:1:l_y);
|
||||
figure;
|
||||
surf(X,Y,acq_grid');
|
||||
|
||||
xlabel('Doppler(Hz)');ylabel('Code Delay(samples)');title(['GLRT statistic of Glonass Parallel Code Phase Search Acquisition. Local replica: L1 cboc PRN ' num2str(sat)]);
|
||||
|
||||
|
||||
end
|
||||
25
utils/matlab/plot_tracking_quality_indicators.m
Normal file
25
utils/matlab/plot_tracking_quality_indicators.m
Normal file
@@ -0,0 +1,25 @@
|
||||
% plot tracking quality indicators
|
||||
|
||||
% GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
||||
% This file is part of GNSS-SDR.
|
||||
%
|
||||
% SPDX-FileCopyrightText: Javier Arribas <jarribas@cttc.es>
|
||||
% SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
figure;
|
||||
hold on;
|
||||
title('Carrier lock test output for all the channels');
|
||||
for n=1:1:length(GNSS_tracking)
|
||||
plot(GNSS_tracking(n).carrier_lock_test)
|
||||
plotnames{n}=['SV ' num2str(round(mean(GNSS_tracking(n).PRN)))];
|
||||
end
|
||||
legend(plotnames);
|
||||
|
||||
figure;
|
||||
hold on;
|
||||
title('Carrier CN0 output for all the channels');
|
||||
for n=1:1:length(GNSS_tracking)
|
||||
plot(GNSS_tracking(n).CN0_SNV_dB_Hz)
|
||||
plotnames{n}=['SV ' num2str(round(mean(GNSS_tracking(n).PRN)))];
|
||||
end
|
||||
legend(plotnames);
|
||||
Reference in New Issue
Block a user