mirror of https://gerrit.osmocom.org/osmo-tetra
352 lines
9.5 KiB
C
352 lines
9.5 KiB
C
/* (C) 2011 by Harald Welte <laforge@gnumonks.org>
|
|
* All Rights Reserved
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero 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 Affero General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <time.h>
|
|
|
|
#include <arpa/inet.h>
|
|
|
|
#include <osmocore/utils.h>
|
|
#include <osmocore/bits.h>
|
|
|
|
|
|
#include "tetra_common.h"
|
|
#include <lower_mac/crc_simple.h>
|
|
#include <lower_mac/tetra_conv_enc.h>
|
|
#include <lower_mac/tetra_interleave.h>
|
|
#include <lower_mac/tetra_scramb.h>
|
|
#include <lower_mac/tetra_rm3014.h>
|
|
#include <lower_mac/viterbi.h>
|
|
#include <phy/tetra_burst.h>
|
|
#include "testpdu.h"
|
|
|
|
|
|
#define swap16(x) ((x)<<8)|((x)>>8)
|
|
|
|
static unsigned int num_crc_err;
|
|
|
|
/* incoming TP-SAP UNITDATA.ind from PHY into lower MAC */
|
|
void tp_sap_udata_ind(enum tp_sap_data_type type, const uint8_t *bits, unsigned int len, void *priv)
|
|
{
|
|
}
|
|
|
|
static void decode_schf(const uint8_t *bits)
|
|
{
|
|
uint8_t type4[1024];
|
|
uint8_t type3dp[1024*4];
|
|
uint8_t type3[1024];
|
|
uint8_t type2[1024];
|
|
|
|
printf("SCH/f type5: %s\n", bitdump(bits, 432));
|
|
memcpy(type4, bits, 432);
|
|
tetra_scramb_bits(SCRAMB_INIT, type4, 432);
|
|
printf("SCH/F type4: %s\n", bitdump(type4, 432));
|
|
/* Run (120,11) block deinterleaving: type-3 bits */
|
|
block_deinterleave(432, 103, type4, type3);
|
|
printf("SCH/F type3: %s\n", bitdump(type3, 432));
|
|
/* De-puncture */
|
|
memset(type3dp, 0xff, sizeof(type3dp));
|
|
tetra_rcpc_depunct(TETRA_RCPC_PUNCT_2_3, type3, 432, type3dp);
|
|
printf("SCH/F type3dp: %s\n", bitdump(type3dp, 288*4));
|
|
viterbi_dec_sb1_wrapper(type3dp, type2, 288);
|
|
printf("SCH/F type2: %s\n", bitdump(type2, 288));
|
|
|
|
{
|
|
uint16_t crc;
|
|
crc = crc16_ccitt_bits(type2, 288-4);
|
|
printf("CRC COMP: 0x%04x ", crc);
|
|
if (crc == 0x1d0f)
|
|
printf("OK\n");
|
|
else {
|
|
printf("WRONG\n");
|
|
num_crc_err++;
|
|
}
|
|
}
|
|
printf("SCH/F type1: %s\n", bitdump(type2, 268));
|
|
}
|
|
|
|
/* Build a full 'downlink continuous SYNC burst' from SYSINFO-PDU and SYNC-PDU */
|
|
int build_ndb_schf()
|
|
{
|
|
/* input: 268 type-1 bits */
|
|
uint8_t type2[284];
|
|
uint8_t master[284*4];
|
|
uint8_t type3[432];
|
|
uint8_t type4[432];
|
|
uint8_t type5[432];
|
|
uint8_t bb_type5[30];
|
|
uint8_t burst[255*2];
|
|
uint16_t crc;
|
|
uint8_t *cur;
|
|
uint32_t bb_rm3014, bb_rm3014_be;
|
|
|
|
memset(type2, 0, sizeof(type2));
|
|
cur = type2;
|
|
|
|
/* Use pdu_sync from testpdu.c */
|
|
cur += osmo_pbit2ubit(type2, pdu_schf, 268);
|
|
|
|
crc = ~crc16_ccitt_bits(type2, 268);
|
|
crc = swap16(crc);
|
|
cur += osmo_pbit2ubit(cur, (uint8_t *) &crc, 16);
|
|
|
|
/* Append 4 tail bits: type-2 bits */
|
|
cur += 4;
|
|
|
|
printf("SCH/F type2: %s\n", bitdump(type2, 288));
|
|
|
|
/* Run rate 2/3 RCPC code: type-3 bits*/
|
|
{
|
|
struct conv_enc_state *ces = calloc(1, sizeof(*ces));
|
|
conv_enc_init(ces);
|
|
conv_enc_input(ces, type2, 288, master);
|
|
get_punctured_rate(TETRA_RCPC_PUNCT_2_3, master, 432, type3);
|
|
free(ces);
|
|
}
|
|
printf("SCH/F type3: %s\n", bitdump(type3, 432));
|
|
|
|
/* Run (432,103) block interleaving: type-4 bits */
|
|
block_interleave(432, 103, type3, type4);
|
|
printf("SCH/F type4: %s\n", bitdump(type4, 432));
|
|
|
|
/* Run scrambling (all-zero): type-5 bits */
|
|
memcpy(type5, type4, 432);
|
|
tetra_scramb_bits(SCRAMB_INIT, type5, 432);
|
|
printf("SCH/F type5: %s\n", bitdump(type5, 432));
|
|
|
|
decode_schf(type5);
|
|
|
|
/* Use pdu_acc_ass from testpdu.c */
|
|
/* Run it through (30,14) RM code: type-2=3=4 bits */
|
|
printf("AACH type-1: %s\n", bitdump(pdu_acc_ass, 2));
|
|
bb_rm3014 = tetra_rm3014_compute(*(uint16_t *)pdu_acc_ass);
|
|
printf("AACH RM3014: 0x0%x\n", bb_rm3014);
|
|
/* convert to big endian */
|
|
bb_rm3014_be = htonl(bb_rm3014);
|
|
/* shift two bits left as it is only a 30 bit value */
|
|
bb_rm3014_be <<= 2;
|
|
osmo_pbit2ubit(bb_type5, (uint8_t *) &bb_rm3014_be, 30);
|
|
/* Run scrambling (all-zero): type-5 bits */
|
|
printf("AACH type-5: %s\n", bitdump(bb_type5, 30));
|
|
|
|
/* Finally, hand it into the physical layer */
|
|
build_norm_c_d_burst(burst, type5, bb_type5, type5+216, 0);
|
|
printf("cont norm DL burst: %s\n", bitdump(burst, 255*2));
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static void decode_sb1(const uint8_t *bits)
|
|
{
|
|
uint8_t type4[1024];
|
|
uint8_t type3dp[1024*4];
|
|
uint8_t type3[1024];
|
|
uint8_t type2[1024];
|
|
|
|
printf("SB1 type5: %s\n", bitdump(bits, 120));
|
|
memcpy(type4, bits, 120);
|
|
tetra_scramb_bits(SCRAMB_INIT, type4, 120);
|
|
printf("SB1 type4: %s\n", bitdump(type4, 120));
|
|
/* Run (120,11) block deinterleaving: type-3 bits */
|
|
block_deinterleave(120, 11, type4, type3);
|
|
printf("SB1 type3: %s\n", bitdump(type3, 120));
|
|
/* De-puncture */
|
|
memset(type3dp, 0xff, sizeof(type3dp));
|
|
tetra_rcpc_depunct(TETRA_RCPC_PUNCT_2_3, type3, 120, type3dp);
|
|
printf("SB1 type3dp: %s\n", bitdump(type3dp, 80*4));
|
|
viterbi_dec_sb1_wrapper(type3dp, type2, 80);
|
|
printf("SB1 type2: %s\n", bitdump(type2, 80));
|
|
|
|
{
|
|
uint16_t crc;
|
|
crc = crc16_ccitt_bits(type2, 76);
|
|
printf("CRC COMP: 0x%04x ", crc);
|
|
if (crc == 0x1d0f)
|
|
printf("OK\n");
|
|
else {
|
|
printf("WRONG\n");
|
|
num_crc_err++;
|
|
}
|
|
}
|
|
|
|
printf("TN %s ", bitdump(type2+10, 2));
|
|
printf("MCC %s ", bitdump(type2+31, 10));
|
|
printf("MNC %s\n", bitdump(type2+41, 14));
|
|
}
|
|
|
|
/* Build a full 'downlink continuous SYNC burst' from SYSINFO-PDU and SYNC-PDU */
|
|
int build_sb()
|
|
{
|
|
uint8_t sb_type2[80];
|
|
uint8_t sb_master[80*4];
|
|
uint8_t sb_type3[120];
|
|
uint8_t sb_type4[120];
|
|
uint8_t sb_type5[120];
|
|
|
|
uint8_t si_type2[140];
|
|
uint8_t si_master[140*4];
|
|
uint8_t si_type3[216];
|
|
uint8_t si_type4[216];
|
|
uint8_t si_type5[216];
|
|
|
|
uint8_t bb_type5[30];
|
|
uint8_t burst[255*2];
|
|
uint16_t crc;
|
|
uint8_t *cur;
|
|
uint32_t bb_rm3014, bb_rm3014_be;
|
|
|
|
memset(sb_type2, 0, sizeof(sb_type2));
|
|
cur = sb_type2;
|
|
|
|
/* Use pdu_sync from testpdu.c */
|
|
cur += osmo_pbit2ubit(sb_type2, pdu_sync, 60);
|
|
|
|
crc = ~crc16_ccitt_bits(sb_type2, 60);
|
|
crc = swap16(crc);
|
|
cur += osmo_pbit2ubit(cur, (uint8_t *) &crc, 16);
|
|
|
|
/* Append 4 tail bits: type-2 bits */
|
|
cur += 4;
|
|
|
|
printf("SYNC type2: %s\n", bitdump(sb_type2, 80));
|
|
|
|
/* Run rate 2/3 RCPC code: type-3 bits*/
|
|
{
|
|
struct conv_enc_state *ces = calloc(1, sizeof(*ces));
|
|
conv_enc_init(ces);
|
|
conv_enc_input(ces, sb_type2, 80, sb_master);
|
|
get_punctured_rate(TETRA_RCPC_PUNCT_2_3, sb_master, 120, sb_type3);
|
|
free(ces);
|
|
}
|
|
printf("SYNC type3: %s\n", bitdump(sb_type3, 120));
|
|
|
|
/* Run (120,11) block interleaving: type-4 bits */
|
|
block_interleave(120, 11, sb_type3, sb_type4);
|
|
printf("SYNC type4: %s\n", bitdump(sb_type4, 120));
|
|
|
|
/* Run scrambling (all-zero): type-5 bits */
|
|
memcpy(sb_type5, sb_type4, 120);
|
|
tetra_scramb_bits(SCRAMB_INIT, sb_type5, 120);
|
|
printf("SYNC type5: %s\n", bitdump(sb_type5, 120));
|
|
|
|
decode_sb1(sb_type5);
|
|
|
|
/* Use pdu_sysinfo from testpdu.c */
|
|
memset(si_type2, 0, sizeof(si_type2));
|
|
cur = si_type2;
|
|
cur += osmo_pbit2ubit(si_type2, pdu_sysinfo, 124);
|
|
|
|
/* Run it through CRC16-CCITT */
|
|
crc = ~crc16_ccitt_bits(si_type2, 124);
|
|
crc = swap16(crc);
|
|
cur += osmo_pbit2ubit(cur, (uint8_t *) &crc, 16);
|
|
|
|
/* Append 4 tail bits: type-2 bits */
|
|
cur += 4;
|
|
|
|
printf("SI type2: %s\n", bitdump(si_type2, 140));
|
|
|
|
/* Run rate 2/3 RCPC code: type-3 bits */
|
|
{
|
|
struct conv_enc_state *ces = calloc(1, sizeof(*ces));
|
|
conv_enc_init(ces);
|
|
conv_enc_input(ces, sb_type2, 144, si_master);
|
|
get_punctured_rate(TETRA_RCPC_PUNCT_2_3, si_master, 216, si_type3);
|
|
free(ces);
|
|
}
|
|
printf("SI type3: %s\n", bitdump(si_type3, 216));
|
|
|
|
/* Run (216,101) block interleaving: type-4 bits */
|
|
block_interleave(216, 101, si_type3, si_type4);
|
|
printf("SI type4: %s\n", bitdump(si_type4, 216));
|
|
|
|
/* Run scrambling (all-zero): type-5 bits */
|
|
memcpy(si_type5, si_type4, 216);
|
|
|
|
|
|
/* Use pdu_acc_ass from testpdu.c */
|
|
/* Run it through (30,14) RM code: type-2=3=4 bits */
|
|
printf("AACH type-1: %s\n", bitdump(pdu_acc_ass, 2));
|
|
bb_rm3014 = tetra_rm3014_compute(*(uint16_t *)pdu_acc_ass);
|
|
printf("AACH RM3014: 0x0%x\n", bb_rm3014);
|
|
/* convert to big endian */
|
|
bb_rm3014_be = htonl(bb_rm3014);
|
|
/* shift two bits left as it is only a 30 bit value */
|
|
bb_rm3014_be <<= 2;
|
|
osmo_pbit2ubit(bb_type5, (uint8_t *) &bb_rm3014_be, 30);
|
|
/* Run scrambling (all-zero): type-5 bits */
|
|
printf("AACH type-5: %s\n", bitdump(bb_type5, 30));
|
|
|
|
/* Finally, hand it into the physical layer */
|
|
build_sync_c_d_burst(burst, sb_type5, bb_type5, si_type5);
|
|
printf("cont sync DL burst: %s\n", bitdump(burst, 255*2));
|
|
|
|
return 0;
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
int err, i;
|
|
uint16_t out;
|
|
uint32_t ret;
|
|
|
|
/* first: run some subsystem tests */
|
|
ret = tetra_punct_test();
|
|
if (ret < 0)
|
|
exit(1);
|
|
|
|
tetra_rm3014_init();
|
|
#if 0
|
|
ret = tetra_rm3014_compute(0x1001);
|
|
printf("RM3014: 0x%08x\n", ret);
|
|
|
|
err = tetra_rm3014_decode(ret, &out);
|
|
printf("RM3014: 0x%x error: %d\n", out, err);
|
|
#endif
|
|
|
|
/* finally, build some test PDUs and encocde them */
|
|
testpdu_init();
|
|
#if 0
|
|
build_sb();
|
|
|
|
build_ndb_schf();
|
|
#else
|
|
/* iterate over various random PDUs and throw them throguh the viterbi */
|
|
srand(time(NULL));
|
|
for (i = 0; i < 100; i++) {
|
|
uint32_t r = rand();
|
|
osmo_pbit2ubit(pdu_sync, (uint8_t *) &r, 32);
|
|
osmo_pbit2ubit(pdu_sync+32, (uint8_t *)&r, 60-32);
|
|
//build_sb();
|
|
|
|
osmo_pbit2ubit(pdu_schf, (uint8_t *) &r, 32);
|
|
osmo_pbit2ubit(pdu_schf+32, (uint8_t *)&r, 60-32);
|
|
build_ndb_schf();
|
|
}
|
|
#endif
|
|
|
|
printf("total number of CRC Errors: %u\n", num_crc_err);
|
|
|
|
exit(0);
|
|
}
|