w4kek/WSJT-X
1
0
Fork 0
mirror of https://github.com/saitohirga/WSJT-X.git synced 2025-05-24 10:22:26 -04:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'develop' of bitbucket.org:k1jt/wsjtx into develop

Browse Source
This commit is contained in:
Joe Taylor 2020-02-26 13:16:12 -05:00
commit b9888a09ff
9 changed files with 287 additions and 223 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
CMakeLists.txt
View File

@ -1308,9 +1308,6 @@ target_link_libraries (ft8code wsjt_fort wsjt_cxx)
add_executable (ft4code lib/ft4/ft4code.f90 wsjtx.rc) add_executable (ft4code lib/ft4/ft4code.f90 wsjtx.rc)
target_link_libraries (ft4code wsjt_fort wsjt_cxx) target_link_libraries (ft4code wsjt_fort wsjt_cxx)
add_executable (ft8 lib/ft8.f90 wsjtx.rc)
target_link_libraries (ft8 wsjt_fort wsjt_cxx)
add_executable (ft8sim_fsk lib/ft8/ft8sim_fsk.f90 wsjtx.rc) add_executable (ft8sim_fsk lib/ft8/ft8sim_fsk.f90 wsjtx.rc)
target_link_libraries (ft8sim_fsk wsjt_fort wsjt_cxx) target_link_libraries (ft8sim_fsk wsjt_fort wsjt_cxx)

11
lib/wsprd/osdwspr.f90
View File

@ -110,11 +110,12 @@ elseif(ndeep.eq.2) then
npre1=1 npre1=1
npre2=0 npre2=0
nt=66 nt=66
ntheta=16 ntheta=22
ntau = 16
elseif(ndeep.eq.3) then elseif(ndeep.eq.3) then
nord=2 nord=1
npre1=1 npre1=1
npre2=0 npre2=1
nt=66 nt=66
ntheta=22 ntheta=22
ntau=16 ntau=16
@ -128,10 +129,10 @@ elseif(ndeep.eq.4) then
elseif(ndeep.eq.5) then elseif(ndeep.eq.5) then
nord=3 nord=3
npre1=1 npre1=1
npre2=0 npre2=1
nt=66 nt=66
ntheta=22 ntheta=22
ntau=20 ntau=16
endif endif
do iorder=1,nord do iorder=1,nord

297
lib/wsprd/wsprd.c
View File

