fskmodem.c

   1 /*
   2  * Asterisk -- A telephony toolkit for Linux.
   3  *
   4  * FSK Modulator/Demodulator
   5  *
   6  * Copyright (C) 1999, Mark Spencer
   7  *
   8  * Mark Spencer <markster@linux-support.net>
   9  *
  10  * This program is free software, distributed under the terms of
  11  * the GNU General Public License.
  12  *
  13  * Includes code and algorithms from the Zapata library.
  14  *
  15  */
  16
  17 #include <asterisk/fskmodem.h>
  18
  19 #include <stdio.h>
  20
  21 #define NBW     2
  22 #define BWLIST  {75,800}
  23 #define NF      4
  24 #define FLIST {1400,1800,1200,2200}
  25
  26 #define STATE_SEARCH_STARTBIT   0
  27 #define STATE_SEARCH_STARTBIT2  1
  28 #define STATE_SEARCH_STARTBIT3  2
  29 #define STATE_GET_BYTE                  3
  30
  31 static inline float get_sample(short **buffer, int *len)
  32 {
  33         float retval;
  34         retval = (float) **buffer / 256;
  35         (*buffer)++;
  36         (*len)--;
  37         return retval;
  38 }
  39
  40 #define GET_SAMPLE get_sample(&buffer, len)
  41
  42 /* Coeficientes para filtros de entrada                                 */
  43 /* Tabla de coeficientes, generada a partir del programa "mkfilter"     */
  44 /* Formato: coef[IDX_FREC][IDX_BW][IDX_COEF]                            */
  45 /* IDX_COEF=0   =>      1/GAIN                                          */
  46 /* IDX_COEF=1-6 =>      Coeficientes y[n]                               */
  47
  48 static double coef_in[NF][NBW][8]={
  49 #include "coef_in.h"
  50 };
  51
  52 /* Coeficientes para filtro de salida                                   */
  53 /* Tabla de coeficientes, generada a partir del programa "mkfilter"     */
  54 /* Formato: coef[IDX_BW][IDX_COEF]                                      */
  55 /* IDX_COEF=0   =>      1/GAIN                                          */
  56 /* IDX_COEF=1-6 =>      Coeficientes y[n]                               */
  57
  58 static double coef_out[NBW][8]={
  59 #include "coef_out.h"
  60 };
  61
  62
  63 /* Filtro pasa-banda para frecuencia de MARCA */
  64 static inline float filtroM(fsk_data *fskd,float in)
  65 {
  66         int i,j;
  67         double s;
  68         double *pc;
  69
  70         pc=&coef_in[fskd->f_mark_idx][fskd->bw][0];
  71         fskd->fmxv[(fskd->fmp+6)&7]=in*(*pc++);
  72
  73         s=(fskd->fmxv[(fskd->fmp+6)&7] - fskd->fmxv[fskd->fmp]) + 3 * (fskd->fmxv[(fskd->fmp+2)&7] - fskd->fmxv[(fskd->fmp+4)&7]);
  74         for (i=0,j=fskd->fmp;i<6;i++,j++) s+=fskd->fmyv[j&7]*(*pc++);
  75         fskd->fmyv[j&7]=s;
  76         fskd->fmp++; fskd->fmp&=7;
  77         return s;
  78 }
  79
  80 /* Filtro pasa-banda para frecuencia de ESPACIO */
  81 static inline float filtroS(fsk_data *fskd,float in)
  82 {
  83         int i,j;
  84         double s;
  85         double *pc;
  86
  87         pc=&coef_in[fskd->f_space_idx][fskd->bw][0];
  88         fskd->fsxv[(fskd->fsp+6)&7]=in*(*pc++);
  89
  90         s=(fskd->fsxv[(fskd->fsp+6)&7] - fskd->fsxv[fskd->fsp]) + 3 * (fskd->fsxv[(fskd->fsp+2)&7] - fskd->fsxv[(fskd->fsp+4)&7]);
  91         for (i=0,j=fskd->fsp;i<6;i++,j++) s+=fskd->fsyv[j&7]*(*pc++);
  92         fskd->fsyv[j&7]=s;
  93         fskd->fsp++; fskd->fsp&=7;
  94         return s;
  95 }
  96
  97 /* Filtro pasa-bajos para datos demodulados */
  98 static inline float filtroL(fsk_data *fskd,float in)
  99 {
 100         int i,j;
 101         double s;
 102         double *pc;
 103
 104         pc=&coef_out[fskd->bw][0];
 105         fskd->flxv[(fskd->flp + 6) & 7]=in * (*pc++);
 106
 107         s=     (fskd->flxv[fskd->flp]       + fskd->flxv[(fskd->flp+6)&7]) +
 108           6  * (fskd->flxv[(fskd->flp+1)&7] + fskd->flxv[(fskd->flp+5)&7]) +
 109           15 * (fskd->flxv[(fskd->flp+2)&7] + fskd->flxv[(fskd->flp+4)&7]) +
 110           20 *  fskd->flxv[(fskd->flp+3)&7];
 111
 112         for (i=0,j=fskd->flp;i<6;i++,j++) s+=fskd->flyv[j&7]*(*pc++);
 113         fskd->flyv[j&7]=s;
 114         fskd->flp++; fskd->flp&=7;
 115         return s;
 116 }
 117
 118 static inline int demodulador(fsk_data *fskd, float *retval, float x)
 119 {
 120         float xS,xM;
 121
 122         fskd->cola_in[fskd->pcola]=x;
 123
 124         xS=filtroS(fskd,x);
 125         xM=filtroM(fskd,x);
 126
 127         fskd->cola_filtro[fskd->pcola]=xM-xS;
 128
 129         x=filtroL(fskd,xM*xM - xS*xS);
 130
 131         fskd->cola_demod[fskd->pcola++]=x;
 132         fskd->pcola &= (NCOLA-1);
 133
 134         *retval = x;
 135         return(0);
 136 }
 137
 138 static int get_bit_raw(fsk_data *fskd, short *buffer, int *len)
 139 {
 140         /* Esta funcion implementa un DPLL para sincronizarse con los bits */
 141         float x,spb,spb2,ds;
 142         int f;
 143
 144         spb=fskd->spb;
 145         if (fskd->spb == 7) spb = 8000.0 / 1200.0;
 146         ds=spb/32.;
 147         spb2=spb/2.;
 148
 149         for (f=0;;){
 150                 if (demodulador(fskd,&x, GET_SAMPLE)) return(-1);
 151                 if ((x*fskd->x0)<0) {   /* Transicion */
 152                         if (!f) {
 153                                 if (fskd->cont<(spb2)) fskd->cont+=ds; else fskd->cont-=ds;
 154                                 f=1;
 155                         }
 156                 }
 157                 fskd->x0=x;
 158                 fskd->cont+=1.;
 159                 if (fskd->cont>spb) {
 160                         fskd->cont-=spb;
 161                         break;
 162                 }
 163         }
 164         f=(x>0)?0x80:0;
 165         return(f);
 166 }
 167
 168 int fsk_serie(fsk_data *fskd, short *buffer, int *len, int *outbyte)
 169 {
 170         int a;
 171         int i,j,n1,r;
 172         int samples=0;
 173         int olen;
 174         switch(fskd->state) {
 175                 /* Pick up where we left off */
 176         case STATE_SEARCH_STARTBIT2:
 177                 goto search_startbit2;
 178         case STATE_SEARCH_STARTBIT3:
 179                 goto search_startbit3;
 180         case STATE_GET_BYTE:
 181                 goto getbyte;
 182         }
 183         /* Esperamos bit de start       */
 184         do {
 185 /* this was jesus's nice, reasonable, working (at least with RTTY) code
 186 to look for the beginning of the start bit. Unfortunately, since TTY/TDD's
 187 just start sending a start bit with nothing preceding it at the beginning
 188 of a transmission (what a LOSING design), we cant do it this elegantly */
 189 /*
 190                 if (demodulador(zap,&x1)) return(-1);
 191                 for(;;) {
 192                         if (demodulador(zap,&x2)) return(-1);
 193                         if (x1>0 && x2<0) break;
 194                         x1=x2;
 195                 }
 196 */
 197 /* this is now the imprecise, losing, but functional code to detect the
 198 beginning of a start bit in the TDD sceanario. It just looks for sufficient
 199 level to maybe, perhaps, guess, maybe that its maybe the beginning of
 200 a start bit, perhaps. This whole thing stinks! */
 201                 if (demodulador(fskd,&fskd->x1,GET_SAMPLE)) return(-1);
 202                 samples++;
 203                 for(;;)
 204                    {
 205 search_startbit2:
 206                         if (!*len) {
 207                                 fskd->state = STATE_SEARCH_STARTBIT2;
 208                                 return 0;
 209                         }
 210                         samples++;
 211                         if (demodulador(fskd,&fskd->x2,GET_SAMPLE)) return(-1);
 212 #if 0
 213                         printf("x2 = %5.5f ", fskd->x2);
 214 #endif
 215                         if (fskd->x2 < -0.5) break;
 216                    }
 217 search_startbit3:
 218                 /* Esperamos 0.5 bits antes de usar DPLL */
 219                 i=fskd->spb/2;
 220                 if (*len < i) {
 221                         fskd->state = STATE_SEARCH_STARTBIT3;
 222                         return 0;
 223                 }
 224                 for(;i;i--) { if (demodulador(fskd,&fskd->x1,GET_SAMPLE)) return(-1);
 225 #if 0
 226                         printf("x1 = %5.5f ", fskd->x1);
 227 #endif
 228         samples++; }
 229
 230                 /* x1 debe ser negativo (confirmación del bit de start) */
 231
 232         } while (fskd->x1>0);
 233         fskd->state = STATE_GET_BYTE;
 234
 235 getbyte:
 236
 237         /* Need at least 80 samples to be sure we'll have a byte */
 238         if (*len < 80)
 239                 return 0;
 240
 241         /* Leemos ahora los bits de datos */
 242         j=fskd->nbit;
 243         for (a=n1=0;j;j--) {
 244                 olen = *len;
 245                 i=get_bit_raw(fskd, buffer, len);
 246                 buffer += (olen - *len);
 247                 if (i == -1) return(-1);
 248                 if (i) n1++;
 249                 a>>=1; a|=i;
 250         }
 251         j=8-fskd->nbit;
 252         a>>=j;
 253
 254         /* Leemos bit de paridad (si existe) y la comprobamos */
 255         if (fskd->paridad) {
 256                 olen = *len;
 257                 i=get_bit_raw(fskd, buffer, len);
 258                 buffer += (olen - *len);
 259                 if (i == -1) return(-1);
 260                 if (i) n1++;
 261                 if (fskd->paridad==1) { /* paridad=1 (par) */
 262                         if (n1&1) a|=0x100;             /* error */
 263                 } else {                        /* paridad=2 (impar) */
 264                         if (!(n1&1)) a|=0x100;  /* error */
 265                 }
 266         }
 267
 268         /* Leemos bits de STOP. Todos deben ser 1 */
 269
 270         for (j=fskd->nstop;j;j--) {
 271                 r = get_bit_raw(fskd, buffer, len);
 272                 if (r == -1) return(-1);
 273                 if (!r) a|=0x200;
 274         }
 275
 276         /* Por fin retornamos  */
 277         /* Bit 8 : Error de paridad */
 278         /* Bit 9 : Error de Framming */
 279
 280         *outbyte = a;
 281         fskd->state = STATE_SEARCH_STARTBIT;
 282         return 1;
 283 }