static int get_bit_raw(fsk_data *fskd, short *buffer, int *len)
{
/* Esta funcion implementa un DPLL para sincronizarse con los bits */
float x,spb,spb2,ds;
int f;
spb=fskd->spb;
if (fskd->spb == 7) spb = 8000.0 / 1200.0;
ds=spb/32.;
spb2=spb/2.;
for (f=0;;){
if (demodulador(fskd,&x, GET_SAMPLE)) return(-1);
if ((x*fskd->x0)<0) { /* Transicion */
if (!f) {
if (fskd->cont<(spb2)) fskd->cont+=ds; else fskd->cont-=ds;
f=1;
}
}
fskd->x0=x;
fskd->cont+=1.;
if (fskd->cont>spb) {
fskd->cont-=spb;
break;
}
}
f=(x>0)?0x80:0;
return(f);
}
int get_bit_raw(ZAP *zap)
{
/* Esta funcion implementa un DPLL para sincronizarse con los bits */
float x,spb,spb2,ds;
int f;
spb=zap->fskd.spb;
if (zap->fskd.spb == 7) spb = 8000.0 / 1200.0;
ds=spb/32.;
spb2=spb/2.;
for (f=0;;){
if (demodulador(zap,&x)) return(-1);
if ((x*zap->x0)<0) { /* Transicion */
if (!f) {
if (zap->cont<(spb2)) zap->cont+=ds; else zap->cont-=ds;
f=1;
}
}
zap->x0=x;
zap->cont+=1.;
if (zap->cont>spb) {
zap->cont-=spb;
break;
}
}
f=(x>0)?0x80:0;
return(f);
}
int fsk_serie(fsk_data *fskd, short *buffer, int *len, int *outbyte)
{
int a;
int i,j,n1,r;
int samples=0;
int olen;
switch(fskd->state) {
/* Pick up where we left off */
case STATE_SEARCH_STARTBIT2:
goto search_startbit2;
case STATE_SEARCH_STARTBIT3:
goto search_startbit3;
case STATE_GET_BYTE:
goto getbyte;
}
/* Esperamos bit de start */
do {
/* this was jesus's nice, reasonable, working (at least with RTTY) code
to look for the beginning of the start bit. Unfortunately, since TTY/TDD's
just start sending a start bit with nothing preceding it at the beginning
of a transmission (what a LOSING design), we cant do it this elegantly */
/*
if (demodulador(zap,&x1)) return(-1);
for(;;) {
if (demodulador(zap,&x2)) return(-1);
if (x1>0 && x2<0) break;
x1=x2;
}
*/
/* this is now the imprecise, losing, but functional code to detect the
beginning of a start bit in the TDD sceanario. It just looks for sufficient
level to maybe, perhaps, guess, maybe that its maybe the beginning of
a start bit, perhaps. This whole thing stinks! */
if (demodulador(fskd,&fskd->x1,GET_SAMPLE)) return(-1);
samples++;
for(;;)
{
search_startbit2:
if (!*len) {
fskd->state = STATE_SEARCH_STARTBIT2;
return 0;
}
samples++;
if (demodulador(fskd,&fskd->x2,GET_SAMPLE)) return(-1);
#if 0
printf("x2 = %5.5f ", fskd->x2);
#endif
if (fskd->x2 < -0.5) break;
}
search_startbit3:
/* Esperamos 0.5 bits antes de usar DPLL */
i=fskd->spb/2;
if (*len < i) {
fskd->state = STATE_SEARCH_STARTBIT3;
return 0;
}
for(;i;i--) { if (demodulador(fskd,&fskd->x1,GET_SAMPLE)) return(-1);
#if 0
printf("x1 = %5.5f ", fskd->x1);
#endif
samples++; }
/* x1 debe ser negativo (confirmación del bit de start) */
} while (fskd->x1>0);
fskd->state = STATE_GET_BYTE;
getbyte:
/* Need at least 80 samples (for 1200) or
1320 (for 45.5) to be sure we'll have a byte */
if (fskd->nbit < 8) {
if (*len < 1320)
return 0;
} else {
if (*len < 80)
return 0;
}
/* Leemos ahora los bits de datos */
j=fskd->nbit;
for (a=n1=0;j;j--) {
olen = *len;
i=get_bit_raw(fskd, buffer, len);
buffer += (olen - *len);
if (i == -1) return(-1);
if (i) n1++;
a>>=1; a|=i;
}
j=8-fskd->nbit;
a>>=j;
/* Leemos bit de paridad (si existe) y la comprobamos */
if (fskd->paridad) {
olen = *len;
i=get_bit_raw(fskd, buffer, len);
buffer += (olen - *len);
if (i == -1) return(-1);
if (i) n1++;
if (fskd->paridad==1) { /* paridad=1 (par) */
if (n1&1) a|=0x100; /* error */
} else { /* paridad=2 (impar) */
if (!(n1&1)) a|=0x100; /* error */
}
}
/* Leemos bits de STOP. Todos deben ser 1 */
for (j=fskd->nstop;j;j--) {
r = get_bit_raw(fskd, buffer, len);
if (r == -1) return(-1);
if (!r) a|=0x200;
}
/* Por fin retornamos */
/* Bit 8 : Error de paridad */
/* Bit 9 : Error de Framming */
*outbyte = a;
fskd->state = STATE_SEARCH_STARTBIT;
return 1;
}
