williamp/osmocom-analog
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

A-Netz / B-Netz: Add function to change state, debug with channel info

Browse Source 
Change state uses a function rather than directly setting state
variable.

Some debug commands now use channel number. (for multi-trx setups)
This commit is contained in:
Andreas Eversberg
2016-12-06 17:47:58 +01:00
parent eed826387a
commit f111c50478
5 changed files with 119 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files

67
src/anetz/anetz.c
View File

@@ -17,6 +17,8 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#define CHAN anetz->sender.kanal
#include <stdio.h> #include <stdio.h>
#include <stdint.h> #include <stdint.h>
#include <stdlib.h> #include <stdlib.h>
@@ -39,6 +41,35 @@ static int new_callref = 0x40000000;
#define PAGING_TO 30 /* Nach dieser Zeit ist der Operator genervt... */ #define PAGING_TO 30 /* Nach dieser Zeit ist der Operator genervt... */
#define RELEASE_TO 3 /* Release time, so station keeps blocked for a while */ #define RELEASE_TO 3 /* Release time, so station keeps blocked for a while */
const char *anetz_state_name(enum anetz_state state)
{
static char invalid[16];
switch (state) {
case ANETZ_NULL:
return "(NULL)";
case ANETZ_FREI:
return "FREI";
case ANETZ_GESPRAECH:
return "GESPRAECH";
case ANETZ_ANRUF:
return "ANRUF";
case ANETZ_AUSLOESEN:
return "AUSLOESEN";
}
sprintf(invalid, "invalid(%d)", state);
return invalid;
}
static void anetz_new_state(anetz_t *anetz, enum anetz_state new_state)
{
if (anetz->state == new_state)
return;
PDEBUG_CHAN(DANETZ, DEBUG_DEBUG, "State change: %s -> %s\n", anetz_state_name(anetz->state), anetz_state_name(new_state));
anetz->state = new_state;
}
/* Convert channel number to frequency number of base station. /* Convert channel number to frequency number of base station.
Set 'unterband' to 1 to get frequency of mobile station. */ Set 'unterband' to 1 to get frequency of mobile station. */
double anetz_kanal2freq(int kanal, int unterband) double anetz_kanal2freq(int kanal, int unterband)
@@ -200,8 +231,8 @@ static void anetz_go_idle(anetz_t *anetz)
{ {
timer_stop(&anetz->timer); timer_stop(&anetz->timer);
PDEBUG(DANETZ, DEBUG_INFO, "Entering IDLE state, sending 2280 Hz tone.\n"); PDEBUG(DANETZ, DEBUG_INFO, "Entering IDLE state on channel %d, sending 2280 Hz tone.\n", anetz->sender.kanal);
anetz->state = ANETZ_FREI; anetz_new_state(anetz, ANETZ_FREI);
anetz_set_dsp_mode(anetz, DSP_MODE_TONE); anetz_set_dsp_mode(anetz, DSP_MODE_TONE);
anetz->station_id[0] = '\0'; anetz->station_id[0] = '\0';
} }
@@ -211,8 +242,8 @@ static void anetz_release(anetz_t *anetz)
{ {
timer_stop(&anetz->timer); timer_stop(&anetz->timer);
PDEBUG(DANETZ, DEBUG_INFO, "Sending 2280 Hz release tone.\n"); PDEBUG_CHAN(DANETZ, DEBUG_INFO, "Sending 2280 Hz release tone.\n");
anetz->state = ANETZ_AUSLOESEN; anetz_new_state(anetz, ANETZ_AUSLOESEN);
anetz_set_dsp_mode(anetz, DSP_MODE_TONE); anetz_set_dsp_mode(anetz, DSP_MODE_TONE);
anetz->station_id[0] = '\0'; anetz->station_id[0] = '\0';
timer_start(&anetz->timer, RELEASE_TO); timer_start(&anetz->timer, RELEASE_TO);
@@ -221,8 +252,8 @@ static void anetz_release(anetz_t *anetz)
/* Enter paging state and transmit 4 paging tones. */ /* Enter paging state and transmit 4 paging tones. */
static void anetz_page(anetz_t *anetz, const char *dial_string, double *freq) static void anetz_page(anetz_t *anetz, const char *dial_string, double *freq)
{ {
PDEBUG(DANETZ, DEBUG_INFO, "Entering paging state, sending 'Selektivruf' to '%s'.\n", dial_string); PDEBUG_CHAN(DANETZ, DEBUG_INFO, "Entering paging state, sending 'Selektivruf' to '%s'.\n", dial_string);
anetz->state = ANETZ_ANRUF; anetz_new_state(anetz, ANETZ_ANRUF);
anetz_set_dsp_mode(anetz, DSP_MODE_PAGING); anetz_set_dsp_mode(anetz, DSP_MODE_PAGING);
dsp_set_paging(anetz, freq); dsp_set_paging(anetz, freq);
strcpy(anetz->station_id, dial_string); strcpy(anetz->station_id, dial_string);
@@ -233,7 +264,7 @@ static void anetz_page(anetz_t *anetz, const char *dial_string, double *freq)
void anetz_loss_indication(anetz_t *anetz) void anetz_loss_indication(anetz_t *anetz)
{ {
if (anetz->state == ANETZ_GESPRAECH) { if (anetz->state == ANETZ_GESPRAECH) {
PDEBUG(DANETZ, DEBUG_NOTICE, "Detected loss of signal, releasing.\n"); PDEBUG_CHAN(DANETZ, DEBUG_NOTICE, "Detected loss of signal, releasing.\n");
anetz_release(anetz); anetz_release(anetz);
call_in_release(anetz->callref, CAUSE_TEMPFAIL); call_in_release(anetz->callref, CAUSE_TEMPFAIL);
anetz->callref = 0; anetz->callref = 0;
@@ -244,9 +275,9 @@ void anetz_loss_indication(anetz_t *anetz)
void anetz_receive_tone(anetz_t *anetz, int tone) void anetz_receive_tone(anetz_t *anetz, int tone)
{ {
if (tone >= 0) if (tone >= 0)
PDEBUG(DANETZ, DEBUG_DEBUG, "Received contiuous %d Hz tone.\n", (tone) ? 1750 : 2280); PDEBUG_CHAN(DANETZ, DEBUG_DEBUG, "Received contiuous %d Hz tone.\n", (tone) ? 1750 : 2280);
else else
PDEBUG(DANETZ, DEBUG_DEBUG, "Continuous tone is gone.\n"); PDEBUG_CHAN(DANETZ, DEBUG_DEBUG, "Continuous tone is gone.\n");
/* skip any handling in loopback mode */ /* skip any handling in loopback mode */
if (anetz->sender.loopback) if (anetz->sender.loopback)
@@ -260,8 +291,8 @@ void anetz_receive_tone(anetz_t *anetz, int tone)
case ANETZ_FREI: case ANETZ_FREI:
/* initiate call on calling tone */ /* initiate call on calling tone */
if (tone == 1) { if (tone == 1) {
PDEBUG(DANETZ, DEBUG_INFO, "Received 1750 Hz calling signal from mobile station, removing idle signal.\n"); PDEBUG_CHAN(DANETZ, DEBUG_INFO, "Received 1750 Hz calling signal from mobile station, removing idle signal.\n");
anetz->state = ANETZ_GESPRAECH; anetz_new_state(anetz, ANETZ_GESPRAECH);
anetz_set_dsp_mode(anetz, DSP_MODE_SILENCE); anetz_set_dsp_mode(anetz, DSP_MODE_SILENCE);
break; break;
} }
@@ -273,23 +304,23 @@ void anetz_receive_tone(anetz_t *anetz, int tone)
int callref = ++new_callref; int callref = ++new_callref;
int rc; int rc;
PDEBUG(DANETZ, DEBUG_INFO, "1750 Hz signal from mobile station is gone, setup call.\n"); PDEBUG_CHAN(DANETZ, DEBUG_INFO, "1750 Hz signal from mobile station is gone, setup call.\n");
rc = call_in_setup(callref, NULL, "010"); rc = call_in_setup(callref, NULL, "010");
if (rc < 0) { if (rc < 0) {
PDEBUG(DANETZ, DEBUG_NOTICE, "Call rejected (cause %d), sending release tone.\n", -rc); PDEBUG_CHAN(DANETZ, DEBUG_NOTICE, "Call rejected (cause %d), sending release tone.\n", -rc);
anetz_release(anetz); anetz_release(anetz);
break; break;
} }
anetz->callref = callref; anetz->callref = callref;
} else { } else {
PDEBUG(DANETZ, DEBUG_INFO, "1750 Hz signal from mobile station is gone, answer call.\n"); PDEBUG_CHAN(DANETZ, DEBUG_INFO, "1750 Hz signal from mobile station is gone, answer call.\n");
call_in_answer(anetz->callref, anetz->station_id); call_in_answer(anetz->callref, anetz->station_id);
} }
anetz_set_dsp_mode(anetz, DSP_MODE_AUDIO); anetz_set_dsp_mode(anetz, DSP_MODE_AUDIO);
} }
/* release call */ /* release call */
if (tone == 1) { if (tone == 1) {
PDEBUG(DANETZ, DEBUG_INFO, "Received 1750 Hz release signal from mobile station, sending release tone.\n"); PDEBUG_CHAN(DANETZ, DEBUG_INFO, "Received 1750 Hz release signal from mobile station, sending release tone.\n");
anetz_release(anetz); anetz_release(anetz);
call_in_release(anetz->callref, CAUSE_NORMAL); call_in_release(anetz->callref, CAUSE_NORMAL);
anetz->callref = 0; anetz->callref = 0;
@@ -299,9 +330,9 @@ void anetz_receive_tone(anetz_t *anetz, int tone)
case ANETZ_ANRUF: case ANETZ_ANRUF:
/* answer call on answer tone */ /* answer call on answer tone */
if (tone == 1) { if (tone == 1) {
PDEBUG(DANETZ, DEBUG_INFO, "Received 1750 Hz answer signal from mobile station, removing paging tones.\n"); PDEBUG_CHAN(DANETZ, DEBUG_INFO, "Received 1750 Hz answer signal from mobile station, removing paging tones.\n");
timer_stop(&anetz->timer); timer_stop(&anetz->timer);
anetz->state = ANETZ_GESPRAECH; anetz_new_state(anetz, ANETZ_GESPRAECH);
anetz_set_dsp_mode(anetz, DSP_MODE_SILENCE); anetz_set_dsp_mode(anetz, DSP_MODE_SILENCE);
break; break;
} }
@@ -317,7 +348,7 @@ static void anetz_timeout(struct timer *timer)
switch (anetz->state) { switch (anetz->state) {
case ANETZ_ANRUF: case ANETZ_ANRUF:
PDEBUG(DANETZ, DEBUG_NOTICE, "Timeout while waiting for answer, releasing.\n"); PDEBUG_CHAN(DANETZ, DEBUG_NOTICE, "Timeout while waiting for answer, releasing.\n");
anetz_go_idle(anetz); anetz_go_idle(anetz);
call_in_release(anetz->callref, CAUSE_NOANSWER); call_in_release(anetz->callref, CAUSE_NOANSWER);
anetz->callref = 0; anetz->callref = 0;

1
src/anetz/anetz.h
View File

@@ -8,6 +8,7 @@ enum dsp_mode {
}; };
enum anetz_state { enum anetz_state {
ANETZ_NULL = 0,
ANETZ_FREI, /* sending 2280 Hz tone */ ANETZ_FREI, /* sending 2280 Hz tone */
ANETZ_GESPRAECH, /* during conversation */ ANETZ_GESPRAECH, /* during conversation */
ANETZ_ANRUF, /* phone is paged */ ANETZ_ANRUF, /* phone is paged */

95
src/bnetz/bnetz.c
View File

@@ -17,6 +17,8 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#define CHAN bnetz->sender.kanal
#include <stdio.h> #include <stdio.h>
#include <stdint.h> #include <stdint.h>
#include <stdlib.h> #include <stdlib.h>
@@ -55,6 +57,43 @@ static int new_callref = 0x40000000;
#define TRENN_COUNT 4 /* min. 350 ms disconnect "Trennsignal" */ #define TRENN_COUNT 4 /* min. 350 ms disconnect "Trennsignal" */
#define TRENN_COUNT_NA 96 /* 12 s disconnect "Trennsignal" if no answer */ #define TRENN_COUNT_NA 96 /* 12 s disconnect "Trennsignal" if no answer */
const char *bnetz_state_name(enum bnetz_state state)
{
static char invalid[16];
switch (state) {
case BNETZ_NULL:
return "(NULL)";
case BNETZ_FREI:
return "FREI";
case BNETZ_WAHLABRUF:
return "WAHLABRUF";
case BNETZ_SELEKTIVRUF_EIN:
return "SELEKTIVRUF_EIN";
case BNETZ_SELEKTIVRUF_AUS:
return "SELEKTIVRUF_AUS";
case BNETZ_RUFBESTAETIGUNG:
return "RUFBESTAETIGUNG";
case BNETZ_RUFHALTUNG:
return "RUFHALTUNG";
case BNETZ_GESPRAECH:
return "GESPRAECH";
case BNETZ_TRENNEN:
return "TRENNEN";
}
sprintf(invalid, "invalid(%d)", state);
return invalid;
}
static void bnetz_new_state(bnetz_t *bnetz, enum bnetz_state new_state)
{
if (bnetz->state == new_state)
return;
PDEBUG_CHAN(DBNETZ, DEBUG_DEBUG, "State change: %s -> %s\n", bnetz_state_name(bnetz->state), bnetz_state_name(new_state));
bnetz->state = new_state;
}
/* Convert channel number to frequency number of base station. /* Convert channel number to frequency number of base station.
Set 'unterband' to 1 to get frequency of mobile station. */ Set 'unterband' to 1 to get frequency of mobile station. */
double bnetz_kanal2freq(int kanal, int unterband) double bnetz_kanal2freq(int kanal, int unterband)
@@ -211,8 +250,8 @@ static void bnetz_go_idle(bnetz_t *bnetz)
{ {
timer_stop(&bnetz->timer); timer_stop(&bnetz->timer);
PDEBUG(DBNETZ, DEBUG_INFO, "Entering IDLE state, sending 'Gruppenfreisignal' %d.\n", bnetz->gfs); PDEBUG(DBNETZ, DEBUG_INFO, "Entering IDLE state on channel %d, sending 'Gruppenfreisignal' %d.\n", bnetz->sender.kanal, bnetz->gfs);
bnetz->state = BNETZ_FREI; bnetz_new_state(bnetz, BNETZ_FREI);
bnetz_set_dsp_mode(bnetz, DSP_MODE_TELEGRAMM); bnetz_set_dsp_mode(bnetz, DSP_MODE_TELEGRAMM);
switch_channel_19(bnetz, 0); switch_channel_19(bnetz, 0);
bnetz->station_id[0] = '\0'; bnetz->station_id[0] = '\0';
@@ -229,8 +268,8 @@ static void bnetz_release(bnetz_t *bnetz, int trenn_count)
{ {
timer_stop(&bnetz->timer); timer_stop(&bnetz->timer);
PDEBUG(DBNETZ, DEBUG_INFO, "Entering release state, sending 'Trennsignal' (%d times).\n", trenn_count); PDEBUG_CHAN(DBNETZ, DEBUG_INFO, "Entering release state, sending 'Trennsignal' (%d times).\n", trenn_count);
bnetz->state = BNETZ_TRENNEN; bnetz_new_state(bnetz, BNETZ_TRENNEN);
bnetz_set_dsp_mode(bnetz, DSP_MODE_TELEGRAMM); bnetz_set_dsp_mode(bnetz, DSP_MODE_TELEGRAMM);
switch_channel_19(bnetz, 0); switch_channel_19(bnetz, 0);
bnetz->trenn_count = trenn_count; bnetz->trenn_count = trenn_count;
@@ -240,8 +279,8 @@ static void bnetz_release(bnetz_t *bnetz, int trenn_count)
/* Enter paging state and transmit station ID. */ /* Enter paging state and transmit station ID. */
static void bnetz_page(bnetz_t *bnetz, const char *dial_string, int try) static void bnetz_page(bnetz_t *bnetz, const char *dial_string, int try)
{ {
PDEBUG(DBNETZ, DEBUG_INFO, "Entering paging state (try %d), sending 'Selektivruf' to '%s'.\n", try, dial_string); PDEBUG_CHAN(DBNETZ, DEBUG_INFO, "Entering paging state (try %d), sending 'Selektivruf' to '%s'.\n", try, dial_string);
bnetz->state = BNETZ_SELEKTIVRUF_EIN; bnetz_new_state(bnetz, BNETZ_SELEKTIVRUF_EIN);
bnetz_set_dsp_mode(bnetz, DSP_MODE_0); bnetz_set_dsp_mode(bnetz, DSP_MODE_0);
bnetz->page_mode = PAGE_MODE_NUMBER; bnetz->page_mode = PAGE_MODE_NUMBER;
bnetz->page_try = try; bnetz->page_try = try;
@@ -287,8 +326,8 @@ const char *bnetz_get_telegramm(bnetz_t *bnetz)
break; break;
case BNETZ_SELEKTIVRUF_EIN: case BNETZ_SELEKTIVRUF_EIN:
if (bnetz->page_mode == PAGE_MODE_KANALBEFEHL) { if (bnetz->page_mode == PAGE_MODE_KANALBEFEHL) {
PDEBUG(DBNETZ, DEBUG_INFO, "Paging mobile station %s complete, waiting for answer.\n", bnetz->station_id); PDEBUG_CHAN(DBNETZ, DEBUG_INFO, "Paging mobile station %s complete, waiting for answer.\n", bnetz->station_id);
bnetz->state = BNETZ_SELEKTIVRUF_AUS; bnetz_new_state(bnetz, BNETZ_SELEKTIVRUF_AUS);
bnetz_set_dsp_mode(bnetz, DSP_MODE_SILENCE); bnetz_set_dsp_mode(bnetz, DSP_MODE_SILENCE);
timer_start(&bnetz->timer, SWITCHBACK_TIME); timer_start(&bnetz->timer, SWITCHBACK_TIME);
return NULL; return NULL;
@@ -302,7 +341,7 @@ const char *bnetz_get_telegramm(bnetz_t *bnetz)
break; break;
case BNETZ_TRENNEN: case BNETZ_TRENNEN:
if (bnetz->trenn_count-- == 0) { if (bnetz->trenn_count-- == 0) {
PDEBUG(DBNETZ, DEBUG_DEBUG, "Maximum number of release digits sent, going idle.\n"); PDEBUG_CHAN(DBNETZ, DEBUG_DEBUG, "Maximum number of release digits sent, going idle.\n");
bnetz_go_idle(bnetz); bnetz_go_idle(bnetz);
return NULL; return NULL;
} }
@@ -315,7 +354,7 @@ const char *bnetz_get_telegramm(bnetz_t *bnetz)
if (!it) if (!it)
abort(); abort();
PDEBUG(DBNETZ, DEBUG_DEBUG, "Sending telegramm '%s'.\n", it->description); PDEBUG_CHAN(DBNETZ, DEBUG_DEBUG, "Sending telegramm '%s'.\n", it->description);
return it->sequence; return it->sequence;
} }
@@ -324,7 +363,7 @@ void bnetz_loss_indication(bnetz_t *bnetz)
{ {
if (bnetz->state == BNETZ_GESPRAECH if (bnetz->state == BNETZ_GESPRAECH
|| bnetz->state == BNETZ_RUFHALTUNG) { || bnetz->state == BNETZ_RUFHALTUNG) {
PDEBUG(DBNETZ, DEBUG_NOTICE, "Detected loss of signal, releasing.\n"); PDEBUG_CHAN(DBNETZ, DEBUG_NOTICE, "Detected loss of signal, releasing.\n");
bnetz_release(bnetz, TRENN_COUNT); bnetz_release(bnetz, TRENN_COUNT);
call_in_release(bnetz->callref, CAUSE_TEMPFAIL); call_in_release(bnetz->callref, CAUSE_TEMPFAIL);
bnetz->callref = 0; bnetz->callref = 0;
@@ -335,9 +374,9 @@ void bnetz_loss_indication(bnetz_t *bnetz)
void bnetz_receive_tone(bnetz_t *bnetz, int bit) void bnetz_receive_tone(bnetz_t *bnetz, int bit)
{ {
if (bit >= 0) if (bit >= 0)
PDEBUG(DBNETZ, DEBUG_DEBUG, "Received contiuous %d Hz tone.\n", (bit)?1950:2070); PDEBUG_CHAN(DBNETZ, DEBUG_DEBUG, "Received contiuous %d Hz tone.\n", (bit)?1950:2070);
else else
PDEBUG(DBNETZ, DEBUG_DEBUG, "Continuous tone is gone.\n"); PDEBUG_CHAN(DBNETZ, DEBUG_DEBUG, "Continuous tone is gone.\n");
if (bnetz->sender.loopback) { if (bnetz->sender.loopback) {
return; return;
@@ -346,8 +385,8 @@ void bnetz_receive_tone(bnetz_t *bnetz, int bit)
switch (bnetz->state) { switch (bnetz->state) {
case BNETZ_FREI: case BNETZ_FREI:
if (bit == 0) { if (bit == 0) {
PDEBUG(DBNETZ, DEBUG_INFO, "Received signal 'Kanalbelegung' from mobile station, sending signal 'Wahlabruf'.\n"); PDEBUG_CHAN(DBNETZ, DEBUG_INFO, "Received signal 'Kanalbelegung' from mobile station, sending signal 'Wahlabruf'.\n");
bnetz->state = BNETZ_WAHLABRUF; bnetz_new_state(bnetz, BNETZ_WAHLABRUF);
bnetz->dial_mode = DIAL_MODE_START; bnetz->dial_mode = DIAL_MODE_START;
bnetz_set_dsp_mode(bnetz, DSP_MODE_1); bnetz_set_dsp_mode(bnetz, DSP_MODE_1);
timer_start(&bnetz->timer, DIALING_TO); timer_start(&bnetz->timer, DIALING_TO);
@@ -356,9 +395,9 @@ void bnetz_receive_tone(bnetz_t *bnetz, int bit)
break; break;
case BNETZ_RUFBESTAETIGUNG: case BNETZ_RUFBESTAETIGUNG:
if (bit == 1) { if (bit == 1) {
PDEBUG(DBNETZ, DEBUG_INFO, "Received signal 'Rufbestaetigung' from mobile station, sending signal 'Rufhaltung'. (call is ringing)\n"); PDEBUG_CHAN(DBNETZ, DEBUG_INFO, "Received signal 'Rufbestaetigung' from mobile station, sending signal 'Rufhaltung'. (call is ringing)\n");
timer_stop(&bnetz->timer); timer_stop(&bnetz->timer);
bnetz->state = BNETZ_RUFHALTUNG; bnetz_new_state(bnetz, BNETZ_RUFHALTUNG);
bnetz_set_dsp_mode(bnetz, DSP_MODE_1); bnetz_set_dsp_mode(bnetz, DSP_MODE_1);
call_in_alerting(bnetz->callref); call_in_alerting(bnetz->callref);
timer_start(&bnetz->timer, ALERTING_TO); timer_start(&bnetz->timer, ALERTING_TO);
@@ -367,9 +406,9 @@ void bnetz_receive_tone(bnetz_t *bnetz, int bit)
break; break;
case BNETZ_RUFHALTUNG: case BNETZ_RUFHALTUNG:
if (bit == 0) { if (bit == 0) {
PDEBUG(DBNETZ, DEBUG_INFO, "Received signal 'Beginnsignal' from mobile station, call establised.\n"); PDEBUG_CHAN(DBNETZ, DEBUG_INFO, "Received signal 'Beginnsignal' from mobile station, call establised.\n");
timer_stop(&bnetz->timer); timer_stop(&bnetz->timer);
bnetz->state = BNETZ_GESPRAECH; bnetz_new_state(bnetz, BNETZ_GESPRAECH);
bnetz_set_dsp_mode(bnetz, DSP_MODE_AUDIO); bnetz_set_dsp_mode(bnetz, DSP_MODE_AUDIO);
call_in_answer(bnetz->callref, bnetz->station_id); call_in_answer(bnetz->callref, bnetz->station_id);
break; break;
@@ -385,7 +424,7 @@ void bnetz_receive_telegramm(bnetz_t *bnetz, uint16_t telegramm, double level, d
struct impulstelegramm *it; struct impulstelegramm *it;
int digit = 0; int digit = 0;
PDEBUG(DFRAME, DEBUG_INFO, "Digit RX Level: %.0f%% Quality=%.0f\n", level * 100.0 + 0.5, quality * 100.0 + 0.5); PDEBUG_CHAN(DFRAME, DEBUG_INFO, "Digit RX Level: %.0f%% Quality=%.0f\n", level * 100.0 + 0.5, quality * 100.0 + 0.5);
/* drop any telegramm that is too bad */ /* drop any telegramm that is too bad */
if (quality < 0.2) if (quality < 0.2)
@@ -528,7 +567,7 @@ void bnetz_receive_telegramm(bnetz_t *bnetz, uint16_t telegramm, double level, d
PDEBUG(DBNETZ, DEBUG_INFO, "Dialing complete %s->%s, call established.\n", bnetz->station_id, dialing); PDEBUG(DBNETZ, DEBUG_INFO, "Dialing complete %s->%s, call established.\n", bnetz->station_id, dialing);
timer_stop(&bnetz->timer); timer_stop(&bnetz->timer);
bnetz_set_dsp_mode(bnetz, DSP_MODE_AUDIO); bnetz_set_dsp_mode(bnetz, DSP_MODE_AUDIO);
bnetz->state = BNETZ_GESPRAECH; bnetz_new_state(bnetz, BNETZ_GESPRAECH);
/* setup call */ /* setup call */
PDEBUG(DBNETZ, DEBUG_INFO, "Setup call to network.\n"); PDEBUG(DBNETZ, DEBUG_INFO, "Setup call to network.\n");
@@ -587,32 +626,32 @@ static void bnetz_timeout(struct timer *timer)
break; break;
#endif #endif
case BNETZ_WAHLABRUF: case BNETZ_WAHLABRUF:
PDEBUG(DBNETZ, DEBUG_NOTICE, "Timeout while receiving call setup from mobile station, aborting.\n"); PDEBUG_CHAN(DBNETZ, DEBUG_NOTICE, "Timeout while receiving call setup from mobile station, aborting.\n");
bnetz_release(bnetz, TRENN_COUNT); bnetz_release(bnetz, TRENN_COUNT);
break; break;
case BNETZ_SELEKTIVRUF_EIN: case BNETZ_SELEKTIVRUF_EIN:
PDEBUG(DBNETZ, DEBUG_DEBUG, "Transmitter switched to channel 19, starting paging telegramms.\n"); PDEBUG_CHAN(DBNETZ, DEBUG_DEBUG, "Transmitter switched to channel 19, starting paging telegramms.\n");
bnetz_set_dsp_mode(bnetz, DSP_MODE_TELEGRAMM); bnetz_set_dsp_mode(bnetz, DSP_MODE_TELEGRAMM);
break; break;
case BNETZ_SELEKTIVRUF_AUS: case BNETZ_SELEKTIVRUF_AUS:
PDEBUG(DBNETZ, DEBUG_DEBUG, "Transmitter switched back to channel %d, waiting for paging response.\n", bnetz->sender.kanal); PDEBUG_CHAN(DBNETZ, DEBUG_DEBUG, "Transmitter switched back to channel %d, waiting for paging response.\n", bnetz->sender.kanal);
bnetz->state = BNETZ_RUFBESTAETIGUNG; bnetz_new_state(bnetz, BNETZ_RUFBESTAETIGUNG);
switch_channel_19(bnetz, 0); switch_channel_19(bnetz, 0);
timer_start(&bnetz->timer, PAGING_TO); timer_start(&bnetz->timer, PAGING_TO);
break; break;
case BNETZ_RUFBESTAETIGUNG: case BNETZ_RUFBESTAETIGUNG:
if (bnetz->page_try == PAGE_TRIES) { if (bnetz->page_try == PAGE_TRIES) {
PDEBUG(DBNETZ, DEBUG_NOTICE, "Timeout while waiting for call acknowledge from mobile station, going idle.\n"); PDEBUG_CHAN(DBNETZ, DEBUG_NOTICE, "Timeout while waiting for call acknowledge from mobile station, going idle.\n");
bnetz_release(bnetz, TRENN_COUNT); bnetz_release(bnetz, TRENN_COUNT);
call_in_release(bnetz->callref, CAUSE_OUTOFORDER); call_in_release(bnetz->callref, CAUSE_OUTOFORDER);
bnetz->callref = 0; bnetz->callref = 0;
break; break;
} }
PDEBUG(DBNETZ, DEBUG_NOTICE, "Timeout while waiting for call acknowledge from mobile station, trying again.\n"); PDEBUG_CHAN(DBNETZ, DEBUG_NOTICE, "Timeout while waiting for call acknowledge from mobile station, trying again.\n");
bnetz_page(bnetz, bnetz->station_id, bnetz->page_try + 1); bnetz_page(bnetz, bnetz->station_id, bnetz->page_try + 1);
break; break;
case BNETZ_RUFHALTUNG: case BNETZ_RUFHALTUNG:
PDEBUG(DBNETZ, DEBUG_NOTICE, "Timeout while waiting for answer of mobile station, releasing.\n"); PDEBUG_CHAN(DBNETZ, DEBUG_NOTICE, "Timeout while waiting for answer of mobile station, releasing.\n");
bnetz_release(bnetz, TRENN_COUNT_NA); bnetz_release(bnetz, TRENN_COUNT_NA);
call_in_release(bnetz->callref, CAUSE_NOANSWER); call_in_release(bnetz->callref, CAUSE_NOANSWER);
bnetz->callref = 0; bnetz->callref = 0;

1
src/bnetz/bnetz.h
View File

@@ -11,6 +11,7 @@ enum dsp_mode {
/* current state of b-netz sender */ /* current state of b-netz sender */
enum bnetz_state { enum bnetz_state {
BNETZ_NULL = 0,
BNETZ_FREI, /* sending 'Gruppenfreisignal' */ BNETZ_FREI, /* sending 'Gruppenfreisignal' */
BNETZ_WAHLABRUF, /* sending 'Wahlabruf', receiving call setup */ BNETZ_WAHLABRUF, /* sending 'Wahlabruf', receiving call setup */
BNETZ_SELEKTIVRUF_EIN, /* paging phone (switch to calling channel) */ BNETZ_SELEKTIVRUF_EIN, /* paging phone (switch to calling channel) */

2
src/nmt/nmt.h
View File

@@ -22,7 +22,7 @@ enum nmt_chan_type {
}; };
enum nmt_state { enum nmt_state {
STATE_NULL, /* power off state */ STATE_NULL = 0, /* power off state */
STATE_IDLE, /* channel is not in use */ STATE_IDLE, /* channel is not in use */
STATE_ROAMING_IDENT, /* seizure received, waiting for identity */ STATE_ROAMING_IDENT, /* seizure received, waiting for identity */
STATE_ROAMING_CONFIRM, /* identity received, sending confirm */ STATE_ROAMING_CONFIRM, /* identity received, sending confirm */