Implementation of NMT (Nordic Mobile Telephoe) network
This commit is contained in:
parent
cbfc818cce
commit
57caa536cf
|
@ -22,3 +22,4 @@ m4
|
||||||
src/common/libcommon.a
|
src/common/libcommon.a
|
||||||
src/anetz/anetz
|
src/anetz/anetz
|
||||||
src/bnetz/bnetz
|
src/bnetz/bnetz
|
||||||
|
src/nmt/nmt
|
||||||
|
|
|
@ -30,6 +30,7 @@ AC_OUTPUT(
|
||||||
src/common/Makefile
|
src/common/Makefile
|
||||||
src/anetz/Makefile
|
src/anetz/Makefile
|
||||||
src/bnetz/Makefile
|
src/bnetz/Makefile
|
||||||
|
src/nmt/Makefile
|
||||||
src/Makefile
|
src/Makefile
|
||||||
Makefile)
|
Makefile)
|
||||||
|
|
||||||
|
|
|
@ -1,3 +1,3 @@
|
||||||
AUTOMAKE_OPTIONS = foreign
|
AUTOMAKE_OPTIONS = foreign
|
||||||
SUBDIRS = common anetz bnetz
|
SUBDIRS = common anetz bnetz nmt
|
||||||
|
|
||||||
|
|
|
@ -39,6 +39,8 @@ struct debug_cat {
|
||||||
{ "audio", "\033[0;31m" },
|
{ "audio", "\033[0;31m" },
|
||||||
{ "anetz", "\033[1;34m" },
|
{ "anetz", "\033[1;34m" },
|
||||||
{ "bnetz", "\033[1;34m" },
|
{ "bnetz", "\033[1;34m" },
|
||||||
|
{ "nmt", "\033[1;34m" },
|
||||||
|
{ "frame", "\033[0;36m" },
|
||||||
{ "call", "\033[1;37m" },
|
{ "call", "\033[1;37m" },
|
||||||
{ "mncc", "\033[1;32m" },
|
{ "mncc", "\033[1;32m" },
|
||||||
};
|
};
|
||||||
|
|
|
@ -10,8 +10,10 @@
|
||||||
#define DAUDIO 3
|
#define DAUDIO 3
|
||||||
#define DANETZ 4
|
#define DANETZ 4
|
||||||
#define DBNETZ 5
|
#define DBNETZ 5
|
||||||
#define DCALL 6
|
#define DNMT 6
|
||||||
#define DMNCC 7
|
#define DFRAME 7
|
||||||
|
#define DCALL 8
|
||||||
|
#define DMNCC 9
|
||||||
|
|
||||||
#define PDEBUG(cat, level, fmt, arg...) _printdebug(__FILE__, __FUNCTION__, __LINE__, cat, level, fmt, ## arg)
|
#define PDEBUG(cat, level, fmt, arg...) _printdebug(__FILE__, __FUNCTION__, __LINE__, cat, level, fmt, ## arg)
|
||||||
void _printdebug(const char *file, const char *function, int line, int cat, int level, const char *fmt, ...);
|
void _printdebug(const char *file, const char *function, int line, int cat, int level, const char *fmt, ...);
|
||||||
|
|
|
@ -0,0 +1,19 @@
|
||||||
|
AM_CPPFLAGS = -Wall -g $(all_includes)
|
||||||
|
|
||||||
|
bin_PROGRAMS = \
|
||||||
|
nmt
|
||||||
|
|
||||||
|
nmt_SOURCES = \
|
||||||
|
nmt.c \
|
||||||
|
dsp.c \
|
||||||
|
frame.c \
|
||||||
|
image.c \
|
||||||
|
tones.c \
|
||||||
|
announcement.c \
|
||||||
|
main.c
|
||||||
|
nmt_LDADD = \
|
||||||
|
$(COMMON_LA) \
|
||||||
|
$(ALSA_LIBS) \
|
||||||
|
$(top_builddir)/src/common/libcommon.a \
|
||||||
|
-lm
|
||||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,3 @@
|
||||||
|
|
||||||
|
void init_announcement(void);
|
||||||
|
|
|
@ -0,0 +1,596 @@
|
||||||
|
/* NMT audio processing
|
||||||
|
*
|
||||||
|
* (C) 2016 by Andreas Eversberg <jolly@eversberg.eu>
|
||||||
|
* All Rights Reserved
|
||||||
|
*
|
||||||
|
* This program is free software: you can redistribute it and/or modify
|
||||||
|
* it under the terms of the GNU General Public License as published by
|
||||||
|
* the Free Software Foundation, either version 3 of the License, or
|
||||||
|
* (at your option) any later version.
|
||||||
|
*
|
||||||
|
* This program is distributed in the hope that it will be useful,
|
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
* GNU General Public License for more details.
|
||||||
|
*
|
||||||
|
* You should have received a copy of the GNU General Public License
|
||||||
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <stdint.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <string.h>
|
||||||
|
#include <errno.h>
|
||||||
|
#include <math.h>
|
||||||
|
#include "../common/debug.h"
|
||||||
|
#include "../common/timer.h"
|
||||||
|
#include "../common/call.h"
|
||||||
|
#include "../common/goertzel.h"
|
||||||
|
#include "nmt.h"
|
||||||
|
#include "dsp.h"
|
||||||
|
|
||||||
|
#define PI M_PI
|
||||||
|
|
||||||
|
/* signalling */
|
||||||
|
#define TX_PEAK_FSK 16384 /* peak amplitude of signalling FSK */
|
||||||
|
#define TX_PEAK_SUPER 1638 /* peak amplitude of supervisory signal */
|
||||||
|
#define BIT_RATE 1200 /* baud rate */
|
||||||
|
#define STEPS_PER_BIT 10 /* step every 1/12000 sec */
|
||||||
|
#define DIALTONE_HZ 425.0 /* dial tone frequency */
|
||||||
|
#define TX_PEAK_DIALTONE 16000 /* dial tone peak */
|
||||||
|
#define SUPER_DURATION 0.25 /* duration of supervisory signal measurement */
|
||||||
|
#define SUPER_DETECT_COUNT 4 /* number of measures to detect supervisory signal */
|
||||||
|
#define MUTE_DURATION 0.280 /* a tiny bit more than two frames */
|
||||||
|
|
||||||
|
/* two signalling tones */
|
||||||
|
static double fsk_bits[2] = {
|
||||||
|
1800.0,
|
||||||
|
1200.0,
|
||||||
|
};
|
||||||
|
|
||||||
|
/* two supervisory tones */
|
||||||
|
static double super_freq[5] = {
|
||||||
|
3955.0, /* 0-Signal 1 */
|
||||||
|
3985.0, /* 0-Signal 2 */
|
||||||
|
4015.0, /* 0-Signal 3 */
|
||||||
|
4045.0, /* 0-Signal 4 */
|
||||||
|
3900.0, /* noise level to check against */
|
||||||
|
};
|
||||||
|
|
||||||
|
/* table for fast sine generation */
|
||||||
|
int dsp_sine_super[256];
|
||||||
|
int dsp_sine_dialtone[256];
|
||||||
|
|
||||||
|
/* global init for FSK */
|
||||||
|
void dsp_init(void)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
double s;
|
||||||
|
|
||||||
|
PDEBUG(DFSK, DEBUG_DEBUG, "Generating sine table for supervisory signal.\n");
|
||||||
|
for (i = 0; i < 256; i++) {
|
||||||
|
s = sin((double)i / 256.0 * 2.0 * PI);
|
||||||
|
dsp_sine_super[i] = (int)(s * TX_PEAK_SUPER);
|
||||||
|
dsp_sine_dialtone[i] = (int)(s * TX_PEAK_DIALTONE);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Init FSK of transceiver */
|
||||||
|
int dsp_init_sender(nmt_t *nmt)
|
||||||
|
{
|
||||||
|
double coeff;
|
||||||
|
int16_t *spl;
|
||||||
|
int i;
|
||||||
|
|
||||||
|
init_compander(&nmt->cstate, 8000, 3.0, 13.5);
|
||||||
|
|
||||||
|
if ((nmt->sender.samplerate % (BIT_RATE * STEPS_PER_BIT))) {
|
||||||
|
PDEBUG(DFSK, DEBUG_ERROR, "Sample rate must be a multiple of %d bits per second.\n", BIT_RATE * STEPS_PER_BIT);
|
||||||
|
return -EINVAL;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* this should not happen. it is implied by previous check */
|
||||||
|
if (nmt->supervisory && nmt->sender.samplerate < 12000) {
|
||||||
|
PDEBUG(DFSK, DEBUG_ERROR, "Sample rate must be at least 12000 Hz to process supervisory signal.\n");
|
||||||
|
return -EINVAL;
|
||||||
|
}
|
||||||
|
|
||||||
|
PDEBUG(DFSK, DEBUG_DEBUG, "Init DSP for Transceiver.\n");
|
||||||
|
|
||||||
|
/* allocate sample for 2 bits with 2 polarities */
|
||||||
|
nmt->samples_per_bit = nmt->sender.samplerate / BIT_RATE;
|
||||||
|
PDEBUG(DFSK, DEBUG_DEBUG, "Using %d samples per bit duration.\n", nmt->samples_per_bit);
|
||||||
|
nmt->fsk_filter_step = nmt->samples_per_bit / STEPS_PER_BIT;
|
||||||
|
PDEBUG(DFSK, DEBUG_DEBUG, "Using %d samples per filter step.\n", nmt->fsk_filter_step);
|
||||||
|
nmt->fsk_sine[0][0] = calloc(4, nmt->samples_per_bit * sizeof(int16_t));
|
||||||
|
nmt->fsk_sine[0][1] = nmt->fsk_sine[0][0] + nmt->samples_per_bit;
|
||||||
|
nmt->fsk_sine[1][0] = nmt->fsk_sine[0][1] + nmt->samples_per_bit;
|
||||||
|
nmt->fsk_sine[1][1] = nmt->fsk_sine[1][0] + nmt->samples_per_bit;
|
||||||
|
if (!nmt->fsk_sine[0][0]) {
|
||||||
|
PDEBUG(DFSK, DEBUG_ERROR, "No memory!\n");
|
||||||
|
return -ENOMEM;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* generate sines */
|
||||||
|
for (i = 0; i < nmt->samples_per_bit; i++) {
|
||||||
|
nmt->fsk_sine[0][0][i] = TX_PEAK_FSK * sin(3.0 * PI * (double)i / (double)nmt->samples_per_bit); /* 1.5 waves */
|
||||||
|
nmt->fsk_sine[0][1][i] = TX_PEAK_FSK * sin(2.0 * PI * (double)i / (double)nmt->samples_per_bit); /* 1 wave */
|
||||||
|
nmt->fsk_sine[1][0][i] = -nmt->fsk_sine[0][0][i];
|
||||||
|
nmt->fsk_sine[1][1][i] = -nmt->fsk_sine[0][1][i];
|
||||||
|
}
|
||||||
|
|
||||||
|
/* allocate ring buffers, one bit duration */
|
||||||
|
spl = calloc(1, nmt->samples_per_bit * sizeof(*spl));
|
||||||
|
if (!spl) {
|
||||||
|
PDEBUG(DFSK, DEBUG_ERROR, "No memory!\n");
|
||||||
|
return -ENOMEM;
|
||||||
|
}
|
||||||
|
nmt->fsk_filter_spl = spl;
|
||||||
|
nmt->fsk_filter_bit = -1;
|
||||||
|
|
||||||
|
/* allocate transmit buffer for a complete frame */
|
||||||
|
spl = calloc(166, nmt->samples_per_bit * sizeof(*spl));
|
||||||
|
if (!spl) {
|
||||||
|
PDEBUG(DFSK, DEBUG_ERROR, "No memory!\n");
|
||||||
|
return -ENOMEM;
|
||||||
|
}
|
||||||
|
nmt->frame_spl = spl;
|
||||||
|
|
||||||
|
/* allocate ring buffer for supervisory signal detection */
|
||||||
|
nmt->super_samples = (int)((double)nmt->sender.samplerate * SUPER_DURATION + 0.5);
|
||||||
|
spl = calloc(166, nmt->super_samples * sizeof(*spl));
|
||||||
|
if (!spl) {
|
||||||
|
PDEBUG(DFSK, DEBUG_ERROR, "No memory!\n");
|
||||||
|
return -ENOMEM;
|
||||||
|
}
|
||||||
|
nmt->super_filter_spl = spl;
|
||||||
|
|
||||||
|
/* count symbols */
|
||||||
|
for (i = 0; i < 2; i++) {
|
||||||
|
coeff = 2.0 * cos(2.0 * PI * fsk_bits[i] / (double)nmt->sender.samplerate);
|
||||||
|
nmt->fsk_coeff[i] = coeff * 32768.0;
|
||||||
|
PDEBUG(DFSK, DEBUG_DEBUG, "coeff[%d] = %d\n", i, (int)nmt->fsk_coeff[i]);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* count supervidory tones */
|
||||||
|
for (i = 0; i < 5; i++) {
|
||||||
|
coeff = 2.0 * cos(2.0 * PI * super_freq[i] / (double)nmt->sender.samplerate);
|
||||||
|
nmt->super_coeff[i] = coeff * 32768.0;
|
||||||
|
PDEBUG(DFSK, DEBUG_DEBUG, "supervisory coeff[%d] = %d\n", i, (int)nmt->super_coeff[i]);
|
||||||
|
|
||||||
|
if (i < 4) {
|
||||||
|
nmt->super_phaseshift256[i] = 256.0 / ((double)nmt->sender.samplerate / super_freq[i]);
|
||||||
|
PDEBUG(DFSK, DEBUG_DEBUG, "phaseshift_super[%d] = %.4f\n", i, nmt->super_phaseshift256[i]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
super_reset(nmt);
|
||||||
|
|
||||||
|
/* dial tone */
|
||||||
|
nmt->dial_phaseshift256 = 256.0 / ((double)nmt->sender.samplerate / DIALTONE_HZ);
|
||||||
|
|
||||||
|
/* dtmf */
|
||||||
|
dtmf_init(&nmt->dtmf, 8000);
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Cleanup transceiver instance. */
|
||||||
|
void dsp_cleanup_sender(nmt_t *nmt)
|
||||||
|
{
|
||||||
|
PDEBUG(DFSK, DEBUG_DEBUG, "Cleanup DSP for 'Sender'.\n");
|
||||||
|
|
||||||
|
if (nmt->frame_spl) {
|
||||||
|
free(nmt->frame_spl);
|
||||||
|
nmt->frame_spl = NULL;
|
||||||
|
}
|
||||||
|
if (nmt->fsk_filter_spl) {
|
||||||
|
free(nmt->fsk_filter_spl);
|
||||||
|
nmt->fsk_filter_spl = NULL;
|
||||||
|
}
|
||||||
|
if (nmt->super_filter_spl) {
|
||||||
|
free(nmt->super_filter_spl);
|
||||||
|
nmt->super_filter_spl = NULL;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Check for SYNC bits, then collect data bits */
|
||||||
|
static void fsk_receive_bit(nmt_t *nmt, int bit, double quality, double level)
|
||||||
|
{
|
||||||
|
double frames_elapsed;
|
||||||
|
|
||||||
|
// printf("bit=%d quality=%.4f\n", bit, quality);
|
||||||
|
if (!nmt->fsk_filter_in_sync) {
|
||||||
|
nmt->fsk_filter_sync = (nmt->fsk_filter_sync << 1) | bit;
|
||||||
|
|
||||||
|
/* check if pattern 1010111100010010 matches */
|
||||||
|
if (nmt->fsk_filter_sync != 0xaf12)
|
||||||
|
return;
|
||||||
|
// printf("sync\n");
|
||||||
|
|
||||||
|
/* sync time */
|
||||||
|
nmt->rx_sample_count_last = nmt->rx_sample_count_current;
|
||||||
|
nmt->rx_sample_count_current = nmt->rx_sample_count - nmt->samples_per_bit * 26;
|
||||||
|
|
||||||
|
/* rest sync register */
|
||||||
|
nmt->fsk_filter_sync = 0;
|
||||||
|
nmt->fsk_filter_in_sync = 1;
|
||||||
|
nmt->fsk_filter_count = 0;
|
||||||
|
nmt->fsk_filter_levelsum = 0;
|
||||||
|
nmt->fsk_filter_qualitysum = 0;
|
||||||
|
|
||||||
|
/* set muting of receive path */
|
||||||
|
nmt->fsk_filter_mute = (int)((double)nmt->sender.samplerate * MUTE_DURATION);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* read bits */
|
||||||
|
nmt->fsk_filter_frame[nmt->fsk_filter_count++] = bit + '0';
|
||||||
|
nmt->fsk_filter_levelsum += level;
|
||||||
|
nmt->fsk_filter_qualitysum += quality;
|
||||||
|
if (nmt->fsk_filter_count != 140)
|
||||||
|
return;
|
||||||
|
|
||||||
|
/* end of frame */
|
||||||
|
nmt->fsk_filter_frame[140] = '\0';
|
||||||
|
nmt->fsk_filter_in_sync = 0;
|
||||||
|
|
||||||
|
/* send telegramm */
|
||||||
|
frames_elapsed = (double)(nmt->rx_sample_count_current - nmt->rx_sample_count_last) / (double)(nmt->samples_per_bit * 166);
|
||||||
|
nmt_receive_frame(nmt, nmt->fsk_filter_frame, nmt->fsk_filter_qualitysum / 140.0, nmt->fsk_filter_levelsum / 140.0, frames_elapsed);
|
||||||
|
}
|
||||||
|
|
||||||
|
char *show_level(int value)
|
||||||
|
{
|
||||||
|
static char text[22];
|
||||||
|
|
||||||
|
value /= 5;
|
||||||
|
if (value < 0)
|
||||||
|
value = 0;
|
||||||
|
if (value > 20)
|
||||||
|
value = 20;
|
||||||
|
strcpy(text, " ");
|
||||||
|
text[value] = '*';
|
||||||
|
|
||||||
|
return text;
|
||||||
|
}
|
||||||
|
|
||||||
|
//#define DEBUG_MODULATOR
|
||||||
|
//#define DEBUG_FILTER
|
||||||
|
//#define DEBUG_QUALITY
|
||||||
|
|
||||||
|
/* Filter one chunk of audio an detect tone, quality and loss of signal.
|
||||||
|
* The chunk is a window of 10ms. This window slides over audio stream
|
||||||
|
* and is processed every 1ms. (one step) */
|
||||||
|
static inline void fsk_decode_step(nmt_t *nmt, int pos)
|
||||||
|
{
|
||||||
|
double level, result[2], softbit, quality;
|
||||||
|
int max;
|
||||||
|
int16_t *spl;
|
||||||
|
int bit;
|
||||||
|
|
||||||
|
max = nmt->samples_per_bit;
|
||||||
|
spl = nmt->fsk_filter_spl;
|
||||||
|
|
||||||
|
/* count time in samples*/
|
||||||
|
nmt->rx_sample_count += nmt->fsk_filter_step;
|
||||||
|
|
||||||
|
level = audio_level(spl, max);
|
||||||
|
// level = 0.63662 / 2.0;
|
||||||
|
|
||||||
|
audio_goertzel(spl, max, pos, nmt->fsk_coeff, result, 2);
|
||||||
|
|
||||||
|
/* calculate soft bit from both frequencies */
|
||||||
|
softbit = (result[1] / level - result[0] / level + 1.0) / 2.0;
|
||||||
|
/* scale it, since both filters overlap by some percent */
|
||||||
|
#define MIN_QUALITY 0.33
|
||||||
|
softbit = (softbit - MIN_QUALITY) / (1.0 - MIN_QUALITY - MIN_QUALITY);
|
||||||
|
if (softbit > 1)
|
||||||
|
softbit = 1;
|
||||||
|
if (softbit < 0)
|
||||||
|
softbit = 0;
|
||||||
|
#ifdef DEBUG_FILTER
|
||||||
|
// printf("|%s", show_level(result[0]/level*100));
|
||||||
|
// printf("|%s| low=%.3f high=%.3f level=%d\n", show_level(result[1]/level*100), result[0]/level, result[1]/level, (int)level);
|
||||||
|
printf("|%s| softbit=%.3f\n", show_level(softbit * 100), softbit);
|
||||||
|
#endif
|
||||||
|
if (softbit > 0.5)
|
||||||
|
bit = 1;
|
||||||
|
else
|
||||||
|
bit = 0;
|
||||||
|
|
||||||
|
if (nmt->fsk_filter_bit != bit) {
|
||||||
|
#ifdef DEBUG_FILTER
|
||||||
|
puts("bit change");
|
||||||
|
#endif
|
||||||
|
/* if we have a bit change, reset sample counter to one half bit duration */
|
||||||
|
nmt->fsk_filter_bit = bit;
|
||||||
|
nmt->fsk_filter_sample = 5;
|
||||||
|
} else if (--nmt->fsk_filter_sample == 0) {
|
||||||
|
#ifdef DEBUG_FILTER
|
||||||
|
puts("sample");
|
||||||
|
#endif
|
||||||
|
/* if sample counter bit reaches 0, we reset sample counter to one bit duration */
|
||||||
|
// quality = result[bit] / level;
|
||||||
|
if (softbit > 0.5)
|
||||||
|
quality = softbit * 2.0 - 1.0;
|
||||||
|
else
|
||||||
|
quality = 1.0 - softbit * 2.0;
|
||||||
|
#ifdef DEBUG_QUALITY
|
||||||
|
printf("|%s| quality=%.2f ", show_level(softbit * 100), quality);
|
||||||
|
printf("|%s|\n", show_level(quality * 100));
|
||||||
|
#endif
|
||||||
|
/* adjust level, so a peak level becomes 100% */
|
||||||
|
fsk_receive_bit(nmt, bit, quality, level / 0.63662);
|
||||||
|
nmt->fsk_filter_sample = 10;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* compare supervisory signal against noise floor on 3900 Hz */
|
||||||
|
static void super_decode(nmt_t *nmt, int16_t *samples, int length)
|
||||||
|
{
|
||||||
|
int coeff[2];
|
||||||
|
double result[2], quality;
|
||||||
|
|
||||||
|
coeff[0] = nmt->super_coeff[nmt->supervisory - 1];
|
||||||
|
coeff[1] = nmt->super_coeff[4]; /* noise floor detection */
|
||||||
|
audio_goertzel(samples, length, 0, coeff, result, 2);
|
||||||
|
|
||||||
|
#if 0
|
||||||
|
/* normalize levels */
|
||||||
|
result[0] *= 32768.0 / (double)TX_PEAK_SUPER / 0.63662;
|
||||||
|
result[1] *= 32768.0 / (double)TX_PEAK_SUPER / 0.63662;
|
||||||
|
printf("signal=%.4f noise=%.4f\n", result[0], result[1]);
|
||||||
|
#endif
|
||||||
|
|
||||||
|
quality = (result[0] - result[1]) / result[0];
|
||||||
|
if (quality < 0)
|
||||||
|
quality = 0;
|
||||||
|
|
||||||
|
if (nmt->sender.loopback)
|
||||||
|
PDEBUG(DFSK, DEBUG_NOTICE, "Supervisory level %.2f%% quality %.0f%%\n", result[0] / 0.63662 * 100.0, quality * 100.0);
|
||||||
|
if (quality > 0.5) {
|
||||||
|
if (nmt->super_detected == 0) {
|
||||||
|
nmt->super_detect_count++;
|
||||||
|
if (nmt->super_detect_count == SUPER_DETECT_COUNT) {
|
||||||
|
nmt->super_detected = 1;
|
||||||
|
nmt->super_detect_count = 0;
|
||||||
|
PDEBUG(DFSK, DEBUG_DEBUG, "Supervisory signal detected with level=%.0f%%, quality=%.0f%%.\n", result[0] / 0.63662 * 100.0, quality * 100.0);
|
||||||
|
nmt_rx_super(nmt, 1, quality);
|
||||||
|
}
|
||||||
|
} else
|
||||||
|
nmt->super_detect_count = 0;
|
||||||
|
} else {
|
||||||
|
if (nmt->super_detected == 1) {
|
||||||
|
nmt->super_detect_count++;
|
||||||
|
if (nmt->super_detect_count == SUPER_DETECT_COUNT) {
|
||||||
|
nmt->super_detected = 0;
|
||||||
|
nmt->super_detect_count = 0;
|
||||||
|
PDEBUG(DFSK, DEBUG_DEBUG, "Supervisory signal lost.\n");
|
||||||
|
nmt_rx_super(nmt, 0, 0.0);
|
||||||
|
}
|
||||||
|
} else
|
||||||
|
nmt->super_detect_count = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Reset supervisory detection states, so ongoing tone will be detected again. */
|
||||||
|
void super_reset(nmt_t *nmt)
|
||||||
|
{
|
||||||
|
PDEBUG(DFSK, DEBUG_DEBUG, "Supervisory detector reset.\n");
|
||||||
|
nmt->super_detected = 0;
|
||||||
|
nmt->super_detect_count = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Process received audio stream from radio unit. */
|
||||||
|
void sender_receive(sender_t *sender, int16_t *samples, int length)
|
||||||
|
{
|
||||||
|
nmt_t *nmt = (nmt_t *) sender;
|
||||||
|
int16_t *spl;
|
||||||
|
int max, pos, step;
|
||||||
|
int i;
|
||||||
|
|
||||||
|
/* write received samples to decode buffer */
|
||||||
|
max = nmt->super_samples;
|
||||||
|
spl = nmt->super_filter_spl;
|
||||||
|
pos = nmt->super_filter_pos;
|
||||||
|
for (i = 0; i < length; i++) {
|
||||||
|
spl[pos++] = samples[i];
|
||||||
|
if (pos == max) {
|
||||||
|
pos = 0;
|
||||||
|
if (nmt->supervisory)
|
||||||
|
super_decode(nmt, spl, max);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
nmt->super_filter_pos = pos;
|
||||||
|
|
||||||
|
/* write received samples to decode buffer */
|
||||||
|
max = nmt->samples_per_bit;
|
||||||
|
pos = nmt->fsk_filter_pos;
|
||||||
|
step = nmt->fsk_filter_step;
|
||||||
|
spl = nmt->fsk_filter_spl;
|
||||||
|
for (i = 0; i < length; i++) {
|
||||||
|
#ifdef DEBUG_MODULATOR
|
||||||
|
printf("|%s|\n", show_level((int)((samples[i] / (double)TX_PEAK_FSK) * 50)+50));
|
||||||
|
#endif
|
||||||
|
spl[pos++] = samples[i];
|
||||||
|
if (nmt->fsk_filter_mute) {
|
||||||
|
samples[i] = 0;
|
||||||
|
nmt->fsk_filter_mute--;
|
||||||
|
}
|
||||||
|
if (pos == max)
|
||||||
|
pos = 0;
|
||||||
|
/* if filter step has been reched */
|
||||||
|
if (!(pos % step)) {
|
||||||
|
fsk_decode_step(nmt, pos);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
nmt->fsk_filter_pos = pos;
|
||||||
|
|
||||||
|
if ((nmt->dsp_mode == DSP_MODE_AUDIO || nmt->dsp_mode == DSP_MODE_DTMF)
|
||||||
|
&& nmt->sender.callref) {
|
||||||
|
int16_t down[length]; /* more than enough */
|
||||||
|
int count;
|
||||||
|
|
||||||
|
count = samplerate_downsample(&nmt->sender.srstate, samples, length, down);
|
||||||
|
if (nmt->compander)
|
||||||
|
expand_audio(&nmt->cstate, down, count);
|
||||||
|
if (nmt->dsp_mode == DSP_MODE_DTMF)
|
||||||
|
dtmf_tone(&nmt->dtmf, down, count);
|
||||||
|
spl = nmt->sender.rxbuf;
|
||||||
|
pos = nmt->sender.rxbuf_pos;
|
||||||
|
for (i = 0; i < count; i++) {
|
||||||
|
spl[pos++] = down[i];
|
||||||
|
if (pos == 160) {
|
||||||
|
call_tx_audio(nmt->sender.callref, spl, 160);
|
||||||
|
pos = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
nmt->sender.rxbuf_pos = pos;
|
||||||
|
} else
|
||||||
|
nmt->sender.rxbuf_pos = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int fsk_frame(nmt_t *nmt, int16_t *samples, int length)
|
||||||
|
{
|
||||||
|
int16_t *spl;
|
||||||
|
const char *frame;
|
||||||
|
int i;
|
||||||
|
int bit, polarity;
|
||||||
|
int count, max;
|
||||||
|
|
||||||
|
next_frame:
|
||||||
|
if (!nmt->frame) {
|
||||||
|
/* request frame */
|
||||||
|
frame = nmt_get_frame(nmt);
|
||||||
|
if (!frame) {
|
||||||
|
PDEBUG(DFSK, DEBUG_DEBUG, "Stop sending frames.\n");
|
||||||
|
return length;
|
||||||
|
}
|
||||||
|
nmt->frame = 1;
|
||||||
|
nmt->frame_pos = 0;
|
||||||
|
spl = nmt->frame_spl;
|
||||||
|
/* render frame */
|
||||||
|
polarity = nmt->fsk_polarity;
|
||||||
|
for (i = 0; i < 166; i++) {
|
||||||
|
bit = (frame[i] == '1');
|
||||||
|
memcpy(spl, nmt->fsk_sine[polarity][bit], nmt->samples_per_bit * sizeof(*spl));
|
||||||
|
spl += nmt->samples_per_bit;
|
||||||
|
/* flip polarity when we have 1.5 sine waves */
|
||||||
|
if (bit == 0)
|
||||||
|
polarity = 1 - polarity;
|
||||||
|
}
|
||||||
|
nmt->fsk_polarity = polarity;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* send audio from frame */
|
||||||
|
max = nmt->samples_per_bit * 166;
|
||||||
|
count = max - nmt->frame_pos;
|
||||||
|
if (count > length)
|
||||||
|
count = length;
|
||||||
|
spl = nmt->frame_spl + nmt->frame_pos;
|
||||||
|
for (i = 0; i < count; i++) {
|
||||||
|
*samples++ = *spl++;
|
||||||
|
}
|
||||||
|
length -= count;
|
||||||
|
nmt->frame_pos += count;
|
||||||
|
/* check for end of telegramm */
|
||||||
|
if (nmt->frame_pos == max) {
|
||||||
|
nmt->frame = 0;
|
||||||
|
/* we need more ? */
|
||||||
|
if (length)
|
||||||
|
goto next_frame;
|
||||||
|
}
|
||||||
|
|
||||||
|
return length;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Generate audio stream with supervisory signal. Keep phase for next call of function. */
|
||||||
|
static void super_encode(nmt_t *nmt, int16_t *samples, int length)
|
||||||
|
{
|
||||||
|
double phaseshift, phase;
|
||||||
|
int32_t sample;
|
||||||
|
int i;
|
||||||
|
|
||||||
|
phaseshift = nmt->super_phaseshift256[nmt->supervisory - 1];
|
||||||
|
phase = nmt->super_phase256;
|
||||||
|
|
||||||
|
for (i = 0; i < length; i++) {
|
||||||
|
sample = *samples;
|
||||||
|
sample += dsp_sine_super[((uint8_t)phase) & 0xff];
|
||||||
|
if (sample > 32767)
|
||||||
|
sample = 32767;
|
||||||
|
else if (sample < -32767)
|
||||||
|
sample = -32767;
|
||||||
|
*samples++ = sample;
|
||||||
|
phase += phaseshift;
|
||||||
|
if (phase >= 256)
|
||||||
|
phase -= 256;
|
||||||
|
}
|
||||||
|
|
||||||
|
nmt->super_phase256 = phase;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Generate audio stream from dial tone. Keep phase for next call of function. */
|
||||||
|
static void dial_tone(nmt_t *nmt, int16_t *samples, int length)
|
||||||
|
{
|
||||||
|
double phaseshift, phase;
|
||||||
|
int i;
|
||||||
|
|
||||||
|
phaseshift = nmt->dial_phaseshift256;
|
||||||
|
phase = nmt->dial_phase256;
|
||||||
|
|
||||||
|
for (i = 0; i < length; i++) {
|
||||||
|
*samples++ = dsp_sine_dialtone[((uint8_t)phase) & 0xff];
|
||||||
|
phase += phaseshift;
|
||||||
|
if (phase >= 256)
|
||||||
|
phase -= 256;
|
||||||
|
}
|
||||||
|
|
||||||
|
nmt->dial_phase256 = phase;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Provide stream of audio toward radio unit */
|
||||||
|
void sender_send(sender_t *sender, int16_t *samples, int length)
|
||||||
|
{
|
||||||
|
nmt_t *nmt = (nmt_t *) sender;
|
||||||
|
int len;
|
||||||
|
|
||||||
|
again:
|
||||||
|
switch (nmt->dsp_mode) {
|
||||||
|
case DSP_MODE_AUDIO:
|
||||||
|
case DSP_MODE_DTMF:
|
||||||
|
jitter_load(&nmt->sender.audio, samples, length);
|
||||||
|
if (nmt->supervisory)
|
||||||
|
super_encode(nmt, samples, length);
|
||||||
|
break;
|
||||||
|
case DSP_MODE_DIALTONE:
|
||||||
|
dial_tone(nmt, samples, length);
|
||||||
|
break;
|
||||||
|
case DSP_MODE_SILENCE:
|
||||||
|
memset(samples, 0, length * sizeof(*samples));
|
||||||
|
break;
|
||||||
|
case DSP_MODE_FRAME:
|
||||||
|
/* Encode frame into audio stream. If frames have
|
||||||
|
* stopped, process again for rest of stream. */
|
||||||
|
len = fsk_frame(nmt, samples, length);
|
||||||
|
/* special case: add supervisory signal to frame at loop test */
|
||||||
|
if (nmt->sender.loopback && nmt->supervisory)
|
||||||
|
super_encode(nmt, samples, length);
|
||||||
|
if (len) {
|
||||||
|
samples += length - len;
|
||||||
|
length = len;
|
||||||
|
goto again;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void nmt_set_dsp_mode(nmt_t *nmt, enum dsp_mode mode)
|
||||||
|
{
|
||||||
|
/* reset telegramm */
|
||||||
|
if (mode == DSP_MODE_FRAME && nmt->dsp_mode != mode)
|
||||||
|
nmt->frame = 0;
|
||||||
|
nmt->dsp_mode = mode;
|
||||||
|
}
|
||||||
|
|
|
@ -0,0 +1,7 @@
|
||||||
|
|
||||||
|
void dsp_init(void);
|
||||||
|
int dsp_init_sender(nmt_t *nmt);
|
||||||
|
void dsp_cleanup_sender(nmt_t *nmt);
|
||||||
|
void nmt_set_dsp_mode(nmt_t *nmt, enum dsp_mode mode);
|
||||||
|
void super_reset(nmt_t *nmt);
|
||||||
|
|
|
@ -0,0 +1,977 @@
|
||||||
|
/* NMT frame transcoding
|
||||||
|
*
|
||||||
|
* (C) 2016 by Andreas Eversberg <jolly@eversberg.eu>
|
||||||
|
* All Rights Reserved
|
||||||
|
*
|
||||||
|
* This program is free software: you can redistribute it and/or modify
|
||||||
|
* it under the terms of the GNU General Public License as published by
|
||||||
|
* the Free Software Foundation, either version 3 of the License, or
|
||||||
|
* (at your option) any later version.
|
||||||
|
*
|
||||||
|
* This program is distributed in the hope that it will be useful,
|
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
* GNU General Public License for more details.
|
||||||
|
*
|
||||||
|
* You should have received a copy of the GNU General Public License
|
||||||
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <stdint.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <string.h>
|
||||||
|
#include <inttypes.h>
|
||||||
|
#include "../common/debug.h"
|
||||||
|
#include "../common/timer.h"
|
||||||
|
#include "nmt.h"
|
||||||
|
#include "frame.h"
|
||||||
|
|
||||||
|
uint64_t nmt_encode_channel(int channel, int power)
|
||||||
|
{
|
||||||
|
uint64_t value = 0;
|
||||||
|
|
||||||
|
if (channel >= 200) {
|
||||||
|
value |= 0x800;
|
||||||
|
channel -= 200;
|
||||||
|
}
|
||||||
|
if (channel >= 100) {
|
||||||
|
value |= 0x100;
|
||||||
|
channel -= 100;
|
||||||
|
}
|
||||||
|
value |= channel;
|
||||||
|
value |= power << 9;
|
||||||
|
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
|
||||||
|
int nmt_decode_channel(uint64_t value, int *channel, int *power)
|
||||||
|
{
|
||||||
|
if ((value & 0xff) > 99)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
*channel = (value & 0xff) +
|
||||||
|
((value & 0x100) >> 8) * 100 +
|
||||||
|
((value & 0x800) >> 11) * 200;
|
||||||
|
*power = (value & 0x600) >> 9;
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
void nmt_value2digits(uint64_t value, char *digits, int num)
|
||||||
|
{
|
||||||
|
int digit, i;
|
||||||
|
|
||||||
|
for (i = 0; i < num; i++) {
|
||||||
|
digit = (value >> ((num - 1 - i) << 2)) & 0xf;
|
||||||
|
if (digit == 10)
|
||||||
|
digits[i] = '0';
|
||||||
|
else if (digit == 0 || digit > 10)
|
||||||
|
digits[i] = '?';
|
||||||
|
else
|
||||||
|
digits[i] = digit + '0';
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
uint64_t nmt_digits2value(const char *digits, int num)
|
||||||
|
{
|
||||||
|
int digit, i;
|
||||||
|
uint64_t value = 0;
|
||||||
|
|
||||||
|
for (i = 0; i < num; i++) {
|
||||||
|
value <<= 4;
|
||||||
|
digit = *digits++;
|
||||||
|
if (digit >= '1' && digit <= '9')
|
||||||
|
value |= digit - '0';
|
||||||
|
else
|
||||||
|
value |= 10;
|
||||||
|
}
|
||||||
|
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
|
||||||
|
char nmt_value2digit(uint64_t value)
|
||||||
|
{
|
||||||
|
return "D1234567890*#ABC"[value & 0x0000f];
|
||||||
|
}
|
||||||
|
|
||||||
|
uint16_t nmt_encode_area_no(uint8_t area_no)
|
||||||
|
{
|
||||||
|
switch (area_no) {
|
||||||
|
case 1:
|
||||||
|
return 0x3f3;
|
||||||
|
case 2:
|
||||||
|
return 0x3f4;
|
||||||
|
case 3:
|
||||||
|
return 0x3f5;
|
||||||
|
case 4:
|
||||||
|
return 0x3f6;
|
||||||
|
default:
|
||||||
|
return 0x000;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* NMT Doc 450-1 4.3.2 */
|
||||||
|
static struct nmt_frame {
|
||||||
|
const char *digits;
|
||||||
|
enum nmt_direction direction;
|
||||||
|
int prefix;
|
||||||
|
const char *nr;
|
||||||
|
const char *description;
|
||||||
|
} nmt_frame[] = {
|
||||||
|
/* Digits Dir. Prefix Nr. Description */
|
||||||
|
/*0*/ { "NNNPYYHHHHHHHHHH", MTX_TO_MS, 12, "1a", "Calling channel indication" },
|
||||||
|
/*1*/ { "NNNPYYHHHHHHHHHH", MTX_TO_MS, 4, "1b", "Combined calling and traffic channel indication" },
|
||||||
|
/*2*/ { "NNNPYYZXXXXXXHHH", MTX_TO_MS, 12, "2a", "Call to mobile subscriber on calling channel" },
|
||||||
|
/*3*/ { "NNNPYYZXXXXXXnnn", MTX_TO_MS, 12, "2b", "Traffic channel allocation on calling channel" },
|
||||||
|
/*4*/ { "NNNPYYZXXXXXXHHH", MTX_TO_MS, 12, "2c", "Queueing information to MS with priority on calling channel" },
|
||||||
|
/*5*/ { "NNNPYYZXXXXXXHHH", MTX_TO_MS, 12, "2d", "Traffic channel scanning order on calling channel" },
|
||||||
|
/*6*/ { "NNNPYYZXXXXXXHHH", MTX_TO_MS, 12, "2f", "Queuing information to ordinary MS" },
|
||||||
|
/*7*/ { "NNNPYYZXXXXXXnnn", MTX_TO_MS, 5, "3a", "Traffic channel allocation on traffic channel" },
|
||||||
|
/*8*/ { "NNNPYYZXXXXXXHHH", MTX_TO_MS, 5, "3b", "Identity request on traffic channel" },
|
||||||
|
/*9*/ { "NNNPYYZXXXXXXnnn", MTX_TO_MS, 9, "3c", "Traffic channel allocation on traffic channel, short procedure" },
|
||||||
|
/*10*/ { "NNNPYYJJJJJJJHHH", MTX_TO_MS, 3, "4", "Free traffic channel indication" },
|
||||||
|
/*11*/ { "NNNPYYZXXXXXXLLL", MTX_TO_MS, 6, "5a", "Line signal" },
|
||||||
|
/*12*/ { "NNNPYYZXXXXXXLQQ", MTX_TO_MS, 6, "5b", "Line signal: Answer to coin-box" },
|
||||||
|
/*13*/ { "JJJPJJJJJJJJJJJJ", MTX_TO_XX, 0, "6", "Idle frame" },
|
||||||
|
/*14*/ { "NNNPYYCCCCCCCJJJ", MTX_TO_MS, 8, "7", "Authentication request" },
|
||||||
|
/*15*/ { "NNNPZXXXXXXTJJJJ", MS_TO_MTX, 1, "10a", "Call acknowledgement from MS on calling channel (shortened frame)" },
|
||||||
|
/*16*/ { "NNNPZXXXXXXTYKKK", MS_TO_MTX, 1, "10b", "Seizure from ordinary MS and identity on traffic channel" },
|
||||||
|
/*17*/ { "NNNPZXXXXXXTYKKK", MS_TO_MTX, 6, "10c", "Seizure and identity from called MS on traffic channel" },
|
||||||
|
/*18*/ { "NNNPZXXXXXXTYKKK", MS_TO_MTX, 14, "11a", "Roaming updating seizure and identity on traffic channel" },
|
||||||
|
/*19*/ { "NNNPZXXXXXXTYKKK", MS_TO_MTX, 15, "11b", "Seizure and call achnowledgement on calling channel from MS with priority (shortened frame)" },
|
||||||
|
/*20*/ { "NNNPZXXXXXXTYKKK", MS_TO_MTX, 11, "12", "Seizure from coin-box on traffic channel" },
|
||||||
|
/*21*/ { "NNNPZXXXXXXLLLLL", MS_TO_MTX, 8, "13a", "Line signal" },
|
||||||
|
/*22*/ { "NNNPZXXXXXXLLLQQ", MS_TO_MTX, 8, "13b", "Line signal: Answer acknowledgement from coin box" },
|
||||||
|
/*23*/ { "NNNPZXXXXXXSSSSS", MS_TO_MTX, 7, "14a", "Digit signal (1st, 3rd, 5th ........digit)" },
|
||||||
|
/*24*/ { "NNNPZXXXXXXSSSSS", MS_TO_MTX, 7, "14b", "Digit signal (2nd, 4th, 6th ........digit)" },
|
||||||
|
/*25*/ { "JJJPJJJJJJJJJJJJ", XX_TO_MTX, 0, "15", "Idle frame" },
|
||||||
|
/*26*/ { "NNNPRRRRRRRRRRRR", MS_TO_MTX, 12, "16", "Signed response" },
|
||||||
|
/*27*/ { "NNNPYYZJJJAfffff", MTX_TO_BS, 15, "20", "Channel activation order" },
|
||||||
|
/*28*/ { "NNNPYYZJJJAJJJJJ", MTX_TO_BS, 15, "20", "Channel activation order" },
|
||||||
|
/*29*/ { "NNNPYYZJJJAfffff", MTX_TO_BS, 15, "20", "Channel activation order" },
|
||||||
|
/*30*/ { "NNNPYYZJJJAlllff", MTX_TO_BS, 15, "20", "Channel activation order" },
|
||||||
|
/*31*/ { "NNNPYYZJJJAlllJJ", MTX_TO_BS, 15, "20", "Channel activation order" },
|
||||||
|
/*32*/ { "NNNPYYZJJJVJJnnn", MTX_TO_BS, 3, "21b", "Signal strength measurement order on data channel or idle or free marked traffic channel" },
|
||||||
|
/*33*/ { "NNNPYYZJJJVJJnnn", MTX_TO_BS, 5, "21c", "Signal strength measurement order on traffic actually used" },
|
||||||
|
/*34*/ { "NNNPYYZJJJVVVVVV", MTX_TO_BS, 14, "22", "Order management/maintenance order on idle channel or data channel" },
|
||||||
|
/*35*/ { "NNNPZJJAJJJJJJJJ", BS_TO_MTX, 9, "25", "Channel status information" },
|
||||||
|
/*36*/ { "NNNPZJJAJJJfllJJ", BS_TO_MTX, 9, "25", "Channel status information" },
|
||||||
|
/*37*/ { "NNNPZJJAJJJJllJJ", BS_TO_MTX, 9, "25", "Channel status information" },
|
||||||
|
/*38*/ { "NNNPZJJAJJJcccJJ", BS_TO_MTX, 9, "25", "Channel status information" },
|
||||||
|
/*39*/ { "NNNPZJJnnnrrrrrr", BS_TO_MTX, 2, "26", "Signal strength measurement result" },
|
||||||
|
/*40*/ { "NNNPZJJVVVVJJJJJ", BS_TO_MTX, 4, "27", "Response on other management/maintenance order on idle channel or data channel" },
|
||||||
|
/*41*/ { "NNNPZJJVVVVJJJJJ", BS_TO_MTX, 13, "28", "Other maintenance information from BS" },
|
||||||
|
/*42*/ { "NNNPYYJJJJJJJHHH", MTX_TO_MS, 10, "30", "Test channel indication" },
|
||||||
|
/*43*/ { "---P------------", MTX_TO_XX, 0, "", "illegal (Spare)" },
|
||||||
|
/*44*/ { "---P------------", XX_TO_MTX, 0, "", "illegal (Spare)" },
|
||||||
|
{ NULL, 0, 0, NULL, NULL }
|
||||||
|
};
|
||||||
|
|
||||||
|
/* store actual number of frames for run-time range check */
|
||||||
|
static int num_frames;
|
||||||
|
|
||||||
|
const char *nmt_frame_name(int index)
|
||||||
|
{
|
||||||
|
if (index < 0 || index >= num_frames)
|
||||||
|
return "invalid";
|
||||||
|
return nmt_frame[index].nr;
|
||||||
|
}
|
||||||
|
|
||||||
|
static const char *param_integer(uint64_t value, int ndigits, enum nmt_direction direction)
|
||||||
|
{
|
||||||
|
static char result[32];
|
||||||
|
sprintf(result, "%" PRIu64, value);
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
static const char *param_hex(uint64_t value, int ndigits, enum nmt_direction direction)
|
||||||
|
{
|
||||||
|
static char result[32];
|
||||||
|
sprintf(result, "0x%" PRIx64, value);
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
static const char *param_channel_no(uint64_t value, int ndigits, enum nmt_direction direction)
|
||||||
|
{
|
||||||
|
static char result[32];
|
||||||
|
int rc, channel, power;
|
||||||
|
|
||||||
|
rc = nmt_decode_channel(value, &channel, &power);
|
||||||
|
if (rc < 0)
|
||||||
|
sprintf(result, "invalid(%" PRIu64 ")", value);
|
||||||
|
else
|
||||||
|
sprintf(result, "channel=%d power=%d", channel, power);
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
static const char *param_country(uint64_t value, int ndigits, enum nmt_direction direction)
|
||||||
|
{
|
||||||
|
static char result[32];
|
||||||
|
|
||||||
|
switch (value) {
|
||||||
|
case 0:
|
||||||
|
return "no additional info";
|
||||||
|
case 4:
|
||||||
|
return "Iceland";
|
||||||
|
case 5:
|
||||||
|
return "Denmark";
|
||||||
|
case 6:
|
||||||
|
return "Sweden";
|
||||||
|
case 7:
|
||||||
|
return "Norway";
|
||||||
|
case 8:
|
||||||
|
return "Finland";
|
||||||
|
case 9:
|
||||||
|
return "nordic country";
|
||||||
|
case 14:
|
||||||
|
return "additional info";
|
||||||
|
case 15:
|
||||||
|
return "information to/from BS";
|
||||||
|
default:
|
||||||
|
sprintf(result, "%" PRIu64 " (unknown)", value);
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static const char *param_number(uint64_t value, int ndigits, enum nmt_direction direction)
|
||||||
|
{
|
||||||
|
static char result[32];
|
||||||
|
|
||||||
|
nmt_value2digits(value, result, ndigits);
|
||||||
|
result[ndigits] = '\0';
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
static const char *param_ta(uint64_t value, int ndigits, enum nmt_direction direction)
|
||||||
|
{
|
||||||
|
static char result[32];
|
||||||
|
|
||||||
|
nmt_value2digits(value, result, ndigits);
|
||||||
|
result[ndigits] = '\0';
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
static const char *param_line_signal(uint64_t value, int ndigits, enum nmt_direction direction)
|
||||||
|
{
|
||||||
|
static char result[64], *desc = "Spare";
|
||||||
|
|
||||||
|
if (direction == MTX_TO_MS) {
|
||||||
|
switch (value & 0xf) {
|
||||||
|
case 0:
|
||||||
|
desc = "Answer to coin-box";
|
||||||
|
break;
|
||||||
|
case 3:
|
||||||
|
desc = "Proceed to send unencrypted digits";
|
||||||
|
break;
|
||||||
|
case 4:
|
||||||
|
desc = "Acknowledge MFT converter in";
|
||||||
|
break;
|
||||||
|
case 5:
|
||||||
|
desc = "Switch compander in";
|
||||||
|
break;
|
||||||
|
case 6:
|
||||||
|
desc = "Address complete";
|
||||||
|
break;
|
||||||
|
case 7:
|
||||||
|
desc = "Switch compander out";
|
||||||
|
break;
|
||||||
|
case 9:
|
||||||
|
desc = "Ringing order";
|
||||||
|
break;
|
||||||
|
case 10:
|
||||||
|
desc = "Acknowledge MFT converter out";
|
||||||
|
break;
|
||||||
|
case 11:
|
||||||
|
desc = "Proceed to send enctrypted digits";
|
||||||
|
break;
|
||||||
|
case 13:
|
||||||
|
desc = "Clearing, call transfer activated";
|
||||||
|
break;
|
||||||
|
case 15:
|
||||||
|
desc = "Clearing, call transfer not activated";
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
switch (value & 0xf) {
|
||||||
|
case 1:
|
||||||
|
desc = "Clearing, release guard";
|
||||||
|
break;
|
||||||
|
case 2:
|
||||||
|
desc = "Answer acknowledgement, (coin-box)";
|
||||||
|
break;
|
||||||
|
case 5:
|
||||||
|
desc = "Register recall ";
|
||||||
|
break;
|
||||||
|
case 7:
|
||||||
|
desc = "MFT converter out acknowledge";
|
||||||
|
break;
|
||||||
|
case 8:
|
||||||
|
desc = "MFT converter in";
|
||||||
|
break;
|
||||||
|
case 14:
|
||||||
|
desc = "Answer";
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
sprintf(result, "L(%" PRIu64 ") %s", value & 0xf, desc);
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
static const char *param_digit(uint64_t value, int ndigits, enum nmt_direction direction)
|
||||||
|
{
|
||||||
|
static char result[32];
|
||||||
|
|
||||||
|
if ((value & 0xf0000) != 0x00000 && (value & 0xf0000) != 0xf0000)
|
||||||
|
return "Invalid digit";
|
||||||
|
if ((value & 0xf0000) != ((value & 0x0f000) << 4)
|
||||||
|
|| (value & 0x00f00) != ((value & 0x000f0) << 4)
|
||||||
|
|| (value & 0x000f0) != ((value & 0x0000f) << 4))
|
||||||
|
return "Inconsistent digit";
|
||||||
|
|
||||||
|
result[0] = nmt_value2digit(value);
|
||||||
|
result[1] = '\0';
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
static const char *param_supervisory(uint64_t value, int ndigits, enum nmt_direction direction)
|
||||||
|
{
|
||||||
|
switch (value) {
|
||||||
|
case 0:
|
||||||
|
return "Reserved";
|
||||||
|
case 3:
|
||||||
|
return "Frequency 1";
|
||||||
|
case 12:
|
||||||
|
return "Frequency 2";
|
||||||
|
case 9:
|
||||||
|
return "Frequency 3";
|
||||||
|
case 6:
|
||||||
|
return "Frequency 4";
|
||||||
|
default:
|
||||||
|
return "Invalid";
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static const char *param_password(uint64_t value, int ndigits, enum nmt_direction direction)
|
||||||
|
{
|
||||||
|
static char result[32];
|
||||||
|
|
||||||
|
nmt_value2digits(value, result, ndigits);
|
||||||
|
result[ndigits] = '\0';
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
static struct nmt_parameter {
|
||||||
|
char digit;
|
||||||
|
const char *description;
|
||||||
|
const char *(*decoder)(uint64_t value, int ndigits, enum nmt_direction direction);
|
||||||
|
} nmt_parameter[] = {
|
||||||
|
{ 'N', "Channel No.", param_channel_no },
|
||||||
|
{ 'n', "TC No.", param_channel_no },
|
||||||
|
{ 'Y', "Traffic area", param_ta },
|
||||||
|
{ 'Z', "Mobile subscriber country", param_country },
|
||||||
|
{ 'X', "Mobile subscriber No.", param_number },
|
||||||
|
{ 'Q', "Tariff class", param_integer },
|
||||||
|
{ 'L', "Line signal", param_line_signal },
|
||||||
|
{ 'S', "Digit signals", param_digit },
|
||||||
|
{ 'J', "Idle information", param_hex },
|
||||||
|
{ 'A', "Channel activation", param_hex },
|
||||||
|
{ 'V', "Management order", param_hex },
|
||||||
|
{ 'r', "Measurement results", param_hex },
|
||||||
|
{ 'P', "Prefix", param_integer },
|
||||||
|
{ 'f', "Supervisory signal", param_supervisory },
|
||||||
|
{ 'K', "Mobile subscriber password", param_password },
|
||||||
|
{ 'T', "Area info", param_hex },
|
||||||
|
{ 'H', "Additional info", param_hex },
|
||||||
|
{ 'C', "Random challenge", param_hex },
|
||||||
|
{ 'R', "Signed response", param_hex },
|
||||||
|
{ 'l', "Limit strength evaluation", param_hex },
|
||||||
|
{ 'c', "c", param_hex },
|
||||||
|
{ 0, NULL }
|
||||||
|
};
|
||||||
|
|
||||||
|
/* Depending on P-value, direction and additional info, frame index (used for
|
||||||
|
* nmt_frame[]) is recoded.
|
||||||
|
*/
|
||||||
|
static int decode_frame_index(const uint8_t *digits, enum nmt_direction direction, int callack)
|
||||||
|
{
|
||||||
|
if (direction == MS_TO_MTX || direction == BS_TO_MTX || direction == XX_TO_MTX) {
|
||||||
|
/* MS/BS TO MTX */
|
||||||
|
switch (digits[3]) {
|
||||||
|
case 0:
|
||||||
|
return 25;
|
||||||
|
case 1:
|
||||||
|
if (callack)
|
||||||
|
return 15;
|
||||||
|
return 16;
|
||||||
|
case 2:
|
||||||
|
return 39;
|
||||||
|
case 3:
|
||||||
|
break;
|
||||||
|
case 4:
|
||||||
|
return 40;
|
||||||
|
case 5:
|
||||||
|
break;
|
||||||
|
case 6:
|
||||||
|
return 17;
|
||||||
|
case 7:
|
||||||
|
if (digits[11] == 0)
|
||||||
|
return 23;
|
||||||
|
if (digits[11] == 15)
|
||||||
|
return 24;
|
||||||
|
return -1;
|
||||||
|
case 8:
|
||||||
|
if (digits[11] == 2)
|
||||||
|
return 22;
|
||||||
|
return 21;
|
||||||
|
case 9:
|
||||||
|
switch((digits[13] << 8) + (digits[14] << 4) + digits[15]) {
|
||||||
|
case 2:
|
||||||
|
case 6:
|
||||||
|
return 36;
|
||||||
|
case 14:
|
||||||
|
return 37;
|
||||||
|
case 7:
|
||||||
|
case 8:
|
||||||
|
return 38;
|
||||||
|
default:
|
||||||
|
return 35;
|
||||||
|
}
|
||||||
|
case 10:
|
||||||
|
break;
|
||||||
|
case 11:
|
||||||
|
return 20;
|
||||||
|
case 12:
|
||||||
|
return 26;
|
||||||
|
case 13:
|
||||||
|
return 41;
|
||||||
|
case 14:
|
||||||
|
return 18;
|
||||||
|
case 15:
|
||||||
|
return 19;
|
||||||
|
}
|
||||||
|
return 44;
|
||||||
|
} else {
|
||||||
|
/* MTX to MS/BS */
|
||||||
|
switch (digits[3]) {
|
||||||
|
case 0:
|
||||||
|
return 13;
|
||||||
|
case 1:
|
||||||
|
break;
|
||||||
|
case 2:
|
||||||
|
break;
|
||||||
|
case 3:
|
||||||
|
if (digits[6] == 15)
|
||||||
|
return 32;
|
||||||
|
return 10;
|
||||||
|
case 4:
|
||||||
|
return 1;
|
||||||
|
case 5:
|
||||||
|
if (digits[6] == 15)
|
||||||
|
return 33;
|
||||||
|
switch((digits[13] << 8) + (digits[14] << 4) + digits[15]) {
|
||||||
|
case 0x3f3:
|
||||||
|
case 0x3f4:
|
||||||
|
case 0x3f5:
|
||||||
|
case 0x3f6:
|
||||||
|
case 0x000:
|
||||||
|
return 8;
|
||||||
|
default:
|
||||||
|
return 7;
|
||||||
|
}
|
||||||
|
case 6:
|
||||||
|
if (digits[13] == 0)
|
||||||
|
return 12;
|
||||||
|
return 11;
|
||||||
|
case 7:
|
||||||
|
break;
|
||||||
|
case 8:
|
||||||
|
return 14;
|
||||||
|
case 9:
|
||||||
|
return 9;
|
||||||
|
case 10:
|
||||||
|
return 42;
|
||||||
|
case 11:
|
||||||
|
break;
|
||||||
|
case 12:
|
||||||
|
/* no subscriber */
|
||||||
|
if (digits[6] == 0)
|
||||||
|
return 0;
|
||||||
|
/* battery saving */
|
||||||
|
if (digits[6] == 14)
|
||||||
|
return 0;
|
||||||
|
/* info to BS (should not happen here) */
|
||||||
|
if (digits[6] == 15)
|
||||||
|
return 0;
|
||||||
|
switch((digits[13] << 8) + (digits[14] << 4) + digits[15]) {
|
||||||
|
case 0x3f3:
|
||||||
|
case 0x3f4:
|
||||||
|
case 0x3f5:
|
||||||
|
case 0x3f6:
|
||||||
|
case 0x000:
|
||||||
|
return 2;
|
||||||
|
case 0x3f0:
|
||||||
|
return 6;
|
||||||
|
case 0x3f1:
|
||||||
|
return 4;
|
||||||
|
case 0x3f2:
|
||||||
|
return 5;
|
||||||
|
default:
|
||||||
|
return 3;
|
||||||
|
}
|
||||||
|
case 13:
|
||||||
|
break;
|
||||||
|
case 14:
|
||||||
|
if (digits[13] != 15)
|
||||||
|
break;
|
||||||
|
return 34;
|
||||||
|
case 15:
|
||||||
|
if (digits[13] != 15)
|
||||||
|
break;
|
||||||
|
switch (digits[10]) {
|
||||||
|
case 3:
|
||||||
|
return 27;
|
||||||
|
case 6:
|
||||||
|
case 13:
|
||||||
|
return 29;
|
||||||
|
case 7:
|
||||||
|
case 14:
|
||||||
|
return 30;
|
||||||
|
case 15:
|
||||||
|
return 31;
|
||||||
|
default:
|
||||||
|
return 28;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return 43;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
int init_frame(void)
|
||||||
|
{
|
||||||
|
int i, j, k;
|
||||||
|
char digit;
|
||||||
|
|
||||||
|
/* check if all digits actually exist */
|
||||||
|
for (i = 0; nmt_frame[i].digits; i++) {
|
||||||
|
for (j = 0; j < 16; j++) {
|
||||||
|
digit = nmt_frame[i].digits[j];
|
||||||
|
if (digit == '-')
|
||||||
|
continue;
|
||||||
|
for (k = 0; nmt_parameter[k].digit; k++) {
|
||||||
|
if (nmt_parameter[k].digit == digit)
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if (!nmt_parameter[k].digit) {
|
||||||
|
PDEBUG(DFRAME, DEBUG_ERROR, "Digit '%c' in message index %d does not exist, please fix!\n", digit, i);
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
num_frames = i;
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* decode 16 digits frame */
|
||||||
|
static void disassemble_frame(frame_t *frame, const uint8_t *digits, enum nmt_direction direction, int callack)
|
||||||
|
{
|
||||||
|
int index;
|
||||||
|
int i, j, ndigits;
|
||||||
|
char digit;
|
||||||
|
uint64_t value;
|
||||||
|
|
||||||
|
memset(frame, 0, sizeof(*frame));
|
||||||
|
|
||||||
|
/* index of frame */
|
||||||
|
index = decode_frame_index(digits, direction, callack);
|
||||||
|
frame->index = index;
|
||||||
|
|
||||||
|
/* update direction */
|
||||||
|
direction = nmt_frame[index].direction;
|
||||||
|
|
||||||
|
PDEBUG(DFRAME, DEBUG_DEBUG, "Decoding %s %s %s\n", nmt_dir_name(direction), nmt_frame[index].nr, nmt_frame[index].description);
|
||||||
|
|
||||||
|
for (i = 0; i < 16; i++) {
|
||||||
|
digit = nmt_frame[index].digits[i];
|
||||||
|
if (digit == '-')
|
||||||
|
continue;
|
||||||
|
value = digits[i];
|
||||||
|
ndigits = 1;
|
||||||
|
for (j = i + 1; j < 16; j++) {
|
||||||
|
if (nmt_frame[index].digits[j] != digit)
|
||||||
|
break;
|
||||||
|
value = (value << 4) | digits[j];
|
||||||
|
ndigits++;
|
||||||
|
i++;
|
||||||
|
}
|
||||||
|
switch (digit) {
|
||||||
|
case 'N':
|
||||||
|
frame->channel_no = value;
|
||||||
|
break;
|
||||||
|
case 'n':
|
||||||
|
frame->tc_no = value;
|
||||||
|
break;
|
||||||
|
case 'Y':
|
||||||
|
frame->traffic_area = value;
|
||||||
|
break;
|
||||||
|
case 'Z':
|
||||||
|
frame->ms_country = value;
|
||||||
|
break;
|
||||||
|
case 'X':
|
||||||
|
frame->ms_number = value;
|
||||||
|
break;
|
||||||
|
case 'Q':
|
||||||
|
frame->tariff_class = value;
|
||||||
|
break;
|
||||||
|
case 'L':
|
||||||
|
frame->line_signal = value;
|
||||||
|
break;
|
||||||
|
case 'S':
|
||||||
|
frame->digit = value;
|
||||||
|
break;
|
||||||
|
case 'J':
|
||||||
|
frame->idle = value;
|
||||||
|
break;
|
||||||
|
case 'A':
|
||||||
|
frame->chan_act = value;
|
||||||
|
break;
|
||||||
|
case 'V':
|
||||||
|
frame->meas_order = value;
|
||||||
|
break;
|
||||||
|
case 'r':
|
||||||
|
frame->meas = value;
|
||||||
|
break;
|
||||||
|
case 'P':
|
||||||
|
frame->prefix = value;
|
||||||
|
break;
|
||||||
|
case 'f':
|
||||||
|
frame->supervisory = value;
|
||||||
|
break;
|
||||||
|
case 'K':
|
||||||
|
frame->ms_password = value;
|
||||||
|
break;
|
||||||
|
case 'T':
|
||||||
|
frame->area_info = value;
|
||||||
|
break;
|
||||||
|
case 'H':
|
||||||
|
frame->additional_info = value;
|
||||||
|
break;
|
||||||
|
case 'C':
|
||||||
|
frame->rand = value;
|
||||||
|
break;
|
||||||
|
case 'R':
|
||||||
|
frame->sres = value;
|
||||||
|
break;
|
||||||
|
case 'l':
|
||||||
|
frame->limit_strength_eval = value;
|
||||||
|
break;
|
||||||
|
case 'c':
|
||||||
|
frame->c = value;
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
PDEBUG(DFRAME, DEBUG_ERROR, "Digit '%c' does not exist, please fix!\n", digit);
|
||||||
|
abort();
|
||||||
|
}
|
||||||
|
if (debuglevel <= DEBUG_DEBUG) {
|
||||||
|
for (j = 0; nmt_parameter[j].digit; j++) {
|
||||||
|
if (nmt_parameter[j].digit == digit) {
|
||||||
|
PDEBUG(DFRAME, DEBUG_DEBUG, " %c: %s\n", digit, nmt_parameter[j].decoder(value, ndigits, direction));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (debuglevel <= DEBUG_DEBUG) {
|
||||||
|
char debug_digits[17];
|
||||||
|
|
||||||
|
for (i = 0; i < 16; i++)
|
||||||
|
debug_digits[i] = "0123456789abcdef"[digits[i]];
|
||||||
|
debug_digits[i] = '\0';
|
||||||
|
PDEBUG(DFRAME, DEBUG_DEBUG, "%s\n", nmt_frame[index].digits);
|
||||||
|
PDEBUG(DFRAME, DEBUG_DEBUG, "%s\n", debug_digits);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* encode 16 digits frame */
|
||||||
|
static void assemble_frame(frame_t *frame, uint8_t *digits, int debug)
|
||||||
|
{
|
||||||
|
int index;
|
||||||
|
int i, j;
|
||||||
|
char digit;
|
||||||
|
uint64_t value;
|
||||||
|
enum nmt_direction direction;
|
||||||
|
|
||||||
|
index = frame->index;
|
||||||
|
|
||||||
|
if (index >= num_frames) {
|
||||||
|
PDEBUG(DFRAME, DEBUG_ERROR, "Frame index %d out of range (0..%d), please fix!\n", index, num_frames - 1);
|
||||||
|
abort();
|
||||||
|
}
|
||||||
|
|
||||||
|
/* set prefix of frame */
|
||||||
|
frame->prefix = nmt_frame[index].prefix;
|
||||||
|
|
||||||
|
/* retrieve direction */
|
||||||
|
direction = nmt_frame[index].direction;
|
||||||
|
|
||||||
|
if (debug)
|
||||||
|
PDEBUG(DFRAME, DEBUG_DEBUG, "Coding %s %s %s\n", nmt_dir_name(direction), nmt_frame[index].nr, nmt_frame[index].description);
|
||||||
|
|
||||||
|
for (i = 15; i >= 0; i--) {
|
||||||
|
digit = nmt_frame[index].digits[i];
|
||||||
|
if (digit == '-') {
|
||||||
|
digits[i] = 0;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
switch (digit) {
|
||||||
|
case 'N':
|
||||||
|
value = frame->channel_no;
|
||||||
|
break;
|
||||||
|
case 'n':
|
||||||
|
value = frame->tc_no;
|
||||||
|
break;
|
||||||
|
case 'Y':
|
||||||
|
value = frame->traffic_area;
|
||||||
|
break;
|
||||||
|
case 'Z':
|
||||||
|
value = frame->ms_country;
|
||||||
|
break;
|
||||||
|
case 'X':
|
||||||
|
value = frame->ms_number;
|
||||||
|
break;
|
||||||
|
case 'Q':
|
||||||
|
value = frame->tariff_class;
|
||||||
|
break;
|
||||||
|
case 'L':
|
||||||
|
value = frame->line_signal;
|
||||||
|
break;
|
||||||
|
case 'S':
|
||||||
|
value = frame->digit;
|
||||||
|
break;
|
||||||
|
case 'J':
|
||||||
|
value = frame->idle;
|
||||||
|
break;
|
||||||
|
case 'A':
|
||||||
|
value = frame->chan_act;
|
||||||
|
break;
|
||||||
|
case 'V':
|
||||||
|
value = frame->meas_order;
|
||||||
|
break;
|
||||||
|
case 'r':
|
||||||
|
value = frame->meas;
|
||||||
|
break;
|
||||||
|
case 'P':
|
||||||
|
value = frame->prefix;
|
||||||
|
break;
|
||||||
|
case 'f':
|
||||||
|
value = frame->supervisory;
|
||||||
|
break;
|
||||||
|
case 'K':
|
||||||
|
value = frame->ms_password;
|
||||||
|
break;
|
||||||
|
case 'T':
|
||||||
|
value = frame->area_info;
|
||||||
|
break;
|
||||||
|
case 'H':
|
||||||
|
value = frame->additional_info;
|
||||||
|
break;
|
||||||
|
case 'C':
|
||||||
|
value = frame->rand;
|
||||||
|
break;
|
||||||
|
case 'R':
|
||||||
|
value = frame->sres;
|
||||||
|
break;
|
||||||
|
case 'l':
|
||||||
|
value = frame->limit_strength_eval;
|
||||||
|
break;
|
||||||
|
case 'c':
|
||||||
|
value = frame->c;
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
PDEBUG(DFRAME, DEBUG_ERROR, "Digit '%c' does not exist, please fix!\n", digit);
|
||||||
|
abort();
|
||||||
|
}
|
||||||
|
|
||||||
|
digits[i] = (value & 0xf);
|
||||||
|
value >>= 4;
|
||||||
|
for (j = i - 1; j >= 0; j--) {
|
||||||
|
if (nmt_frame[index].digits[j] != digit)
|
||||||
|
break;
|
||||||
|
digits[j] = (value & 0xf);
|
||||||
|
value >>= 4;
|
||||||
|
i--;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (debug && debuglevel <= DEBUG_DEBUG) {
|
||||||
|
char debug_digits[17];
|
||||||
|
int ndigits;
|
||||||
|
|
||||||
|
for (i = 0; i < 16; i++) {
|
||||||
|
digit = nmt_frame[index].digits[i];
|
||||||
|
if (digit == '-')
|
||||||
|
continue;
|
||||||
|
value = digits[i];
|
||||||
|
ndigits = 1;
|
||||||
|
for (j = i + 1; j < 16; j++) {
|
||||||
|
if (nmt_frame[index].digits[j] != digit)
|
||||||
|
break;
|
||||||
|
value = (value << 4) | digits[j];
|
||||||
|
ndigits++;
|
||||||
|
i++;
|
||||||
|
}
|
||||||
|
for (j = 0; nmt_parameter[j].digit; j++) {
|
||||||
|
if (nmt_parameter[j].digit == digit) {
|
||||||
|
PDEBUG(DFRAME, DEBUG_DEBUG, " %c: %s\n", digit, nmt_parameter[j].decoder(value, ndigits, direction));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i = 0; i < 16; i++)
|
||||||
|
debug_digits[i] = "0123456789abcdef"[digits[i]];
|
||||||
|
debug_digits[i] = '\0';
|
||||||
|
PDEBUG(DFRAME, DEBUG_DEBUG, "%s\n", nmt_frame[index].digits);
|
||||||
|
PDEBUG(DFRAME, DEBUG_DEBUG, "%s\n", debug_digits);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* encode digits of a frame to 166 bits */
|
||||||
|
static void encode_digits(const uint8_t *digits, char *bits)
|
||||||
|
{
|
||||||
|
uint8_t x[64];
|
||||||
|
int i;
|
||||||
|
uint8_t digit;
|
||||||
|
|
||||||
|
/* copy bit sync and frame sync */
|
||||||
|
memcpy(bits, "10101010101010111100010010", 26);
|
||||||
|
bits += 26;
|
||||||
|
|
||||||
|
for (i = 0; i < 16; i++) {
|
||||||
|
digit = *digits++;
|
||||||
|
x[(i << 2) + 0] = (digit >> 3) & 1;
|
||||||
|
x[(i << 2) + 1] = (digit >> 2) & 1;
|
||||||
|
x[(i << 2) + 2] = (digit >> 1) & 1;
|
||||||
|
x[(i << 2) + 3] = digit & 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* parity check bits */
|
||||||
|
for (i = 0; i < 3; i++)
|
||||||
|
bits[(i << 1)] = '1' - x[i];
|
||||||
|
for (i = 3; i < 64; i++)
|
||||||
|
bits[(i << 1)] = '1' - (x[i] ^ x[i - 3]);
|
||||||
|
for (i = 64; i < 67; i++)
|
||||||
|
bits[(i << 1)] = '1' - x[i - 3];
|
||||||
|
for (i = 67; i < 70; i++)
|
||||||
|
bits[(i << 1)] = '1';
|
||||||
|
|
||||||
|
/* information bits */
|
||||||
|
for (i = 0; i < 6; i++)
|
||||||
|
bits[(i << 1) + 1] = '0';
|
||||||
|
for (i = 6; i < 70; i++)
|
||||||
|
bits[(i << 1) + 1] = x[i - 6] + '0';
|
||||||
|
}
|
||||||
|
|
||||||
|
/* decode digits from 140 bits (not including sync) */
|
||||||
|
// FIXME: do real convolutional decoding
|
||||||
|
static int decode_digits(uint8_t *digits, const char *bits, int callack)
|
||||||
|
{
|
||||||
|
uint8_t x[64];
|
||||||
|
int i, short_frame = 0;
|
||||||
|
|
||||||
|
/* information bits */
|
||||||
|
for (i = 0; i < 6; i++) {
|
||||||
|
if (bits[(i << 1) + 1] != '0')
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
for (i = 6; i < 70; i++)
|
||||||
|
x[i - 6] = bits[(i << 1) + 1] - '0';
|
||||||
|
|
||||||
|
/* create digits */
|
||||||
|
for (i = 0; i < 16; i++) {
|
||||||
|
digits[i] = ((x[(i << 2) + 0] & 1) << 3)
|
||||||
|
| ((x[(i << 2) + 1] & 1) << 2)
|
||||||
|
| ((x[(i << 2) + 2] & 1) << 1)
|
||||||
|
| (x[(i << 2) + 3] & 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* check for short frame */
|
||||||
|
if (callack && (digits[3] == 1 || digits[3] == 15)) {
|
||||||
|
digits[13] = 0;
|
||||||
|
digits[14] = 0;
|
||||||
|
digits[15] = 0;
|
||||||
|
short_frame = 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* parity check bits */
|
||||||
|
for (i = 0; i < 3; i++) {
|
||||||
|
if (bits[(i << 1)] != '1' - x[i])
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
for (i = 3; i < ((short_frame) ? 52 : 64); i++) {
|
||||||
|
if (bits[(i << 1)] != '1' - (x[i] ^ x[i - 3])) {
|
||||||
|
/* According to NMT Doc 450-3, bits after Y(114) shall
|
||||||
|
* be omitted for short frame. It would make more sense
|
||||||
|
* to stop after Y(116), so only the last three digits
|
||||||
|
* are omitted and not the last bit of digit13 also.
|
||||||
|
* Tests have showed that it we receive correctly up to
|
||||||
|
* Y(116), but we ignore an error, if only up to Y(114)
|
||||||
|
* is received.
|
||||||
|
*/
|
||||||
|
if (short_frame && i == 51) {
|
||||||
|
PDEBUG(DFRAME, DEBUG_DEBUG, "Frame bad after bit Y(114), ignoring.\n");
|
||||||
|
digits[13] = 0;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (short_frame)
|
||||||
|
return 0;
|
||||||
|
for (i = 64; i < 67; i++) {
|
||||||
|
if (bits[(i << 1)] != '1' - x[i - 3])
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
for (i = 67; i < 70; i++) {
|
||||||
|
if (bits[(i << 1)] != '1')
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* encode frame to bits
|
||||||
|
* debug can be turned on or off
|
||||||
|
*/
|
||||||
|
const char *encode_frame(frame_t *frame, int debug)
|
||||||
|
{
|
||||||
|
uint8_t digits[16];
|
||||||
|
static char bits[166];
|
||||||
|
|
||||||
|
assemble_frame(frame, digits, debug);
|
||||||
|
encode_digits(digits, bits);
|
||||||
|
|
||||||
|
return bits;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* decode bits to frame */
|
||||||
|
int decode_frame(frame_t *frame, const char *bits, enum nmt_direction direction, int callack)
|
||||||
|
{
|
||||||
|
uint8_t digits[16];
|
||||||
|
int rc;
|
||||||
|
|
||||||
|
rc = decode_digits(digits, bits, callack);
|
||||||
|
if (rc < 0)
|
||||||
|
return rc;
|
||||||
|
disassemble_frame(frame, digits, direction, callack);
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
|
@ -0,0 +1,84 @@
|
||||||
|
|
||||||
|
#define NMT_MESSAGE_1a 0
|
||||||
|
#define NMT_MESSAGE_1b 1
|
||||||
|
#define NMT_MESSAGE_2a 2
|
||||||
|
#define NMT_MESSAGE_2b 3
|
||||||
|
#define NMT_MESSAGE_2c 4
|
||||||
|
#define NMT_MESSAGE_2d 5
|
||||||
|
#define NMT_MESSAGE_2f 6
|
||||||
|
#define NMT_MESSAGE_3a 7
|
||||||
|
#define NMT_MESSAGE_3b 8
|
||||||
|
#define NMT_MESSAGE_3c 9
|
||||||
|
#define NMT_MESSAGE_4 10
|
||||||
|
#define NMT_MESSAGE_5a 11
|
||||||
|
#define NMT_MESSAGE_5b 12
|
||||||
|
#define NMT_MESSAGE_6 13
|
||||||
|
#define NMT_MESSAGE_7 14
|
||||||
|
#define NMT_MESSAGE_10a 15
|
||||||
|
#define NMT_MESSAGE_10b 16
|
||||||
|
#define NMT_MESSAGE_10c 17
|
||||||
|
#define NMT_MESSAGE_11a 18
|
||||||
|
#define NMT_MESSAGE_11b 19
|
||||||
|
#define NMT_MESSAGE_12 20
|
||||||
|
#define NMT_MESSAGE_13a 21
|
||||||
|
#define NMT_MESSAGE_13b 22
|
||||||
|
#define NMT_MESSAGE_14a 23
|
||||||
|
#define NMT_MESSAGE_14b 24
|
||||||
|
#define NMT_MESSAGE_15 25
|
||||||
|
#define NMT_MESSAGE_16 26
|
||||||
|
#define NMT_MESSAGE_20a 27
|
||||||
|
#define NMT_MESSAGE_20b 28
|
||||||
|
#define NMT_MESSAGE_20c 29
|
||||||
|
#define NMT_MESSAGE_20d 30
|
||||||
|
#define NMT_MESSAGE_20e 31
|
||||||
|
#define NMT_MESSAGE_21b 32
|
||||||
|
#define NMT_MESSAGE_21c 33
|
||||||
|
#define NMT_MESSAGE_22 34
|
||||||
|
#define NMT_MESSAGE_25a 35
|
||||||
|
#define NMT_MESSAGE_25b 36
|
||||||
|
#define NMT_MESSAGE_25c 37
|
||||||
|
#define NMT_MESSAGE_25d 38
|
||||||
|
#define NMT_MESSAGE_26 39
|
||||||
|
#define NMT_MESSAGE_27 40
|
||||||
|
#define NMT_MESSAGE_28 41
|
||||||
|
#define NMT_MESSAGE_30 42
|
||||||
|
|
||||||
|
typedef struct frame {
|
||||||
|
uint8_t index;
|
||||||
|
uint16_t channel_no;
|
||||||
|
uint16_t tc_no;
|
||||||
|
uint8_t traffic_area;
|
||||||
|
uint8_t ms_country;
|
||||||
|
uint32_t ms_number;
|
||||||
|
uint8_t tariff_class;
|
||||||
|
uint32_t line_signal;
|
||||||
|
uint32_t digit;
|
||||||
|
uint64_t idle;
|
||||||
|
uint8_t chan_act;
|
||||||
|
uint32_t meas_order;
|
||||||
|
uint32_t meas;
|
||||||
|
uint8_t prefix;
|
||||||
|
uint32_t supervisory;
|
||||||
|
uint16_t ms_password;
|
||||||
|
uint8_t area_info;
|
||||||
|
uint64_t additional_info;
|
||||||
|
uint32_t rand;
|
||||||
|
uint64_t sres;
|
||||||
|
uint16_t limit_strength_eval;
|
||||||
|
uint16_t c;
|
||||||
|
} frame_t;
|
||||||
|
|
||||||
|
int init_frame(void);
|
||||||
|
|
||||||
|
uint64_t nmt_encode_channel(int channel, int power);
|
||||||
|
int nmt_decode_channel(uint64_t value, int *channel, int *power);
|
||||||
|
void nmt_value2digits(uint64_t value, char *digits, int num);
|
||||||
|
uint64_t nmt_digits2value(const char *digits, int num);
|
||||||
|
char nmt_value2digit(uint64_t value);
|
||||||
|
uint16_t nmt_encode_area_no(uint8_t area_no);
|
||||||
|
|
||||||
|
const char *nmt_frame_name(int index);
|
||||||
|
|
||||||
|
const char *encode_frame(frame_t *frame, int debug);
|
||||||
|
int decode_frame(frame_t *frame, const char *bits, enum nmt_direction direction, int callack);
|
||||||
|
|
|
@ -0,0 +1,68 @@
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <string.h>
|
||||||
|
#include "image.h"
|
||||||
|
|
||||||
|
const char *image[] = {
|
||||||
|
"",
|
||||||
|
"@g ______ @r####@w##@r########",
|
||||||
|
" @g/ \\___ @r__ @r####@w##@r########",
|
||||||
|
" @g/ Hej! __\\ @r/ ) @r####@w##@r########",
|
||||||
|
" @g\\ / @r/ / @wNMT @w##############",
|
||||||
|
" @g\\______/ @r/ / @r####@w##@r########",
|
||||||
|
" @y_@G_@r/@G__@r/@y_ @b####@y##@b##@r####@w##@r########",
|
||||||
|
" @y/@G/ \\ @y\\ @b####@y##@b##@r####@w##@r########",
|
||||||
|
" @y/.@G\\____/@y// @b####@y##@b########",
|
||||||
|
" @y/@G_@r/@G__@r/@y..// @y##############",
|
||||||
|
" @y/@G/ \\@y.// @b####@y##@b########",
|
||||||
|
" @y/.@G\\____/@y// @r####@w|@b#@w|@r#@b####@y##@b########",
|
||||||
|
" @y/@G_@r/@G__@r/@y..// @r####@w|@b#@w|@r#@b####@y##@b########",
|
||||||
|
" @y/@G/ \\@y.// @r####@w|@b#@w|@r#######",
|
||||||
|
" @y\\@G\\____/@y// @b##############",
|
||||||
|
" @r/ /@y__/ @r####@w|@b#@w|@r#######",
|
||||||
|
" @r/ / @w####@b##@w##@r####@w|@b#@w|@r#######",
|
||||||
|
" @r/ / @w####@b##@w##@r####@w|@b#@w|@r#######",
|
||||||
|
" @r(__/ @w####@b##@w########",
|
||||||
|
" @b##############",
|
||||||
|
" @w####@b##@w########",
|
||||||
|
" @w####@b##@w########",
|
||||||
|
" @w####@b##@w########",
|
||||||
|
"",
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
void print_image(void)
|
||||||
|
{
|
||||||
|
int i, j;
|
||||||
|
|
||||||
|
for (i = 0; image[i]; i++) {
|
||||||
|
for (j = 0; j < strlen(image[i]); j++) {
|
||||||
|
if (image[i][j] == '@') {
|
||||||
|
j++;
|
||||||
|
switch(image[i][j]) {
|
||||||
|
case 'r': /* red */
|
||||||
|
printf("\033[0;31m");
|
||||||
|
break;
|
||||||
|
case 'g': /* gray */
|
||||||
|
printf("\033[0;37m");
|
||||||
|
break;
|
||||||
|
case 'G': /* green */
|
||||||
|
printf("\033[0;32m");
|
||||||
|
break;
|
||||||
|
case 'w': /* white */
|
||||||
|
printf("\033[1;37m");
|
||||||
|
break;
|
||||||
|
case 'y': /* yellow */
|
||||||
|
printf("\033[0;33m");
|
||||||
|
break;
|
||||||
|
case 'b': /* blue */
|
||||||
|
printf("\033[0;34m");
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
} else
|
||||||
|
printf("%c", image[i][j]);
|
||||||
|
}
|
||||||
|
printf("\n");
|
||||||
|
}
|
||||||
|
printf("\033[0;39m");
|
||||||
|
}
|
||||||
|
|
|
@ -0,0 +1,3 @@
|
||||||
|
|
||||||
|
void print_image(void);
|
||||||
|
|
|
@ -0,0 +1,291 @@
|
||||||
|
/* NMT main
|
||||||
|
*
|
||||||
|
* (C) 2016 by Andreas Eversberg <jolly@eversberg.eu>
|
||||||
|
* All Rights Reserved
|
||||||
|
*
|
||||||
|
* This program is free software: you can redistribute it and/or modify
|
||||||
|
* it under the terms of the GNU General Public License as published by
|
||||||
|
* the Free Software Foundation, either version 3 of the License, or
|
||||||
|
* (at your option) any later version.
|
||||||
|
*
|
||||||
|
* This program is distributed in the hope that it will be useful,
|
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
* GNU General Public License for more details.
|
||||||
|
*
|
||||||
|
* You should have received a copy of the GNU General Public License
|
||||||
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <stdint.h>
|
||||||
|
#include <getopt.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <string.h>
|
||||||
|
#include <signal.h>
|
||||||
|
#include <sched.h>
|
||||||
|
#include "../common/main.h"
|
||||||
|
#include "../common/debug.h"
|
||||||
|
#include "../common/timer.h"
|
||||||
|
#include "../common/call.h"
|
||||||
|
#include "../common/mncc_sock.h"
|
||||||
|
#include "nmt.h"
|
||||||
|
#include "frame.h"
|
||||||
|
#include "dsp.h"
|
||||||
|
#include "image.h"
|
||||||
|
#include "tones.h"
|
||||||
|
#include "announcement.h"
|
||||||
|
|
||||||
|
/* settings */
|
||||||
|
enum nmt_chan_type chan_type = CHAN_TYPE_CC_TC;
|
||||||
|
int ms_power = 1; /* 1..3 */
|
||||||
|
char traffic_area[3] = "";
|
||||||
|
char area_no = 0;
|
||||||
|
int compander = 1;
|
||||||
|
int supervisory = 0;
|
||||||
|
|
||||||
|
void print_help(const char *arg0)
|
||||||
|
{
|
||||||
|
print_help_common(arg0, "-y <traffic area> | list ");
|
||||||
|
/* - - */
|
||||||
|
printf(" -t --channel-type <channel type> | list\n");
|
||||||
|
printf(" Give channel type, use 'list' to get a list. (default = '%s')\n", chan_type_short_name(chan_type));
|
||||||
|
printf(" -P --ms-power <power level>\n");
|
||||||
|
printf(" Give power level of the mobile station 1..3. (default = '%d')\n", ms_power);
|
||||||
|
printf(" 3 = 15 W / 7 W (handheld), 2 = 1.5 W, 1 = 150 mW\n");
|
||||||
|
printf(" -y --traffic-area <traffic area> | list\n");
|
||||||
|
printf(" NOTE: MUST MATCH WITH YOUR ROAMING SETTINGS IN THE PHONE!\n");
|
||||||
|
printf(" Your phone will not connect, if country code is different!\n");
|
||||||
|
printf(" Give two digits of traffic area, the first digit defines the country\n");
|
||||||
|
printf(" code, the second defines the cell area. (Example: 61 = Sweden, cell 1)\n");
|
||||||
|
printf(" Alternatively you can give the short code for country and the cell\n");
|
||||||
|
printf(" area seperated by comma. (Example: SE,1 = Sweden, cell 1)\n");
|
||||||
|
printf(" Use 'list' to get a list of available short country code names\n");
|
||||||
|
printf(" -a --area-number <area no> | 0\n");
|
||||||
|
printf(" Give area number 1..4 or 0 for no area number. (default = '%d')\n", area_no);
|
||||||
|
printf(" -C --compander 1 | 0\n");
|
||||||
|
printf(" Make use of the compander to reduce noise during call. (default = '%d')\n", compander);
|
||||||
|
printf(" -0 --supervisory 1..4 | 0\n");
|
||||||
|
printf(" Use supervisory signal 1..4 to detect loss of signal from mobile\n");
|
||||||
|
printf(" station, use 0 to disable. (default = '%d')\n", supervisory);
|
||||||
|
printf("\nstation-id: Give 7 digits of station-id, you don't need to enter it\n");
|
||||||
|
printf(" for every start of this program.\n");
|
||||||
|
}
|
||||||
|
|
||||||
|
static int handle_options(int argc, char **argv)
|
||||||
|
{
|
||||||
|
char country[32], *p;
|
||||||
|
int skip_args = 0;
|
||||||
|
|
||||||
|
static struct option long_options_special[] = {
|
||||||
|
{"channel-type", 1, 0, 't'},
|
||||||
|
{"ms-power", 1, 0, 'P'},
|
||||||
|
{"area-number", 1, 0, 'a'},
|
||||||
|
{"traffic-area", 1, 0, 'y'},
|
||||||
|
{"compander", 1, 0, 'C'},
|
||||||
|
{"supervisory", 1, 0, '0'},
|
||||||
|
{0, 0, 0, 0}
|
||||||
|
};
|
||||||
|
|
||||||
|
set_options_common("t:P:a:y:C:0:", long_options_special);
|
||||||
|
|
||||||
|
while (1) {
|
||||||
|
int option_index = 0, c, rc;
|
||||||
|
|
||||||
|
c = getopt_long(argc, argv, optstring, long_options, &option_index);
|
||||||
|
|
||||||
|
if (c == -1)
|
||||||
|
break;
|
||||||
|
|
||||||
|
switch (c) {
|
||||||
|
case 't':
|
||||||
|
|
||||||
|
if (!strcmp(optarg, "list")) {
|
||||||
|
nmt_channel_list();
|
||||||
|
exit(0);
|
||||||
|
}
|
||||||
|
rc = nmt_channel_by_short_name(optarg);
|
||||||
|
if (rc < 0) {
|
||||||
|
fprintf(stderr, "Error, channel type '%s' unknown. Please use '-t list' to get a list. I suggest to use the default.\n", optarg);
|
||||||
|
exit(0);
|
||||||
|
}
|
||||||
|
chan_type = rc;
|
||||||
|
skip_args += 2;
|
||||||
|
break;
|
||||||
|
case 'P':
|
||||||
|
ms_power = atoi(optarg);
|
||||||
|
if (ms_power > 3)
|
||||||
|
ms_power = 3;
|
||||||
|
if (ms_power < 1)
|
||||||
|
ms_power = 1;
|
||||||
|
skip_args += 2;
|
||||||
|
break;
|
||||||
|
case 'a':
|
||||||
|
area_no = optarg[0] - '0';
|
||||||
|
if (area_no > 4) {
|
||||||
|
fprintf(stderr, "Area number '%s' out of range, please use 1..4 or 0 for no area\n", optarg);
|
||||||
|
exit(0);
|
||||||
|
}
|
||||||
|
skip_args += 2;
|
||||||
|
break;
|
||||||
|
case 'y':
|
||||||
|
|
||||||
|
if (!strcmp(optarg, "list")) {
|
||||||
|
nmt_country_list();
|
||||||
|
exit(0);
|
||||||
|
}
|
||||||
|
/* digits */
|
||||||
|
if (optarg[0] >= '0' && optarg[0] <= '9') {
|
||||||
|
traffic_area[0] = optarg[0];
|
||||||
|
if (optarg[1] < '0' || optarg[1] > '9') {
|
||||||
|
error_ta:
|
||||||
|
fprintf(stderr, "Illegal traffic area '%s', see '-h' for help\n", optarg);
|
||||||
|
exit(0);
|
||||||
|
}
|
||||||
|
traffic_area[1] = optarg[1];
|
||||||
|
if (optarg[2] != '\0')
|
||||||
|
goto error_ta;
|
||||||
|
traffic_area[2] = '\0';
|
||||||
|
} else {
|
||||||
|
strncpy(country, optarg, sizeof(country) - 1);
|
||||||
|
country[sizeof(country) - 1] = '\0';
|
||||||
|
p = strchr(country, ',');
|
||||||
|
if (!p)
|
||||||
|
goto error_ta;
|
||||||
|
*p++ = '\0';
|
||||||
|
rc = nmt_country_by_short_name(country);
|
||||||
|
if (!rc)
|
||||||
|
goto error_ta;
|
||||||
|
if (*p < '0' || *p > '9')
|
||||||
|
goto error_ta;
|
||||||
|
traffic_area[0] = rc + '0';
|
||||||
|
traffic_area[1] = *p;
|
||||||
|
traffic_area[2] = '\0';
|
||||||
|
}
|
||||||
|
skip_args += 2;
|
||||||
|
break;
|
||||||
|
case 'C':
|
||||||
|
compander = atoi(optarg);
|
||||||
|
skip_args += 2;
|
||||||
|
break;
|
||||||
|
case '0':
|
||||||
|
supervisory = atoi(optarg);
|
||||||
|
if (supervisory < 0 || supervisory > 4) {
|
||||||
|
fprintf(stderr, "Given supervisory signal is wrong, use '-h' for help!\n");
|
||||||
|
exit(0);
|
||||||
|
}
|
||||||
|
skip_args += 2;
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
opt_switch_common(c, argv[0], &skip_args);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
free(long_options);
|
||||||
|
|
||||||
|
return skip_args;
|
||||||
|
}
|
||||||
|
|
||||||
|
int main(int argc, char *argv[])
|
||||||
|
{
|
||||||
|
int rc;
|
||||||
|
int skip_args;
|
||||||
|
const char *station_id = "";
|
||||||
|
|
||||||
|
/* init common tones */
|
||||||
|
init_nmt_tones();
|
||||||
|
init_announcement();
|
||||||
|
|
||||||
|
skip_args = handle_options(argc, argv);
|
||||||
|
argc -= skip_args;
|
||||||
|
argv += skip_args;
|
||||||
|
|
||||||
|
if (argc > 1)
|
||||||
|
station_id = argv[1];
|
||||||
|
|
||||||
|
if (!kanal) {
|
||||||
|
printf("No channel (\"Kanal\") is specified, I suggest channel 1.\n\n");
|
||||||
|
print_help(argv[0]);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!traffic_area[0]) {
|
||||||
|
printf("No traffic area is specified, I suggest to use 'SE' for Sweden and set the phone's roaming to 'SE' also.\n\n");
|
||||||
|
print_help(argv[0]);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!loopback)
|
||||||
|
print_image();
|
||||||
|
|
||||||
|
/* init functions */
|
||||||
|
if (use_mncc_sock) {
|
||||||
|
rc = mncc_init("/tmp/bsc_mncc");
|
||||||
|
if (rc < 0) {
|
||||||
|
fprintf(stderr, "Failed to setup MNCC socket. Quitting!\n");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
init_frame();
|
||||||
|
dsp_init();
|
||||||
|
rc = call_init(station_id, call_sounddev, samplerate, latency, 7, loopback);
|
||||||
|
if (rc < 0) {
|
||||||
|
fprintf(stderr, "Failed to create call control instance. Quitting!\n");
|
||||||
|
goto fail;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* create transceiver instance */
|
||||||
|
rc = nmt_create(sounddev, samplerate, kanal, (loopback) ? CHAN_TYPE_TEST : chan_type, ms_power, nmt_digits2value(traffic_area, 2), area_no, compander, supervisory, loopback);
|
||||||
|
if (rc < 0) {
|
||||||
|
fprintf(stderr, "Failed to create transceiver instance. Quitting!\n");
|
||||||
|
goto fail;
|
||||||
|
}
|
||||||
|
if (kanal > 200) {
|
||||||
|
printf("Base station ready, please tune transmitter to %.4f MHz and receiver "
|
||||||
|
"to %.4f MHz.\n", nmt_channel2freq(kanal, 0),
|
||||||
|
nmt_channel2freq(kanal, 1));
|
||||||
|
} else {
|
||||||
|
printf("Base station ready, please tune transmitter to %.3f MHz and receiver "
|
||||||
|
"to %.3f MHz.\n", nmt_channel2freq(kanal, 0),
|
||||||
|
nmt_channel2freq(kanal, 1));
|
||||||
|
}
|
||||||
|
|
||||||
|
signal(SIGINT,sighandler);
|
||||||
|
signal(SIGHUP,sighandler);
|
||||||
|
signal(SIGTERM,sighandler);
|
||||||
|
signal(SIGPIPE,sighandler);
|
||||||
|
|
||||||
|
if (rt_prio > 0) {
|
||||||
|
struct sched_param schedp;
|
||||||
|
int rc;
|
||||||
|
|
||||||
|
memset(&schedp, 0, sizeof(schedp));
|
||||||
|
schedp.sched_priority = rt_prio;
|
||||||
|
rc = sched_setscheduler(0, SCHED_RR, &schedp);
|
||||||
|
if (rc)
|
||||||
|
fprintf(stderr, "Error setting SCHED_RR with prio %d\n", rt_prio);
|
||||||
|
}
|
||||||
|
|
||||||
|
main_loop(&quit, latency);
|
||||||
|
|
||||||
|
if (rt_prio > 0) {
|
||||||
|
struct sched_param schedp;
|
||||||
|
|
||||||
|
memset(&schedp, 0, sizeof(schedp));
|
||||||
|
schedp.sched_priority = 0;
|
||||||
|
sched_setscheduler(0, SCHED_OTHER, &schedp);
|
||||||
|
}
|
||||||
|
|
||||||
|
fail:
|
||||||
|
/* cleanup functions */
|
||||||
|
call_cleanup();
|
||||||
|
if (use_mncc_sock)
|
||||||
|
mncc_exit();
|
||||||
|
|
||||||
|
/* destroy transceiver instance */
|
||||||
|
while (sender_head)
|
||||||
|
nmt_destroy(sender_head);
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,142 @@
|
||||||
|
#include "../common/sender.h"
|
||||||
|
#include "../common/compander.h"
|
||||||
|
#include "../common/dtmf.h"
|
||||||
|
|
||||||
|
enum dsp_mode {
|
||||||
|
DSP_MODE_DIALTONE, /* stream dial tone to mobile phone */
|
||||||
|
DSP_MODE_AUDIO, /* stream audio */
|
||||||
|
DSP_MODE_SILENCE, /* stream nothing */
|
||||||
|
DSP_MODE_FRAME, /* send frames */
|
||||||
|
DSP_MODE_DTMF, /* send DTMF tones */
|
||||||
|
};
|
||||||
|
|
||||||
|
enum nmt_chan_type {
|
||||||
|
CHAN_TYPE_CC, /* calling channel */
|
||||||
|
CHAN_TYPE_TC, /* traffic channel */
|
||||||
|
CHAN_TYPE_CC_TC, /* combined CC + TC */
|
||||||
|
CHAN_TYPE_TEST, /* test channel */
|
||||||
|
};
|
||||||
|
|
||||||
|
enum nmt_state {
|
||||||
|
STATE_NULL, /* power off state */
|
||||||
|
STATE_IDLE, /* channel is not in use */
|
||||||
|
STATE_ROAMING_IDENT, /* seizure received, waiting for identity */
|
||||||
|
STATE_ROAMING_CONFIRM, /* identity received, sending confirm */
|
||||||
|
STATE_MO_IDENT, /* seizure of mobile originated call, waiting for identity */
|
||||||
|
STATE_MO_CONFIRM, /* identity received, sending confirm */
|
||||||
|
STATE_MO_DIALING, /* receiving digits from phone */
|
||||||
|
STATE_MO_COMPLETE, /* all digits received, completing call */
|
||||||
|
STATE_MT_PAGING, /* paging mobile phone */
|
||||||
|
STATE_MT_CHANNEL, /* assigning traffic channel */
|
||||||
|
STATE_MT_IDENT, /* waiting for identity */
|
||||||
|
STATE_MT_RINGING, /* mobile phone is ringing, waiting for answer */
|
||||||
|
STATE_MT_COMPLETE, /* mobile phone has answered, completing call */
|
||||||
|
STATE_ACTIVE, /* during active call */
|
||||||
|
STATE_MO_RELEASE, /* acknowlegde release from mobile phone */
|
||||||
|
STATE_MT_RELEASE, /* sending release toward mobile phone */
|
||||||
|
};
|
||||||
|
|
||||||
|
enum nmt_active_state {
|
||||||
|
ACTIVE_STATE_VOICE, /* normal conversation */
|
||||||
|
ACTIVE_STATE_MFT_IN, /* ack MFT converter in */
|
||||||
|
ACTIVE_STATE_MFT, /* receive digits in MFT mode */
|
||||||
|
ACTIVE_STATE_MFT_OUT, /* ack MFT converter out */
|
||||||
|
};
|
||||||
|
|
||||||
|
enum nmt_direction {
|
||||||
|
MTX_TO_MS,
|
||||||
|
MTX_TO_BS,
|
||||||
|
MTX_TO_XX,
|
||||||
|
BS_TO_MTX,
|
||||||
|
MS_TO_MTX,
|
||||||
|
XX_TO_MTX,
|
||||||
|
};
|
||||||
|
|
||||||
|
typedef struct nmt_sysinfo {
|
||||||
|
enum nmt_chan_type chan_type; /* channel type */
|
||||||
|
int ms_power; /* ms power level 3 = full */
|
||||||
|
uint8_t traffic_area; /* two digits traffic area, encoded as YY */
|
||||||
|
uint8_t area_no; /* Area no. 1..4, 0 = no Area no. */
|
||||||
|
} nmt_sysinfo_t;
|
||||||
|
|
||||||
|
typedef struct nmt_subscriber {
|
||||||
|
/* NOTE: country must be followed by number, so both represent a string */
|
||||||
|
char country; /* country digit */
|
||||||
|
char number[7]; /* phone suffix */
|
||||||
|
char password[4]; /* phone's password + '\0' */
|
||||||
|
int coinbox; /* phone is a coinbox and accept tariff information */
|
||||||
|
} nmt_subscriber_t;
|
||||||
|
|
||||||
|
const char *nmt_dir_name(enum nmt_direction dir);
|
||||||
|
|
||||||
|
typedef struct nmt {
|
||||||
|
sender_t sender;
|
||||||
|
nmt_sysinfo_t sysinfo;
|
||||||
|
compander_t cstate;
|
||||||
|
dtmf_t dtmf;
|
||||||
|
|
||||||
|
/* sender's states */
|
||||||
|
enum nmt_state state;
|
||||||
|
enum nmt_active_state active_state;
|
||||||
|
nmt_subscriber_t subscriber; /* current subscriber */
|
||||||
|
struct timer timer;
|
||||||
|
int rx_frame_count; /* receive frame counter */
|
||||||
|
int tx_frame_count; /* transmit frame counter */
|
||||||
|
char dialing[33]; /* dialed digits */
|
||||||
|
int page_try; /* number of paging try */
|
||||||
|
|
||||||
|
/* features */
|
||||||
|
int compander; /* if compander shall be used */
|
||||||
|
int supervisory; /* if set, use supervisory signal 1..4 */
|
||||||
|
|
||||||
|
/* dsp states */
|
||||||
|
enum dsp_mode dsp_mode; /* current mode: audio, durable tone 0 or 1, paging */
|
||||||
|
int samples_per_bit; /* number of samples for one bit (1200 Baud) */
|
||||||
|
int super_samples; /* number of samples in buffer for supervisory detection */
|
||||||
|
int fsk_coeff[2]; /* coefficient k = 2*cos(2*PI*f/samplerate), k << 15 */
|
||||||
|
int super_coeff[5]; /* coefficient for supervisory signal */
|
||||||
|
int16_t *fsk_sine[2][2]; /* 4 pointers to 4 precalc. sine curves */
|
||||||
|
int fsk_polarity; /* current polarity state of bit */
|
||||||
|
int samples_per_chunk; /* how many samples lasts one chunk */
|
||||||
|
int16_t *fsk_filter_spl; /* array with samples_per_chunk */
|
||||||
|
int fsk_filter_pos; /* current sample position in filter_spl */
|
||||||
|
int fsk_filter_step; /* number of samples for each analyzation */
|
||||||
|
int fsk_filter_bit; /* last bit, so we detect a bit change */
|
||||||
|
int fsk_filter_sample; /* count until it is time to sample bit */
|
||||||
|
uint16_t fsk_filter_sync; /* shift register to detect sync */
|
||||||
|
int fsk_filter_in_sync; /* if we are in sync and receive bits */
|
||||||
|
int fsk_filter_mute; /* mute count down after sync */
|
||||||
|
char fsk_filter_frame[141]; /* receive frame (one extra byte to terminate string) */
|
||||||
|
int fsk_filter_count; /* next bit to receive */
|
||||||
|
double fsk_filter_levelsum; /* sum of 140 level infos */
|
||||||
|
double fsk_filter_qualitysum; /* sum of 140 quality infos */
|
||||||
|
int16_t *super_filter_spl; /* array with sample buffer for supervisory detection */
|
||||||
|
int super_filter_pos; /* current sample position in filter_spl */
|
||||||
|
double super_phaseshift256[4]; /* how much the phase of sine wave changes per sample */
|
||||||
|
double super_phase256; /* current phase */
|
||||||
|
double dial_phaseshift256; /* how much the phase of sine wave changes per sample */
|
||||||
|
double dial_phase256; /* current phase */
|
||||||
|
int frame; /* set, if there is a valid frame */
|
||||||
|
int16_t *frame_spl; /* 166 * fsk_bit_length */
|
||||||
|
int frame_pos; /* current sample position in frame_spl */
|
||||||
|
uint64_t rx_sample_count; /* sample counter */
|
||||||
|
uint64_t rx_sample_count_current;/* sample counter of current frame */
|
||||||
|
uint64_t rx_sample_count_last; /* sample counter of last frame */
|
||||||
|
int super_detected; /* current detection state flag */
|
||||||
|
int super_detect_count; /* current number of consecutive detections/losses */
|
||||||
|
int mft_num; /* counter for digit */
|
||||||
|
} nmt_t;
|
||||||
|
|
||||||
|
void nmt_channel_list(void);
|
||||||
|
int nmt_channel_by_short_name(const char *short_name);
|
||||||
|
const char *chan_type_short_name(enum nmt_chan_type chan_type);
|
||||||
|
const char *chan_type_long_name(enum nmt_chan_type chan_type);
|
||||||
|
double nmt_channel2freq(int channel, int uplink);
|
||||||
|
void nmt_country_list(void);
|
||||||
|
uint8_t nmt_country_by_short_name(const char *short_name);
|
||||||
|
int nmt_create(const char *sounddev, int samplerate, int channel, enum nmt_chan_type chan_type, uint8_t ms_power, uint8_t traffic_area, uint8_t area_no, int compander, int supervisory, int loopback);
|
||||||
|
void nmt_destroy(sender_t *sender);
|
||||||
|
void nmt_receive_frame(nmt_t *nmt, const char *bits, double quality, double level, double frames_elapsed);
|
||||||
|
const char *nmt_get_frame(nmt_t *nmt);
|
||||||
|
void nmt_rx_super(nmt_t *nmt, int tone, double quality);
|
||||||
|
|
|
@ -0,0 +1,43 @@
|
||||||
|
|
||||||
|
#include <stdint.h>
|
||||||
|
|
||||||
|
static int16_t pattern[] = {
|
||||||
|
0, 5320, 10063, 13716, 15883, 16328, 15004, 12054, 7798, 2697, -2697, -7798, -12054, -15004, -16328, -15883, -13716, -10063, -5320,
|
||||||
|
//0, 2660, 5032, 6858, 7941, 8164, 7502, 6027, 3899, 1348, -1348, -3899, -6027, -7502, -8164, -7941, -6858, -5032, -2660,
|
||||||
|
};
|
||||||
|
|
||||||
|
static int16_t tone[7999];
|
||||||
|
|
||||||
|
extern int16_t *ringback_spl;
|
||||||
|
extern int ringback_size;
|
||||||
|
extern int ringback_max;
|
||||||
|
extern int16_t *busy_spl;
|
||||||
|
extern int busy_size;
|
||||||
|
extern int busy_max;
|
||||||
|
extern int16_t *congestion_spl;
|
||||||
|
extern int congestion_size;
|
||||||
|
extern int congestion_max;
|
||||||
|
|
||||||
|
void init_nmt_tones(void)
|
||||||
|
{
|
||||||
|
int i, j;
|
||||||
|
|
||||||
|
for (i = 0, j = 0; i < 7999; i++) {
|
||||||
|
tone[i] = pattern[j++];
|
||||||
|
if (j == 19)
|
||||||
|
j = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
ringback_spl = tone;
|
||||||
|
ringback_size = 7999;
|
||||||
|
ringback_max = 8 * 5000; /* 1000 / 4000 */
|
||||||
|
|
||||||
|
busy_spl = tone;
|
||||||
|
busy_size = 1995;
|
||||||
|
busy_max = 8 * 500; /* 250 / 250 */
|
||||||
|
|
||||||
|
congestion_spl = tone;
|
||||||
|
congestion_size = 1995;
|
||||||
|
congestion_max = 8 * 500; /* 250 / 250 */
|
||||||
|
}
|
||||||
|
|
|
@ -0,0 +1,3 @@
|
||||||
|
|
||||||
|
void init_nmt_tones(void);
|
||||||
|
|
Loading…
Reference in New Issue