kopia lustrzana https://github.com/projecthorus/radiosonde_auto_rx
Re-base to latest upstream demodulators (noting this reverts the rs41dm auxdata change)
Mark Jessop
rodzic
994a93b957
commit
8a58501189
|
|
@ -13,6 +13,7 @@
|
|||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
#include <complex.h>
|
||||
|
||||
|
||||
typedef unsigned char ui8_t;
|
||||
|
|
@ -27,7 +28,7 @@ typedef int i32_t;
|
|||
static unsigned int sample_in, sample_out, delay;
|
||||
static int buffered = 0;
|
||||
|
||||
static int N, M;
|
||||
static int L, M;
|
||||
|
||||
static float *match = NULL,
|
||||
*bufs = NULL;
|
||||
|
|
@ -45,7 +46,6 @@ static float dc = 0.0;
|
|||
|
||||
/* ------------------------------------------------------------------------------------ */
|
||||
|
||||
#include <complex.h>
|
||||
|
||||
static int LOG2N, N_DFT;
|
||||
|
||||
|
|
@ -106,53 +106,54 @@ static void Nidft(float complex *Z, float complex *z) {
|
|||
|
||||
/* ------------------------------------------------------------------------------------ */
|
||||
|
||||
int getCorrDFT(int abs, int K, unsigned int pos, float *maxv, unsigned int *maxvpos) {
|
||||
int getCorrDFT(int K, unsigned int pos, float *maxv, unsigned int *maxvpos) {
|
||||
int i;
|
||||
int mp = -1;
|
||||
float mx = 0.0;
|
||||
float mx2 = 0.0;
|
||||
float re_cx = 0.0;
|
||||
float xnorm = 1;
|
||||
unsigned int mpos = 0;
|
||||
|
||||
dc = 0.0;
|
||||
|
||||
if (N + K > N_DFT/2 - 2) return -1;
|
||||
if (sample_in < delay+N+K) return -2;
|
||||
if (K + L > N_DFT) return -1;
|
||||
if (sample_out < L) return -2;
|
||||
|
||||
if (pos == 0) pos = sample_out;
|
||||
|
||||
|
||||
for (i = 0; i < N+K; i++) xn[i] = bufs[(pos+M -(N+K-1) + i) % M];
|
||||
for (i = 0; i < K+L; i++) xn[i] = bufs[(pos+M -(K+L-1) + i) % M];
|
||||
while (i < N_DFT) xn[i++] = 0.0;
|
||||
|
||||
dft(xn, X);
|
||||
|
||||
dc = get_bufmu(pos-sample_out); //oder: dc = creal(X[0])/N_DFT;
|
||||
dc = get_bufmu(pos-sample_out); //oder: dc = creal(X[0])/(K+L);
|
||||
|
||||
for (i = 0; i < N_DFT; i++) Z[i] = X[i]*Fm[i];
|
||||
|
||||
Nidft(Z, cx);
|
||||
|
||||
|
||||
if (abs) {
|
||||
for (i = N; i < N+K; i++) {
|
||||
if (fabs(creal(cx[i])) > fabs(mx)) { // imag(cx)=0
|
||||
mx = creal(cx[i]);
|
||||
mp = i;
|
||||
}
|
||||
// relativ Peak - Normierung erst zum Schluss;
|
||||
// dann jedoch nicht zwingend corr-Max wenn FM-Amplitude bzw. norm(x) nicht konstant
|
||||
// (z.B. rs41 Signal-Pausen). Moeglicherweise wird dann wahres corr-Max in dem
|
||||
// K-Fenster nicht erkannt, deshalb K nicht zu gross waehlen.
|
||||
//
|
||||
mx2 = 0.0; // t = L-1
|
||||
for (i = L-1; i < K+L; i++) { // i=t .. i=t+K < t+1+K
|
||||
re_cx = creal(cx[i]); // imag(cx)=0
|
||||
if (re_cx*re_cx > mx2) {
|
||||
mx = re_cx;
|
||||
mx2 = mx*mx;
|
||||
mp = i;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (i = N; i < N+K; i++) {
|
||||
if (creal(cx[i]) > mx) { // imag(cx)=0
|
||||
mx = creal(cx[i]);
|
||||
mp = i;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (mp == N || mp == N+K-1) return -4; // Randwert
|
||||
if (mp == L-1 || mp == K+L-1) return -4; // Randwert
|
||||
// mp == t mp == K+t
|
||||
|
||||
mpos = pos - ( N+K-1 - mp );
|
||||
xnorm = sqrt(qs[(mpos + 2*M) % M]);
|
||||
mpos = pos - (K + L-1) + mp;
|
||||
xnorm = sqrt(qs[(mpos + 2*M) % M]); // Nvar = L
|
||||
mx /= xnorm*N_DFT;
|
||||
|
||||
*maxv = mx;
|
||||
|
|
@ -270,7 +271,7 @@ float get_bufmu(int ofs) {
|
|||
return mu;
|
||||
}
|
||||
|
||||
int f32buf_sample(FILE *fp, int inv, int cm) {
|
||||
int f32buf_sample(FILE *fp, int inv) {
|
||||
float s = 0.0;
|
||||
float xneu, xalt;
|
||||
|
||||
|
|
@ -288,11 +289,6 @@ int f32buf_sample(FILE *fp, int inv, int cm) {
|
|||
qs[sample_in % M] = qsum;
|
||||
|
||||
|
||||
if (0 && cm) {
|
||||
// direct correlation
|
||||
}
|
||||
|
||||
|
||||
sample_out = sample_in - delay;
|
||||
|
||||
sample_in += 1;
|
||||
|
|
@ -369,7 +365,7 @@ int headcmp(int symlen, char *hdr, int len, unsigned int mvp, int inv, int optio
|
|||
|
||||
/* -------------------------------------------------------------------------- */
|
||||
|
||||
int read_sbit(FILE *fp, int symlen, int *bit, int inv, int ofs, int reset, int cm) {
|
||||
int read_sbit(FILE *fp, int symlen, int *bit, int inv, int ofs, int reset) {
|
||||
// symlen==2: manchester2 10->0,01->1: 2.bit
|
||||
|
||||
static double bitgrenze;
|
||||
|
|
@ -388,7 +384,7 @@ int read_sbit(FILE *fp, int symlen, int *bit, int inv, int ofs, int reset, int c
|
|||
bitgrenze += samples_per_bit;
|
||||
do {
|
||||
if (buffered > 0) buffered -= 1;
|
||||
else if (f32buf_sample(fp, inv, cm) == EOF) return EOF;
|
||||
else if (f32buf_sample(fp, inv) == EOF) return EOF;
|
||||
|
||||
sample = bufs[(sample_out-buffered + ofs + M) % M];
|
||||
sum -= sample;
|
||||
|
|
@ -400,7 +396,7 @@ int read_sbit(FILE *fp, int symlen, int *bit, int inv, int ofs, int reset, int c
|
|||
bitgrenze += samples_per_bit;
|
||||
do {
|
||||
if (buffered > 0) buffered -= 1;
|
||||
else if (f32buf_sample(fp, inv, cm) == EOF) return EOF;
|
||||
else if (f32buf_sample(fp, inv) == EOF) return EOF;
|
||||
|
||||
sample = bufs[(sample_out-buffered + ofs + M) % M];
|
||||
sum += sample;
|
||||
|
|
@ -414,7 +410,7 @@ int read_sbit(FILE *fp, int symlen, int *bit, int inv, int ofs, int reset, int c
|
|||
return 0;
|
||||
}
|
||||
|
||||
int read_spkbit(FILE *fp, int symlen, int *bit, int inv, int ofs, int reset, int cm, int spike) {
|
||||
int read_spkbit(FILE *fp, int symlen, int *bit, int inv, int ofs, int reset, int spike) {
|
||||
// symlen==2: manchester2 10->0,01->1: 2.bit
|
||||
|
||||
static double bitgrenze;
|
||||
|
|
@ -435,7 +431,7 @@ int read_spkbit(FILE *fp, int symlen, int *bit, int inv, int ofs, int reset, int
|
|||
bitgrenze += samples_per_bit;
|
||||
do {
|
||||
if (buffered > 0) buffered -= 1;
|
||||
else if (f32buf_sample(fp, inv, cm) == EOF) return EOF;
|
||||
else if (f32buf_sample(fp, inv) == EOF) return EOF;
|
||||
|
||||
sample = bufs[(sample_out-buffered + ofs + M) % M];
|
||||
avg = 0.5*(bufs[(sample_out-buffered-1 + ofs + M) % M]
|
||||
|
|
@ -451,7 +447,7 @@ int read_spkbit(FILE *fp, int symlen, int *bit, int inv, int ofs, int reset, int
|
|||
bitgrenze += samples_per_bit;
|
||||
do {
|
||||
if (buffered > 0) buffered -= 1;
|
||||
else if (f32buf_sample(fp, inv, cm) == EOF) return EOF;
|
||||
else if (f32buf_sample(fp, inv) == EOF) return EOF;
|
||||
|
||||
sample = bufs[(sample_out-buffered + ofs + M) % M];
|
||||
avg = 0.5*(bufs[(sample_out-buffered-1 + ofs + M) % M]
|
||||
|
|
@ -471,7 +467,7 @@ int read_spkbit(FILE *fp, int symlen, int *bit, int inv, int ofs, int reset, int
|
|||
|
||||
/* -------------------------------------------------------------------------- */
|
||||
|
||||
int read_softbit(FILE *fp, int symlen, int *bit, float *sb, float level, int inv, int ofs, int reset, int cm) {
|
||||
int read_softbit(FILE *fp, int symlen, int *bit, float *sb, float level, int inv, int ofs, int reset) {
|
||||
// symlen==2: manchester2 10->0,01->1: 2.bit
|
||||
|
||||
static double bitgrenze;
|
||||
|
|
@ -491,7 +487,7 @@ int read_softbit(FILE *fp, int symlen, int *bit, float *sb, float level, int inv
|
|||
bitgrenze += samples_per_bit;
|
||||
do {
|
||||
if (buffered > 0) buffered -= 1;
|
||||
else if (f32buf_sample(fp, inv, cm) == EOF) return EOF;
|
||||
else if (f32buf_sample(fp, inv) == EOF) return EOF;
|
||||
|
||||
sample = bufs[(sample_out-buffered + ofs + M) % M];
|
||||
if (scount > bitgrenze-samples_per_bit && scount < bitgrenze-2)
|
||||
|
|
@ -506,7 +502,7 @@ int read_softbit(FILE *fp, int symlen, int *bit, float *sb, float level, int inv
|
|||
bitgrenze += samples_per_bit;
|
||||
do {
|
||||
if (buffered > 0) buffered -= 1;
|
||||
else if (f32buf_sample(fp, inv, cm) == EOF) return EOF;
|
||||
else if (f32buf_sample(fp, inv) == EOF) return EOF;
|
||||
|
||||
sample = bufs[(sample_out-buffered + ofs + M) % M];
|
||||
if (scount > bitgrenze-samples_per_bit && scount < bitgrenze-2)
|
||||
|
|
@ -541,9 +537,9 @@ float header_level(char hdr[], int hLen, unsigned int pos, int inv) {
|
|||
|
||||
n = 0;
|
||||
bitn = 0;
|
||||
while ( bitn < hLen && (n < N) ) {
|
||||
while ( bitn < hLen && (n < L) ) {
|
||||
sgn = (hdr[bitn]&1)*2-1; // {'0','1'} -> {-1,1}
|
||||
s = bufs[(pos-N + n + M) % M];
|
||||
s = bufs[(pos-L + n + M) % M];
|
||||
if (inv) s = -s;
|
||||
sum += s * sgn;
|
||||
n++;
|
||||
|
|
@ -560,7 +556,7 @@ float header_level(char hdr[], int hLen, unsigned int pos, int inv) {
|
|||
static double norm2_match() {
|
||||
int i;
|
||||
double x, y = 0.0;
|
||||
for (i = 0; i < N; i++) {
|
||||
for (i = 0; i < L; i++) {
|
||||
x = match[i];
|
||||
y += x*x;
|
||||
}
|
||||
|
|
@ -576,24 +572,40 @@ int init_buffers(char hdr[], int hLen, int shape) {
|
|||
|
||||
float alpha, sqalp, a = 1.0;
|
||||
|
||||
int p2 = 1;
|
||||
int K;
|
||||
int n, k;
|
||||
float *m = NULL;
|
||||
|
||||
|
||||
N = hLen * samples_per_bit + 0.5;
|
||||
M = 3*N;
|
||||
if (samples_per_bit < 6) M = 6*N;
|
||||
Nvar = N; //N/2; // = N/k
|
||||
L = hLen * samples_per_bit + 0.5;
|
||||
M = 3*L;
|
||||
// if (samples_per_bit < 6) M = 6*L;
|
||||
|
||||
sample_in = 0;
|
||||
|
||||
p2 = 1;
|
||||
while (p2 < M) p2 <<= 1;
|
||||
while (p2 < 0x2000) p2 <<= 1; // or 0x4000, if sample not too short
|
||||
M = p2;
|
||||
N_DFT = p2;
|
||||
LOG2N = log(N_DFT)/log(2)+0.1; // 32bit cpu ... intermediate floating-point precision
|
||||
//while ((1 << LOG2N) < N_DFT) LOG2N++; // better N_DFT = (1 << LOG2N) ...
|
||||
|
||||
delay = L/16;
|
||||
K = M-L - delay; // L+K < M
|
||||
|
||||
Nvar = L; //L/2; // = L/k
|
||||
|
||||
|
||||
bufs = (float *)calloc( M+1, sizeof(float)); if (bufs == NULL) return -100;
|
||||
match = (float *)calloc( N+1, sizeof(float)); if (match == NULL) return -100;
|
||||
match = (float *)calloc( L+1, sizeof(float)); if (match == NULL) return -100;
|
||||
|
||||
xs = (float *)calloc( M+1, sizeof(float)); if (xs == NULL) return -100;
|
||||
qs = (float *)calloc( M+1, sizeof(float)); if (qs == NULL) return -100;
|
||||
|
||||
|
||||
rawbits = (char *)calloc( N+1, sizeof(char)); if (rawbits == NULL) return -100;
|
||||
rawbits = (char *)calloc( 2*hLen+1, sizeof(char)); if (rawbits == NULL) return -100;
|
||||
|
||||
for (i = 0; i < M; i++) bufs[i] = 0.0;
|
||||
|
||||
|
|
@ -601,7 +613,7 @@ int init_buffers(char hdr[], int hLen, int shape) {
|
|||
sqalp = sqrt(alpha/M_PI);
|
||||
//a = sqalp;
|
||||
|
||||
for (i = 0; i < N; i++) {
|
||||
for (i = 0; i < L; i++) {
|
||||
pos = i/samples_per_bit;
|
||||
x = (i - pos*samples_per_bit)*2.0/samples_per_bit - 1;
|
||||
a = sqalp;
|
||||
|
|
@ -629,25 +641,11 @@ int init_buffers(char hdr[], int hLen, int shape) {
|
|||
}
|
||||
|
||||
normMatch = sqrt(norm2_match());
|
||||
for (i = 0; i < N; i++) {
|
||||
for (i = 0; i < L; i++) {
|
||||
match[i] /= normMatch;
|
||||
}
|
||||
|
||||
|
||||
delay = N/16;
|
||||
sample_in = 0;
|
||||
|
||||
K = M-N - delay; //N/2 - delay; // N+K < M
|
||||
|
||||
LOG2N = 2 + (int)(log(N+K)/log(2));
|
||||
N_DFT = 1 << LOG2N;
|
||||
|
||||
while (N + K > N_DFT/2 - 2) {
|
||||
LOG2N += 1;
|
||||
N_DFT <<= 1;
|
||||
}
|
||||
|
||||
|
||||
xn = calloc(N_DFT+1, sizeof(float)); if (xn == NULL) return -1;
|
||||
|
||||
ew = calloc(LOG2N+1, sizeof(complex float)); if (ew == NULL) return -1;
|
||||
|
|
@ -662,7 +660,7 @@ int init_buffers(char hdr[], int hLen, int shape) {
|
|||
}
|
||||
|
||||
m = calloc(N_DFT+1, sizeof(float)); if (m == NULL) return -1;
|
||||
for (i = 0; i < N; i++) m[N-1 - i] = match[i];
|
||||
for (i = 0; i < L; i++) m[L-1 - i] = match[i]; // t = L-1
|
||||
while (i < N_DFT) m[i++] = 0.0;
|
||||
dft(m, Fm);
|
||||
|
||||
|
|
|
|||
|
|
@ -1,12 +1,12 @@
|
|||
|
||||
float read_wav_header(FILE*, float, int);
|
||||
int f32buf_sample(FILE*, int, int);
|
||||
int read_sbit(FILE*, int, int*, int, int, int, int);
|
||||
int read_spkbit(FILE*, int, int*, int, int, int, int, int);
|
||||
int read_softbit(FILE *fp, int symlen, int *bit, float *sb, float level, int inv, int ofs, int reset, int cm);
|
||||
int f32buf_sample(FILE*, int);
|
||||
int read_sbit(FILE*, int, int*, int, int, int);
|
||||
int read_spkbit(FILE*, int, int*, int, int, int, int);
|
||||
int read_softbit(FILE *fp, int symlen, int *bit, float *sb, float level, int inv, int ofs, int reset);
|
||||
float header_level(char hdr[], int hLen, unsigned int pos, int inv);
|
||||
|
||||
int getCorrDFT(int, int, unsigned int, float *, unsigned int *);
|
||||
int getCorrDFT(int, unsigned int, float *, unsigned int *);
|
||||
int headcmp(int, char*, int, unsigned int, int, int);
|
||||
float get_bufvar(int);
|
||||
float get_bufmu(int);
|
||||
|
|
|
|||
152
demod/demod_iq.c
152
demod/demod_iq.c
|
|
@ -137,57 +137,63 @@ static int dft_window(dft_t *dft, int w) {
|
|||
|
||||
/* ------------------------------------------------------------------------------------ */
|
||||
|
||||
int getCorrDFT(dsp_t *dsp, int abs, ui32_t pos, float *maxv, ui32_t *maxvpos) {
|
||||
int getCorrDFT(dsp_t *dsp, ui32_t pos, float *maxv, ui32_t *maxvpos) {
|
||||
int i;
|
||||
int mp = -1;
|
||||
float mx = 0.0;
|
||||
float mx2 = 0.0;
|
||||
float re_cx = 0.0;
|
||||
float xnorm = 1;
|
||||
ui32_t mpos = 0;
|
||||
|
||||
|
||||
dsp->dc = 0.0;
|
||||
|
||||
if (dsp->N + dsp->K > dsp->DFT.N/2 - 2) return -1;
|
||||
if (dsp->sample_in < dsp->delay + dsp->N + dsp->K) return -2;
|
||||
if (dsp->K + dsp->L > dsp->DFT.N) return -1;
|
||||
if (dsp->sample_out < dsp->L) return -2;
|
||||
|
||||
if (pos == 0) pos = dsp->sample_out;
|
||||
|
||||
dsp->dc = get_bufmu(dsp, pos - dsp->sample_out); //oder unten: dft_dc = creal(X[0])/DFT_N;
|
||||
dsp->dc = get_bufmu(dsp, pos - dsp->sample_out); //oder unten: dft_dc = creal(X[0])/(K+L);
|
||||
// wenn richtige Stelle (Varianz pruefen, kein M10-carrier?), dann von bufs[] subtrahieren
|
||||
|
||||
|
||||
for (i = 0; i < dsp->N + dsp->K; i++) (dsp->DFT).xn[i] = dsp->bufs[(pos+dsp->M -(dsp->N + dsp->K - 1) + i) % dsp->M];
|
||||
while (i < (dsp->DFT).N) (dsp->DFT).xn[i++] = 0.0;
|
||||
for (i = 0; i < dsp->K + dsp->L; i++) (dsp->DFT).xn[i] = dsp->bufs[(pos+dsp->M -(dsp->K + dsp->L-1) + i) % dsp->M];
|
||||
while (i < dsp->DFT.N) (dsp->DFT).xn[i++] = 0.0;
|
||||
|
||||
rdft(&dsp->DFT, (dsp->DFT).xn, (dsp->DFT).X);
|
||||
rdft(&dsp->DFT, dsp->DFT.xn, dsp->DFT.X);
|
||||
|
||||
// dft_dc = creal((dsp->DFT).X[0])/(dsp->DFT).N;
|
||||
// dft_dc = creal(dsp->DFT.X[0])/dsp->DFT.N;
|
||||
|
||||
for (i = 0; i < (dsp->DFT).N; i++) (dsp->DFT).Z[i] = (dsp->DFT).X[i]*(dsp->DFT).Fm[i];
|
||||
for (i = 0; i < dsp->DFT.N; i++) dsp->DFT.Z[i] = dsp->DFT.X[i]*dsp->DFT.Fm[i];
|
||||
|
||||
Nidft(&dsp->DFT, (dsp->DFT).Z, (dsp->DFT).cx);
|
||||
Nidft(&dsp->DFT, dsp->DFT.Z, dsp->DFT.cx);
|
||||
|
||||
|
||||
if (abs) {
|
||||
for (i = dsp->N; i < dsp->N + dsp->K; i++) {
|
||||
if (fabs(creal((dsp->DFT).cx[i])) > fabs(mx)) { // imag(cx)=0
|
||||
mx = creal((dsp->DFT).cx[i]);
|
||||
mp = i;
|
||||
}
|
||||
// relativ Peak - Normierung erst zum Schluss;
|
||||
// dann jedoch nicht zwingend corr-Max wenn FM-Amplitude bzw. norm(x) nicht konstant
|
||||
// (z.B. rs41 Signal-Pausen). Moeglicherweise wird dann wahres corr-Max in dem
|
||||
// K-Fenster nicht erkannt, deshalb K nicht zu gross waehlen.
|
||||
//
|
||||
mx2 = 0.0; // t = L-1
|
||||
for (i = dsp->L-1; i < dsp->K + dsp->L; i++) { // i=t .. i=t+K < t+1+K
|
||||
re_cx = creal(dsp->DFT.cx[i]); // imag(cx)=0
|
||||
if (re_cx*re_cx > mx2) {
|
||||
mx = re_cx;
|
||||
mx2 = mx*mx;
|
||||
mp = i;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (i = dsp->N; i < dsp->N + dsp->K; i++) {
|
||||
if (creal((dsp->DFT).cx[i]) > mx) { // imag(cx)=0
|
||||
mx = creal((dsp->DFT).cx[i]);
|
||||
mp = i;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (mp == dsp->N || mp == dsp->N + dsp->K - 1) return -4; // Randwert
|
||||
if (mp == dsp->L-1 || mp == dsp->K + dsp->L-1) return -4; // Randwert
|
||||
// mp == t mp == K+t
|
||||
|
||||
mpos = pos - (dsp->K + dsp->L-1) + mp; // t = L-1
|
||||
|
||||
//xnorm = sqrt(dsp->qs[(mpos + 2*dsp->M) % dsp->M]); // Nvar = L
|
||||
xnorm = 0.0;
|
||||
for (i = 0; i < dsp->L; i++) xnorm += dsp->bufs[(mpos-i + dsp->M) % dsp->M]*dsp->bufs[(mpos-i + dsp->M) % dsp->M];
|
||||
xnorm = sqrt(xnorm);
|
||||
|
||||
mpos = pos - ( dsp->N + dsp->K - 1 - mp );
|
||||
xnorm = sqrt(dsp->qs[(mpos + 2*dsp->M) % dsp->M]);
|
||||
mx /= xnorm*(dsp->DFT).N;
|
||||
|
||||
*maxv = mx;
|
||||
|
|
@ -462,14 +468,14 @@ int headcmp(dsp_t *dsp, int symlen, ui32_t mvp, int inv, int option_dc) {
|
|||
int pos;
|
||||
int step = 1;
|
||||
char sign = 0;
|
||||
int len = dsp->hdrlen;
|
||||
int len = dsp->hdrlen/symlen;
|
||||
|
||||
if (symlen != 1) step = 2;
|
||||
if (inv) sign=1;
|
||||
|
||||
for (pos = 0; pos < len; pos += step) { // N = dsp->hdrlen * dsp->sps + 0.5;
|
||||
//read_bufbit(dsp, symlen, dsp->rawbits+pos, mvp+1-(int)(len*dsp->sps), pos);
|
||||
read_bufbit(dsp, symlen, dsp->rawbits+pos, mvp+1-dsp->N, pos);
|
||||
for (pos = 0; pos < len; pos++) { // L = dsp->hdrlen * dsp->sps + 0.5;
|
||||
//read_bufbit(dsp, symlen, dsp->rawbits+pos*step, mvp+1-(int)(len*dsp->sps), pos);
|
||||
read_bufbit(dsp, symlen, dsp->rawbits+pos*step, mvp+1-dsp->L, pos);
|
||||
}
|
||||
dsp->rawbits[pos] = '\0';
|
||||
|
||||
|
|
@ -527,18 +533,21 @@ int get_fqofs_rs41(dsp_t *dsp, ui32_t mvp, float *freq, float *snr) {
|
|||
|
||||
/* -------------------------------------------------------------------------- */
|
||||
|
||||
int read_slbit(dsp_t *dsp, int symlen, int *bit, int inv, int ofs, int pos, float l) {
|
||||
int read_slbit(dsp_t *dsp, int symlen, int *bit, int inv, int ofs, int pos, float l, int spike) {
|
||||
// symlen==2: manchester2 10->0,01->1: 2.bit
|
||||
|
||||
float bitgrenze = pos*symlen*dsp->sps;
|
||||
ui32_t scount = bitgrenze+0.99; // ceil
|
||||
ui32_t scount = ceil(bitgrenze);//+0.99; // dfm?
|
||||
|
||||
float sample;
|
||||
float avg;
|
||||
float ths = 0.5, scale = 0.27;
|
||||
|
||||
double sum = 0.0;
|
||||
double mid;
|
||||
//double l = 0.5 .. 1.0 .. sps/2;
|
||||
|
||||
if (pos == 0) scount = 0;
|
||||
|
||||
if (symlen == 2) {
|
||||
mid = bitgrenze + (dsp->sps-1)/2.0;
|
||||
|
|
@ -548,6 +557,9 @@ int read_slbit(dsp_t *dsp, int symlen, int *bit, int inv, int ofs, int pos, floa
|
|||
else if (f32buf_sample(dsp, inv) == EOF) return EOF;
|
||||
|
||||
sample = dsp->bufs[(dsp->sample_out-dsp->buffered + ofs + dsp->M) % dsp->M];
|
||||
avg = 0.5*(dsp->bufs[(dsp->sample_out-dsp->buffered-1 + ofs + dsp->M) % dsp->M]
|
||||
+dsp->bufs[(dsp->sample_out-dsp->buffered+1 + ofs + dsp->M) % dsp->M]);
|
||||
if (spike && fabs(sample - avg) > ths) sample = avg + scale*(sample - avg); // spikes
|
||||
|
||||
if ( l < 0 || (mid-l < scount && scount < mid+l)) sum -= sample;
|
||||
|
||||
|
|
@ -562,6 +574,9 @@ int read_slbit(dsp_t *dsp, int symlen, int *bit, int inv, int ofs, int pos, floa
|
|||
else if (f32buf_sample(dsp, inv) == EOF) return EOF;
|
||||
|
||||
sample = dsp->bufs[(dsp->sample_out-dsp->buffered + ofs + dsp->M) % dsp->M];
|
||||
avg = 0.5*(dsp->bufs[(dsp->sample_out-dsp->buffered-1 + ofs + dsp->M) % dsp->M]
|
||||
+dsp->bufs[(dsp->sample_out-dsp->buffered+1 + ofs + dsp->M) % dsp->M]);
|
||||
if (spike && fabs(sample - avg) > ths) sample = avg + scale*(sample - avg); // spikes
|
||||
|
||||
if ( l < 0 || (mid-l < scount && scount < mid+l)) sum += sample;
|
||||
|
||||
|
|
@ -609,29 +624,51 @@ int init_buffers(dsp_t *dsp) {
|
|||
float normMatch;
|
||||
double sigma = sqrt(log(2)) / (2*M_PI*dsp->BT);
|
||||
|
||||
int K, N, M;
|
||||
int p2 = 1;
|
||||
int K, L, M;
|
||||
int n, k;
|
||||
float *m = NULL;
|
||||
|
||||
|
||||
N = dsp->hdrlen * dsp->sps + 0.5;
|
||||
M = 3*N;
|
||||
if (dsp->sps < 6) M = 6*N;
|
||||
L = dsp->hdrlen * dsp->sps + 0.5;
|
||||
M = 3*L;
|
||||
//if (dsp->sps < 6) M = 6*L;
|
||||
|
||||
dsp->delay = L/16;
|
||||
dsp->sample_in = 0;
|
||||
|
||||
p2 = 1;
|
||||
while (p2 < M) p2 <<= 1;
|
||||
while (p2 < 0x2000) p2 <<= 1; // or 0x4000, if sample not too short
|
||||
M = p2;
|
||||
dsp->DFT.N = p2;
|
||||
dsp->DFT.LOG2N = log(dsp->DFT.N)/log(2)+0.1; // 32bit cpu ... intermediate floating-point precision
|
||||
//while ((1 << dsp->DFT.LOG2N) < dsp->DFT.N) dsp->DFT.LOG2N++; // better N = (1 << LOG2N) ...
|
||||
|
||||
K = M-L - dsp->delay; // L+K < M
|
||||
|
||||
dsp->DFT.sr = dsp->sr;
|
||||
|
||||
dsp->K = K;
|
||||
dsp->L = L;
|
||||
dsp->M = M;
|
||||
|
||||
dsp->Nvar = L; // wenn Nvar fuer xnorm, dann Nvar=rshd.L
|
||||
|
||||
|
||||
dsp->bufs = (float *)calloc( M+1, sizeof(float)); if (dsp->bufs == NULL) return -100;
|
||||
dsp->match = (float *)calloc( N+1, sizeof(float)); if (dsp->match == NULL) return -100;
|
||||
dsp->match = (float *)calloc( L+1, sizeof(float)); if (dsp->match == NULL) return -100;
|
||||
|
||||
dsp->xs = (float *)calloc( M+1, sizeof(float)); if (dsp->xs == NULL) return -100;
|
||||
dsp->qs = (float *)calloc( M+1, sizeof(float)); if (dsp->qs == NULL) return -100;
|
||||
|
||||
dsp->rawbits = (char *)calloc( N+1, sizeof(char)); if (dsp->rawbits == NULL) return -100;
|
||||
dsp->rawbits = (char *)calloc( 2*dsp->hdrlen+1, sizeof(char)); if (dsp->rawbits == NULL) return -100;
|
||||
|
||||
|
||||
for (i = 0; i < M; i++) dsp->bufs[i] = 0.0;
|
||||
|
||||
|
||||
for (i = 0; i < N; i++) {
|
||||
for (i = 0; i < L; i++) {
|
||||
pos = i/dsp->sps;
|
||||
t = (i - pos*dsp->sps)/dsp->sps - 0.5;
|
||||
|
||||
|
|
@ -651,31 +688,12 @@ int init_buffers(dsp_t *dsp) {
|
|||
dsp->match[i] = b;
|
||||
}
|
||||
|
||||
normMatch = sqrt( norm2_vect(dsp->match, N) );
|
||||
for (i = 0; i < N; i++) {
|
||||
normMatch = sqrt( norm2_vect(dsp->match, L) );
|
||||
for (i = 0; i < L; i++) {
|
||||
dsp->match[i] /= normMatch;
|
||||
}
|
||||
|
||||
|
||||
dsp->N = N;
|
||||
dsp->M = M;
|
||||
dsp->Nvar = N; //N/2; // = N/k
|
||||
|
||||
dsp->delay = N/16;
|
||||
dsp->sample_in = 0;
|
||||
|
||||
K = M - N - dsp->delay; //N/2 - delay; // N+K < M
|
||||
dsp->K = K;
|
||||
|
||||
dsp->DFT.sr = dsp->sr;
|
||||
dsp->DFT.LOG2N = 2 + (int)(log(N+K)/log(2));
|
||||
dsp->DFT.N = 1 << dsp->DFT.LOG2N;
|
||||
|
||||
while (N + K > dsp->DFT.N/2 - 2) {
|
||||
dsp->DFT.LOG2N += 1;
|
||||
dsp->DFT.N <<= 1;
|
||||
}
|
||||
|
||||
dsp->DFT.xn = calloc(dsp->DFT.N+1, sizeof(float)); if (dsp->DFT.xn == NULL) return -1;
|
||||
|
||||
dsp->DFT.Fm = calloc(dsp->DFT.N+1, sizeof(float complex)); if (dsp->DFT.Fm == NULL) return -1;
|
||||
|
|
@ -690,7 +708,7 @@ int init_buffers(dsp_t *dsp) {
|
|||
// b) N2 < N (interpolation)
|
||||
dsp->DFT.win = calloc(dsp->DFT.N+1, sizeof(float complex)); if (dsp->DFT.win == NULL) return -1; // float real
|
||||
dsp->DFT.N2 = dsp->DFT.N;
|
||||
//dsp->DFT.N2 = dsp->DFT.N/2 - 1; // DFT_N=2^log2N
|
||||
//dsp->DFT.N2 = dsp->DFT.N/2 - 1; // N=2^log2N
|
||||
dft_window(&dsp->DFT, 1);
|
||||
|
||||
for (n = 0; n < dsp->DFT.LOG2N; n++) {
|
||||
|
|
@ -699,7 +717,7 @@ int init_buffers(dsp_t *dsp) {
|
|||
}
|
||||
|
||||
m = calloc(dsp->DFT.N+1, sizeof(float)); if (m == NULL) return -1;
|
||||
for (i = 0; i < N; i++) m[N-1 - i] = dsp->match[i];
|
||||
for (i = 0; i < L; i++) m[L-1 - i] = dsp->match[i]; // t = L-1
|
||||
while (i < dsp->DFT.N) m[i++] = 0.0;
|
||||
rdft(&dsp->DFT, m, dsp->DFT.Fm);
|
||||
|
||||
|
|
@ -709,13 +727,7 @@ int init_buffers(dsp_t *dsp) {
|
|||
if (dsp->opt_iq)
|
||||
{
|
||||
if (dsp->nch < 2) return -1;
|
||||
/*
|
||||
N2 = dsp->sps*256+0.5;
|
||||
while ( (1 << LOG2N) < N2 ) LOG2N++;
|
||||
LOG2N++;
|
||||
N = (1 << LOG2N);
|
||||
N_IQBUF = N2 + sps*(64+16);
|
||||
*/
|
||||
|
||||
dsp->N_IQBUF = dsp->DFT.N;
|
||||
dsp->raw_iqbuf = calloc(dsp->N_IQBUF+1, sizeof(float complex)); if (dsp->raw_iqbuf == NULL) return -1;
|
||||
dsp->rot_iqbuf = calloc(dsp->N_IQBUF+1, sizeof(float complex)); if (dsp->rot_iqbuf == NULL) return -1;
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@ typedef struct {
|
|||
ui32_t sample_out;
|
||||
ui32_t delay;
|
||||
int buffered;
|
||||
int N;
|
||||
int L;
|
||||
int M;
|
||||
int K;
|
||||
float *match;
|
||||
|
|
@ -100,9 +100,9 @@ typedef struct {
|
|||
|
||||
float read_wav_header(pcm_t *, FILE *);
|
||||
int f32buf_sample(dsp_t *, int);
|
||||
int read_slbit(dsp_t *, int, int*, int, int, int, float);
|
||||
int read_slbit(dsp_t *, int, int*, int, int, int, float, int);
|
||||
|
||||
int getCorrDFT(dsp_t *, int, ui32_t, float *, ui32_t *);
|
||||
int getCorrDFT(dsp_t *, ui32_t, float *, ui32_t *);
|
||||
int headcmp(dsp_t *, int, ui32_t, int, int);
|
||||
int get_fqofs_rs41(dsp_t *, ui32_t, float *, float *);
|
||||
float get_bufvar(dsp_t *, int);
|
||||
|
|
|
|||
|
|
@ -686,7 +686,7 @@ void print_gpx() {
|
|||
}
|
||||
}
|
||||
else {
|
||||
if (option_auto && option_verbose >= 2) printf("[%c] ", option_inv?'-':'+');
|
||||
if (option_auto && option_verbose >= 2) printf("<%c> ", option_inv?'-':'+');
|
||||
printf("[%3d] ", gpx.frnr);
|
||||
printf("%4d-%02d-%02d ", gpx.jahr, gpx.monat, gpx.tag);
|
||||
printf("%02d:%02d:%04.1f ", gpx.std, gpx.min, gpx.sek);
|
||||
|
|
@ -851,8 +851,9 @@ int main(int argc, char **argv) {
|
|||
|
||||
float thres = 0.65;
|
||||
|
||||
int bitofs = 0;
|
||||
int symlen = 2;
|
||||
int bitofs = 2; // +1 .. +2
|
||||
int shift = 0;
|
||||
|
||||
|
||||
#ifdef CYGWIN
|
||||
|
|
@ -904,6 +905,15 @@ int main(int argc, char **argv) {
|
|||
}
|
||||
else return -1;
|
||||
}
|
||||
else if ( (strcmp(*argv, "-d") == 0) ) {
|
||||
++argv;
|
||||
if (*argv) {
|
||||
shift = atoi(*argv);
|
||||
if (shift > 4) shift = 4;
|
||||
if (shift < -4) shift = -4;
|
||||
}
|
||||
else return -1;
|
||||
}
|
||||
else {
|
||||
fp = fopen(*argv, "rb");
|
||||
if (fp == NULL) {
|
||||
|
|
@ -932,8 +942,9 @@ int main(int argc, char **argv) {
|
|||
|
||||
|
||||
symlen = 2;
|
||||
bitofs += shift;
|
||||
|
||||
headerlen = strlen(rawheader);
|
||||
bitofs = 2; // +1 .. +2
|
||||
K = init_buffers(rawheader, headerlen, 0); // shape=0 (alt. shape=1)
|
||||
if ( K < 0 ) {
|
||||
fprintf(stderr, "error: init buffers\n");
|
||||
|
|
@ -941,14 +952,16 @@ int main(int argc, char **argv) {
|
|||
};
|
||||
|
||||
k = 0;
|
||||
mv = 0; mv_pos = 0;
|
||||
mv = 0;
|
||||
mv_pos = 0;
|
||||
|
||||
while ( f32buf_sample(fp, option_inv, 1) != EOF ) {
|
||||
while ( f32buf_sample(fp, option_inv) != EOF ) {
|
||||
|
||||
k += 1;
|
||||
if (k >= K-4) {
|
||||
mv0_pos = mv_pos;
|
||||
mp = getCorrDFT(option_auto, K, 0, &mv, &mv_pos);
|
||||
mp = getCorrDFT(K, 0, &mv, &mv_pos);
|
||||
if (option_auto == 0 && mv < 0) mv = 0;
|
||||
k = 0;
|
||||
}
|
||||
else {
|
||||
|
|
@ -993,8 +1006,7 @@ int main(int argc, char **argv) {
|
|||
while ( frm < nfrms ) { // nfrms=1,2,4,8
|
||||
frm_cnt = mv_pos/(spb*2.0*BITFRAME_LEN) + frm;
|
||||
while ( pos < BITFRAME_LEN ) {
|
||||
header_found = !(frm==nfrms-1 && pos>=BITFRAME_LEN-10);
|
||||
bitQ = read_sbit(fp, symlen, &bit, option_inv, bitofs, bitpos==0, !header_found); // symlen=2, return: zeroX/bit
|
||||
bitQ = read_sbit(fp, symlen, &bit, option_inv, bitofs, bitpos==0); // symlen=2
|
||||
if (bitQ == EOF) { frm = nfrms; break; }
|
||||
frame_bits[pos] = 0x30 + bit;
|
||||
pos++;
|
||||
|
|
|
|||
|
|
@ -873,8 +873,10 @@ int main(int argc, char **argv) {
|
|||
|
||||
float thres = 0.76;
|
||||
|
||||
int bitofs = 0;
|
||||
int symlen = 1;
|
||||
int bitofs = 1; // +1 .. +2
|
||||
int shift = 0;
|
||||
|
||||
unsigned int bc = 0;
|
||||
|
||||
float sb = 0.0;
|
||||
|
|
@ -931,6 +933,15 @@ int main(int argc, char **argv) {
|
|||
}
|
||||
else return -1;
|
||||
}
|
||||
else if ( (strcmp(*argv, "-d") == 0) ) {
|
||||
++argv;
|
||||
if (*argv) {
|
||||
shift = atoi(*argv);
|
||||
if (shift > 4) shift = 4;
|
||||
if (shift < -4) shift = -4;
|
||||
}
|
||||
else return -1;
|
||||
}
|
||||
else if ( (strcmp(*argv, "--level") == 0) ) {
|
||||
++argv;
|
||||
if (*argv) {
|
||||
|
|
@ -973,8 +984,9 @@ int main(int argc, char **argv) {
|
|||
|
||||
|
||||
symlen = 1;
|
||||
bitofs += shift;
|
||||
|
||||
headerlen = strlen(rawheader);
|
||||
bitofs = 1; // +1 .. +2
|
||||
K = init_buffers(rawheader, headerlen, 2); // shape=2 (alt. shape=1)
|
||||
if ( K < 0 ) {
|
||||
fprintf(stderr, "error: init buffers\n");
|
||||
|
|
@ -983,14 +995,15 @@ int main(int argc, char **argv) {
|
|||
|
||||
level = ll;
|
||||
k = 0;
|
||||
mv = -1; mv_pos = 0;
|
||||
mv = 0;
|
||||
mv_pos = 0;
|
||||
|
||||
while ( f32buf_sample(fp, option_inv, 1) != EOF ) {
|
||||
while ( f32buf_sample(fp, option_inv) != EOF ) {
|
||||
|
||||
k += 1;
|
||||
if (k >= K-4) {
|
||||
mv0_pos = mv_pos;
|
||||
mp = getCorrDFT(-1, K, 0, &mv, &mv_pos);
|
||||
mp = getCorrDFT(K, 0, &mv, &mv_pos);
|
||||
k = 0;
|
||||
}
|
||||
else {
|
||||
|
|
@ -1024,9 +1037,9 @@ int main(int argc, char **argv) {
|
|||
if (mv > 0) bc = 0; else bc = 1;
|
||||
|
||||
while ( pos < RAWBITBLOCK_LEN ) {
|
||||
header_found = !(pos>=RAWBITBLOCK_LEN-10);
|
||||
//bitQ = read_sbit(fp, symlen, &rbit, option_inv, bitofs, bitpos==0, !header_found); // symlen=1, return: zeroX/bit
|
||||
bitQ = read_softbit(fp, symlen, &rbit, &sb, level, option_inv, bitofs, bitpos==0, !header_found); // symlen=1, return: zeroX/bit
|
||||
|
||||
//bitQ = read_sbit(fp, symlen, &rbit, option_inv, bitofs, bitpos==0); // symlen=1
|
||||
bitQ = read_softbit(fp, symlen, &rbit, &sb, level, option_inv, bitofs, bitpos==0); // symlen=1
|
||||
if (bitQ == EOF) { break; }
|
||||
|
||||
bit = rbit ^ (bc%2); // (c0,inv(c1))
|
||||
|
|
|
|||
Plik diff jest za duży
Load Diff
|
|
@ -802,8 +802,9 @@ int main(int argc, char **argv) {
|
|||
|
||||
float thres = 0.76;
|
||||
|
||||
int bitofs = 0;
|
||||
int symlen = 2;
|
||||
int bitofs = 0; // 0 .. +2
|
||||
int shift = 0;
|
||||
|
||||
|
||||
#ifdef CYGWIN
|
||||
|
|
@ -854,6 +855,15 @@ int main(int argc, char **argv) {
|
|||
}
|
||||
else return -1;
|
||||
}
|
||||
else if ( (strcmp(*argv, "-d") == 0) ) {
|
||||
++argv;
|
||||
if (*argv) {
|
||||
shift = atoi(*argv);
|
||||
if (shift > 4) shift = 4;
|
||||
if (shift < -4) shift = -4;
|
||||
}
|
||||
else return -1;
|
||||
}
|
||||
else {
|
||||
fp = fopen(*argv, "rb");
|
||||
if (fp == NULL) {
|
||||
|
|
@ -879,8 +889,9 @@ int main(int argc, char **argv) {
|
|||
|
||||
|
||||
symlen = 2;
|
||||
bitofs += shift;
|
||||
|
||||
headerlen = strlen(rawheader);
|
||||
bitofs = 0; // 0 .. +2
|
||||
K = init_buffers(rawheader, headerlen, 1); // shape=0 (alt. shape=1)
|
||||
if ( K < 0 ) {
|
||||
fprintf(stderr, "error: init buffers\n");
|
||||
|
|
@ -889,14 +900,15 @@ int main(int argc, char **argv) {
|
|||
|
||||
|
||||
k = 0;
|
||||
mv = -1; mv_pos = 0;
|
||||
mv = 0;
|
||||
mv_pos = 0;
|
||||
|
||||
while ( f32buf_sample(fp, option_inv, 1) != EOF ) {
|
||||
while ( f32buf_sample(fp, option_inv) != EOF ) {
|
||||
|
||||
k += 1;
|
||||
if (k >= K-4) {
|
||||
mv0_pos = mv_pos;
|
||||
mp = getCorrDFT(-1, K, 0, &mv, &mv_pos);
|
||||
mp = getCorrDFT(K, 0, &mv, &mv_pos);
|
||||
k = 0;
|
||||
}
|
||||
else {
|
||||
|
|
@ -925,11 +937,10 @@ int main(int argc, char **argv) {
|
|||
bitpos = 0;
|
||||
pos = 0;
|
||||
pos /= 2;
|
||||
bit0 = '0';
|
||||
bit0 = '0'; // oder: mv[j] > 0
|
||||
|
||||
while ( pos < BITFRAME_LEN+BITAUX_LEN ) {
|
||||
header_found = !(pos>=BITFRAME_LEN-10);
|
||||
bitQ = read_spkbit(fp, symlen, &bit, option_inv, bitofs, bitpos==0, !header_found, spike); // symlen=2, return: zeroX/bit
|
||||
bitQ = read_spkbit(fp, symlen, &bit, option_inv, bitofs, bitpos==0, spike); // symlen=2
|
||||
if (bitQ == EOF) { break; }
|
||||
frame_bits[pos] = 0x31 ^ (bit0 ^ bit);
|
||||
pos++;
|
||||
|
|
@ -945,7 +956,7 @@ int main(int argc, char **argv) {
|
|||
// bis Ende der Sekunde vorspulen; allerdings Doppel-Frame alle 10 sek
|
||||
if (option_verbose < 3) { // && (regulare frame) // print_frame-return?
|
||||
while ( bitpos < 5*BITFRAME_LEN ) {
|
||||
bitQ = read_spkbit(fp, symlen, &bit, option_inv, bitofs, bitpos==0, 0, spike); // symlen=2, return: zeroX/bit
|
||||
bitQ = read_spkbit(fp, symlen, &bit, option_inv, bitofs, bitpos==0, spike); // symlen=2
|
||||
if ( bitQ == EOF) break;
|
||||
bitpos++;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -789,7 +789,7 @@ int get_GPS3() {
|
|||
return err;
|
||||
}
|
||||
|
||||
int get_Aux(char* aux_data) {
|
||||
int get_Aux() {
|
||||
//
|
||||
// "Ozone Sounding with Vaisala Radiosonde RS41" user's guide
|
||||
//
|
||||
|
|
@ -813,7 +813,6 @@ int get_Aux(char* aux_data) {
|
|||
//fprintf(stdout, " # %02x : ", framebyte(pos7E+2));
|
||||
for (i = 1; i < auxlen; i++) {
|
||||
ui8_t c = framebyte(pos7E+2+i);
|
||||
aux_data[i-1] = c;
|
||||
if (c > 0x1E) fprintf(stdout, "%c", c);
|
||||
}
|
||||
count7E++;
|
||||
|
|
@ -1098,26 +1097,18 @@ int print_position(int ec) {
|
|||
|
||||
get_Calconf(output);
|
||||
|
||||
char aux_data[FRAME_LEN] = "";
|
||||
if (option_verbose > 1 || option_json) get_Aux(aux_data);
|
||||
if (option_verbose > 1) get_Aux();
|
||||
|
||||
fprintf(stdout, "\n"); // fflush(stdout);
|
||||
|
||||
|
||||
if (option_json) {
|
||||
char auxbuffer[FRAME_LEN] = "";
|
||||
fprintf(stdout, "\n"); // fflush(stdout) as get_Aux prints to stdout
|
||||
// Print JSON output required by auto_rx.
|
||||
if (!err && !err1 && !err3) { // frame-nb/id && gps-time && gps-position (crc-)ok; 3 CRCs, RS not needed
|
||||
if ( strlen(aux_data) > 0 ){
|
||||
strcpy( auxbuffer, ", \"aux\":\"");
|
||||
strcpy( auxbuffer+9, aux_data);
|
||||
strcpy( auxbuffer+strlen(aux_data)+8, "\"\0" );
|
||||
}
|
||||
if (option_ptu && !err0 && gpx.T > -273.0) {
|
||||
printf("{ \"frame\": %d, \"id\": \"%s\", \"datetime\": \"%04d-%02d-%02dT%02d:%02d:%06.3fZ\", \"lat\": %.5f, \"lon\": %.5f, \"alt\": %.5f, \"vel_h\": %.5f, \"heading\": %.5f, \"vel_v\": %.5f, \"sats\": %d, \"temp\":%.1f %s}\n", gpx.frnr, gpx.id, gpx.jahr, gpx.monat, gpx.tag, gpx.std, gpx.min, gpx.sek, gpx.lat, gpx.lon, gpx.alt, gpx.vH, gpx.vD, gpx.vU, gpx.numSV, gpx.T, auxbuffer);
|
||||
printf("{ \"frame\": %d, \"id\": \"%s\", \"datetime\": \"%04d-%02d-%02dT%02d:%02d:%06.3fZ\", \"lat\": %.5f, \"lon\": %.5f, \"alt\": %.5f, \"vel_h\": %.5f, \"heading\": %.5f, \"vel_v\": %.5f, \"sats\": %d, \"temp\":%.1f }\n", gpx.frnr, gpx.id, gpx.jahr, gpx.monat, gpx.tag, gpx.std, gpx.min, gpx.sek, gpx.lat, gpx.lon, gpx.alt, gpx.vH, gpx.vD, gpx.vU, gpx.numSV, gpx.T );
|
||||
} else {
|
||||
printf("{ \"frame\": %d, \"id\": \"%s\", \"datetime\": \"%04d-%02d-%02dT%02d:%02d:%06.3fZ\", \"lat\": %.5f, \"lon\": %.5f, \"alt\": %.5f, \"vel_h\": %.5f, \"heading\": %.5f, \"vel_v\": %.5f, \"sats\": %d %s}\n", gpx.frnr, gpx.id, gpx.jahr, gpx.monat, gpx.tag, gpx.std, gpx.min, gpx.sek, gpx.lat, gpx.lon, gpx.alt, gpx.vH, gpx.vD, gpx.vU, gpx.numSV, auxbuffer);
|
||||
printf("{ \"frame\": %d, \"id\": \"%s\", \"datetime\": \"%04d-%02d-%02dT%02d:%02d:%06.3fZ\", \"lat\": %.5f, \"lon\": %.5f, \"alt\": %.5f, \"vel_h\": %.5f, \"heading\": %.5f, \"vel_v\": %.5f, \"sats\": %d }\n", gpx.frnr, gpx.id, gpx.jahr, gpx.monat, gpx.tag, gpx.std, gpx.min, gpx.sek, gpx.lat, gpx.lon, gpx.alt, gpx.vH, gpx.vD, gpx.vU, gpx.numSV );
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
|
|
@ -1218,6 +1209,7 @@ int main(int argc, char *argv[]) {
|
|||
|
||||
int symlen = 1;
|
||||
int bitofs = 2;
|
||||
int shift = 0;
|
||||
|
||||
|
||||
#ifdef CYGWIN
|
||||
|
|
@ -1270,6 +1262,15 @@ int main(int argc, char *argv[]) {
|
|||
}
|
||||
else return -1;
|
||||
}
|
||||
else if ( (strcmp(*argv, "-d") == 0) ) {
|
||||
++argv;
|
||||
if (*argv) {
|
||||
shift = atoi(*argv);
|
||||
if (shift > 4) shift = 4;
|
||||
if (shift < -4) shift = -4;
|
||||
}
|
||||
else return -1;
|
||||
}
|
||||
else {
|
||||
fp = fopen(*argv, "rb");
|
||||
if (fp == NULL) {
|
||||
|
|
@ -1300,8 +1301,9 @@ int main(int argc, char *argv[]) {
|
|||
|
||||
|
||||
symlen = 1;
|
||||
bitofs += shift;
|
||||
|
||||
headerlen = strlen(header);
|
||||
bitofs = 2; // +1 .. +2
|
||||
K = init_buffers(header, headerlen, 2); // shape=2
|
||||
if ( K < 0 ) {
|
||||
fprintf(stderr, "error: init buffers\n");
|
||||
|
|
@ -1310,14 +1312,15 @@ int main(int argc, char *argv[]) {
|
|||
|
||||
|
||||
k = 0;
|
||||
mv = -1; mv_pos = 0;
|
||||
mv = 0;
|
||||
mv_pos = 0;
|
||||
|
||||
while ( f32buf_sample(fp, option_inv, 1) != EOF ) {
|
||||
while ( f32buf_sample(fp, option_inv) != EOF ) {
|
||||
|
||||
k += 1;
|
||||
if (k >= K-4) {
|
||||
mv0_pos = mv_pos;
|
||||
mp = getCorrDFT(0, K, 0, &mv, &mv_pos);
|
||||
mp = getCorrDFT(K, 0, &mv, &mv_pos);
|
||||
k = 0;
|
||||
}
|
||||
else {
|
||||
|
|
@ -1350,7 +1353,7 @@ int main(int argc, char *argv[]) {
|
|||
ft_len = frmlen;
|
||||
|
||||
while ( byte_count < frmlen ) {
|
||||
bitQ = read_sbit(fp, symlen, &bit, option_inv, bitofs, bit_count==0, 0); // symlen=1, return: zeroX/bit
|
||||
bitQ = read_sbit(fp, symlen, &bit, option_inv, bitofs, bit_count==0); // symlen=1
|
||||
if ( bitQ == EOF) break;
|
||||
bit_count += 1;
|
||||
bitbuf[bitpos] = bit;
|
||||
|
|
@ -1380,7 +1383,7 @@ int main(int argc, char *argv[]) {
|
|||
header_found = 0;
|
||||
|
||||
while ( bit_count < BITS*(FRAME_LEN-8+24) ) {
|
||||
bitQ = read_sbit(fp, symlen, &bit, option_inv, bitofs, bit_count==0, 0); // symlen=1, return: zeroX/bit
|
||||
bitQ = read_sbit(fp, symlen, &bit, option_inv, bitofs, bit_count==0); // symlen=1
|
||||
if ( bitQ == EOF) break;
|
||||
bit_count++;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -33,6 +33,7 @@ typedef struct {
|
|||
i8_t ecc; // Reed-Solomon ECC
|
||||
i8_t sat; // GPS sat data
|
||||
i8_t ptu; // PTU: temperature
|
||||
i8_t jsn; // JSON output (auto_rx)
|
||||
} option_t;
|
||||
|
||||
typedef struct {
|
||||
|
|
@ -789,7 +790,7 @@ static int get_Aux(gpx_t *gpx) {
|
|||
|
||||
if ( auxcrc == crc16(gpx, pos7E+2, auxlen) ) {
|
||||
if (count7E == 0) fprintf(stdout, "\n # xdata = ");
|
||||
else { fprintf(stdout, " # "); gpx->xdata[n++] = '#'; }
|
||||
else { fprintf(stdout, " # "); gpx->xdata[n++] = '#'; } // aux separator
|
||||
|
||||
//fprintf(stdout, " # %02x : ", gpx->frame[pos7E+2]);
|
||||
for (i = 1; i < auxlen; i++) {
|
||||
|
|
@ -1073,10 +1074,29 @@ static int print_position(gpx_t *gpx, int ec) {
|
|||
|
||||
get_Calconf(gpx, output);
|
||||
|
||||
if (gpx->option.vbs > 1) gpx->aux = get_Aux(gpx);
|
||||
if (gpx->option.vbs > 1 || gpx->option.jsn) {
|
||||
gpx->aux = get_Aux(gpx);
|
||||
//if (gpx->aux) fprintf(stdout, "\n%d: %s", gpx->aux, gpx->xdata);
|
||||
}
|
||||
|
||||
fprintf(stdout, "\n"); // fflush(stdout);
|
||||
|
||||
|
||||
if (gpx->option.jsn) {
|
||||
// Print JSON output required by auto_rx.
|
||||
if (!err && !err1 && !err3) { // frame-nb/id && gps-time && gps-position (crc-)ok; 3 CRCs, RS not needed
|
||||
printf("{ \"frame\": %d, \"id\": \"%s\", \"datetime\": \"%04d-%02d-%02dT%02d:%02d:%06.3fZ\", \"lat\": %.5f, \"lon\": %.5f, \"alt\": %.5f, \"vel_h\": %.5f, \"heading\": %.5f, \"vel_v\": %.5f, \"sats\": %d", gpx->frnr, gpx->id, gpx->jahr, gpx->monat, gpx->tag, gpx->std, gpx->min, gpx->sek, gpx->lat, gpx->lon, gpx->alt, gpx->vH, gpx->vD, gpx->vU, gpx->numSV );
|
||||
if (gpx->option.ptu && !err0 && gpx->T > -273.0) {
|
||||
printf(", \"temp\":%.1f", gpx->T );
|
||||
}
|
||||
if (gpx->aux) { // <=> gpx->xdata[0]!='\0'
|
||||
printf(", \"aux\":\"%s\"", gpx->xdata );
|
||||
}
|
||||
printf(" }\n");
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
err |= err1 | err3;
|
||||
|
|
@ -1210,6 +1230,11 @@ int main(int argc, char *argv[]) {
|
|||
else if (strcmp(*argv, "--ecc2") == 0) { gpx.option.ecc = 2; }
|
||||
else if (strcmp(*argv, "--sat") == 0) { gpx.option.sat = 1; }
|
||||
else if (strcmp(*argv, "--ptu") == 0) { gpx.option.ptu = 1; }
|
||||
else if (strcmp(*argv, "--json") == 0) {
|
||||
gpx.option.jsn = 1;
|
||||
gpx.option.ecc = 2;
|
||||
gpx.option.crc = 1;
|
||||
}
|
||||
else if (strcmp(*argv, "--ch2") == 0) { sel_wavch = 1; } // right channel (default: 0=left)
|
||||
else if (strcmp(*argv, "--ths") == 0) {
|
||||
++argv;
|
||||
|
|
@ -1310,7 +1335,7 @@ int main(int argc, char *argv[]) {
|
|||
k += 1;
|
||||
if (k >= dsp.K-4) {
|
||||
mv0_pos = mv_pos;
|
||||
mp = getCorrDFT(&dsp, 0, 0, &mv, &mv_pos);
|
||||
mp = getCorrDFT(&dsp, 0, &mv, &mv_pos);
|
||||
k = 0;
|
||||
}
|
||||
else {
|
||||
|
|
@ -1340,10 +1365,10 @@ int main(int argc, char *argv[]) {
|
|||
|
||||
while ( byte_count < FRAME_LEN ) {
|
||||
if (option_iq >= 2) {
|
||||
bitQ = read_slbit(&dsp, symlen, &bit, option_inv, bitofs, bit_count, 1.0);
|
||||
bitQ = read_slbit(&dsp, symlen, &bit, option_inv, bitofs, bit_count, 1.0, 0);
|
||||
}
|
||||
else {
|
||||
bitQ = read_slbit(&dsp, symlen, &bit, option_inv, bitofs, bit_count, -1);
|
||||
bitQ = read_slbit(&dsp, symlen, &bit, option_inv, bitofs, bit_count, -1, 0);
|
||||
}
|
||||
if ( bitQ == EOF) break;
|
||||
bit_count += 1;
|
||||
|
|
|
|||
|
|
@ -1240,8 +1240,9 @@ int main(int argc, char *argv[]) {
|
|||
|
||||
float thres = 0.7;
|
||||
|
||||
int bitofs = 0;
|
||||
int symlen = 2;
|
||||
int bitofs = 2; // +0 .. +3
|
||||
int shift = 0;
|
||||
|
||||
|
||||
#ifdef CYGWIN
|
||||
|
|
@ -1342,7 +1343,7 @@ int main(int argc, char *argv[]) {
|
|||
else if (strcmp(*argv, "-g2") == 0) { option_vergps = 2; } // verbose2 GPS (bancroft)
|
||||
else if (strcmp(*argv, "-gg") == 0) { option_vergps = 8; } // vverbose GPS
|
||||
else if (strcmp(*argv, "--ecc") == 0) { option_ecc = 1; }
|
||||
else if (strcmp(*argv, "--json") == 0) { option_json = 1; } // JSON output (for auto_rx)
|
||||
else if (strcmp(*argv, "--json") == 0) {option_json = 1; option_ecc = 1; option_crc = 1; }
|
||||
else if (strcmp(*argv, "--ch2") == 0) { wav_channel = 1; } // right channel (default: 0=left)
|
||||
else if (strcmp(*argv, "--ths") == 0) {
|
||||
++argv;
|
||||
|
|
@ -1351,6 +1352,15 @@ int main(int argc, char *argv[]) {
|
|||
}
|
||||
else return -1;
|
||||
}
|
||||
else if ( (strcmp(*argv, "-d") == 0) ) {
|
||||
++argv;
|
||||
if (*argv) {
|
||||
shift = atoi(*argv);
|
||||
if (shift > 4) shift = 4;
|
||||
if (shift < -4) shift = -4;
|
||||
}
|
||||
else return -1;
|
||||
}
|
||||
else {
|
||||
if (!rawin) fp = fopen(*argv, "rb");
|
||||
else fp = fopen(*argv, "r");
|
||||
|
|
@ -1405,8 +1415,9 @@ int main(int argc, char *argv[]) {
|
|||
|
||||
|
||||
symlen = 2;
|
||||
bitofs += shift;
|
||||
|
||||
headerlen = strlen(rawheader);
|
||||
bitofs = 2; // +1 .. +2
|
||||
K = init_buffers(rawheader, headerlen, 2); // shape=2
|
||||
if ( K < 0 ) {
|
||||
fprintf(stderr, "error: init buffers\n");
|
||||
|
|
@ -1414,14 +1425,15 @@ int main(int argc, char *argv[]) {
|
|||
};
|
||||
|
||||
k = 0;
|
||||
mv = -1; mv_pos = 0;
|
||||
mv = 0;
|
||||
mv_pos = 0;
|
||||
|
||||
while ( f32buf_sample(fp, option_inv, 1) != EOF ) {
|
||||
while ( f32buf_sample(fp, option_inv) != EOF ) {
|
||||
|
||||
k += 1;
|
||||
if (k >= K-4) {
|
||||
mv0_pos = mv_pos;
|
||||
mp = getCorrDFT(0, K, 0, &mv, &mv_pos);
|
||||
mp = getCorrDFT(K, 0, &mv, &mv_pos);
|
||||
k = 0;
|
||||
}
|
||||
else {
|
||||
|
|
@ -1451,8 +1463,7 @@ int main(int argc, char *argv[]) {
|
|||
bitpos = 0;
|
||||
|
||||
while ( byte_count < FRAME_LEN ) {
|
||||
header_found = !(byte_count>=FRAME_LEN-2);
|
||||
bitQ = read_sbit(fp, symlen, &bit, option_inv, bitofs, bit_count==0, !header_found); // symlen=2, return: zeroX/bit
|
||||
bitQ = read_sbit(fp, symlen, &bit, option_inv, bitofs, bit_count==0); // symlen=2
|
||||
if ( bitQ == EOF) break;
|
||||
bit_count += 1;
|
||||
bitbuf[bitpos] = bit;
|
||||
|
|
|
|||
Ładowanie…
Reference in New Issue