mirror of
https://github.com/lwvmobile/dsd-fme.git
synced 2026-11-20 20:55:40 -05:00
Included error correction on P25 TDULC.
Added a new "heuristics" module for P25 that improves the estimation of the symbol (dibit) that corresponds to a given analog signal value. Added a BER (bit error reate) estimation for P25.
This commit is contained in:
479
p25p1_tdulc.c
479
p25p1_tdulc.c
@@ -17,141 +17,374 @@
|
||||
|
||||
#include "dsd.h"
|
||||
|
||||
void
|
||||
processTDULC (dsd_opts * opts, dsd_state * state)
|
||||
{
|
||||
#include "p25p1_hdu.h"
|
||||
#include "p25p1_check_hdu.h"
|
||||
#include "p25p1_check_ldu.h"
|
||||
#include "p25p1_heuristics.h"
|
||||
|
||||
char lcinfo[57], lcformat[9], mfid[9];
|
||||
// Uncomment for some verbose debug info
|
||||
//#define TDULC_DEBUG
|
||||
|
||||
/**
|
||||
* Reverse the order of bits in a 12-bit word. We need this to accommodate to the expected bit order in
|
||||
* some algorithms.
|
||||
* \param dodeca The 12-bit word to reverse.
|
||||
*/
|
||||
static void
|
||||
swap_hex_words_bits(char* dodeca)
|
||||
{
|
||||
int j;
|
||||
for(j=0; j<6; j++)
|
||||
{
|
||||
int swap;
|
||||
swap = dodeca[j];
|
||||
dodeca[j] = dodeca[j+6];
|
||||
dodeca[j+6] = swap;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Reverse the order of bits in a sequence of six pairs of 12-bit words and their parities.
|
||||
* \param dodeca_data Pointer to the start of the 12-bit words sequence.
|
||||
* \param dodeca_parity Pointer to the parities sequence.
|
||||
*/
|
||||
static void
|
||||
swap_hex_words(char* dodeca_data, char* dodeca_parity)
|
||||
{
|
||||
int i;
|
||||
for(i=0; i<6; i++)
|
||||
{
|
||||
swap_hex_words_bits(dodeca_data + i*12);
|
||||
swap_hex_words_bits(dodeca_parity + i*12);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Read an hex word, its parity bits and attempts to error correct it using the Hamming algorithm.
|
||||
*/
|
||||
static void
|
||||
read_and_correct_dodeca_word (dsd_opts* opts, dsd_state* state, char* dodeca, int* status_count,
|
||||
AnalogSignal* analog_signal_array, int* analog_signal_index)
|
||||
{
|
||||
char parity[12];
|
||||
int fixed_errors;
|
||||
int irrecoverable_errors;
|
||||
|
||||
// Read the hex word
|
||||
read_word (opts, state, dodeca, 12, status_count, analog_signal_array, analog_signal_index);
|
||||
// Read the parity
|
||||
read_golay24_parity (opts, state, parity, status_count, analog_signal_array, analog_signal_index);
|
||||
|
||||
#ifdef TDULC_DEBUG
|
||||
printf("[");
|
||||
for (i = 0; i < 12; i++)
|
||||
{
|
||||
printf("%c", (dodeca[i] == 1)? 'X' : ' ');
|
||||
}
|
||||
printf("-");
|
||||
for (i = 0; i < 12; i++)
|
||||
{
|
||||
printf("%c", (parity[i] == 1)? 'X' : ' ');
|
||||
}
|
||||
printf("]");
|
||||
#endif
|
||||
|
||||
// Use extended golay to error correct the dodeca word
|
||||
irrecoverable_errors = check_and_fix_golay_24_12(dodeca, parity, &fixed_errors);
|
||||
|
||||
state->debug_header_errors += fixed_errors;
|
||||
if (irrecoverable_errors != 0)
|
||||
{
|
||||
state->debug_header_critical_errors++;
|
||||
}
|
||||
|
||||
#ifdef TDULC_DEBUG
|
||||
printf(" -> [");
|
||||
for (i = 0; i < 12; i++)
|
||||
{
|
||||
printf("%c", (dodeca[i] == 1)? 'X' : ' ');
|
||||
}
|
||||
printf("]");
|
||||
if (irrecoverable_errors == 0)
|
||||
{
|
||||
if (fixed_errors > 0)
|
||||
{
|
||||
printf(" fixed!");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
printf(" IRRECOVERABLE");
|
||||
}
|
||||
printf("\n");
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* Correct the information in analog_signal_array according with the content of data, which has been
|
||||
* error corrected and should be valid.
|
||||
* \param data A sequence of 12-bit words.
|
||||
* \param count Number of words in the sequence.
|
||||
* \param analog_signal_array Pointer to a sequence of AnalogSignal elements, as many as the value of count.
|
||||
*/
|
||||
static void
|
||||
correct_golay_dibits_12(char* data, int count, AnalogSignal* analog_signal_array)
|
||||
{
|
||||
int i, j;
|
||||
int analog_signal_index;
|
||||
int dibit;
|
||||
char parity[12];
|
||||
|
||||
|
||||
analog_signal_index = 0;
|
||||
|
||||
for (i=count-1; i>=0; i--)
|
||||
{
|
||||
for (j=0; j<12; j+=2) // 6 iterations -> 6 dibits
|
||||
{
|
||||
dibit = (data[i*12+j] << 1) | data[i*12+j+1];
|
||||
analog_signal_array[analog_signal_index].corrected_dibit = dibit;
|
||||
|
||||
#ifdef HEURISTICS_DEBUG
|
||||
if (analog_signal_array[analog_signal_index].dibit != dibit)
|
||||
{
|
||||
printf("TDULC data word corrected from %i to %i, analog value %i\n",
|
||||
analog_signal_array[analog_signal_index].dibit, dibit, analog_signal_array[analog_signal_index].value);
|
||||
}
|
||||
#endif
|
||||
|
||||
analog_signal_index++;
|
||||
}
|
||||
|
||||
// Calculate the golay parity for the hex word
|
||||
encode_golay_24_12(data+i*12, parity);
|
||||
|
||||
for (j=0; j<12; j+=2) // 6 iterations -> 6 dibits
|
||||
{
|
||||
dibit = (parity[j] << 1) | parity[j+1];
|
||||
analog_signal_array[analog_signal_index].corrected_dibit = dibit;
|
||||
|
||||
#ifdef HEURISTICS_DEBUG
|
||||
if (analog_signal_array[analog_signal_index].dibit != dibit)
|
||||
{
|
||||
printf("TDULC parity corrected from %i to %i, analog value %i\n",
|
||||
analog_signal_array[analog_signal_index].dibit, dibit, analog_signal_array[analog_signal_index].value);
|
||||
}
|
||||
#endif
|
||||
|
||||
analog_signal_index++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
read_zeros(dsd_opts* opts, dsd_state* state, AnalogSignal* analog_signal_array, unsigned int length,
|
||||
int* status_count, int new_sequence)
|
||||
{
|
||||
char* buffer;
|
||||
unsigned int i;
|
||||
int analog_signal_index;
|
||||
|
||||
analog_signal_index = 0;
|
||||
buffer = malloc(length);
|
||||
read_dibit_update_analog_data (opts, state, buffer, length, status_count, analog_signal_array, &analog_signal_index);
|
||||
free(buffer);
|
||||
if (new_sequence)
|
||||
{
|
||||
analog_signal_array[0].sequence_broken = 1;
|
||||
}
|
||||
|
||||
for (i=0;i<length/2;i++)
|
||||
{
|
||||
analog_signal_array[i].corrected_dibit = 0;
|
||||
#ifdef HEURISTICS_DEBUG
|
||||
if (analog_signal_array[i].corrected_dibit != analog_signal_array[i].dibit)
|
||||
{
|
||||
printf("TDULC ending zeros corrected from %i to %i, analog value %i\n",
|
||||
analog_signal_array[i].dibit, 0, analog_signal_array[i].value);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
// We know that all these bits should be zero. Use this information for the heuristics module
|
||||
contribute_to_heuristics(state->rf_mod, &(state->p25_heuristics), analog_signal_array, length/2);
|
||||
}
|
||||
|
||||
void
|
||||
processTDULC (dsd_opts* opts, dsd_state* state)
|
||||
{
|
||||
int i;
|
||||
char lcinfo[57], lcformat[9], mfid[9];
|
||||
|
||||
int status_count;
|
||||
|
||||
char dodeca_data[6][12]; // Data in 12-bit words. A total of 6 words.
|
||||
char dodeca_parity[6][12]; // Reed-Solomon parity of the data. A total of 6 parity 12-bit words.
|
||||
|
||||
int irrecoverable_errors;
|
||||
|
||||
AnalogSignal analog_signal_array[6*(6+6)+6*(6+6)+10];
|
||||
int analog_signal_index;
|
||||
|
||||
|
||||
analog_signal_index = 0;
|
||||
|
||||
// we skip the status dibits that occur every 36 symbols
|
||||
// the first IMBE frame starts 14 symbols before next status
|
||||
// so we start counter at 36-14-1 = 21
|
||||
status_count = 21;
|
||||
|
||||
for(i=5; i>=0; i--) {
|
||||
read_and_correct_dodeca_word (opts, state, &(dodeca_data[i][0]), &status_count, analog_signal_array, &analog_signal_index);
|
||||
}
|
||||
|
||||
for(i=5; i>=0; i--) {
|
||||
read_and_correct_dodeca_word (opts, state, &(dodeca_parity[i][0]), &status_count, analog_signal_array, &analog_signal_index);
|
||||
}
|
||||
|
||||
// Swap the two 6-bit words to accommodate for the expected word order of the Reed-Solomon decoding
|
||||
swap_hex_words((char*)dodeca_data, (char*)dodeca_parity);
|
||||
|
||||
// Error correct the hex_data using Reed-Solomon hex_parity
|
||||
irrecoverable_errors = check_and_fix_reedsolomon_24_12_13((char*)dodeca_data, (char*)dodeca_parity);
|
||||
|
||||
// Recover the original order
|
||||
swap_hex_words((char*)dodeca_data, (char*)dodeca_parity);
|
||||
|
||||
if (irrecoverable_errors == 1)
|
||||
{
|
||||
state->debug_header_critical_errors++;
|
||||
|
||||
// We can correct (13-1)/2 = 6 errors. If we failed, it means that there were more than 6 errors in
|
||||
// these 12+12 words. But take into account that each hex word was already error corrected with
|
||||
// Golay 24, which can correct 3 bits on each sequence of (12+12) bits. We could say that there were
|
||||
// 7 errors of 4 bits.
|
||||
update_error_stats(&state->p25_heuristics, 12*6+12*6, 7*4);
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
// Same comments as in processHDU. See there.
|
||||
|
||||
char fixed_parity[6*12];
|
||||
|
||||
// Correct the dibits that we read according with hex_data values
|
||||
correct_golay_dibits_12((char*)dodeca_data, 6, analog_signal_array);
|
||||
|
||||
// Generate again the Reed-Solomon parity
|
||||
// Now, swap again for Reed-Solomon
|
||||
swap_hex_words((char*)dodeca_data, (char*)dodeca_parity);
|
||||
encode_reedsolomon_24_12_13((char*)dodeca_data, fixed_parity);
|
||||
// Swap again to recover the original order
|
||||
swap_hex_words((char*)dodeca_data, fixed_parity);
|
||||
|
||||
// Correct the dibits that we read according with the fixed parity values
|
||||
correct_golay_dibits_12(fixed_parity, 6, analog_signal_array+6*(6+6));
|
||||
|
||||
// Once corrected, contribute this information to the heuristics module
|
||||
analog_signal_array[0].sequence_broken = 1;
|
||||
contribute_to_heuristics(state->rf_mod, &(state->p25_heuristics), analog_signal_array, 6*(6+6)+6*(6+6));
|
||||
}
|
||||
|
||||
|
||||
// Next 10 dibits should be zeros
|
||||
read_zeros(opts, state, analog_signal_array + 6*(6+6)+6*(6+6), 20, &status_count, 0);
|
||||
|
||||
// Next we should find an status dibit
|
||||
if (status_count != 35) {
|
||||
printf("*** SYNC ERROR\n");
|
||||
}
|
||||
|
||||
// trailing status symbol
|
||||
{
|
||||
int status;
|
||||
status = getDibit (opts, state) + '0';
|
||||
// TODO: do something useful with the status bits...
|
||||
}
|
||||
|
||||
// Put the corrected data into the DSD structures
|
||||
|
||||
lcformat[8] = 0;
|
||||
mfid[8] = 0;
|
||||
lcinfo[56] = 0;
|
||||
|
||||
// Now processing NID
|
||||
lcformat[0] = dodeca_data[5][ 0] + '0';
|
||||
lcformat[1] = dodeca_data[5][ 1] + '0';
|
||||
lcformat[2] = dodeca_data[5][ 2] + '0';
|
||||
lcformat[3] = dodeca_data[5][ 3] + '0';
|
||||
lcformat[4] = dodeca_data[5][ 4] + '0';
|
||||
lcformat[5] = dodeca_data[5][ 5] + '0';
|
||||
lcformat[6] = dodeca_data[5][ 6] + '0';
|
||||
lcformat[7] = dodeca_data[5][ 7] + '0';
|
||||
mfid[0] = dodeca_data[5][ 8] + '0';
|
||||
mfid[1] = dodeca_data[5][ 9] + '0';
|
||||
mfid[2] = dodeca_data[5][10] + '0';
|
||||
mfid[3] = dodeca_data[5][11] + '0';
|
||||
|
||||
dibit = getDibit (opts, state);
|
||||
lcformat[0] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcformat[1] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
lcformat[2] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcformat[3] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
lcformat[4] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcformat[5] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
lcformat[6] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcformat[7] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
mfid[0] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
mfid[1] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
mfid[2] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
mfid[3] = (1 & dibit) + 48; // bit 0
|
||||
skipDibit (opts, state, 6);
|
||||
mfid[4] = dodeca_data[4][ 0] + '0';
|
||||
mfid[5] = dodeca_data[4][ 1] + '0';
|
||||
mfid[6] = dodeca_data[4][ 2] + '0';
|
||||
mfid[7] = dodeca_data[4][ 3] + '0';
|
||||
lcinfo[0] = dodeca_data[4][ 4] + '0';
|
||||
lcinfo[1] = dodeca_data[4][ 5] + '0';
|
||||
lcinfo[2] = dodeca_data[4][ 6] + '0';
|
||||
lcinfo[3] = dodeca_data[4][ 7] + '0';
|
||||
lcinfo[4] = dodeca_data[4][ 8] + '0';
|
||||
lcinfo[5] = dodeca_data[4][ 9] + '0';
|
||||
lcinfo[6] = dodeca_data[4][10] + '0';
|
||||
lcinfo[7] = dodeca_data[4][11] + '0';
|
||||
|
||||
dibit = getDibit (opts, state);
|
||||
mfid[4] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
mfid[5] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
mfid[6] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
mfid[7] = (1 & dibit) + 48; // bit 0
|
||||
skipDibit (opts, state, 1);
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[0] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[1] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[2] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[3] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[4] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[5] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[6] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[7] = (1 & dibit) + 48; // bit 0
|
||||
skipDibit (opts, state, 6);
|
||||
lcinfo[8] = dodeca_data[3][ 0] + '0';
|
||||
lcinfo[9] = dodeca_data[3][ 1] + '0';
|
||||
lcinfo[10] = dodeca_data[3][ 2] + '0';
|
||||
lcinfo[11] = dodeca_data[3][ 3] + '0';
|
||||
lcinfo[12] = dodeca_data[3][ 4] + '0';
|
||||
lcinfo[13] = dodeca_data[3][ 5] + '0';
|
||||
lcinfo[14] = dodeca_data[3][ 6] + '0';
|
||||
lcinfo[15] = dodeca_data[3][ 7] + '0';
|
||||
lcinfo[16] = dodeca_data[3][ 8] + '0';
|
||||
lcinfo[17] = dodeca_data[3][ 9] + '0';
|
||||
lcinfo[18] = dodeca_data[3][10] + '0';
|
||||
lcinfo[19] = dodeca_data[3][11] + '0';
|
||||
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[8] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[9] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[10] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[11] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[12] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[13] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[14] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[15] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[16] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[17] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[18] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[19] = (1 & dibit) + 48; // bit 0
|
||||
skipDibit (opts, state, 6);
|
||||
lcinfo[20] = dodeca_data[2][ 0] + '0';
|
||||
lcinfo[21] = dodeca_data[2][ 1] + '0';
|
||||
lcinfo[22] = dodeca_data[2][ 2] + '0';
|
||||
lcinfo[23] = dodeca_data[2][ 3] + '0';
|
||||
lcinfo[24] = dodeca_data[2][ 4] + '0';
|
||||
lcinfo[25] = dodeca_data[2][ 5] + '0';
|
||||
lcinfo[26] = dodeca_data[2][ 6] + '0';
|
||||
lcinfo[27] = dodeca_data[2][ 7] + '0';
|
||||
lcinfo[28] = dodeca_data[2][ 8] + '0';
|
||||
lcinfo[29] = dodeca_data[2][ 9] + '0';
|
||||
lcinfo[30] = dodeca_data[2][10] + '0';
|
||||
lcinfo[31] = dodeca_data[2][11] + '0';
|
||||
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[20] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[21] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[22] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[23] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[24] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[25] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[26] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[27] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[28] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[29] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[30] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[31] = (1 & dibit) + 48; // bit 0
|
||||
skipDibit (opts, state, 6);
|
||||
lcinfo[32] = dodeca_data[1][ 0] + '0';
|
||||
lcinfo[33] = dodeca_data[1][ 1] + '0';
|
||||
lcinfo[34] = dodeca_data[1][ 2] + '0';
|
||||
lcinfo[35] = dodeca_data[1][ 3] + '0';
|
||||
lcinfo[36] = dodeca_data[1][ 4] + '0';
|
||||
lcinfo[37] = dodeca_data[1][ 5] + '0';
|
||||
lcinfo[38] = dodeca_data[1][ 6] + '0';
|
||||
lcinfo[39] = dodeca_data[1][ 7] + '0';
|
||||
lcinfo[40] = dodeca_data[1][ 8] + '0';
|
||||
lcinfo[41] = dodeca_data[1][ 9] + '0';
|
||||
lcinfo[42] = dodeca_data[1][10] + '0';
|
||||
lcinfo[43] = dodeca_data[1][11] + '0';
|
||||
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[32] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[33] = (1 & dibit) + 48; // bit 0
|
||||
skipDibit (opts, state, 1);
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[34] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[35] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[36] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[37] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[38] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[39] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[40] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[41] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[42] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[43] = (1 & dibit) + 48; // bit 0
|
||||
skipDibit (opts, state, 6);
|
||||
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[44] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[45] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[46] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[47] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[48] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[49] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[50] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[51] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[52] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[53] = (1 & dibit) + 48; // bit 0
|
||||
dibit = getDibit (opts, state);
|
||||
lcinfo[54] = (1 & (dibit >> 1)) + 48; // bit 1
|
||||
lcinfo[55] = (1 & dibit) + 48; // bit 0
|
||||
|
||||
skipDibit (opts, state, 91);
|
||||
lcinfo[44] = dodeca_data[0][ 0] + '0';
|
||||
lcinfo[45] = dodeca_data[0][ 1] + '0';
|
||||
lcinfo[46] = dodeca_data[0][ 2] + '0';
|
||||
lcinfo[47] = dodeca_data[0][ 3] + '0';
|
||||
lcinfo[48] = dodeca_data[0][ 4] + '0';
|
||||
lcinfo[49] = dodeca_data[0][ 5] + '0';
|
||||
lcinfo[50] = dodeca_data[0][ 6] + '0';
|
||||
lcinfo[51] = dodeca_data[0][ 7] + '0';
|
||||
lcinfo[52] = dodeca_data[0][ 8] + '0';
|
||||
lcinfo[53] = dodeca_data[0][ 9] + '0';
|
||||
lcinfo[54] = dodeca_data[0][10] + '0';
|
||||
lcinfo[55] = dodeca_data[0][11] + '0';
|
||||
|
||||
processP25lcw (opts, state, lcformat, mfid, lcinfo);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user