matlab/matlab.mat matlab/rf_data_plot.m @@ -171,40 +171,6 @@ void wipeoff_gen(MIX *_dest, double _f, double _fs, int32 _samps) /*----------------------------------------------------------------------------------------------*/ -/*! - * resample, resample a vector where _samps is from _dest - * */ -void resample(CPX *_dest, CPX *_source, double _fdest, double _fsource, int32 _samps) -{ -// -// int32 lcv, k; -// float phase, phase_step; -// -// uint32 phase_step; -// uint32 phase; -// -// phase_step = 0xffffffff/_fsource; -// phase_step *= _fdest; -// -// for(lcv = 0; lcv < _samps; lcv++) -// { -// /* Take advantage of addition rollover */ -// phase += phase_step; -// -// if(phase < lphase) -// _dest[k] = _source[lcv]; -// -// -// k = (int32) floor(phase); -// -// phase += phase_step; - //} - -} -/*----------------------------------------------------------------------------------------------*/ - - -/*----------------------------------------------------------------------------------------------*/ void downsample(CPX *_dest, CPX *_source, double _fdest, double _fsource, int32 _samps) { @@ -257,30 +223,35 @@ int32 round_2(int32 _N) /*! * Gather statistics and run AGC * */ -int32 run_agc(CPX *_buff, int32 _samps, int32 bits, int32 scale) +int32 run_agc(CPX *_buff, int32 _samps, int32 _bits, int32 _scale) { int32 lcv, num; int16 max, *p; - int16 lscale; - int16 shift; int16 val; p = (int16 *)&_buff[0]; - /* Get rid of the divide, replace with a multiply to scale to 2^15, then right shift to get - * back into AGC_BITS of magnitude */ -// lscale = (1 << 14) / scale; -// shift = 14 - bits; - max = 1 << bits; + val = (1 << _scale - 1); + max = 1 << _bits; num = 0; -// x86_muls((int16 *)_buff, &lscale, 2*_samps, shift); - - for(lcv = 0; lcv < 2*_samps; lcv++) + if(_scale) + { + for(lcv = 0; lcv < 2*_samps; lcv++) + { + p[lcv] += val; + p[lcv] >>= _scale; + if(abs(p[lcv]) > max) + num++; + } + } + else { - p[lcv] >>= 7; - if(abs(p[lcv]) > max) - num++; + for(lcv = 0; lcv < 2*_samps; lcv++) + { + if(abs(p[lcv]) > max) + num++; + } } return(num); accessories/misc.cpp @@ -9,9 +9,9 @@ INCPATH = -I. \ -I../includes \ -I../objects -WX_FLAGS = `wx-config --libs` +WX_FLAGS = `wx-config --libs` LDFLAGS = -lpthread -CFLAGS = -D_FORTIFY_SOURCE=0 `wx-config --cxxflags` -g3 $(INCPATH) +CFLAGS = -D_FORTIFY_SOURCE=0 `wx-config --cxxflags` $(INCPATH) SRC = $(wildcard src/*.cpp) SRC += gui_classes.cpp gse/Makefile gse/gps-gse @@ -67,6 +67,7 @@ class GUI_Serial : public Threaded_Object uint32 command_sent; //!< Flag to indicate command was transmitted uint32 command_ack; //!< Flag to indicate command was executed uint32 command_count; //!< Used to detect a command ack + uint8 packet_body[2048]; //!< Complete packet body Message_Struct messages; //!< Hold all the messages Message_Union message_body; //!< Union for messages gse/include/gui_serial.h @@ -94,7 +94,7 @@ void GUI_Channel::render(wxDC& dc) tChannel->SetDefaultStyle(style); - if(pchan->count > 2000) + if(pchan->count > 1000) { str2.Clear(); gse/src/gui_channel.cpp @@ -23,6 +23,34 @@ Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1 #include "gui_serial.h" #define SWAP64(X) *((long long *)(&X)) = (((*((long long *)(&X)) & (0x00000000ffffffffLLU)) << 32) | ((*((long long *)(&X)) & (0xffffffff00000000LLU)) >> 32)) +/*----------------------------------------------------------------------------------------------*/ +#define MOD_ADLER 65521 +/* Data is input buffer, len is in bytes! */ +uint32 adler(uint8 *data, int32 len) +{ + + uint32 a, b; + int32 tlen; + + a = 1; b = 0; + + if(len < 5552) + { + do + { + a += *data++; + b += a; + } while (--len); + + a %= MOD_ADLER; + b %= MOD_ADLER; + } + + return (b << 16) | a; + +} +/*----------------------------------------------------------------------------------------------*/ + static uint32 SIZEOF_M[LAST_M_ID + 1] = { 0, @@ -373,21 +401,30 @@ void endian_swap(void *_b, int32 _bytes, int32 _flag) int GUI_Serial::Read(void *_b, int32 _bytes) { - int32 nbytes, bread; + int32 nbytes, bread, k; uint8 *buff; - nbytes = 0; bread = 0; + k = 0; nbytes = 0; bread = 0; buff = (uint8 *)_b; while((nbytes < _bytes) && grun && npipe_open) { bread = read(npipe[READ], buff, _bytes - nbytes); + if(bread > -1) { nbytes += bread; buff += bread; } + + if(k++ > 5000) + { + closePipe(); + return(0); + } + usleep(100); + } //endian_swap(_b, _bytes, _bytes <= 6); @@ -418,6 +455,7 @@ int GUI_Serial::Write(void *_b, int32 _bytes) /*----------------------------------------------------------------------------------------------*/ void GUI_Serial::readGPS() { + uint32 checksumc, checksumr; int32 nbytes, bread, k, chan; uint8 v; @@ -478,8 +516,24 @@ void GUI_Serial::readGPS() /* Read in the message */ Read(src, decoded_packet.length); + /* Assemble into a complete packet for the checksum */ + memcpy(&packet_body[0], &packet_header, 6); //!< CCSDS Header + memcpy(&packet_body[6], src, decoded_packet.length); //!< Body + checksumc = adler(&packet_body[0], 6 + decoded_packet.length); + + /* Read in the checksum */ + byte_count += Read(&checksumr, sizeof(uint32)); + + /* Now verify the checksum */ + if(checksumc != checksumr) + { + message_sync = 0; + packet_count[LAST_M_ID]++; + return; + } + /* Read in the postword */ - Read(&postword, sizeof(uint32)); + byte_count += Read(&postword, sizeof(uint32)); if(postword != 0xBBBBBBBB) { @@ -674,6 +728,7 @@ void GUI_Serial::readGPS() if(CheckPacket(&decoded_packet) == true) { Read(&buff[0], decoded_packet.length); + Read(&checksumr, sizeof(uint32)); Read(&postword, sizeof(uint32)); if(postword != 0xBBBBBBBB) { @@ -699,13 +754,16 @@ void GUI_Serial::readGPS() bool GUI_Serial::CheckPacket(CCSDS_Decoded_Header *_p) { - bool val; + bool val = true; - /* Now copy in the body */ - if(SIZEOF_M[_p->id] == _p->length) - val = true; - else + if((_p->id >= LAST_M_ID) || (_p->id <= FIRST_M_ID)) + { + val = false; + } + else if(SIZEOF_M[_p->id] != _p->length) + { val = false; + } return(val); } @@ -729,18 +787,29 @@ void GUI_Serial::FixDoubles(void *_b, int32 _num) void GUI_Serial::writeGPS() { - uint32 preamble = 0xAAAAAAAA; + uint8 *sbuff; + uint32 pre = 0xAAAAAAAA; + uint32 post = 0xBBBBBBBB; + uint32 checksum; Lock(); // endian_swap(&command_header, sizeof(CCSDS_Packet_Header), 1); // endian_swap(&command_body, decoded_command.length, 0); + sbuff = &packet_body[0]; + if(command_ready && (command_sent == 0)) { - Write(&preamble, sizeof(uint32)); - Write(&command_header, sizeof(CCSDS_Packet_Header)); - Write(&command_body, decoded_command.length); + /* Assemble into a complete packet */ + memcpy(sbuff, &pre, 4); sbuff += 4; //!< Prefix + memcpy(sbuff, &command_header, 6); sbuff += 6; //!< CCSDS Header + memcpy(sbuff, &command_body, decoded_command.length); sbuff += decoded_command.length; //!< Payload + checksum = adler(&packet_body[4], 6 + decoded_command.length); + memcpy(sbuff, &checksum, 4); sbuff += 4; //!< Checksum + memcpy(sbuff, &post, 4); sbuff += 4; //!< Postfix + + Write(&packet_body[0], decoded_command.length + 18); command_sent = 1; } gse/src/gui_serial.cpp @@ -47,16 +47,6 @@ /*----------------------------------------------------------------------------------------------*/ -/* What stuff to log */ -/*----------------------------------------------------------------------------------------------*/ -#define CHANNEL_DEBUG (1) //!< Log channel data to HD -#define CHANNEL_INVESTIGATE (0) //!< Try to figure out Nav bug -#define LOG_PSEUDO (0) //!< Pseudoranges -#define LOG_SV (0) //!< SV Navigation data -#define LOG_NAV (1) //!< Nav Output -/*----------------------------------------------------------------------------------------------*/ - - /* MISC GPS Constants */ /*----------------------------------------------------------------------------------------------*/ #define MAX_SV (32) //!< Number of PRN codes @@ -70,7 +60,7 @@ /*----------------------------------------------------------------------------------------------*/ #define MASK_ANGLE (0) //!< Add this many degrees to altitude dependant mask #define ACQ_MODULO_WEAK (8) //!< Do this many weak acqs per 32 PRN strong search -#define MAX_ACQS_PER_PVT (12) //!< Max # of acquisitions per PVT +#define MAX_ACQS_PER_PVT (1) //!< Max # of acquisitions per PVT #define MAX_DOPPLER_ABSOLUTE (15000) //!< Limit any and all Dopplers the be within this range #define MAX_DOPPLER_STRONG (15000) //!< Cold Doppler search space for strong signal #define MAX_DOPPLER_MEDIUM (15000) //!< Cold Doppler search space for strong signal @@ -87,11 +77,9 @@ /* Correlator Defines */ /*----------------------------------------------------------------------------------------------*/ -#define CORR_DELAYS (1) //!< Number of delays to calculate (plus-minus) -#define CORR_SPACING (.5) //!< How far should the correlators be spaced (chips) #define FRAME_SIZE_PLUS_2 (12) //!< 10 words per frame, 12 = 10 + 2 -#define CODE_BINS (20) //!< Partial code offset bins code resolution -> 1 chip/X bins -#define CARRIER_SPACING (20) //!< Spacing of bins (Hz) +#define CODE_BINS (50) //!< Partial code offset bins code resolution -> 1 chip/X bins +#define CARRIER_SPACING (10) //!< Spacing of bins (Hz) #define CARRIER_BINS (MAX_DOPPLER_ABSOLUTE/CARRIER_SPACING) //!< Number of pre-sampled carrier wipeoff bins /*----------------------------------------------------------------------------------------------*/ @@ -108,14 +96,13 @@ /*----------------------------------------------------------------------------------------------*/ -/* Channel defines */ +/* AGC Control */ /*----------------------------------------------------------------------------------------------*/ -#define CARRIER_AIDING (1) //!< Carrier aid the DLL -#define PLL_BN (15) //!< PLL Bandwidth -#define FLL_BN (10) //!< FLL Bandwidth #define AGC_BITS (6) //!< AGC to this bit depth -#define OVERFLOW_LOW (4) //!< Overflow low -#define OVERFLOW_HIGH (64) //!< Overflow high +//#define OVERFLOW_LOW (256) //!< Overflow low +//#define OVERFLOW_HIGH (1024) //!< Overflow high +#define OVERFLOW_LOW (64) //!< Overflow low +#define OVERFLOW_HIGH (256) //!< Overflow high /*----------------------------------------------------------------------------------------------*/ includes/config.h @@ -142,6 +142,7 @@ typedef unsigned int uint32; #ifndef SPEED_OF_LIGHT #define SPEED_OF_LIGHT (2.99792458e8) //!< Speed of light (m/s) as specified in IS-GPS-200D #endif +#define INVERSE_L1 (6.347513678891978e-10) //!< 1/L1 #define INVERSE_SPEED_OF_LIGHT (3.33564095198152049576e-9) //!< Inverse speed of light #define CODE_RATE (1.023e6) //!< L1 C/A code chipping rate #define INVERSE_CODE_RATE (9.775171065493646e-07) //!< 1/L1 C/A code chipping rate includes/defines.h @@ -49,7 +49,6 @@ int32 code_gen(CPX *_dest, int32 _prn); void sine_gen(CPX *_dest, double _f, double _fs, int32 _samps); void sine_gen(CPX *_dest, double _f, double _fs, int32 _samps, double _p); void wipeoff_gen(MIX *_dest, double _f, double _fs, int32 _samps); -void resample(CPX *_dest, CPX *_source, double _fdest, double _fsource, int32 _samps); void downsample(CPX *_dest, CPX *_source, double _fdest, double _fsource, int32 _samps); void init_agc(CPX *_buff, int32 _samps, int32 bits, int32 *scale); int32 run_agc(CPX *_buff, int32 _samps, int32 bits, int32 scale); includes/protos.h @@ -109,7 +109,7 @@ void Parse_Arguments(int32 argc, char* argv[]) gopt.tlm_type = TELEM_NAMED_PIPE; gopt.mode = 0; //!< Single board L1 mode by default gopt.decimate = 16; //!< Default to work with both 65.536 and 64 MHz clocks - gopt.gr = 40; //!< 40 dB of RF gain + gopt.gr = 30; //!< 40 dB of RF gain gopt.gi = 10; //!< 10 dB of IF gain gopt.f_lo_a = L1 - IF_FREQUENCY; //!< Board A L1 by default gopt.f_ddc_a = 0; //!< no DDC correction main/init.cpp @@ -6,9 +6,8 @@ % 3: PLL and FLL lock indicators % 4: Raw Correlations & CN0 -function [] = chan_peek(chan) +function [A] = chan_peek(chan) -close all; clc; A = get_chan(chan); % uint32 tic; //!< Corresponds to this receiver tic @@ -34,18 +33,27 @@ A = get_chan(chan); % Q[0] % P_buff[0] + figure +hold all; grid on; +plot((A(:,21).^2+A(:,24).^2),'.') +plot((A(:,22).^2+A(:,25).^2),'r.') +plot(A(:,13)./(A(:,6)),'k') -subplot(211) -plot(A(:,3)); ylabel('SV'); -grid on; +figure +cor = A(:,21)+i*A(:,24); +plot(real(cor),'b.') -subplot(212) -plot(A(:,13),'k') -hold on; grid on; -ylabel('I^{2}+Q^{2}'); +figure +hold all; grid on; +plot(A(:,7)) +plot(A(:,9)) +plot(A(:,8)*0.5) + +bl = A(:,end-19:end); figure +mesh(bl) +shading interp; + -surf(A(:,end-19:end)) -shading interp \ No newline at end of file matlab/plot_chan.m @@ -255,7 +255,7 @@ Acq_Command_S Acquisition::doAcqStrong(int32 _sv, int32 _doppmin, int32 _doppmax for(lcv = (_doppmin/1000); lcv < (_doppmax/1000); lcv++) { /* Sweep through the doppler range */ - for(lcv2 = 0; lcv2 < 4; lcv2 += 2) + for(lcv2 = 0; lcv2 < 4; lcv2 ++) { if(gopt.realtime) objects/acquisition.cpp @@ -88,9 +88,8 @@ void Channel::Clear() I_prev = Q_prev = 1; //Important to prevent divide by zero I_avg = 1; Q_var = 1; - P_avg = 1e4; + P_avg = 8e4; cn0 = 40.0; - NP = 10; /* Bit lock stuff */ bit_lock = false; @@ -142,24 +141,25 @@ void Channel::Start(int32 _sv, Acq_Command_S result, int32 _corr_len) carrier_nco = IF_FREQUENCY + result.doppler; aDLL.x = 2.0*result.doppler*CODE_RATE/L1; + + aPLL.w = 0; aPLL.x = 2.0*result.doppler; aPLL.z = result.doppler; - len = _corr_len; - - switch(len) + switch(_corr_len) { case 1: - PLL_W(30.0); - break; - case 10: - PLL_W(25.0); + len = 1; + PLL_W(18.0); break; case 20: - PLL_W(20.0); + len = 20; + PLL_W(18.0); break; default: - PLL_W(30.0); + len = 1; + PLL_W(18.0); + break; } DLL_W(1.0); @@ -182,12 +182,12 @@ Channel_M Channel::getPacket() void Channel::Accum(Correlation_S *corr, NCO_Command_S *_feedback) { - corr->I[0] >>= 3; - corr->I[1] >>= 3; - corr->I[2] >>= 3; - corr->Q[0] >>= 3; - corr->Q[1] >>= 3; - corr->Q[2] >>= 3; + corr->I[0] >>= 2; + corr->I[1] >>= 2; + corr->I[2] >>= 2; + corr->Q[0] >>= 2; + corr->Q[1] >>= 2; + corr->Q[2] >>= 2; /* Integrate */ I[0] += corr->I[0]; @@ -201,12 +201,18 @@ void Channel::Accum(Correlation_S *corr, NCO_Command_S *_feedback) I_sum20 += corr->I[1] - I_buff[_1ms_epoch]; Q_sum20 += corr->Q[1] - Q_buff[_1ms_epoch]; +// if((I_buff[_1ms_epoch] > 0) != (corr->I[1] > 0)) +// { +// P_buff[_1ms_epoch]++; +// } + /* Buffer storing past 20 1ms accumulations */ I_buff[_1ms_epoch] = corr->I[1]; Q_buff[_1ms_epoch] = corr->Q[1]; /* Lowpass filter */ - P_buff[_1ms_epoch] = (63 * P_buff[_1ms_epoch] + (I_sum20 >> 6) * (I_sum20 >> 6) + (Q_sum20 >> 6)*(Q_sum20 >> 6) + 32) >> 6; + //P_buff[_1ms_epoch] = (63 * P_buff[_1ms_epoch] + (I_sum20 >> 6) * (I_sum20 >> 6) + (Q_sum20 >> 6)*(Q_sum20 >> 6) + 32) >> 6; + P_buff[_1ms_epoch] = (63 * P_buff[_1ms_epoch] + (I_sum20 >> 6) * (I_sum20 >> 6) + 32) >> 6; /* Dump accumulation and do tracking according to integration length */ if((_1ms_epoch % len) == 0) @@ -276,14 +282,14 @@ void Channel::Accum(Correlation_S *corr, NCO_Command_S *_feedback) void Channel::DumpAccum() { /* Compute the powers */ - P[0] = I[0]*I[0]+Q[0]*Q[0]; - P[1] = I[1]*I[1]+Q[1]*Q[1]; - P[2] = I[2]*I[2]+Q[2]*Q[2]; + P[0] = (I[0]) * (I[0]) + (Q[0]) * (Q[0]); + P[1] = (I[1]) * (I[1]) + (Q[1]) * (Q[1]); + P[2] = (I[2]) * (I[2]) + (Q[2]) * (Q[2]); /* Lowpass filtered values here */ I_avg += (fabs((float)I[1]) - I_avg) * .02; Q_var += ((float)Q[1]*(float)Q[1] - Q_var) * .02; - P_avg += ((float)P[1]/float(len) - P_avg) * .1; + P_avg += ((float)P[1]/len - P_avg) * .02; /* First do estimate of frequency offset via FFT */ if(freq_lock == false) @@ -293,9 +299,10 @@ void Channel::DumpAccum() else { PLL(); - DLL(); } + DLL(); + /* Dump pertinent data */ Error(); @@ -315,15 +322,14 @@ void Channel::DumpAccum() void Channel::EstCN0() { int32 lcv; + float NP; float NBP; float WBP; + float ncn0; /* Try out new cn0 estimate, PG 393 of Global Positioning System, Theory and Applications */ if((_1ms_epoch == 19) && bit_lock) { - /* Old school cn0 */ - CN0_old = 10*log10(I_avg*I_avg/(2*Q_var)) - 10*log10(aPLL.t); - NBP = I_sum20*I_sum20 + Q_sum20*Q_sum20; WBP = 0; @@ -331,10 +337,15 @@ void Channel::EstCN0() WBP += I_buff[lcv]*I_buff[lcv] + Q_buff[lcv]*Q_buff[lcv]; if(WBP > 0.0) - NP += (NBP/WBP - NP) * .02; + NP = NBP/WBP; + + ncn0 = 10*log10((NP - 1.0)/(20.0 - NP)) + 30.0 + .25; if((NP - 1.0)/(20.0 - NP) > 0.0) - cn0 = 10*log10((NP - 1.0)/(20.0 - NP)) + 30.0 + .25; + { + ncn0 = 10*log10((NP - 1.0)/(20.0 - NP)) + 30.0 + .25; + cn0 += (ncn0 - cn0)*.02; + } if(cn0 < 15.0) { @@ -359,10 +370,12 @@ void Channel::FrequencyLock() qt = Q[1] >> 3; /* First frequency double to remove data bits */ - fft_buff[freq_lock_ticks].i = (int16)(it*it - qt*qt); - fft_buff[freq_lock_ticks].q = (int16)(2*it*qt); - - freq_lock_ticks++; + if(count > 1000) + { + fft_buff[freq_lock_ticks].i = (int16)(it*it - qt*qt); + fft_buff[freq_lock_ticks].q = (int16)(2*it*qt); + freq_lock_ticks++; + } if(freq_lock_ticks >= FREQ_LOCK_POINTS) { @@ -412,19 +425,27 @@ void Channel::DLL() { float code_err; - float ep, lp; + float ep, lp, sp; ep = sqrt(float(P[0])); lp = sqrt(float(P[2])); + sp = sqrt(float(P_avg)); - code_err = (ep - lp)/(ep + lp); + code_err = (ep - lp) / sp; /* Not working too well right now, debug some later */ // aDLL.x += aDLL.t*(code_err*aDLL.w02); // aDLL.z = 0.5*aDLL.x + aDLL.a*aDLL.w02*code_err; -// code_nco = CODE_RATE + ((carrier_nco - IF_FREQUENCY)*CODE_RATE/L1) + aDLL.z; -// - code_nco = CODE_RATE + ((carrier_nco - IF_FREQUENCY)*CODE_RATE/L1) + code_err; +// code_nco = CODE_RATE + (0.5*aPLL.x*CODE_RATE*INVERSE_L1) + aDLL.z; + + if((count < 1000) && (P_avg < 8e4)) + { + code_nco = CODE_RATE + (0.5 * aPLL.x * CODE_RATE * INVERSE_L1) - 5.0; + } + else + { + code_nco = CODE_RATE + (0.5 * aPLL.x * CODE_RATE * INVERSE_L1) + code_err; + } } /*----------------------------------------------------------------------------------------------*/ @@ -441,31 +462,21 @@ void Channel::PLL() df = dp = 0; - if(len != 1) - { - for(lcv = 0; lcv < 10; lcv++) - { - I2 += I_buff[lcv]; - Q2 += Q_buff[lcv]; - } - - for(lcv; lcv < 20; lcv++) - { - I1 += I_buff[lcv]; - Q1 += Q_buff[lcv]; - } - - /* FLL discriminator */ - dot = I2*I1 + Q2*Q1; - cross = -I2*Q1 + Q2*I1; - - /* No FLL for now */ - if((dot != 0.0) && (cross != 0.0)) - { - df = atan2(cross, dot); - df /= TWO_PI; - } - } + //if(len == 20 || (_1ms_epoch & 0x1)) +// { +// /* FLL discriminator */ +// dot = I_prev*I[1] + Q_prev*Q[1]; +// cross = -I_prev*Q[1] + Q_prev*I[1]; +// +// /* No FLL for now */ +// if((dot != 0.0) && (cross != 0.0)) +// { +// df = atan2(cross, dot); +// df /= (TWO_PI * aPLL.t); +// } +// } +// +// df = 0; /* PLL discriminator */ if(I[1] != 0) @@ -521,9 +532,9 @@ void Channel::BitLock() uint32 best_sum; /* Set bitlock threshold */ - thresh = 5000; + thresh = 1000; - if(_1ms_epoch == 19) + if(_1ms_epoch == 19 && (bit_lock_ticks >= thresh)) { if(bit_lock == false) { @@ -911,8 +922,10 @@ void Channel::PLL_W(float _bwpll) aPLL.t = .001*(float)len; } +/*----------------------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------------------------*/ void Channel::DLL_W(float _bwdll) { @@ -930,17 +943,16 @@ void Channel::DLL_W(float _bwdll) void Channel::Error() { - float mcn0; - - mcn0 = cn0 > CN0_old ? cn0 : CN0_old; - /* Monitor DLL */ - if((P_avg < 2e4) && (count > 1000)) + if((P_avg < 8e4) && (count > 1000)) Kill(); /* Monitor cn0 for false PLL lock */ - if((count > 10000) && (mcn0 < 17.0)) - Kill(); + if((count == 15000) && (bit_lock == false) && (freq_lock == true)) + { + freq_lock_ticks = 0; + freq_lock = false; + } /* If 30 seconds have passed and channel has not converged dump it */ if((count > 30000) && (converged == false)) @@ -953,23 +965,17 @@ void Channel::Error() /* Adjust integration length based on cn0 */ if(bit_lock) { -// if((mcn0 > 39.0) && (len != 1)) -// { -// len = 1; -// PLL_W(18.0); -// } + if((cn0 > 39.0) && (len != 1)) + { + len = 1; + PLL_W(18.0); + } -// if((mcn0 < 37.0) && (len != 20)) + if((cn0 < 37.0) && (len != 20)) { len = 20; PLL_W(18.0); } - -// if((mcn0 < 30.0) && (len != 20)) -// { -// len = 20; -// PLL_W(20.0); -// } } } objects/channel.cpp @@ -87,8 +87,6 @@ class Channel : public Threaded_Object float Q_var; //!< Variance of Q float P_avg; //!< Moving average of P float cn0; //!< Current CN0 estimate - float CN0_old; //!< Old CN0 estimate (used to detect meta stable loop convergence) - float NP; //!< New CN0 estimate thing /*----------------------------------------------------------------------------------------------*/ /* Bit lock stuff */ objects/channel.h @@ -633,7 +633,7 @@ void Correlator::InitCorrelator(Correlator_State_S *s) /* Convert delay in samples to chips */ code_phase = (double)result.code_phase * 1023.0 / 2048.0; - code_phase += (double)CODE_CHIPS + dt; + code_phase += (double)CODE_CHIPS - dt + 2.5; code_phase = fmod(code_phase,(double) CODE_CHIPS); s->sv = result.sv; objects/correlator.cpp @@ -100,6 +100,7 @@ void GPS_Source::Read(ms_packet *_p) { double gain; + int32 shift; switch(source_type) { @@ -117,32 +118,50 @@ void GPS_Source::Read(ms_packet *_p) break; } - /* Dont need to AGC the SOURCE_SIGE_GN3S */ - if(source_type != SOURCE_SIGE_GN3S) + switch(source_type) { - /* Add to the buff */ - soverflw += run_agc(&_p->data[0], SAMPS_MS, AGC_BITS, 1); + case SOURCE_USRP_V1: - /* Figure out the agc_scale value */ - if((ms_count & 0xF) == 0) - { - gain = dbs_rx_a->rf_gain(); + /* Count the overflows and shift if needed */ + soverflw += run_agc(&_p->data[0], SAMPS_MS, AGC_BITS, 6); - if(soverflw > OVERFLOW_HIGH) - gain -= 0.5; + /* Figure out the agc_scale value */ + if((ms_count & 0xFF) == 0) + { + gain = dbs_rx_a->rf_gain(); - if(soverflw < OVERFLOW_LOW) - gain += 0.5; + if(soverflw > OVERFLOW_HIGH) + gain -= 0.5; - dbs_rx_a->rf_gain(gain); + if(soverflw < OVERFLOW_LOW) + gain += 0.5; - overflw = soverflw; - soverflw = 0; + dbs_rx_a->rf_gain(gain); - agc_scale = (int32)floor(2.0*(dbs_rx_a->max_rf_gain() - gain)); - } + agc_scale = (int32)floor(2.0*(dbs_rx_a->max_rf_gain() - gain)); + + overflw = soverflw; + soverflw = 0; + } + + break; + case SOURCE_USRP_V2: + +// Read_SOURCE_USRP_V2(_p); + break; + + case SOURCE_SIGE_GN3S: + + break; + default: + break; } +// FILE *fp; +// fp = fopen("crap.dat","a"); +// fwrite(&_p->data[0], 1, SAMPS_MS*sizeof(CPX), fp); +// fclose(fp); + ms_count++; } @@ -491,6 +510,7 @@ void GPS_Source::Read_GN3S(ms_packet *_p) /* Start transfer */ while(!started) { + usleep(100); started = gn3s_a->usrp_xfer(VRQ_XFER, 1); } @@ -598,46 +618,66 @@ void GPS_Source::Resample_USRP_V1(CPX *_in, CPX *_out) void GPS_Source::Resample_GN3S(CPX *_in, CPX *_out) { /* Runs specified filter on incoming signal. */ - //static short filter[7] = {3,4,5,6,5,4,3}; Mike's Filter - //static short filter[7] = {-3,10,27,34,27,10,-3}; Greg's Filter int32 lcv, ind; + int16 tmp; /* Process the array */ for(lcv = 0; lcv < 10240; lcv++) { ind = gdec[lcv]; -// _out[lcv].i = _in[ind + 6].i * -3 + -// _in[ind + 5].i * 10 + -// _in[ind + 4].i * 27 + -// _in[ind + 3].i * 34 + -// _in[ind + 2].i * 27 + -// _in[ind + 1].i * 10 + -// _in[ind + 0].i * -3; + tmp = 8; + tmp += _in[ind + 6].i * 3; + tmp += _in[ind + 5].i * 97; + tmp += _in[ind + 4].i * 77; + tmp += _in[ind + 3].i * 86; + tmp += _in[ind + 2].i * 77; + tmp += _in[ind + 1].i * 97; + tmp += _in[ind + 0].i * 3; + _out[lcv].i = tmp >> 4; + + tmp = 8; + tmp += _in[ind + 6].q * 3; + tmp += _in[ind + 5].q * 97; + tmp += _in[ind + 4].q * 77; + tmp += _in[ind + 3].q * 86; + tmp += _in[ind + 2].q * 77; + tmp += _in[ind + 1].q * 97; + tmp += _in[ind + 0].q * 3; + _out[lcv].q = tmp >> 4; + +// tmp = 4; +// tmp += _in[ind + 12].i * 3; +// tmp += _in[ind + 11].i * -8; +// tmp += _in[ind + 10].i * -11; +// tmp += _in[ind + 9].i * 1; +// tmp += _in[ind + 8].i * 26; +// tmp += _in[ind + 7].i * 52; +// tmp += _in[ind + 6].i * 63; +// tmp += _in[ind + 5].i * 52; +// tmp += _in[ind + 4].i * 26; +// tmp += _in[ind + 3].i * 1; +// tmp += _in[ind + 2].i * -11; +// tmp += _in[ind + 1].i * -8; +// tmp += _in[ind + 0].i * 3; +// _out[lcv].i = tmp >> 3; // -// _out[lcv].q = _in[ind + 6].q * -3 + -// _in[ind + 5].q * 10 + -// _in[ind + 4].q * 27 + -// _in[ind + 3].q * 34 + -// _in[ind + 2].q * 27 + -// _in[ind + 1].q * 10 + -// _in[ind + 0].q * -3; - - _out[lcv].i = _in[ind + 6].i * 4 + - _in[ind + 5].i * 5 + - _in[ind + 4].i * 6 + - _in[ind + 3].i * 7 + - _in[ind + 2].i * 6 + - _in[ind + 1].i * 5 + - _in[ind + 0].i * 4; - - _out[lcv].q = _in[ind + 6].q * 4 + - _in[ind + 5].q * 5 + - _in[ind + 4].q * 6 + - _in[ind + 3].q * 7 + - _in[ind + 2].q * 6 + - _in[ind + 1].q * 5 + - _in[ind + 0].q * 4; +// tmp = 4; +// tmp += _in[ind + 12].q * 3; +// tmp += _in[ind + 11].q * -8; +// tmp += _in[ind + 10].q * -11; +// tmp += _in[ind + 9].q * 1; +// tmp += _in[ind + 8].q * 26; +// tmp += _in[ind + 7].q * 52; +// tmp += _in[ind + 6].q * 63; +// tmp += _in[ind + 5].q * 52; +// tmp += _in[ind + 4].q * 26; +// tmp += _in[ind + 3].q * 1; +// tmp += _in[ind + 2].q * -11; +// tmp += _in[ind + 1].q * -8; +// tmp += _in[ind + 0].q * 3; +// _out[lcv].q = tmp >> 3; + } return; objects/gps_source.cpp @@ -70,7 +70,7 @@ class GPS_Source /* Data buffers */ int8 gbuff[40919*2]; //!< Byte buffer for GN3S - CPX buff[40926]; //!< Base buffer for GN3S/USRP + CPX buff[40932]; //!< Base buffer for GN3S/USRP CPX buff_out[10240]; //!< Output buffer @ 2.048 Msps CPX *buff_out_p; //!< Pointer to a spot in buff_out CPX dbuff[16384]; //!< Buffer for double buffering objects/gps_source.h @@ -72,6 +72,7 @@ Telemetry::Telemetry():Threaded_Object("TLMTASK") npipe[READ] = npipe[WRITE] = -1; pheader = (uint8 *)&command_header; pcommand = (uint8 *)&command_body; + pchecksumr = (uint8 *)&checksumr; signal(SIGPIPE, lost_gui_pipe); @@ -375,6 +376,15 @@ void Telemetry::ImportSerial() break; } + case 3: /* Get the checksum */ + { + pchecksumr[checksum_bytes] = abyte; checksum_bytes++; + + if(checksum_bytes >= sizeof(uint32)) + StateThree(); + + break; + } default: { syncstate = 0; @@ -436,20 +446,42 @@ void Telemetry::StateOne() void Telemetry::StateTwo() { - /* Decode the header */ - DecodeCCSDSPacketHeader(&decoded_header, &command_header); + /* Reset bytes */ + command_bytes = 0; + command_bytes_2_read = 0; - /* Bent pipe data to Commando */ - write(TLM_2_CMD_P[WRITE], &command_header, sizeof(CCSDS_Packet_Header)); - write(TLM_2_CMD_P[WRITE], &command_body, decoded_header.length); + /* Next state */ + syncstate = 3; - syncstate = 0; +} +/*----------------------------------------------------------------------------------------------*/ - command_bytes = 0; - command_bytes_2_read = 0; + +/*----------------------------------------------------------------------------------------------*/ +void Telemetry::StateThree() +{ + + uint32 checksumc; + + /* Assemble into packet */ + memcpy(&packet_body[0], &command_header, sizeof(CCSDS_Packet_Header)); + memcpy(&packet_body[sizeof(CCSDS_Packet_Header)], &command_body, decoded_header.length); + checksumc = adler(&packet_body[0], decoded_header.length + sizeof(CCSDS_Packet_Header)); + + if(checksumc == checksumr) + { + /* Bent pipe data to Commando */ + write(TLM_2_CMD_P[WRITE], &command_header, sizeof(CCSDS_Packet_Header)); + write(TLM_2_CMD_P[WRITE], &command_body, decoded_header.length); + } + + checksum_bytes = 0; + syncstate = 0; + checksumr = 0; memset(&command_body, 0x0, sizeof(Command_Union)); memset(&command_header, 0x0, sizeof(CCSDS_Packet_Header)); + } /*----------------------------------------------------------------------------------------------*/ @@ -909,34 +941,30 @@ void Telemetry::EmitCCSDSPacket(void *_buff, int32 _len) int32 lcv; uint8 *sbuff; - uint8 pre = 0xAA; - uint8 post = 0xBB; + uint32 pre = 0xAAAAAAAA; + uint32 post = 0xBBBBBBBB; + uint32 checksum; + + sbuff = &packet_body[0]; + + /* Assemble into a complete packet */ + memcpy(sbuff, &pre, 4); sbuff += 4; //!< Prefix + memcpy(sbuff, &packet_header, 6); sbuff += 6; //!< CCSDS Header + memcpy(sbuff, _buff, _len); sbuff += _len; //!< Payload + checksum = adler(&packet_body[4], 6 + _len); + memcpy(sbuff, &checksum, 4); sbuff += 4; //!< Checksum + memcpy(sbuff, &post, 4); sbuff += 4; //!< Postfix /* Write the sync header to the UART */ if(npipe_open) { - for(lcv = 0; lcv < 4; lcv++) - write(npipe[WRITE], &pre, sizeof(uint8)); - - /* Write the CCSDS header to the UART */ - sbuff = (uint8 *)&packet_header; - for(lcv = 0; lcv < 6; lcv++) - { - write(npipe[WRITE], sbuff, sizeof(uint8)); - sbuff++; - } - /* Now write the body to the UART */ - sbuff = (uint8 *)_buff; - for(lcv = 0; lcv < _len; lcv++) + sbuff = (uint8 *)&packet_body[0]; + for(lcv = 0; lcv < _len + 18; lcv++) { write(npipe[WRITE], sbuff, sizeof(uint8)); sbuff++; } - - /* Write the sync postfix to the UART */ - for(lcv = 0; lcv < 4; lcv++) - write(npipe[WRITE], &post, sizeof(uint8)); } } objects/telemetry.cpp @@ -83,9 +83,15 @@ class Telemetry : public Threaded_Object Message_Union message_body; //!< Body of a message SV_Prediction_M sv_predictions[MAX_SV]; //!< Buffer SV predictions + uint8 packet_body[2048]; //!< Complete packet body + /* Variables for serial input */ uint32 syncstate; //!< Flag to indicate synchronization step 0 for nothing, 1 for preamble, 2 for CCSDS header, 3 for packet uint32 syncword; //!< Synchronize to the 0xAAAAAAAA preamble + uint32 checksumr; //!< Received checksum + + uint8 *pchecksumr; //!< Pointer to received checksum + uint32 checksum_bytes; //!< Bytes to read in checksum uint8 *pheader; //!< Pointer to header uint32 header_bytes; //!< Bytes left to read in header @@ -122,6 +128,7 @@ class Telemetry : public Threaded_Object void StateZero(); //!< State zero, waiting for 0xAAAAAAAA preamble void StateOne(); //!< State one, collecting CCSDS header void StateTwo(); //!< State two, collecting body of command + void StateThree(); //!< State three, verify packet and pass on to Commando uint32 ReadSHU(uint32 _shu); //!< Read the status and health A/D objects/telemetry.h 51b78da0ea332fc4877f0e507c3e500194b1b576 gpssim gpssim@gpsdevc.(none) http://github.com/gps-sdr/gps-sdr/commit/72a7faba1770aae88aa7d690d3cc99bef8df18f1 72a7faba1770aae88aa7d690d3cc99bef8df18f1 2009-07-31T14:07:38-07:00 2009-07-31T14:07:38-07:00 Whoa, lotsa changes. Normalized noise floors of GN3S and USRP. Code should work equally well with both devices. Played with the GN3S filter. Added a checksum (adler) to the communication with the GUI. 4d48ddab3cd2de2568835272e94619cd74a9a307 gpssim gpssim@gpsdevc.(none)