kopia lustrzana https://github.com/kgoba/ft8_lib
Move varible definition out of for() to avoid std=c99 error
Kimi Jin
rodzic
22b5299169
commit
b095d79590
|
|
@ -11,9 +11,10 @@ uint16_t ft8_crc(const uint8_t message[], int num_bits)
|
|||
{
|
||||
uint16_t remainder = 0;
|
||||
int idx_byte = 0;
|
||||
int idx_bit = 0;
|
||||
|
||||
// Perform modulo-2 division, a bit at a time.
|
||||
for (int idx_bit = 0; idx_bit < num_bits; ++idx_bit)
|
||||
for (idx_bit = 0; idx_bit < num_bits; ++idx_bit)
|
||||
{
|
||||
if (idx_bit % 8 == 0)
|
||||
{
|
||||
|
|
@ -45,7 +46,8 @@ uint16_t extract_crc(const uint8_t a91[])
|
|||
void add_crc(const uint8_t payload[], uint8_t a91[])
|
||||
{
|
||||
// Copy 77 bits of payload data
|
||||
for (int i = 0; i < 10; i++)
|
||||
int i = 0;
|
||||
for (i = 0; i < 10; i++)
|
||||
a91[i] = payload[i];
|
||||
|
||||
// Clear 3 bits after the payload to make 82 bits
|
||||
|
|
|
|||
|
|
@ -30,25 +30,31 @@ int find_sync(const waterfall_t *power, int num_candidates, candidate_t heap[],
|
|||
{
|
||||
int heap_size = 0;
|
||||
int sym_stride = power->time_osr * power->freq_osr * power->num_bins;
|
||||
int time_sub = 0;
|
||||
int freq_sub = 0;
|
||||
int time_offset = 0;
|
||||
int freq_offset = 0;
|
||||
int m = 0;
|
||||
int k = 0;
|
||||
|
||||
// Here we allow time offsets that exceed signal boundaries, as long as we still have all data bits.
|
||||
// I.e. we can afford to skip the first 7 or the last 7 Costas symbols, as long as we track how many
|
||||
// sync symbols we included in the score, so the score is averaged.
|
||||
for (int time_sub = 0; time_sub < power->time_osr; ++time_sub)
|
||||
for (time_sub = 0; time_sub < power->time_osr; ++time_sub)
|
||||
{
|
||||
for (int freq_sub = 0; freq_sub < power->freq_osr; ++freq_sub)
|
||||
for (freq_sub = 0; freq_sub < power->freq_osr; ++freq_sub)
|
||||
{
|
||||
for (int time_offset = -12; time_offset < 24; ++time_offset)
|
||||
for (time_offset = -12; time_offset < 24; ++time_offset)
|
||||
{
|
||||
for (int freq_offset = 0; freq_offset + 7 < power->num_bins; ++freq_offset)
|
||||
for (freq_offset = 0; freq_offset + 7 < power->num_bins; ++freq_offset)
|
||||
{
|
||||
int score = 0;
|
||||
int num_average = 0;
|
||||
|
||||
// Compute average score over sync symbols (m+k = 0-7, 36-43, 72-79)
|
||||
for (int m = 0; m <= 72; m += 36)
|
||||
for (m = 0; m <= 72; m += 36)
|
||||
{
|
||||
for (int k = 0; k < 7; ++k)
|
||||
for (k = 0; k < 7; ++k)
|
||||
{
|
||||
int block = time_offset + m + k;
|
||||
// Check for time boundaries
|
||||
|
|
@ -152,7 +158,8 @@ void extract_likelihood(const waterfall_t *power, const candidate_t *cand, float
|
|||
const int n_syms = 1;
|
||||
const int n_bits = 3 * n_syms;
|
||||
const int n_tones = (1 << n_bits);
|
||||
for (int k = 0; k < FT8_ND; k += n_syms)
|
||||
int k = 0;
|
||||
for (k = 0; k < FT8_ND; k += n_syms)
|
||||
{
|
||||
// Add either 7 or 14 extra symbols to account for sync
|
||||
int sym_idx = (k < FT8_ND / 2) ? (k + 7) : (k + 14);
|
||||
|
|
@ -177,7 +184,8 @@ void extract_likelihood(const waterfall_t *power, const candidate_t *cand, float
|
|||
// Compute the variance of log174
|
||||
float sum = 0;
|
||||
float sum2 = 0;
|
||||
for (int i = 0; i < FT8_LDPC_N; ++i)
|
||||
int i = 0;
|
||||
for (i = 0; i < FT8_LDPC_N; ++i)
|
||||
{
|
||||
sum += log174[i];
|
||||
sum2 += log174[i] * log174[i];
|
||||
|
|
@ -187,7 +195,7 @@ void extract_likelihood(const waterfall_t *power, const candidate_t *cand, float
|
|||
|
||||
// Normalize log174 distribution and scale it with experimentally found coefficient
|
||||
float norm_factor = sqrtf(24.0f / variance);
|
||||
for (int i = 0; i < FT8_LDPC_N; ++i)
|
||||
for (i = 0; i < FT8_LDPC_N; ++i)
|
||||
{
|
||||
log174[i] *= norm_factor;
|
||||
}
|
||||
|
|
@ -300,8 +308,9 @@ static void decode_symbol(const uint8_t *power, int bit_idx, float *log174)
|
|||
{
|
||||
// Cleaned up code for the simple case of n_syms==1
|
||||
float s2[8];
|
||||
int j = 0;
|
||||
|
||||
for (int j = 0; j < 8; ++j)
|
||||
for (j = 0; j < 8; ++j)
|
||||
{
|
||||
s2[j] = (float)power[kFT8_Gray_map[j]];
|
||||
}
|
||||
|
|
@ -318,8 +327,9 @@ static void decode_multi_symbols(const uint8_t *power, int num_bins, int n_syms,
|
|||
const int n_tones = (1 << n_bits);
|
||||
|
||||
float s2[n_tones];
|
||||
int j = 0;
|
||||
|
||||
for (int j = 0; j < n_tones; ++j)
|
||||
for (j = 0; j < n_tones; ++j)
|
||||
{
|
||||
int j1 = j & 0x07;
|
||||
if (n_syms == 1)
|
||||
|
|
@ -342,7 +352,9 @@ static void decode_multi_symbols(const uint8_t *power, int num_bins, int n_syms,
|
|||
|
||||
// Extract bit significance (and convert them to float)
|
||||
// 8 FSK tones = 3 bits
|
||||
for (int i = 0; i < n_bits; ++i)
|
||||
int i = 0;
|
||||
int n = 0;
|
||||
for (i = 0; i < n_bits; ++i)
|
||||
{
|
||||
if (bit_idx + i >= FT8_LDPC_N)
|
||||
{
|
||||
|
|
@ -352,7 +364,7 @@ static void decode_multi_symbols(const uint8_t *power, int num_bins, int n_syms,
|
|||
|
||||
uint16_t mask = (n_tones >> (i + 1));
|
||||
float max_zero = -1000, max_one = -1000;
|
||||
for (int n = 0; n < n_tones; ++n)
|
||||
for (n = 0; n < n_tones; ++n)
|
||||
{
|
||||
if (n & mask)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -24,7 +24,9 @@ void encode174(const uint8_t *message, uint8_t *codeword)
|
|||
// This implementation accesses the generator bits straight from the packed binary representation in kFT8_LDPC_generator
|
||||
|
||||
// Fill the codeword with message and zeros, as we will only update binary ones later
|
||||
for (int j = 0; j < FT8_LDPC_N_BYTES; ++j)
|
||||
int j = 0;
|
||||
int i = 0;
|
||||
for (j = 0; j < FT8_LDPC_N_BYTES; ++j)
|
||||
{
|
||||
codeword[j] = (j < FT8_LDPC_K_BYTES) ? message[j] : 0;
|
||||
}
|
||||
|
|
@ -34,13 +36,13 @@ void encode174(const uint8_t *message, uint8_t *codeword)
|
|||
uint8_t col_idx = FT8_LDPC_K_BYTES - 1; // index into byte array
|
||||
|
||||
// Compute the LDPC checksum bits and store them in codeword
|
||||
for (int i = 0; i < FT8_LDPC_M; ++i)
|
||||
for (i = 0; i < FT8_LDPC_M; ++i)
|
||||
{
|
||||
// Fast implementation of bitwise multiplication and parity checking
|
||||
// Normally nsum would contain the result of dot product between message and kFT8_LDPC_generator[i],
|
||||
// but we only compute the sum modulo 2.
|
||||
uint8_t nsum = 0;
|
||||
for (int j = 0; j < FT8_LDPC_K_BYTES; ++j)
|
||||
for (j = 0; j < FT8_LDPC_K_BYTES; ++j)
|
||||
{
|
||||
uint8_t bits = message[j] & kFT8_LDPC_generator[i][j]; // bitwise AND (bitwise multiplication)
|
||||
nsum ^= parity8(bits); // bitwise XOR (addition modulo 2)
|
||||
|
|
@ -78,7 +80,8 @@ void genft8(const uint8_t *payload, uint8_t *tones)
|
|||
|
||||
uint8_t mask = 0x80u; // Mask to extract 1 bit from codeword
|
||||
int i_byte = 0; // Index of the current byte of the codeword
|
||||
for (int i_tone = 0; i_tone < FT8_NN; ++i_tone)
|
||||
int i_tone = 0;
|
||||
for (i_tone = 0; i_tone < FT8_NN; ++i_tone)
|
||||
{
|
||||
if ((i_tone >= 0) && (i_tone < 7))
|
||||
{
|
||||
|
|
@ -140,7 +143,8 @@ void genft4(const uint8_t *payload, uint8_t *tones)
|
|||
|
||||
uint8_t mask = 0x80u; // Mask to extract 1 bit from codeword
|
||||
int i_byte = 0; // Index of the current byte of the codeword
|
||||
for (int i_tone = 0; i_tone < FT4_NN; ++i_tone)
|
||||
int i_tone = 0;
|
||||
for (i_tone = 0; i_tone < FT4_NN; ++i_tone)
|
||||
{
|
||||
if ((i_tone == 0) || (i_tone == 104))
|
||||
{
|
||||
|
|
|
|||
|
|
@ -26,14 +26,15 @@ static float fast_atanh(float x);
|
|||
void pack_bits(const uint8_t plain[], int num_bits, uint8_t packed[])
|
||||
{
|
||||
int num_bytes = (num_bits + 7) / 8;
|
||||
for (int i = 0; i < num_bytes; ++i)
|
||||
int i = 0;
|
||||
for (i = 0; i < num_bytes; ++i)
|
||||
{
|
||||
packed[i] = 0;
|
||||
}
|
||||
|
||||
uint8_t mask = 0x80;
|
||||
int byte_idx = 0;
|
||||
for (int i = 0; i < num_bits; ++i)
|
||||
for (i = 0; i < num_bits; ++i)
|
||||
{
|
||||
if (plain[i])
|
||||
{
|
||||
|
|
@ -57,25 +58,32 @@ void ldpc_decode(float codeword[], int max_iters, uint8_t plain[], int *ok)
|
|||
float m[FT8_LDPC_M][FT8_LDPC_N]; // ~60 kB
|
||||
float e[FT8_LDPC_M][FT8_LDPC_N]; // ~60 kB
|
||||
int min_errors = FT8_LDPC_M;
|
||||
int i = 0;
|
||||
int j = 0;
|
||||
int ii1 = 0;
|
||||
int ii2 = 0;
|
||||
int ji1 = 0;
|
||||
int ji2 = 0;
|
||||
int iter = 0;
|
||||
|
||||
for (int j = 0; j < FT8_LDPC_M; j++)
|
||||
for (j = 0; j < FT8_LDPC_M; j++)
|
||||
{
|
||||
for (int i = 0; i < FT8_LDPC_N; i++)
|
||||
for (i = 0; i < FT8_LDPC_N; i++)
|
||||
{
|
||||
m[j][i] = codeword[i];
|
||||
e[j][i] = 0.0f;
|
||||
}
|
||||
}
|
||||
|
||||
for (int iter = 0; iter < max_iters; iter++)
|
||||
for (iter = 0; iter < max_iters; iter++)
|
||||
{
|
||||
for (int j = 0; j < FT8_LDPC_M; j++)
|
||||
for (j = 0; j < FT8_LDPC_M; j++)
|
||||
{
|
||||
for (int ii1 = 0; ii1 < kFT8_LDPC_num_rows[j]; ii1++)
|
||||
for (ii1 = 0; ii1 < kFT8_LDPC_num_rows[j]; ii1++)
|
||||
{
|
||||
int i1 = kFT8_LDPC_Nm[j][ii1] - 1;
|
||||
float a = 1.0f;
|
||||
for (int ii2 = 0; ii2 < kFT8_LDPC_num_rows[j]; ii2++)
|
||||
for (ii2 = 0; ii2 < kFT8_LDPC_num_rows[j]; ii2++)
|
||||
{
|
||||
int i2 = kFT8_LDPC_Nm[j][ii2] - 1;
|
||||
if (i2 != i1)
|
||||
|
|
@ -87,10 +95,10 @@ void ldpc_decode(float codeword[], int max_iters, uint8_t plain[], int *ok)
|
|||
}
|
||||
}
|
||||
|
||||
for (int i = 0; i < FT8_LDPC_N; i++)
|
||||
for (i = 0; i < FT8_LDPC_N; i++)
|
||||
{
|
||||
float l = codeword[i];
|
||||
for (int j = 0; j < 3; j++)
|
||||
for (j = 0; j < 3; j++)
|
||||
l += e[kFT8_LDPC_Mn[i][j] - 1][i];
|
||||
plain[i] = (l > 0) ? 1 : 0;
|
||||
}
|
||||
|
|
@ -108,13 +116,13 @@ void ldpc_decode(float codeword[], int max_iters, uint8_t plain[], int *ok)
|
|||
}
|
||||
}
|
||||
|
||||
for (int i = 0; i < FT8_LDPC_N; i++)
|
||||
for (i = 0; i < FT8_LDPC_N; i++)
|
||||
{
|
||||
for (int ji1 = 0; ji1 < 3; ji1++)
|
||||
for (ji1 = 0; ji1 < 3; ji1++)
|
||||
{
|
||||
int j1 = kFT8_LDPC_Mn[i][ji1] - 1;
|
||||
float l = codeword[i];
|
||||
for (int ji2 = 0; ji2 < 3; ji2++)
|
||||
for (ji2 = 0; ji2 < 3; ji2++)
|
||||
{
|
||||
if (ji1 != ji2)
|
||||
{
|
||||
|
|
@ -138,11 +146,13 @@ void ldpc_decode(float codeword[], int max_iters, uint8_t plain[], int *ok)
|
|||
static int ldpc_check(uint8_t codeword[])
|
||||
{
|
||||
int errors = 0;
|
||||
int i = 0;
|
||||
int m = 0;
|
||||
|
||||
for (int m = 0; m < FT8_LDPC_M; ++m)
|
||||
for (m = 0; m < FT8_LDPC_M; ++m)
|
||||
{
|
||||
uint8_t x = 0;
|
||||
for (int i = 0; i < kFT8_LDPC_num_rows[m]; ++i)
|
||||
for (i = 0; i < kFT8_LDPC_num_rows[m]; ++i)
|
||||
{
|
||||
x ^= codeword[kFT8_LDPC_Nm[m][i] - 1];
|
||||
}
|
||||
|
|
@ -160,18 +170,23 @@ void bp_decode(float codeword[], int max_iters, uint8_t plain[], int *ok)
|
|||
float toc[FT8_LDPC_M][7];
|
||||
|
||||
int min_errors = FT8_LDPC_M;
|
||||
int n = 0;
|
||||
int m = 0;
|
||||
int iter = 0;
|
||||
int n_idx = 0;
|
||||
int m_idx = 0;
|
||||
|
||||
// initialize message data
|
||||
for (int n = 0; n < FT8_LDPC_N; ++n)
|
||||
for (n = 0; n < FT8_LDPC_N; ++n)
|
||||
{
|
||||
tov[n][0] = tov[n][1] = tov[n][2] = 0;
|
||||
}
|
||||
|
||||
for (int iter = 0; iter < max_iters; ++iter)
|
||||
for (iter = 0; iter < max_iters; ++iter)
|
||||
{
|
||||
// Do a hard decision guess (tov=0 in iter 0)
|
||||
int plain_sum = 0;
|
||||
for (int n = 0; n < FT8_LDPC_N; ++n)
|
||||
for (n = 0; n < FT8_LDPC_N; ++n)
|
||||
{
|
||||
plain[n] = ((codeword[n] + tov[n][0] + tov[n][1] + tov[n][2]) > 0) ? 1 : 0;
|
||||
plain_sum += plain[n];
|
||||
|
|
@ -198,14 +213,14 @@ void bp_decode(float codeword[], int max_iters, uint8_t plain[], int *ok)
|
|||
}
|
||||
|
||||
// Send messages from bits to check nodes
|
||||
for (int m = 0; m < FT8_LDPC_M; ++m)
|
||||
for (m = 0; m < FT8_LDPC_M; ++m)
|
||||
{
|
||||
for (int n_idx = 0; n_idx < kFT8_LDPC_num_rows[m]; ++n_idx)
|
||||
for (n_idx = 0; n_idx < kFT8_LDPC_num_rows[m]; ++n_idx)
|
||||
{
|
||||
int n = kFT8_LDPC_Nm[m][n_idx] - 1;
|
||||
n = kFT8_LDPC_Nm[m][n_idx] - 1;
|
||||
// for each (n, m)
|
||||
float Tnm = codeword[n];
|
||||
for (int m_idx = 0; m_idx < 3; ++m_idx)
|
||||
for (m_idx = 0; m_idx < 3; ++m_idx)
|
||||
{
|
||||
if ((kFT8_LDPC_Mn[n][m_idx] - 1) != m)
|
||||
{
|
||||
|
|
@ -217,14 +232,14 @@ void bp_decode(float codeword[], int max_iters, uint8_t plain[], int *ok)
|
|||
}
|
||||
|
||||
// send messages from check nodes to variable nodes
|
||||
for (int n = 0; n < FT8_LDPC_N; ++n)
|
||||
for (n = 0; n < FT8_LDPC_N; ++n)
|
||||
{
|
||||
for (int m_idx = 0; m_idx < 3; ++m_idx)
|
||||
for (m_idx = 0; m_idx < 3; ++m_idx)
|
||||
{
|
||||
int m = kFT8_LDPC_Mn[n][m_idx] - 1;
|
||||
m = kFT8_LDPC_Mn[n][m_idx] - 1;
|
||||
// for each (n, m)
|
||||
float Tmn = 1.0f;
|
||||
for (int n_idx = 0; n_idx < kFT8_LDPC_num_rows[m]; ++n_idx)
|
||||
for (n_idx = 0; n_idx < kFT8_LDPC_num_rows[m]; ++n_idx)
|
||||
{
|
||||
if ((kFT8_LDPC_Nm[m][n_idx] - 1) != n)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -224,6 +224,8 @@ int pack77_1(const char *msg, uint8_t *b77)
|
|||
void packtext77(const char *text, uint8_t *b77)
|
||||
{
|
||||
int length = strlen(text);
|
||||
int i = 0;
|
||||
int j = 0;
|
||||
|
||||
// Skip leading and trailing spaces
|
||||
while (*text == ' ' && *text != 0)
|
||||
|
|
@ -237,18 +239,18 @@ void packtext77(const char *text, uint8_t *b77)
|
|||
}
|
||||
|
||||
// Clear the first 72 bits representing a long number
|
||||
for (int i = 0; i < 9; ++i)
|
||||
for (i = 0; i < 9; ++i)
|
||||
{
|
||||
b77[i] = 0;
|
||||
}
|
||||
|
||||
// Now express the text as base-42 number stored
|
||||
// in the first 72 bits of b77
|
||||
for (int j = 0; j < 13; ++j)
|
||||
for (j = 0; j < 13; ++j)
|
||||
{
|
||||
// Multiply the long integer in b77 by 42
|
||||
uint16_t x = 0;
|
||||
for (int i = 8; i >= 0; --i)
|
||||
for (i = 8; i >= 0; --i)
|
||||
{
|
||||
x += b77[i] * (uint16_t)42;
|
||||
b77[i] = (x & 0xFF);
|
||||
|
|
@ -270,7 +272,7 @@ void packtext77(const char *text, uint8_t *b77)
|
|||
x <<= 1;
|
||||
|
||||
// Now add the number to our long number
|
||||
for (int i = 8; i >= 0; --i)
|
||||
for (i = 8; i >= 0; --i)
|
||||
{
|
||||
if (x == 0)
|
||||
break;
|
||||
|
|
@ -322,8 +324,9 @@ bool test1()
|
|||
"LL3AJG",
|
||||
"CQ ",
|
||||
0};
|
||||
int i = 0;
|
||||
|
||||
for (int i = 0; inputs[i]; ++i)
|
||||
for (i = 0; inputs[i]; ++i)
|
||||
{
|
||||
int32_t result = ft8_v2::pack28(inputs[i]);
|
||||
printf("pack28(\"%s\") = %d\n", inputs[i], result);
|
||||
|
|
@ -342,13 +345,15 @@ bool test2()
|
|||
"L0UAA LL3JG RRR",
|
||||
"L0UAA LL3JG 73",
|
||||
0};
|
||||
int i = 0;
|
||||
int j = 0;
|
||||
|
||||
for (int i = 0; inputs[i]; ++i)
|
||||
for (i = 0; inputs[i]; ++i)
|
||||
{
|
||||
uint8_t result[10];
|
||||
int rc = ft8_v2::pack77_1(inputs[i], result);
|
||||
printf("pack77_1(\"%s\") = %d\t[", inputs[i], rc);
|
||||
for (int j = 0; j < 10; ++j)
|
||||
for (j = 0; j < 10; ++j)
|
||||
{
|
||||
printf("%02x ", result[j]);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -69,7 +69,8 @@ bool equals(const char *string1, const char *string2)
|
|||
|
||||
int char_index(const char *string, char c)
|
||||
{
|
||||
for (int i = 0; *string; ++i, ++string)
|
||||
int i = 0;
|
||||
for (i = 0; *string; ++i, ++string)
|
||||
{
|
||||
if (c == *string)
|
||||
{
|
||||
|
|
@ -133,6 +134,7 @@ int dd_to_int(const char *str, int length)
|
|||
// Convert a 2 digit integer to string
|
||||
void int_to_dd(char *str, int value, int width, bool full_sign)
|
||||
{
|
||||
int i = 0;
|
||||
if (value < 0)
|
||||
{
|
||||
*str = '-';
|
||||
|
|
@ -146,7 +148,7 @@ void int_to_dd(char *str, int value, int width, bool full_sign)
|
|||
}
|
||||
|
||||
int divisor = 1;
|
||||
for (int i = 0; i < width - 1; ++i)
|
||||
for (i = 0; i < width - 1; ++i)
|
||||
{
|
||||
divisor *= 10;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@
|
|||
int unpack_callsign(uint32_t n28, uint8_t ip, uint8_t i3, char *result)
|
||||
{
|
||||
// Check for special tokens DE, QRZ, CQ, CQ_nnn, CQ_aaaa
|
||||
int i = 0;
|
||||
if (n28 < NTOKENS)
|
||||
{
|
||||
if (n28 <= 2)
|
||||
|
|
@ -38,7 +39,7 @@ int unpack_callsign(uint32_t n28, uint8_t ip, uint8_t i3, char *result)
|
|||
char aaaa[5];
|
||||
|
||||
aaaa[4] = '\0';
|
||||
for (int i = 3; /* */; --i)
|
||||
for (i = 3; /* */; --i)
|
||||
{
|
||||
aaaa[i] = charn(n % 27, 4);
|
||||
if (i == 0)
|
||||
|
|
@ -206,10 +207,12 @@ int unpack_text(const uint8_t *a71, char *text)
|
|||
{
|
||||
// TODO: test
|
||||
uint8_t b71[9];
|
||||
int i = 0;
|
||||
int idx = 0;
|
||||
|
||||
// Shift 71 bits right by 1 bit, so that it's right-aligned in the byte array
|
||||
uint8_t carry = 0;
|
||||
for (int i = 0; i < 9; ++i)
|
||||
for (i = 0; i < 9; ++i)
|
||||
{
|
||||
b71[i] = carry | (a71[i] >> 1);
|
||||
carry = (a71[i] & 1) ? 0x80 : 0;
|
||||
|
|
@ -217,11 +220,11 @@ int unpack_text(const uint8_t *a71, char *text)
|
|||
|
||||
char c14[14];
|
||||
c14[13] = 0;
|
||||
for (int idx = 12; idx >= 0; --idx)
|
||||
for (idx = 12; idx >= 0; --idx)
|
||||
{
|
||||
// Divide the long integer in b71 by 42
|
||||
uint16_t rem = 0;
|
||||
for (int i = 0; i < 9; ++i)
|
||||
for (i = 0; i < 9; ++i)
|
||||
{
|
||||
rem = (rem << 8) | b71[i];
|
||||
b71[i] = rem / 42;
|
||||
|
|
@ -237,17 +240,18 @@ int unpack_text(const uint8_t *a71, char *text)
|
|||
int unpack_telemetry(const uint8_t *a71, char *telemetry)
|
||||
{
|
||||
uint8_t b71[9];
|
||||
int i = 0;
|
||||
|
||||
// Shift bits in a71 right by 1 bit
|
||||
uint8_t carry = 0;
|
||||
for (int i = 0; i < 9; ++i)
|
||||
for (i = 0; i < 9; ++i)
|
||||
{
|
||||
b71[i] = (carry << 7) | (a71[i] >> 1);
|
||||
carry = (a71[i] & 0x01);
|
||||
}
|
||||
|
||||
// Convert b71 to hexadecimal string
|
||||
for (int i = 0; i < 9; ++i)
|
||||
for (i = 0; i < 9; ++i)
|
||||
{
|
||||
uint8_t nibble1 = (b71[i] >> 4);
|
||||
uint8_t nibble2 = (b71[i] & 0x0F);
|
||||
|
|
@ -267,6 +271,7 @@ int unpack_nonstandard(const uint8_t *a77, char *call_to, char *call_de, char *e
|
|||
{
|
||||
uint32_t n12, iflip, nrpt, icq;
|
||||
uint64_t n58;
|
||||
int i = 0;
|
||||
n12 = (a77[0] << 4); //11 ~4 : 8
|
||||
n12 |= (a77[1] >> 4); //3~0 : 12
|
||||
|
||||
|
|
@ -287,7 +292,7 @@ int unpack_nonstandard(const uint8_t *a77, char *call_to, char *call_de, char *e
|
|||
char c11[12];
|
||||
c11[11] = '\0';
|
||||
|
||||
for (int i = 10; /* no condition */; --i)
|
||||
for (i = 10; /* no condition */; --i)
|
||||
{
|
||||
c11[i] = charn(n58 % 38, 5);
|
||||
if (i == 0)
|
||||
|
|
|
|||
Ładowanie…
Reference in New Issue