This source file includes following definitions.
- fsk_byte_handler
- FT_DECLARE
- FT_DECLARE
- FT_DECLARE
- FT_DECLARE
- FT_DECLARE
- FT_DECLARE
- FT_DECLARE
- FT_DECLARE
- FT_DECLARE
- FT_DECLARE
- FT_DECLARE
- FT_DECLARE
- FT_DECLARE
1 #include "private/ftdm_core.h"
2 #include "fsk.h"
3 #include "uart.h"
4
5
6
7 static void fsk_byte_handler (void *x, int data)
8 {
9 ftdm_fsk_data_state_t *state = (ftdm_fsk_data_state_t *) x;
10 uint8_t byte = (uint8_t)data;
11
12 top:
13
14 if (state->init == 3) {
15 return;
16 }
17
18 if (state->dlen) {
19 goto add_byte;
20 }
21
22 if (state->bpos == 1) {
23 state->blen = byte;
24
25 if ((uint32_t)(state->dlen = state->bpos + byte + 2) > state->bufsize) {
26 state->dlen = state->bufsize;
27 }
28 goto top;
29 }
30
31 add_byte:
32
33 if (state->bpos <= state->dlen) {
34 state->buf[state->bpos++] = byte;
35 } else {
36 state->init = 3;
37 }
38 }
39
40 FT_DECLARE(ftdm_status_t) ftdm_fsk_data_init(ftdm_fsk_data_state_t *state, uint8_t *data, uint32_t datalen)
41 {
42 memset(state, 0, sizeof(*state));
43 state->buf = data;
44 state->bufsize = datalen;
45 state->bpos = 2;
46
47 return FTDM_SUCCESS;
48 }
49
50 FT_DECLARE(ftdm_status_t) ftdm_fsk_data_add_sdmf(ftdm_fsk_data_state_t *state, const char *date, char *number)
51 {
52 size_t dlen = strlen(date);
53 size_t nlen = strlen(number);
54
55 state->buf[0] = FTDM_CID_TYPE_SDMF;
56 memcpy(&state->buf[state->bpos], date, dlen);
57 state->bpos += dlen;
58 memcpy(&state->buf[state->bpos], number, nlen);
59 state->bpos += nlen;
60
61 return FTDM_SUCCESS;
62 }
63
64 FT_DECLARE(ftdm_status_t) ftdm_fsk_data_add_mdmf(ftdm_fsk_data_state_t *state, ftdm_mdmf_type_t type, const uint8_t *data, uint32_t datalen)
65 {
66 state->buf[0] = FTDM_CID_TYPE_MDMF;
67 state->buf[state->bpos++] = type;
68 state->buf[state->bpos++] = (uint8_t)datalen;
69 memcpy(&state->buf[state->bpos], data, datalen);
70 state->bpos += datalen;
71 return FTDM_SUCCESS;
72 }
73
74
75 FT_DECLARE(ftdm_status_t) ftdm_fsk_data_add_checksum(ftdm_fsk_data_state_t *state)
76 {
77 uint32_t i;
78 uint8_t check = 0;
79
80 state->buf[1] = (uint8_t)(state->bpos - 2);
81
82 for (i = 0; i < state->bpos; i++) {
83 check = check + state->buf[i];
84 }
85
86 state->checksum = state->buf[state->bpos] = (uint8_t)(256 - check);
87 state->bpos++;
88
89 state->dlen = state->bpos;
90 state->blen = state->buf[1];
91
92 return FTDM_SUCCESS;
93 }
94
95
96 FT_DECLARE(ftdm_status_t) ftdm_fsk_data_parse(ftdm_fsk_data_state_t *state, ftdm_size_t *type, char **data, ftdm_size_t *len)
97 {
98
99 ftdm_size_t i;
100 int sum = 0;
101
102 top:
103
104 if (state->checksum != 0 || state->ppos >= state->dlen - 1) {
105 return FTDM_FAIL;
106 }
107
108 if (!state->ppos) {
109 for(i = 0; i < state->bpos; i++) {
110 sum += state->buf[i];
111 }
112 state->checksum = sum % 256;
113 state->ppos = 2;
114
115 if (state->buf[0] != FTDM_CID_TYPE_MDMF && state->buf[0] != FTDM_CID_TYPE_SDMF) {
116 state->checksum = -1;
117 }
118 goto top;
119 }
120
121 if (state->buf[0] == FTDM_CID_TYPE_SDMF) {
122
123 if (state->ppos == 2) {
124 *type = MDMF_DATETIME;
125 *len = 8;
126 } else {
127 if (state->buf[state->ppos] == 'P' || state->buf[state->ppos] == 'O') {
128 *type = MDMF_NO_NUM;
129 *len = 1;
130 } else {
131 *type = MDMF_PHONE_NUM;
132 *len = state->blen - 8;
133 }
134 }
135 *data = (char *)&state->buf[state->ppos];
136 state->ppos += *len;
137 return FTDM_SUCCESS;
138 } else if (state->buf[0] == FTDM_CID_TYPE_MDMF) {
139 *type = state->buf[state->ppos++];
140 *len = state->buf[state->ppos++];
141 *data = (char *)&state->buf[state->ppos];
142 state->ppos += *len;
143 return FTDM_SUCCESS;
144 }
145
146 return FTDM_FAIL;
147 }
148
149 FT_DECLARE(ftdm_status_t) ftdm_fsk_demod_feed(ftdm_fsk_data_state_t *state, int16_t *data, ftdm_size_t samples)
150 {
151 uint32_t x;
152 int16_t *sp = data;
153
154 if (state->init == 3) {
155 return FTDM_FAIL;
156 }
157
158 for (x = 0; x < samples; x++) {
159 dsp_fsk_sample (state->fsk1200_handle, (double) *sp++ / 32767.0);
160 if (state->dlen && state->bpos >= state->dlen) {
161 state->init = 3;
162 return FTDM_FAIL;
163 }
164 }
165
166 return FTDM_SUCCESS;
167 }
168
169 FT_DECLARE(ftdm_status_t) ftdm_fsk_demod_destroy(ftdm_fsk_data_state_t *state)
170 {
171 dsp_fsk_destroy(&state->fsk1200_handle);
172 memset(state, 0, sizeof(*state));
173 return FTDM_SUCCESS;
174 }
175
176 FT_DECLARE(int) ftdm_fsk_demod_init(ftdm_fsk_data_state_t *state, int rate, uint8_t *buf, ftdm_size_t bufsize)
177 {
178
179 dsp_fsk_attr_t fsk1200_attr;
180
181 if (state->fsk1200_handle) {
182 dsp_fsk_destroy(&state->fsk1200_handle);
183 }
184
185 memset(state, 0, sizeof(*state));
186 memset(buf, 0, bufsize);
187 state->buf = buf;
188 state->bufsize = bufsize;
189
190 dsp_fsk_attr_init (&fsk1200_attr);
191 dsp_fsk_attr_set_samplerate (&fsk1200_attr, rate);
192 dsp_fsk_attr_set_bytehandler (&fsk1200_attr, fsk_byte_handler, state);
193 state->fsk1200_handle = dsp_fsk_create (&fsk1200_attr);
194
195 if (state->fsk1200_handle == NULL) {
196 return FTDM_FAIL;
197 }
198
199 return FTDM_SUCCESS;
200 }
201
202 FT_DECLARE(ftdm_size_t) ftdm_fsk_modulator_generate_bit(ftdm_fsk_modulator_t *fsk_trans, int8_t bit, int16_t *buf, ftdm_size_t buflen)
203 {
204 ftdm_size_t i;
205
206 for(i = 0 ; i < buflen; i++) {
207 fsk_trans->bit_accum += fsk_trans->bit_factor;
208 if (fsk_trans->bit_accum >= FTDM_FSK_MOD_FACTOR) {
209 fsk_trans->bit_accum -= (FTDM_FSK_MOD_FACTOR + fsk_trans->bit_factor);
210 break;
211 }
212
213 buf[i] = teletone_dds_state_modulate_sample(&fsk_trans->dds, bit);
214 }
215
216 return i;
217 }
218
219
220 FT_DECLARE(int32_t) ftdm_fsk_modulator_generate_carrier_bits(ftdm_fsk_modulator_t *fsk_trans, uint32_t bits)
221 {
222 uint32_t i = 0;
223 ftdm_size_t r = 0;
224 int8_t bit = 1;
225
226 for (i = 0; i < bits; i++) {
227 if ((r = ftdm_fsk_modulator_generate_bit(fsk_trans, bit, fsk_trans->sample_buffer, sizeof(fsk_trans->sample_buffer) / 2))) {
228 if (fsk_trans->write_sample_callback(fsk_trans->sample_buffer, r, fsk_trans->user_data) != FTDM_SUCCESS) {
229 break;
230 }
231 } else {
232 break;
233 }
234 }
235
236 return i;
237 }
238
239
240 FT_DECLARE(void) ftdm_fsk_modulator_generate_chan_sieze(ftdm_fsk_modulator_t *fsk_trans)
241 {
242 uint32_t i = 0;
243 ftdm_size_t r = 0;
244 int8_t bit = 0;
245
246 for (i = 0; i < fsk_trans->chan_sieze_bits; i++) {
247 if ((r = ftdm_fsk_modulator_generate_bit(fsk_trans, bit, fsk_trans->sample_buffer, sizeof(fsk_trans->sample_buffer) / 2))) {
248 if (fsk_trans->write_sample_callback(fsk_trans->sample_buffer, r, fsk_trans->user_data) != FTDM_SUCCESS) {
249 break;
250 }
251 } else {
252 break;
253 }
254 bit = !bit;
255 }
256
257
258 }
259
260
261 FT_DECLARE(void) ftdm_fsk_modulator_send_data(ftdm_fsk_modulator_t *fsk_trans)
262 {
263 ftdm_size_t r = 0;
264 int8_t bit = 0;
265
266 while((bit = ftdm_bitstream_get_bit(&fsk_trans->bs)) > -1) {
267 if ((r = ftdm_fsk_modulator_generate_bit(fsk_trans, bit, fsk_trans->sample_buffer, sizeof(fsk_trans->sample_buffer) / 2))) {
268 if (fsk_trans->write_sample_callback(fsk_trans->sample_buffer, r, fsk_trans->user_data) != FTDM_SUCCESS) {
269 break;
270 }
271 } else {
272 break;
273 }
274 }
275 }
276
277
278 FT_DECLARE(ftdm_status_t) ftdm_fsk_modulator_init(ftdm_fsk_modulator_t *fsk_trans,
279 fsk_modem_types_t modem_type,
280 uint32_t sample_rate,
281 ftdm_fsk_data_state_t *fsk_data,
282 float db_level,
283 uint32_t carrier_bits_start,
284 uint32_t carrier_bits_stop,
285 uint32_t chan_sieze_bits,
286 ftdm_fsk_write_sample_t write_sample_callback,
287 void *user_data)
288 {
289 memset(fsk_trans, 0, sizeof(*fsk_trans));
290 fsk_trans->modem_type = modem_type;
291 teletone_dds_state_set_tone(&fsk_trans->dds, fsk_modem_definitions[fsk_trans->modem_type].freq_space, sample_rate, 0);
292 teletone_dds_state_set_tone(&fsk_trans->dds, fsk_modem_definitions[fsk_trans->modem_type].freq_mark, sample_rate, 1);
293 fsk_trans->bit_factor = (uint32_t)((fsk_modem_definitions[fsk_trans->modem_type].baud_rate * FTDM_FSK_MOD_FACTOR) / (float)sample_rate);
294 fsk_trans->samples_per_bit = (uint32_t) (sample_rate / fsk_modem_definitions[fsk_trans->modem_type].baud_rate);
295 fsk_trans->est_bytes = (int32_t)(((fsk_data->dlen * 10) + carrier_bits_start + carrier_bits_stop + chan_sieze_bits) * ((fsk_trans->samples_per_bit + 1) * 2));
296 fsk_trans->bit_accum = 0;
297 fsk_trans->fsk_data = fsk_data;
298 teletone_dds_state_set_tx_level(&fsk_trans->dds, db_level);
299 ftdm_bitstream_init(&fsk_trans->bs, fsk_trans->fsk_data->buf, (uint32_t)fsk_trans->fsk_data->dlen, FTDM_ENDIAN_BIG, 1);
300 fsk_trans->carrier_bits_start = carrier_bits_start;
301 fsk_trans->carrier_bits_stop = carrier_bits_stop;
302 fsk_trans->chan_sieze_bits = chan_sieze_bits;
303 fsk_trans->write_sample_callback = write_sample_callback;
304 fsk_trans->user_data = user_data;
305 return FTDM_SUCCESS;
306 }
307