fskmodem_int.h File Reference

FSK Modem Support. More...

Go to the source code of this file.

Data Structures
struct	filter_struct
struct	fsk_data

Macros
#define	NCOLA   0x4000
#define	PARITY_EVEN   1
#define	PARITY_NONE   0
#define	PARITY_ODD   2

Functions
int	fsk_serial (fsk_data *fskd, short *buffer, int *len, int *outbyte)
	Retrieve a serial byte into outbyte. Buffer is a pointer into a series of shorts and len records the number of bytes in the buffer. len will be overwritten with the number of bytes left that were not consumed. More...
int	fskmodem_init (fsk_data *fskd)

Detailed Description

FSK Modem Support.

Note

Includes code and algorithms from the Zapata library.

Definition in file fskmodem_int.h.

Macro Definition Documentation

NCOLA

#define NCOLA   0x4000

Definition at line 32 of file fskmodem_int.h.

PARITY_EVEN

#define PARITY_EVEN   1

Definition at line 28 of file fskmodem_int.h.

PARITY_NONE

#define PARITY_NONE   0

Definition at line 27 of file fskmodem_int.h.

PARITY_ODD

#define PARITY_ODD   2

Definition at line 29 of file fskmodem_int.h.

Function Documentation

fsk_serial()

int fsk_serial	(	fsk_data *	fskd,
		short *	buffer,
		int *	len,
		int *	outbyte
	)

Retrieve a serial byte into outbyte. Buffer is a pointer into a series of shorts and len records the number of bytes in the buffer. len will be overwritten with the number of bytes left that were not consumed.

Return values

0	Still looking for something...
1	An output byte was received and stored in outbyte
-1	An error occured in the transmission He must be called with at least 80 bytes of buffer.

Definition at line 224 of file fskmodem_float.c.

{
    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;
    }
    /* We await for start bit   */
    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 (demodulator(zap,&x1)) return(-1);
        for (;;) {
            if (demodulator(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 (demodulator(fskd, &fskd->x1, GET_SAMPLE))
            return -1;
        samples++;
        for (;;) {
search_startbit2:
            if (*len <= 0) {
                fskd->state  =  STATE_SEARCH_STARTBIT2;
                return 0;
            }
            samples++;
            if (demodulator(fskd, &fskd->x2, GET_SAMPLE))
                return(-1);
#if 0
            printf("x2  =  %5.5f ", fskd->x2);
#endif
            if (fskd->x2 < -0.5)
                break;
        }
search_startbit3:
        /* We await for 0.5 bits before using DPLL */
        i = fskd->spb/2;
        if (*len < i) {
            fskd->state = STATE_SEARCH_STARTBIT3;
            return 0;
        }
        for (; i>0; i--) {
            if (demodulator(fskd, &fskd->x1, GET_SAMPLE))
                return(-1);
#if 0
            printf("x1 = %5.5f ", fskd->x1);
#endif
            samples++;
        }
 
        /* x1 must be negative (start bit confirmation) */
 
    } 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;
    }
    /* Now we read the data bits */
    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;
 
    /* We read parity bit (if exists) and check parity */
    if (fskd->parity) {
        olen = *len;
        i = get_bit_raw(fskd, buffer, len);
        buffer += (olen - *len);
        if (i == -1)
            return(-1);
        if (i)
            n1++;
        if (fskd->parity == 1) {    /* parity=1 (even) */
            if (n1&1)
                a |= 0x100;     /* error */
        } else {            /* parity=2 (odd) */
            if (!(n1&1))
                a |= 0x100; /* error */
        }
    }
 
    /* We read STOP bits. All of them must be 1 */
 
    for (j = fskd->nstop;j;j--) {
        r = get_bit_raw(fskd, buffer, len);
        if (r == -1)
            return(-1);
        if (!r)
            a |= 0x200;
    }
 
    /* And finally we return  */
    /* Bit 8 : Parity error */
    /* Bit 9 : Framing error*/
 
    *outbyte = a;
    fskd->state = STATE_SEARCH_STARTBIT;
    return 1;
}

References a, get_bit_raw(), idemodulator(), IGET_SAMPLE, fsk_data::instop, fsk_data::ispb, len(), fsk_data::nbit, fsk_data::parity, fsk_data::state, STATE_GET_BYTE, STATE_SEARCH_STARTBIT, STATE_SEARCH_STARTBIT2, STATE_SEARCH_STARTBIT3, fsk_data::xi1, and fsk_data::xi2.

fskmodem_init()

int fskmodem_init

(

fsk_data *

fskd

)

Definition at line 195 of file fskmodem_int.c.

{
    int i;
 
    fskd->space_filter.ip  = 0;
    fskd->mark_filter.ip   = 0;
    fskd->demod_filter.ip  = 0;
 
    for ( i = 0 ; i < 7 ; i++ ) {
        fskd->space_filter.icoefs[i] =
            coef_in[fskd->f_space_idx][fskd->bw][i] * 256;
        fskd->space_filter.ixv[i] = 0;;
        fskd->space_filter.iyv[i] = 0;;
 
        fskd->mark_filter.icoefs[i] =
            coef_in[fskd->f_mark_idx][fskd->bw][i] * 256;
        fskd->mark_filter.ixv[i] = 0;;
        fskd->mark_filter.iyv[i] = 0;;
 
        fskd->demod_filter.icoefs[i] =
            coef_out[fskd->bw][i] * 1024;
        fskd->demod_filter.ixv[i] = 0;;
        fskd->demod_filter.iyv[i] = 0;;
    }
    return 0;
}

References fsk_data::bw, coef_in, coef_out, fsk_data::demod_filter, fsk_data::f_mark_idx, fsk_data::f_space_idx, filter_struct::icoefs, filter_struct::ip, filter_struct::ixv, filter_struct::iyv, fsk_data::mark_filter, and fsk_data::space_filter.

Referenced by callerid_new(), and tdd_new().