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