fskmodem_float.h File Reference

FSK Modem Support. More...

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
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...

Detailed Description

FSK Modem Support.

Note

Includes code and algorithms from the Zapata library.

Definition in file fskmodem_float.h.

Macro Definition Documentation

NCOLA

#define NCOLA   0x4000

Definition at line 32 of file fskmodem_float.h.

PARITY_EVEN

#define PARITY_EVEN   1

Definition at line 28 of file fskmodem_float.h.

PARITY_NONE

#define PARITY_NONE   0

Definition at line 27 of file fskmodem_float.h.

PARITY_ODD

#define PARITY_ODD   2

Definition at line 29 of file fskmodem_float.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, demodulator(), get_bit_raw(), GET_SAMPLE, len(), fsk_data::nbit, fsk_data::nstop, fsk_data::parity, fsk_data::spb, fsk_data::state, STATE_GET_BYTE, STATE_SEARCH_STARTBIT, STATE_SEARCH_STARTBIT2, STATE_SEARCH_STARTBIT3, fsk_data::x1, and fsk_data::x2.

Referenced by callerid_feed(), callerid_feed_jp(), and tdd_feed().