@ -335,7 +335,7 @@ void sync_and_demodulate(float *id, float *qd, long np,
void noncoherent_sequence_detection(float *id, float *qd, long np, void noncoherent_sequence_detection(float *id, float *qd, long np,
unsigned char *symbols, float *f1, int *shift1, unsigned char *symbols, float *f1, int *shift1,
float *drift1, int symfac, int *nblocksize) float *drift1, int symfac, int *nblocksize, int *bitmetric)
{ {
/************************************************************************ /************************************************************************
* Noncoherent sequence detection for wspr. * * Noncoherent sequence detection for wspr. *
@ -364,6 +364,7 @@ void noncoherent_sequence_detection(float *id, float *qd, long np,
lag=*shift1; lag=*shift1;
nblock=*nblocksize; nblock=*nblocksize;
nseq=1<<nblock; nseq=1<<nblock;
int bitbybit=*bitmetric;
for (i=0; i<162; i++) { for (i=0; i<162; i++) {
fp = f0 + (*drift1/2.0)*((float)i-81.0)/81.0; fp = f0 + (*drift1/2.0)*((float)i-81.0)/81.0;
@ -456,6 +457,9 @@ void noncoherent_sequence_detection(float *id, float *qd, long np,
} }
} }
fsymb[i+ib]=xm1-xm0; fsymb[i+ib]=xm1-xm0;
if( bitbybit == 1 ) {
fsymb[i+ib]=fsymb[i+ib]/(xm1 > xm0 ? xm1 : xm0);
}
} }
} }
for (i=0; i<162; i++) { //Normalize the soft symbols for (i=0; i<162; i++) { //Normalize the soft symbols
@ -529,14 +533,14 @@ void subtract_signal(float *id, float *qd, long np,
return; return;
} }
/****************************************************************************** /******************************************************************************
Fully coherent signal subtraction Subtract the coherent component of a signal
*******************************************************************************/ *******************************************************************************/
void subtract_signal2(float *id, float *qd, long np, void subtract_signal2(float *id, float *qd, long np,
float f0, int shift0, float drift0, unsigned char* channel_symbols) float f0, int shift0, float drift0, unsigned char* channel_symbols)
{ {
float dt=1.0/375.0, df=375.0/256.0; float dt=1.0/375.0, df=375.0/256.0;
float pi=4.*atan(1.0), twopidt, phi=0, dphi, cs; float pi=4.*atan(1.0), twopidt, phi=0, dphi, cs;
int i, j, k, ii, nsym=162, nspersym=256, nfilt=256; //nfilt must be even number. int i, j, k, ii, nsym=162, nspersym=256, nfilt=360; //nfilt must be even number.
int nsig=nsym*nspersym; int nsig=nsym*nspersym;
int nc2=45000; int nc2=45000;
@ -579,6 +583,20 @@ void subtract_signal2(float *id, float *qd, long np,
} }
} }
float w[nfilt], norm=0, partialsum[nfilt];
//lowpass filter and remove startup transient
for (i=0; i<nfilt; i++) partialsum[i]=0.0;
for (i=0; i<nfilt; i++) {
w[i]=sin(pi*(float)i/(float)(nfilt-1));
norm=norm+w[i];
}
for (i=0; i<nfilt; i++) {
w[i]=w[i]/norm;
}
for (i=1; i<nfilt; i++) {
partialsum[i]=partialsum[i-1]+w[i];
}
// s(t) * conjugate(r(t)) // s(t) * conjugate(r(t))
// beginning of first symbol in reference signal is at i=0 // beginning of first symbol in reference signal is at i=0
// beginning of first symbol in received data is at shift0. // beginning of first symbol in received data is at shift0.
@ -592,20 +610,6 @@ void subtract_signal2(float *id, float *qd, long np,
} }
} }
//lowpass filter and remove startup transient
float w[nfilt], norm=0, partialsum[nfilt];
for (i=0; i<nfilt; i++) partialsum[i]=0.0;
for (i=0; i<nfilt; i++) {
w[i]=sin(pi*(float)i/(float)(nfilt-1));
norm=norm+w[i];
}
for (i=0; i<nfilt; i++) {
w[i]=w[i]/norm;
}
for (i=1; i<nfilt; i++) {
partialsum[i]=partialsum[i-1]+w[i];
}
// LPF // LPF
for (i=nfilt/2; i<45000-nfilt/2; i++) { for (i=nfilt/2; i<45000-nfilt/2; i++) {
cfi[i]=0.0; cfq[i]=0.0; cfi[i]=0.0; cfq[i]=0.0;
@ -616,7 +620,7 @@ void subtract_signal2(float *id, float *qd, long np,
} }
// subtract c(t)*r(t) here // subtract c(t)*r(t) here
// (ci+j*cq)(refi+j*refq)=(ci*refi-cq*refq)+j(ci*refq)+cq*refi) // (ci+j*cq)(refi+j*refq)=(ci*refi-cq*refq)+j(ci*refq+cq*refi)
// beginning of first symbol in reference signal is at i=nfilt // beginning of first symbol in reference signal is at i=nfilt
// beginning of first symbol in received data is at shift0. // beginning of first symbol in received data is at shift0.
for (i=0; i<nsig; i++) { for (i=0; i<nsig; i++) {
@ -675,6 +679,23 @@ unsigned long writec2file(char *c2filename, int trmin, double freq
} }
} }
unsigned int count_hard_errors( unsigned char *symbols, unsigned char *channel_symbols)
{
int i,is;
unsigned char cw[162];
unsigned int nerrors;
for (i=0; i<162; i++) {
cw[i] = channel_symbols[i] >=2 ? 1:0;
}
deinterleave(cw);
nerrors=0;
for (i=0; i<162; i++) {
is = symbols[i] > 127 ? 1:0;
nerrors = nerrors + (is == cw[i] ? 0:1);
}
return nerrors;
}
//*************************************************************************** //***************************************************************************
void usage(void) void usage(void)
{ {
@ -710,7 +731,7 @@ int main(int argc, char *argv[])
int i,j,k; int i,j,k;
unsigned char *symbols, *decdata, *channel_symbols, *apmask, *cw; unsigned char *symbols, *decdata, *channel_symbols, *apmask, *cw;
signed char message[]={-9,13,-35,123,57,-39,64,0,0,0,0}; signed char message[]={-9,13,-35,123,57,-39,64,0,0,0,0};
char *callsign, *call_loc_pow; char *callsign, *grid, *call_loc_pow;
char *ptr_to_infile,*ptr_to_infile_suffix; char *ptr_to_infile,*ptr_to_infile_suffix;
char *data_dir=NULL; char *data_dir=NULL;
char wisdom_fname[200],all_fname[200],spots_fname[200]; char wisdom_fname[200],all_fname[200],spots_fname[200];
@ -720,13 +741,11 @@ int main(int argc, char *argv[])
int writenoise=0,usehashtable=1,wspr_type=2, ipass, nblocksize; int writenoise=0,usehashtable=1,wspr_type=2, ipass, nblocksize;
int nhardmin,ihash; int nhardmin,ihash;
int writec2=0,maxdrift; int writec2=0,maxdrift;
int shift1, lagmin, lagmax, lagstep, ifmin, ifmax, worth_a_try, not_decoded; int shift1, lagmin, lagmax, lagstep, ifmin, ifmax, not_decoded;
unsigned int nbits=81, stacksize=200000; unsigned int nbits=81, stacksize=200000;
unsigned int npoints, metric, cycles, maxnp; unsigned int npoints, cycles, maxnp, metric;
float df=375.0/256.0/2; float df=375.0/256.0/2;
float freq0[200],snr0[200],drift0[200],sync0[200];
float fsymbs[162]; float fsymbs[162];
int shift0[200];
float dt=1.0/375.0, dt_print; float dt=1.0/375.0, dt_print;
double dialfreq_cmdline=0.0, dialfreq, freq_print; double dialfreq_cmdline=0.0, dialfreq, freq_print;
double dialfreq_error=0.0; double dialfreq_error=0.0;
@ -737,16 +756,21 @@ int main(int argc, char *argv[])
float *idat, *qdat; float *idat, *qdat;
clock_t t0,t00; clock_t t0,t00;
float tfano=0.0,treadwav=0.0,tcandidates=0.0,tsync0=0.0; float tfano=0.0,treadwav=0.0,tcandidates=0.0,tsync0=0.0;
float tsync1=0.0,tsync2=0.0,ttotal=0.0; float tsync1=0.0,tsync2=0.0,tosd=0.0,ttotal=0.0;
struct cand { float freq; float snr; int shift; float drift; float sync; };
struct cand candidates[200];
struct result { char date[7]; char time[5]; float sync; float snr; struct result { char date[7]; char time[5]; float sync; float snr;
float dt; double freq; char message[23]; float drift; float dt; double freq; char message[23]; float drift;
unsigned int cycles; int jitter; int blocksize; unsigned int metric; unsigned int cycles; int jitter; int blocksize; unsigned int metric;
unsigned char osd_decode; }; int nhardmin; int ipass; int decodetype;};
struct result decodes[50]; struct result decodes[50];
char *hashtab; char *hashtab;
hashtab=calloc(32768*13,sizeof(char)); hashtab=calloc(32768*13,sizeof(char));
char *loctab;
loctab=calloc(32768*5,sizeof(char));
int nh; int nh;
symbols=calloc(nbits*2,sizeof(unsigned char)); symbols=calloc(nbits*2,sizeof(unsigned char));
apmask=calloc(162,sizeof(unsigned char)); apmask=calloc(162,sizeof(unsigned char));
@ -754,6 +778,7 @@ int main(int argc, char *argv[])
decdata=calloc(11,sizeof(unsigned char)); decdata=calloc(11,sizeof(unsigned char));
channel_symbols=calloc(nbits*2,sizeof(unsigned char)); channel_symbols=calloc(nbits*2,sizeof(unsigned char));
callsign=calloc(13,sizeof(char)); callsign=calloc(13,sizeof(char));
grid=calloc(5,sizeof(char));
call_loc_pow=calloc(23,sizeof(char)); call_loc_pow=calloc(23,sizeof(char));
float allfreqs[100]; float allfreqs[100];
char allcalls[100][13]; char allcalls[100][13];
@ -768,9 +793,8 @@ int main(int argc, char *argv[])
float minsync2=0.12; //Second sync limit float minsync2=0.12; //Second sync limit
int iifac=8; //Step size in final DT peakup int iifac=8; //Step size in final DT peakup
int symfac=50; //Soft-symbol normalizing factor int symfac=50; //Soft-symbol normalizing factor
int block_demod=1; //Default is to use block demod on pass 2
int subtraction=1; int subtraction=1;
int npasses=2; int npasses=3;
int ndepth=-1; //Depth for OSD int ndepth=-1; //Depth for OSD
float minrms=52.0 * (symfac/64.0); //Final test for plausible decoding float minrms=52.0 * (symfac/64.0); //Final test for plausible decoding
@ -792,7 +816,7 @@ int main(int argc, char *argv[])
data_dir = optarg; data_dir = optarg;
break; break;
case 'B': case 'B':
block_demod=0; npasses=2;
break; break;
case 'c': case 'c':
writec2=1; writec2=1;
@ -892,8 +916,8 @@ int main(int argc, char *argv[])
if((ftimer=fopen(timer_fname,"r"))) { if((ftimer=fopen(timer_fname,"r"))) {
//Accumulate timing data //Accumulate timing data
fscanf(ftimer,"%f %f %f %f %f %f %f", fscanf(ftimer,"%f %f %f %f %f %f %f %f",
&treadwav,&tcandidates,&tsync0,&tsync1,&tsync2,&tfano,&ttotal); &treadwav,&tcandidates,&tsync0,&tsync1,&tsync2,&tfano,&tosd,&ttotal);
fclose(ftimer); fclose(ftimer);
} }
ftimer=fopen(timer_fname,"w"); ftimer=fopen(timer_fname,"w");
@ -941,11 +965,13 @@ int main(int argc, char *argv[])
} }
if( usehashtable ) { if( usehashtable ) {
char line[80], hcall[12]; char line[80], hcall[13], hgrid[5];
if( (fhash=fopen(hash_fname,"r+")) ) { if( (fhash=fopen(hash_fname,"r+")) ) {
while (fgets(line, sizeof(line), fhash) != NULL) { while (fgets(line, sizeof(line), fhash) != NULL) {
sscanf(line,"%d %s",&nh,hcall); hgrid[0]='\0';
sscanf(line,"%d %s %s",&nh,hcall,hgrid);
strcpy(hashtab+nh*13,hcall); strcpy(hashtab+nh*13,hcall);
if(strlen(hgrid)>0) strcpy(loctab+nh*5,hgrid);
} }
} else { } else {
fhash=fopen(hash_fname,"w+"); fhash=fopen(hash_fname,"w+");
@ -955,21 +981,16 @@ int main(int argc, char *argv[])
//*************** main loop starts here ***************** //*************** main loop starts here *****************
for (ipass=0; ipass<npasses; ipass++) { for (ipass=0; ipass<npasses; ipass++) {
if(ipass == 0) { if(ipass==1 && ndecodes_pass == 0) ipass=2;
if(ipass < 2) {
nblocksize=1; nblocksize=1;
maxdrift=4; maxdrift=4;
minsync2=0.12; minsync2=0.12;
} }
if(ipass == 1 ) { if(ipass == 2 ) {
if(block_demod == 1) { nblocksize=4; // try 3 blocksizes plus bitbybit normalization
nblocksize=3; // try all blocksizes up to 3
maxdrift=0; // no drift for smaller frequency estimator variance maxdrift=0; // no drift for smaller frequency estimator variance
minsync2=0.10; minsync2=0.10;
} else { // if called with -B, revert to "classic" wspr params
nblocksize=1;
maxdrift=4;
minsync2=0.12;
}
} }
ndecodes_pass=0; // still needed? ndecodes_pass=0; // still needed?
@ -1023,7 +1044,6 @@ int main(int argc, char *argv[])
* The corresponding threshold is -42.3 dB in 2500 Hz bandwidth for WSPR-15. */ * The corresponding threshold is -42.3 dB in 2500 Hz bandwidth for WSPR-15. */
float min_snr, snr_scaling_factor; float min_snr, snr_scaling_factor;
// min_snr = pow(10.0,-7.0/10.0); //this is min snr in wspr bw
min_snr = pow(10.0,-8.0/10.0); //this is min snr in wspr bw min_snr = pow(10.0,-8.0/10.0); //this is min snr in wspr bw
if( wspr_type == 2 ) { if( wspr_type == 2 ) {
snr_scaling_factor=26.3; snr_scaling_factor=26.3;
@ -1038,32 +1058,31 @@ int main(int argc, char *argv[])
// Find all local maxima in smoothed spectrum. // Find all local maxima in smoothed spectrum.
for (i=0; i<200; i++) { for (i=0; i<200; i++) {
freq0[i]=0.0; candidates[i].freq=0.0;
snr0[i]=0.0; candidates[i].snr=0.0;
drift0[i]=0.0; candidates[i].drift=0.0;
shift0[i]=0; candidates[i].shift=0;
sync0[i]=0.0; candidates[i].sync=0.0;
} }
int npk=0; int npk=0;
unsigned char candidate; unsigned char candidate;
if( more_candidates ) {
for(j=0; j<411; j=j+2) {
candidate = (smspec[j]>min_snr) && (npk<200);
if ( candidate ) {
freq0[npk]=(j-205)*df;
snr0[npk]=10*log10(smspec[j])-snr_scaling_factor;
npk++;
}
}
} else {
for(j=1; j<410; j++) { for(j=1; j<410; j++) {
candidate = (smspec[j]>smspec[j-1]) && candidate = (smspec[j]>smspec[j-1]) &&
(smspec[j]>smspec[j+1]) && (smspec[j]>smspec[j+1]) &&
(npk<200); (npk<200);
if ( candidate ) { if ( candidate ) {
freq0[npk]=(j-205)*df; candidates[npk].freq = (j-205)*df;
snr0[npk]=10*log10(smspec[j])-snr_scaling_factor; candidates[npk].snr = 10*log10(smspec[j])-snr_scaling_factor;
npk++;
}
}
if( more_candidates ) {
for(j=0; j<411; j=j+3) {
candidate = (smspec[j]>min_snr) && (npk<200);
if ( candidate ) {
candidates[npk].freq = (j-205)*df;
candidates[npk].snr = 10*log10(smspec[j])-snr_scaling_factor;
npk++; npk++;
} }
} }
@ -1076,26 +1095,22 @@ int main(int argc, char *argv[])
// Don't waste time on signals outside of the range [fmin,fmax]. // Don't waste time on signals outside of the range [fmin,fmax].
i=0; i=0;
for( j=0; j<npk; j++) { for( j=0; j<npk; j++) {
if( freq0[j] >= fmin && freq0[j] <= fmax ) { if( candidates[j].freq >= fmin && candidates[j].freq <= fmax ) {
freq0[i]=freq0[j]; candidates[i]=candidates[j];
snr0[i]=snr0[j];
i++; i++;
} }
} }
npk=i; npk=i;
// bubble sort on snr, bringing freq along for the ride // bubble sort on snr
int pass; int pass;
float tmp; struct cand tmp;
for (pass = 1; pass <= npk - 1; pass++) { for (pass = 1; pass <= npk - 1; pass++) {
for (k = 0; k < npk - pass ; k++) { for (k = 0; k < npk - pass ; k++) {
if (snr0[k] < snr0[k+1]) { if (candidates[k].snr < candidates[k+1].snr) {
tmp = snr0[k]; tmp = candidates[k];
snr0[k] = snr0[k+1]; candidates[k]=candidates[k+1];
snr0[k+1] = tmp; candidates[k+1] = tmp;
tmp = freq0[k];
freq0[k] = freq0[k+1];
freq0[k+1] = tmp;
} }
} }
} }
@ -1127,7 +1142,7 @@ int main(int argc, char *argv[])
float smax,ss,pow,p0,p1,p2,p3; float smax,ss,pow,p0,p1,p2,p3;
for(j=0; j<npk; j++) { //For each candidate... for(j=0; j<npk; j++) { //For each candidate...
smax=-1e30; smax=-1e30;
if0=freq0[j]/df+256; if0=candidates[j].freq/df+256;
for (ifr=if0-2; ifr<=if0+2; ifr++) { //Freq search for (ifr=if0-2; ifr<=if0+2; ifr++) { //Freq search
for( k0=-10; k0<22; k0++) { //Time search for( k0=-10; k0<22; k0++) { //Time search
for (idrift=-maxdrift; idrift<=maxdrift; idrift++) { //Drift search for (idrift=-maxdrift; idrift<=maxdrift; idrift++) { //Drift search
@ -1154,10 +1169,10 @@ int main(int argc, char *argv[])
sync1=ss/pow; sync1=ss/pow;
if( sync1 > smax ) { //Save coarse parameters if( sync1 > smax ) { //Save coarse parameters
smax=sync1; smax=sync1;
shift0[j]=128*(k0+1); candidates[j].shift=128*(k0+1);
drift0[j]=idrift; candidates[j].drift=idrift;
freq0[j]=(ifr-256)*df; candidates[j].freq=(ifr-256)*df;
sync0[j]=sync1; candidates[j].sync=sync1;
} }
} }
} }
@ -1182,14 +1197,11 @@ int main(int argc, char *argv[])
could each work on one candidate at a time. could each work on one candidate at a time.
*/ */
for (j=0; j<npk; j++) { for (j=0; j<npk; j++) {
memset(symbols,0,sizeof(char)*nbits*2);
memset(callsign,0,sizeof(char)*13);
memset(call_loc_pow,0,sizeof(char)*23);
f1=freq0[j]; f1=candidates[j].freq;
drift1=drift0[j]; drift1=candidates[j].drift;
shift1=shift0[j]; shift1=candidates[j].shift;
sync1=sync0[j]; sync1=candidates[j].sync;
// coarse-grid lag and freq search, then if sync>minsync1 continue // coarse-grid lag and freq search, then if sync>minsync1 continue
fstep=0.0; ifmin=0; ifmax=0; fstep=0.0; ifmin=0; ifmax=0;
@ -1206,7 +1218,7 @@ int main(int argc, char *argv[])
sync_and_demodulate(idat, qdat, npoints, symbols, &f1, ifmin, ifmax, fstep, &shift1, sync_and_demodulate(idat, qdat, npoints, symbols, &f1, ifmin, ifmax, fstep, &shift1,
lagmin, lagmax, lagstep, &drift1, symfac, &sync1, 1); lagmin, lagmax, lagstep, &drift1, symfac, &sync1, 1);
if(ipass == 0) { if(ipass < 2) {
// refine drift estimate // refine drift estimate
fstep=0.0; ifmin=0; ifmax=0; fstep=0.0; ifmin=0; ifmax=0;
float driftp,driftm,syncp,syncm; float driftp,driftm,syncp,syncm;
@ -1244,30 +1256,65 @@ int main(int argc, char *argv[])
lagmin, lagmax, lagstep, &drift1, symfac, &sync1, 1); lagmin, lagmax, lagstep, &drift1, symfac, &sync1, 1);
tsync1 += (float)(clock()-t0)/CLOCKS_PER_SEC; tsync1 += (float)(clock()-t0)/CLOCKS_PER_SEC;
worth_a_try = 1; candidates[j].freq=f1;
} else { candidates[j].shift=shift1;
worth_a_try = 0; candidates[j].drift=drift1;
candidates[j].sync=sync1;
}
}
int nwat=0;
int idupe;
for ( j=0; j<npk; j++) {
idupe=0;
for (k=0;k<nwat;k++) {
if( fabsf(candidates[j].freq - candidates[k].freq) < 0.05 &&
abs(candidates[j].shift - candidates[k].shift) < 16 ) {
idupe=1;
break;
}
}
if( idupe == 1 ) {
if(candidates[j].sync > candidates[k].sync) candidates[k]=candidates[j];
} else if ( candidates[j].sync > minsync2 ) {
candidates[nwat]=candidates[j];
nwat++;
}
} }
int idt, ii, jittered_shift; int idt, ii, jittered_shift;
float y,sq,rms; float y,sq,rms;
not_decoded=1; int ib, blocksize, bitmetric;
int osd_decode=0;
int ib=1, blocksize;
int n1,n2,n3,nadd,nu,ntype; int n1,n2,n3,nadd,nu,ntype;
int osd_decode;
for (j=0; j<nwat; j++) {
memset(symbols,0,sizeof(char)*nbits*2);
memset(callsign,0,sizeof(char)*13);
memset(grid,0,sizeof(char)*5);
memset(call_loc_pow,0,sizeof(char)*23);
f1=candidates[j].freq;
shift1=candidates[j].shift;
drift1=candidates[j].drift;
not_decoded=1;
osd_decode=0;
ib=1;
while( ib <= nblocksize && not_decoded ) { while( ib <= nblocksize && not_decoded ) {
blocksize=ib; if (ib < 4) { blocksize=ib; bitmetric=0; }
if (ib == 4) { blocksize=1; bitmetric=1; }
idt=0; ii=0; idt=0; ii=0;
while ( worth_a_try && not_decoded && idt<=(128/iifac)) { while ( not_decoded && idt<=(128/iifac)) {
ii=(idt+1)/2; ii=(idt+1)/2;
if( idt%2 == 1 ) ii=-ii; if( idt%2 == 1 ) ii=-ii;
ii=iifac*ii; ii=iifac*ii;
jittered_shift=shift1+ii; jittered_shift=shift1+ii;
nhardmin=0; dmin=0.0;
// Use mode 2 to get soft-decision symbols // Get soft-decision symbols
t0 = clock(); t0 = clock();
noncoherent_sequence_detection(idat, qdat, npoints, symbols, &f1, noncoherent_sequence_detection(idat, qdat, npoints, symbols, &f1,
&jittered_shift, &drift1, symfac, &blocksize); &jittered_shift, &drift1, symfac, &blocksize, &bitmetric);
tsync2 += (float)(clock()-t0)/CLOCKS_PER_SEC; tsync2 += (float)(clock()-t0)/CLOCKS_PER_SEC;
sq=0.0; sq=0.0;
@ -1277,7 +1324,7 @@ int main(int argc, char *argv[])
} }
rms=sqrt(sq/162.0); rms=sqrt(sq/162.0);
if((sync1 > minsync2) && (rms > minrms)) { if(rms > minrms) {
deinterleave(symbols); deinterleave(symbols);
t0 = clock(); t0 = clock();
@ -1293,9 +1340,12 @@ int main(int argc, char *argv[])
if( (ndepth >= 0) && not_decoded ) { if( (ndepth >= 0) && not_decoded ) {
for(i=0; i<162; i++) { for(i=0; i<162; i++) {
fsymbs[i]=symbols[i]-127; fsymbs[i]=symbols[i]-128.0;
} }
t0 = clock();
osdwspr_(fsymbs,apmask,&ndepth,cw,&nhardmin,&dmin); osdwspr_(fsymbs,apmask,&ndepth,cw,&nhardmin,&dmin);
tosd += (float)(clock()-t0)/CLOCKS_PER_SEC;
for(i=0; i<162; i++) { for(i=0; i<162; i++) {
symbols[i]=255*cw[i]; symbols[i]=255*cw[i];
} }
@ -1311,21 +1361,30 @@ int main(int argc, char *argv[])
unpack50(message,&n1,&n2); unpack50(message,&n1,&n2);
if( !unpackcall(n1,callsign) ) break; if( !unpackcall(n1,callsign) ) break;
callsign[12]=0; callsign[12]=0;
if( !unpackgrid(n2, grid) ) break;
grid[4]=0;
ntype = (n2&127) - 64; ntype = (n2&127) - 64;
int itype;
if( (ntype >= 0) && (ntype <= 62) ) { if( (ntype >= 0) && (ntype <= 62) ) {
nu = ntype%10; nu = ntype%10;
itype=1;
if( !(nu == 0 || nu == 3 || nu == 7) ) { if( !(nu == 0 || nu == 3 || nu == 7) ) {
nadd=nu; nadd=nu;
if( nu > 3 ) nadd=nu-3; if( nu > 3 ) nadd=nu-3;
if( nu > 7 ) nadd=nu-7; if( nu > 7 ) nadd=nu-7;
n3=n2/128+32768*(nadd-1); n3=n2/128+32768*(nadd-1);
if( !unpackpfx(n3,callsign) ) break; if( !unpackpfx(n3,callsign) ) {
break;
}
itype=2;
} }
ihash=nhash(callsign,strlen(callsign),(uint32_t)146); ihash=nhash(callsign,strlen(callsign),(uint32_t)146);
if(strncmp(hashtab+ihash*13,callsign,13)==0) { if(strncmp(hashtab+ihash*13,callsign,13)==0) {
if( (itype==1 && strncmp(loctab+ihash*5,grid,5)==0) ||
(itype==2) ) {
not_decoded=0; not_decoded=0;
osd_decode =1; osd_decode =1;
break; }
} }
} }
} }
@ -1337,7 +1396,7 @@ int main(int argc, char *argv[])
ib++; ib++;
} }
if( worth_a_try && !not_decoded ) { if( !not_decoded ) {
ndecodes_pass++; ndecodes_pass++;
for(i=0; i<11; i++) { for(i=0; i<11; i++) {
@ -1353,22 +1412,21 @@ int main(int argc, char *argv[])
// Unpack the decoded message, update the hashtable, apply // Unpack the decoded message, update the hashtable, apply
// sanity checks on grid and power, and return // sanity checks on grid and power, and return
// call_loc_pow string and also callsign (for de-duping). // call_loc_pow string and also callsign (for de-duping).
noprint=unpk_(message,hashtab,call_loc_pow,callsign); noprint=unpk_(message,hashtab,loctab,call_loc_pow,callsign);
if( subtraction && !noprint ) {
// subtract even on last pass if( get_wspr_channel_symbols(call_loc_pow, hashtab, loctab, channel_symbols) ) {
if( subtraction && (ipass < npasses ) && !noprint ) {
if( get_wspr_channel_symbols(call_loc_pow, hashtab, channel_symbols) ) {
subtract_signal2(idat, qdat, npoints, f1, shift1, drift1, channel_symbols); subtract_signal2(idat, qdat, npoints, f1, shift1, drift1, channel_symbols);
if(!osd_decode) nhardmin=count_hard_errors(symbols,channel_symbols);
} else { } else {
break; break;
} }
} }
// Remove dupes (same callsign and freq within 3 Hz) // Remove dupes (same callsign and freq within 4 Hz)
int dupe=0; int dupe=0;
for (i=0; i<uniques; i++) { for (i=0; i<uniques; i++) {
if(!strcmp(callsign,allcalls[i]) && if(!strcmp(callsign,allcalls[i]) &&
(fabs(f1-allfreqs[i]) <3.0)) dupe=1; (fabs(f1-allfreqs[i]) <4.0)) dupe=1;
} }
if( (verbose || !dupe) && !noprint) { if( (verbose || !dupe) && !noprint) {
strcpy(allcalls[uniques],callsign); strcpy(allcalls[uniques],callsign);
@ -1388,17 +1446,19 @@ int main(int argc, char *argv[])
strcpy(decodes[uniques-1].date,date); strcpy(decodes[uniques-1].date,date);
strcpy(decodes[uniques-1].time,uttime); strcpy(decodes[uniques-1].time,uttime);
decodes[uniques-1].sync=sync1; decodes[uniques-1].sync=candidates[j].sync;
decodes[uniques-1].snr=snr0[j]; decodes[uniques-1].snr=candidates[j].snr;
decodes[uniques-1].dt=dt_print; decodes[uniques-1].dt=dt_print;
decodes[uniques-1].freq=freq_print; decodes[uniques-1].freq=freq_print;
strcpy(decodes[uniques-1].message,call_loc_pow); strcpy(decodes[uniques-1].message,call_loc_pow);
decodes[uniques-1].drift=drift1; decodes[uniques-1].drift=drift1;
decodes[uniques-1].cycles=cycles; decodes[uniques-1].cycles=cycles;
decodes[uniques-1].jitter=ii; decodes[uniques-1].jitter=ii;
decodes[uniques-1].blocksize=blocksize; decodes[uniques-1].blocksize=blocksize+3*bitmetric;
decodes[uniques-1].metric=metric; decodes[uniques-1].metric=metric;
decodes[uniques-1].osd_decode=osd_decode; decodes[uniques-1].nhardmin=nhardmin;
decodes[uniques-1].ipass=ipass;
decodes[uniques-1].decodetype=osd_decode;
} }
} }
} }
@ -1430,11 +1490,12 @@ int main(int argc, char *argv[])
decodes[i].time, decodes[i].snr,decodes[i].dt, decodes[i].freq, decodes[i].time, decodes[i].snr,decodes[i].dt, decodes[i].freq,
(int)decodes[i].drift, decodes[i].message); (int)decodes[i].drift, decodes[i].message);
fprintf(fall_wspr, fprintf(fall_wspr,
"%6s %4s %3d %3.0f %5.2f %11.7f %-22s %2d %5u %4d %4d %4d %2u\n", "%6s %4s %4d %3.0f %5.2f %11.7f %-22s %2d %2d %2d %4d %2d %4d %5u %5d\n",
decodes[i].date, decodes[i].time, (int)(10*decodes[i].sync), decodes[i].date, decodes[i].time, (int)(100*decodes[i].sync),
decodes[i].snr, decodes[i].dt, decodes[i].freq, decodes[i].snr, decodes[i].dt, decodes[i].freq,
decodes[i].message, (int)decodes[i].drift, decodes[i].cycles/81, decodes[i].message, (int)decodes[i].drift, decodes[i].ipass,
decodes[i].jitter,decodes[i].blocksize,decodes[i].metric,decodes[i].osd_decode); decodes[i].blocksize,decodes[i].jitter,decodes[i].decodetype,
decodes[i].nhardmin,decodes[i].cycles/81,decodes[i].metric);
fprintf(fwsprd, fprintf(fwsprd,
"%6s %4s %3d %3.0f %4.1f %10.6f %-22s %2d %5u %4d\n", "%6s %4s %3d %3.0f %4.1f %10.6f %-22s %2d %5u %4d\n",
decodes[i].date, decodes[i].time, (int)(10*decodes[i].sync), decodes[i].date, decodes[i].time, (int)(10*decodes[i].sync),
@ -1455,8 +1516,8 @@ int main(int argc, char *argv[])
ttotal += (float)(clock()-t00)/CLOCKS_PER_SEC; ttotal += (float)(clock()-t00)/CLOCKS_PER_SEC;
fprintf(ftimer,"%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n\n", fprintf(ftimer,"%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n\n",
treadwav,tcandidates,tsync0,tsync1,tsync2,tfano,ttotal); treadwav,tcandidates,tsync0,tsync1,tsync2,tfano,tosd,ttotal);
fprintf(ftimer,"Code segment Seconds Frac\n"); fprintf(ftimer,"Code segment Seconds Frac\n");
fprintf(ftimer,"-----------------------------------\n"); fprintf(ftimer,"-----------------------------------\n");
@ -1467,6 +1528,7 @@ int main(int argc, char *argv[])
fprintf(ftimer,"sync_and_demod(1) %7.2f %7.2f\n",tsync1,tsync1/ttotal); fprintf(ftimer,"sync_and_demod(1) %7.2f %7.2f\n",tsync1,tsync1/ttotal);
fprintf(ftimer,"sync_and_demod(2) %7.2f %7.2f\n",tsync2,tsync2/ttotal); fprintf(ftimer,"sync_and_demod(2) %7.2f %7.2f\n",tsync2,tsync2/ttotal);
fprintf(ftimer,"Stack/Fano decoder %7.2f %7.2f\n",tfano,tfano/ttotal); fprintf(ftimer,"Stack/Fano decoder %7.2f %7.2f\n",tfano,tfano/ttotal);
fprintf(ftimer,"OSD decoder %7.2f %7.2f\n",tosd,tosd/ttotal);
fprintf(ftimer,"-----------------------------------\n"); fprintf(ftimer,"-----------------------------------\n");
fprintf(ftimer,"Total %7.2f %7.2f\n",ttotal,1.0); fprintf(ftimer,"Total %7.2f %7.2f\n",ttotal,1.0);
@ -1482,13 +1544,14 @@ int main(int argc, char *argv[])
fhash=fopen(hash_fname,"w"); fhash=fopen(hash_fname,"w");
for (i=0; i<32768; i++) { for (i=0; i<32768; i++) {
if( strncmp(hashtab+i*13,"\0",1) != 0 ) { if( strncmp(hashtab+i*13,"\0",1) != 0 ) {
fprintf(fhash,"%5d %s\n",i,hashtab+i*13); fprintf(fhash,"%5d %s %s\n",i,hashtab+i*13,loctab+i*5);
} }
} }
fclose(fhash); fclose(fhash);
} }
free(hashtab); free(hashtab);
free(loctab);
free(symbols); free(symbols);
free(decdata); free(decdata);
free(channel_symbols); free(channel_symbols);

3
lib/wsprd/wsprd_utils.c
View File

@ -240,7 +240,7 @@ int floatcomp(const void* elem1, const void* elem2)
return *(const float*)elem1 > *(const float*)elem2; return *(const float*)elem1 > *(const float*)elem2;
} }
int unpk_(signed char *message, char *hashtab, char *call_loc_pow, char *callsign) int unpk_(signed char *message, char *hashtab, char *loctab, char *call_loc_pow, char *callsign)
{ {
int n1,n2,n3,ndbm,ihash,nadd,noprint=0; int n1,n2,n3,ndbm,ihash,nadd,noprint=0;
char grid[5],grid6[7],cdbm[3]; char grid[5],grid6[7],cdbm[3];
@ -279,6 +279,7 @@ int unpk_(signed char *message, char *hashtab, char *call_loc_pow, char *callsig
strncat(call_loc_pow,"\0",1); strncat(call_loc_pow,"\0",1);
ihash=nhash(callsign,strlen(callsign),(uint32_t)146); ihash=nhash(callsign,strlen(callsign),(uint32_t)146);
strcpy(hashtab+ihash*13,callsign); strcpy(hashtab+ihash*13,callsign);
strcpy(loctab+ihash*5,grid);
} else { } else {
nadd=nu; nadd=nu;
if( nu > 3 ) nadd=nu-3; if( nu > 3 ) nadd=nu-3;

2
lib/wsprd/wsprd_utils.h
View File

@ -24,6 +24,6 @@ void deinterleave(unsigned char *sym);
int doublecomp(const void* elem1, const void* elem2); int doublecomp(const void* elem1, const void* elem2);
int floatcomp(const void* elem1, const void* elem2); int floatcomp(const void* elem1, const void* elem2);
int unpk_( signed char *message, char* hashtab, char *call_loc_pow, char *callsign); int unpk_( signed char *message, char* hashtab, char* loctab, char *call_loc_pow, char *callsign);
#endif #endif

6
lib/wsprd/wsprsim.c
View File

@ -128,10 +128,12 @@ int main(int argc, char *argv[])
int i, c, printchannel=0, writec2=0; int i, c, printchannel=0, writec2=0;
float snr=50.0; float snr=50.0;
float f0=0.0, t0=1.0; float f0=0.0, t0=1.0;
char *message, *c2filename, *hashtab; char *message, *c2filename, *hashtab, *loctab;
c2filename=malloc(sizeof(char)*15); c2filename=malloc(sizeof(char)*15);
hashtab=malloc(sizeof(char)*32768*13); hashtab=malloc(sizeof(char)*32768*13);
loctab=malloc(sizeof(char)*32768*5);
memset(hashtab,0,sizeof(char)*32768*13); memset(hashtab,0,sizeof(char)*32768*13);
memset(hashtab,0,sizeof(char)*32768*5);
// message length is 22 characters // message length is 22 characters
message=malloc(sizeof(char)*23); message=malloc(sizeof(char)*23);
@ -169,7 +171,7 @@ int main(int argc, char *argv[])
} }
unsigned char channel_symbols[162]; unsigned char channel_symbols[162];
get_wspr_channel_symbols(message, hashtab, channel_symbols); get_wspr_channel_symbols(message, hashtab, loctab, channel_symbols);
if( printchannel ) { if( printchannel ) {
printf("Channel symbols:\n"); printf("Channel symbols:\n");

4
lib/wsprd/wsprsim_utils.c
View File

@ -162,7 +162,7 @@ void interleave(unsigned char *sym)
} }
} }
int get_wspr_channel_symbols(char* rawmessage, char* hashtab, unsigned char* symbols) { int get_wspr_channel_symbols(char* rawmessage, char* hashtab, char* loctab, unsigned char* symbols) {
int m=0, ntype=0; int m=0, ntype=0;
long unsigned int n=0; long unsigned int n=0;
int i, j, ihash; int i, j, ihash;
@ -292,7 +292,7 @@ int get_wspr_channel_symbols(char* rawmessage, char* hashtab, unsigned char* sym
signed char check_data[11]; signed char check_data[11];
memcpy(check_data,data,sizeof(char)*11); memcpy(check_data,data,sizeof(char)*11);
unpk_(check_data,hashtab,check_call_loc_pow,check_callsign); unpk_(check_data,hashtab,loctab,check_call_loc_pow,check_callsign);
// printf("Will decode as: %s\n",check_call_loc_pow); // printf("Will decode as: %s\n",check_call_loc_pow);
unsigned int nbytes=11; // The message with tail is packed into almost 11 bytes. unsigned int nbytes=11; // The message with tail is packed into almost 11 bytes.

2
lib/wsprd/wsprsim_utils.h
View File

@ -11,6 +11,6 @@
extern int printdata; extern int printdata;
int get_wspr_channel_symbols(char* message, char* hashtab, unsigned char* symbols); int get_wspr_channel_symbols(char* message, char* hashtab, char*loctab, unsigned char* symbols);
#endif #endif

4
widgets/mainwindow.cpp
View File

@ -1491,8 +1491,8 @@ void MainWindow::dataSink(qint64 frames)
double f0m1500=m_dialFreqRxWSPR/1000000.0; // + 0.000001*(m_BFO - 1500); double f0m1500=m_dialFreqRxWSPR/1000000.0; // + 0.000001*(m_BFO - 1500);
t2.sprintf(" -f %.6f ",f0m1500); t2.sprintf(" -f %.6f ",f0m1500);
if((m_ndepth&7)==1) depth_string=" -qB "; //2 pass w subtract, no Block detection, no shift jittering if((m_ndepth&7)==1) depth_string=" -qB "; //2 pass w subtract, no Block detection, no shift jittering
if((m_ndepth&7)==2) depth_string=" -B "; //2 pass w subtract, no Block detection if((m_ndepth&7)==2) depth_string=" -C 500 -o 4 "; //3 pass, subtract, Block detection, OSD
if((m_ndepth&7)==3) depth_string=" -C 5000 -o 4"; //2 pass w subtract, Block detection and OSD. if((m_ndepth&7)==3) depth_string=" -C 500 -o 4 -d "; //3 pass, subtract, Block detect, OSD, more candidates
QString degrade; QString degrade;
degrade.sprintf("-d %4.1f ",m_config.degrade()); degrade.sprintf("-d %4.1f ",m_config.degrade());