Asterisk.org: Developer Documentation (28 Oct 2009)

Wed Oct 28 15:48:55 2009

## Asterisk developer's documentation

# fskmodem.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

## Defines

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

## Functions

int | fsk_serie (fsk_data *fskd, short *buffer, int *len, int *outbyte)

## Detailed Description

FSK Modem Support.

Note:
  Includes code and algorithms from the Zapata library.

Todo:
  Translate Emiliano Zapata's spanish comments to english, please.

Definition in file fskmodem.h.

## Define Documentation

#define NCOLA 0x4000

Definition at line 33 of file fskmodem.h.

Referenced by demodulador().

#define PARITY_EVEN 1

Definition at line 29 of file fskmodem.h.

#define PARITY_NONE 0

Definition at line 28 of file fskmodem.h.

#define PARITY_ODD 2

Definition at line 30 of file fskmodem.h.

## Function Documentation

int fsk_serie | ( | fsk_data * | fskd,
|  | short * | buffer,
|  | int * | len,
|  | int * | outbyte |
| ) |  |  |

Definition at line 182 of file fskmodem.c.

References demodulador(), get_bit_raw(), GET_SAMPLE, fsk_data::nbit, fsk_data::nstop, fsk_data::paridad, ast_frame::samples, 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(), and tdd_feed().

    00183 {
    00184    int a;
    00185    int i,j,n1,r;
    00186    int samples=0;
    00187    int olen;
    00188    int beginlen=*len;
    00189    int beginlenx;
    00190
    00191    switch(fskd->state) {
    00192       /* Pick up where we left off */
    00193    case STATE_SEARCH_STARTBIT2:
    00194       goto search_startbit2;
    00195    case STATE_SEARCH_STARTBIT3:
    00196       goto search_startbit3;
    00197    case STATE_GET_BYTE:
    00198       goto getbyte;
    00199    }
    00200    /* Esperamos bit de start  */
    00201    do {
    00202 /* this was jesus's nice, reasonable, working (at least with RTTY) code
    00203 to look for the beginning of the start bit. Unfortunately, since TTY/TDD's
    00204 just start sending a start bit with nothing preceding it at the beginning
    00205 of a transmission (what a LOSING design), we cant do it this elegantly */
    00206 /*
    00207       if (demodulador(zap,&x1)) return(-1);
    00208       for(;;) {
    00209          if (demodulador(zap,&x2)) return(-1);
    00210          if (x1>0 && x2<0) break;
    00211          x1=x2;
    00212       }
    00213 */
    00214 /* this is now the imprecise, losing, but functional code to detect the
    00215 beginning of a start bit in the TDD sceanario. It just looks for sufficient
    00216 level to maybe, perhaps, guess, maybe that its maybe the beginning of
    00217 a start bit, perhaps. This whole thing stinks! */
    00218       beginlenx=beginlen; /* just to avoid unused war warnings */
    00219       if (demodulador(fskd,&fskd->x1,GET_SAMPLE)) return(-1);
    00220       samples++;
    00221       for(;;)
    00222          {
    00223 search_startbit2:
    00224          if (*len <= 0) {
    00225             fskd->state = STATE_SEARCH_STARTBIT2;
    00226             return 0;
    00227          }
    00228          samples++;
    00229          if (demodulador(fskd,&fskd->x2,GET_SAMPLE)) return(-1);
    00230 #if 0
    00231          printf("x2 = %5.5f ", fskd->x2);
    00232 #endif
    00233          if (fskd->x2 < -0.5) break;
    00234          }
    00235 search_startbit3:
    00236       /* Esperamos 0.5 bits antes de usar DPLL */
    00237       i=fskd->spb/2;
    00238       if (*len < i) {
    00239          fskd->state = STATE_SEARCH_STARTBIT3;
    00240          return 0;
    00241       }
    00242       for(;i>0;i--) { if (demodulador(fskd,&fskd->x1,GET_SAMPLE)) return(-1);
    00243 #if 0
    00244          printf("x1 = %5.5f ", fskd->x1);
    00245 #endif
    00246    samples++; }
    00247
    00248       /* x1 debe ser negativo (confirmación del bit de start) */
    00249
    00250    } while (fskd->x1>0);
    00251    fskd->state = STATE_GET_BYTE;
    00252
    00253 getbyte:
    00254
    00255    /* Need at least 80 samples (for 1200) or
    00256       1320 (for 45.5) to be sure we'll have a byte */
    00257    if (fskd->nbit < 8) {
    00258       if (*len < 1320)
    00259          return 0;
    00260    } else {
    00261       if (*len < 80)
    00262          return 0;
    00263    }
    00264    /* Leemos ahora los bits de datos */
    00265    j=fskd->nbit;
    00266    for (a=n1=0;j;j--) {
    00267       olen = *len;
    00268       i=get_bit_raw(fskd, buffer, len);
    00269       buffer += (olen - *len);
    00270       if (i == -1) return(-1);
    00271       if (i) n1++;
    00272       a>>=1; a|=i;
    00273    }
    00274    j=8-fskd->nbit;
    00275    a>>=j;
    00276
    00277    /* Leemos bit de paridad (si existe) y la comprobamos */
    00278    if (fskd->paridad) {
    00279       olen = *len;
    00280       i=get_bit_raw(fskd, buffer, len);
    00281       buffer += (olen - *len);
    00282       if (i == -1) return(-1);
    00283       if (i) n1++;
    00284       if (fskd->paridad==1) { /* paridad=1 (par) */
    00285          if (n1&1) a|=0x100;     /* error */
    00286       } else {       /* paridad=2 (impar) */
    00287          if (!(n1&1)) a|=0x100;  /* error */
    00288       }
    00289    }
    00290
    00291    /* Leemos bits de STOP. Todos deben ser 1 */
    00292
    00293    for (j=fskd->nstop;j;j--) {
    00294       r = get_bit_raw(fskd, buffer, len);
    00295       if (r == -1) return(-1);
    00296       if (!r) a|=0x200;
    00297    }
    00298
    00299    /* Por fin retornamos  */
    00300    /* Bit 8 : Error de paridad */
    00301    /* Bit 9 : Error de Framming */
    00302
    00303    *outbyte = a;
    00304    fskd->state = STATE_SEARCH_STARTBIT;
    00305    return 1;
    00306 }