wirtz
/
OpenAudio_ArduinoLibrary
mirror of https://github.com/chipaudette/OpenAudio_ArduinoLibrary.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Organized variable declarations

Browse Source
pull/16/merge
Bob Larkin 2 years ago
parent 1a2ba41e1b
commit fa19a9cfb9
6 changed files with 92 additions and 102 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 94
      examples/FT8Receive/FT8Receive.ino
  2. 10
      examples/FT8Receive/Process_DSP_R.ino
  3. 20
      examples/FT8Receive/decodeR.ino
  4. 26
      examples/FT8Receive/decode_ft8R.ino
  5. 4
      examples/FT8Receive/encodeR.ino
  6. 38
      examples/FT8Receive/ldpcR.ino

94
examples/FT8Receive/FT8Receive.ino
Unescape View File

@ -64,6 +64,16 @@
#define ft8_min_freq FT8_FREQ_SPACING * LOW_FREQ_INDEX #define ft8_min_freq FT8_FREQ_SPACING * LOW_FREQ_INDEX
#define ft8_msg_samples 92 #define ft8_msg_samples 92
// Define FT8 symbol counts
#define FT8_ND 58
#define FT8_NN 79
// Define the LDPC sizes
#define FT8_N 174
#define FT8_K 91
#define FT8_M 83
#define FT8_K_BYTES 12
// A couple of prototypes to help the compile order // A couple of prototypes to help the compile order
void init_DSP(void); void init_DSP(void);
void extract_power(int); void extract_power(int);
@ -87,35 +97,32 @@ AudioConnection_F32 patchCord2(gain1, demod1);
AudioConnection_F32 patchCord3(gain1, peak1); AudioConnection_F32 patchCord3(gain1, peak1);
AudioControlSGTL5000 sgtl5000_1; //xy=100,250 AudioControlSGTL5000 sgtl5000_1; //xy=100,250
// Communicate amongst decode functions:
typedef struct Candidate {
int16_t score;
int16_t time_offset;
int16_t freq_offset;
uint8_t time_sub;
uint8_t freq_sub;
uint8_t alt; // Added for convenience Teensy, RSL
float32_t syncPower; // Added for Teensy, RSL
} Candidate;
// This is the big file of log powers // This is the big file of log powers
uint8_t export_fft_power[ft8_msg_samples*HIGH_FREQ_INDEX*4] ; uint8_t export_fft_power[ft8_msg_samples*HIGH_FREQ_INDEX*4] ;
// Pointer to 2048 float data for FFT array in radioDemodulator_F32 // Pointer to 2048 float data for FFT array in radioDemodulator_F32
float32_t* pData2K = NULL; float32_t* pData2K = NULL;
float32_t noisePowerEstimateL = 0.0f; // Works when big signals are absent float32_t FT8noisePowerEstimateL = 0.0f; // Works when big signals are absent
int16_t noisePwrDBIntL = 0; int16_t FT8noisePwrDBIntL = 0;
float32_t noisePowerEstimateH = 0.0f; // Works for big signals and QRMt float32_t FT8noisePowerEstimateH = 0.0f; // Works for big signals and QRMt
int16_t noisePwrDBIntH = 0; int16_t FT8noisePwrDBIntH = 0;
float32_t noisePeakAveRatio = 0.0f; // > about 100 for big sigs float32_t FT8noisePeakAveRatio = 0.0f; // > about 100 for big sigs
// /char Station_Call[11]; //six character call sign + /0
// /char home_Locator[11];; // four character locator + /0
// /char Locator[11]; // four character locator + /0
char Station_Call[11]; // six character call sign + /0 char Station_Call[11]; // six character call sign + /0
char home_Locator[11]; // four character locator + /0 char home_Locator[11]; // four character locator + /0
char Locator[11]; // four character locator + /0 char Locator[11]; // four character locator + /0
uint16_t currentFrequency;
// Next 3 lines were uint32_t Sept 22 change to allow tOffset
int32_t current_time, start_time, ft8_time, ft8_mod_time, ft8_mod_time_last;
int32_t days_fraction, hours_fraction, minute_fraction;
int32_t tOffset = 0; // Added Sept 22
uint8_t ft8_hours, ft8_minutes, ft8_seconds; uint8_t ft8_hours, ft8_minutes, ft8_seconds;
int ft8_flag, FT_8_counter, ft8_marker, decode_flag;
int num_decoded_msg;
int xmit_flag, ft8_xmit_counter, Transmit_Armned;
int DSP_Flag; // =1 if new data is ready for FFT
int master_decoded;
// rcvFT8State // rcvFT8State
#define FT8_RCV_IDLE 0 #define FT8_RCV_IDLE 0
@ -123,48 +130,23 @@ int master_decoded;
#define FT8_RCV_FIND_POWERS 2 #define FT8_RCV_FIND_POWERS 2
#define FT8_RCV_READY_DECODE 3 #define FT8_RCV_READY_DECODE 3
#define FT8_RCV_DECODE 4 #define FT8_RCV_DECODE 4
int rcvFT8State = FT8_RCV_IDLE; int rcvFT8State = FT8_RCV_IDLE;
int master_offset, offset_step; int offset_step;
int Target_Flag = 0;
//From gen_ft8.cpp //From gen_ft8.cpp, i.e., also used for transmit
char Target_Call[7]; //six character call sign + /0 char Target_Call[7]; //six character call sign + /0
char Target_Locator[5]; // four character locator + /0 char Target_Locator[5]; // four character locator + /0
int Target_RSL; // four character RSL + /0 int Target_RSL; // four character RSL + /0
float32_t Station_Latitude, Station_Longitude; float32_t Station_Latitude, Station_Longitude;
float32_t Target_Latitude, Target_Longitude; float32_t Target_Latitude, Target_Longitude;
int32_t current_time, start_time;
// Define FT8 symbol counts int32_t ft8_time, ft8_mod_time, ft8_mod_time_last;
int ND = 58; int32_t tOffset = 0; // Added Sept 22
int NS = 21;
int NN = 79;
// Define the LDPC sizes
int N = 174;
int K = 91;
int M = 83;
int K_BYTES = 12;
// Define CRC parameters
uint16_t CRC_POLYNOMIAL = 0X2757; // CRC-14 polynomial without the leading (MSB) 1
int CRC_WIDTH = 14;
// Communicate amongst decode functions:
typedef struct Candidate {
int16_t score;
int16_t time_offset;
int16_t freq_offset;
uint8_t time_sub;
uint8_t freq_sub;
uint8_t alt; // Added for convenience Teensy, RSL
float32_t syncPower; // Added for Teensy, RSL
} Candidate;
uint8_t secLast = 0; uint8_t secLast = 0;
const int ledPin = 13; const int ledPin = 13;
bool showPower = false; bool showPower = false;
uint32_t tp = 0; uint32_t tp = 0;
uint32_t tu; uint32_t tu = 0;
uint32_t ct=0;
void setup(void) { void setup(void) {
strcpy(Station_Call, "W7PUA"); strcpy(Station_Call, "W7PUA");
@ -197,6 +179,10 @@ void setup(void) {
void loop(void) { void loop(void) {
int16_t inCmd; int16_t inCmd;
int master_offset;
if( Serial.available() ) if( Serial.available() )
{ {
inCmd = Serial.read(); inCmd = Serial.read();
@ -323,16 +309,14 @@ void loop(void) {
Serial.println("FT8 Decode"); Serial.println("FT8 Decode");
#endif #endif
tu = micros(); tu = micros();
num_decoded_msg = ft8_decode(); ft8_decode();
printFT8Received(); printFT8Received();
rcvFT8State = FT8_RCV_IDLE; rcvFT8State = FT8_RCV_IDLE;
master_decoded = num_decoded_msg;
#ifdef DEBUG1 #ifdef DEBUG1
Serial.print("ft8_decode Time, uSec = "); Serial.print("ft8_decode Time, uSec = ");
Serial.println(micros() - tu); Serial.println(micros() - tu);
#endif #endif
} }
delay(1); delay(1);
} // End loop() } // End loop()
@ -342,6 +326,8 @@ time_t getTeensy3Time() {
// This starts the receiving data collection every 15 sec // This starts the receiving data collection every 15 sec
void update_synchronization() { void update_synchronization() {
int32_t hours_fraction;
current_time = millis() + tOffset; current_time = millis() + tOffset;
ft8_time = current_time - start_time; ft8_time = current_time - start_time;
ft8_hours = (int8_t)(ft8_time/3600000); ft8_hours = (int8_t)(ft8_time/3600000);

10
examples/FT8Receive/Process_DSP_R.ino
Unescape View File

@ -143,16 +143,16 @@ void extract_power( int offset) {
// This measurement occurs once every 15 sec, but may be just before // This measurement occurs once every 15 sec, but may be just before
// or just after decode. Either way, the "latest" noise estimate is used. // or just after decode. Either way, the "latest" noise estimate is used.
noiseMeasured = true; // Reset after decode() noiseMeasured = true; // Reset after decode()
noisePowerEstimateH = 0.2f*(y[0]+y[1]+y[2]+y[3]+y[4]); FT8noisePowerEstimateH = 0.2f*(y[0]+y[1]+y[2]+y[3]+y[4]);
noisePwrDBIntH = (int16_t)(10.0f*log10f(noisePowerEstimateH)); FT8noisePwrDBIntH = (int16_t)(10.0f*log10f(FT8noisePowerEstimateH));
noisePeakAveRatio = runningMax/(0.00156*runningSum); FT8noisePeakAveRatio = runningMax/(0.00156*runningSum);
#ifdef DEBUG_N #ifdef DEBUG_N
Serial.println("Noise measurement between transmit time periods:"); Serial.println("Noise measurement between transmit time periods:");
Serial.print(" rSum, rMax= "); Serial.print(0.00156*runningSum, 5); Serial.print(" rSum, rMax= "); Serial.print(0.00156*runningSum, 5);
Serial.print(" "); Serial.print(runningMax, 5); Serial.print(" "); Serial.print(runningMax, 5);
Serial.print(" Ratio= "); Serial.print(noisePeakAveRatio, 3); Serial.print(" Ratio= "); Serial.print(FT8noisePeakAveRatio, 3);
Serial.print(" Int noise= "); Serial.print(" Int noise= ");
Serial.println(noisePwrDBIntH); // dB increments Serial.println(FT8noisePwrDBIntH); // dB increments
#endif #endif
} }

20
examples/FT8Receive/decodeR.ino
Unescape View File

@ -66,13 +66,13 @@ int find_sync(const uint8_t *power, int num_blocks, int num_bins, //
npCount++; npCount++;
} }
} }
noisePowerEstimateL = np/(float32_t)npCount; FT8noisePowerEstimateL = np/(float32_t)npCount;
noisePwrDBIntL = (int16_t)(0.5f*noisePowerEstimateL); FT8noisePwrDBIntL = (int16_t)(0.5f*FT8noisePowerEstimateL);
#if DEBUG_N #if DEBUG_N
Serial.println("Data for low SNR noise estimate:"); Serial.println("Data for low SNR noise estimate:");
Serial.print(" Full Ave Noise = "); Serial.println(noisePowerEstimateL); Serial.print(" Full Ave Noise = "); Serial.println(FT8noisePowerEstimateL);
Serial.print(" Full Ave dB Noise Int = "); Serial.println(noisePwrDBIntL); Serial.print(" Full Ave dB Noise Int = "); Serial.println(FT8noisePwrDBIntL);
Serial.print(" Noise Sample Count = "); Serial.println(npCount); Serial.print(" Noise Sample Count = "); Serial.println(npCount);
#endif #endif
@ -83,7 +83,7 @@ int find_sync(const uint8_t *power, int num_blocks, int num_bins, //
for (int alt = 0; alt < 4; ++alt) for (int alt = 0; alt < 4; ++alt)
{ {
// 92-79+7=20 // 92-79+7=20
for (int time_offset = -7; time_offset < num_blocks - NN + 7; ++time_offset) // NN=79 for (int time_offset = -7; time_offset < num_blocks - FT8_NN + 7; ++time_offset) // FT8_NN=79
{ {
// 48 368-8=360 // 48 368-8=360
for (int freq_offset = LOW_FREQ_INDEX; freq_offset < num_bins - 8; ++freq_offset) for (int freq_offset = LOW_FREQ_INDEX; freq_offset < num_bins - 8; ++freq_offset)
@ -205,9 +205,9 @@ void extract_likelihood(const uint8_t *power, int num_bins,
const int n_syms = 1; const int n_syms = 1;
// const int n_bits = 3 * n_syms; // const int n_bits = 3 * n_syms;
// const int n_tones = (1 << n_bits); // const int n_tones = (1 << n_bits);
for (int k = 0; k < ND; k += n_syms) for (int k = 0; k < FT8_ND; k += n_syms)
{ {
int sym_idx = (k < ND / 2) ? (k + 7) : (k + 14); int sym_idx = (k < FT8_ND / 2) ? (k + 7) : (k + 14);
int bit_idx = 3 * k; int bit_idx = 3 * k;
// Pointer to 8 bins of the current symbol // Pointer to 8 bins of the current symbol
const uint8_t *ps = power + (ft8_offset + sym_idx * 4 * num_bins); const uint8_t *ps = power + (ft8_offset + sym_idx * 4 * num_bins);
@ -216,8 +216,8 @@ void extract_likelihood(const uint8_t *power, int num_bins,
// Compute the variance of log174 // Compute the variance of log174
float sum = 0; float sum = 0;
float sum2 = 0; float sum2 = 0;
float inv_n = 1.0f / N; float inv_n = 1.0f / FT8_N;
for (int i = 0; i < N; ++i) for (int i = 0; i < FT8_N; ++i)
{ {
sum += log174[i]; sum += log174[i];
sum2 += log174[i] * log174[i]; sum2 += log174[i] * log174[i];
@ -226,7 +226,7 @@ void extract_likelihood(const uint8_t *power, int num_bins,
// Normalize log174 such that sigma = 2.83 (Why? It's in WSJT-X, ft8b.f90) // Normalize log174 such that sigma = 2.83 (Why? It's in WSJT-X, ft8b.f90)
// Seems to be 2.83 = sqrt(8). Experimentally sqrt(16) works better. // Seems to be 2.83 = sqrt(8). Experimentally sqrt(16) works better.
float norm_factor = sqrtf(16.0f / variance); float norm_factor = sqrtf(16.0f / variance);
for (int i = 0; i < N; ++i) for (int i = 0; i < FT8_N; ++i)
{ {
log174[i] *= norm_factor; log174[i] *= norm_factor;
} }

26
examples/FT8Receive/decode_ft8R.ino
Unescape View File

@ -78,9 +78,9 @@ int ft8_decode(void) {
char decoded[kMax_decoded_messages][kMax_message_length]; char decoded[kMax_decoded_messages][kMax_message_length];
const float fsk_dev = 6.25f; // tone spacing in Hz and symbol rate const float fsk_dev = 6.25f; // tone spacing in Hz and symbol rate
Candidate candidate_list[kMax_candidates]; Candidate candidate_list[kMax_candidates];
float log174[N]; float log174[FT8_N];
uint8_t plain[N]; uint8_t plain[FT8_N];
uint8_t a91[K_BYTES]; uint8_t a91[FT8_K_BYTES];
// Find top candidates by Costas sync score and localize them in time and frequency // Find top candidates by Costas sync score and localize them in time and frequency
int num_candidates = find_sync(export_fft_power, int num_candidates = find_sync(export_fft_power,
@ -100,7 +100,7 @@ int ft8_decode(void) {
if (n_errors > 0) if (n_errors > 0)
continue; continue;
// Extract payload + CRC (first K bits) // Extract payload + CRC (first K bits)
pack_bits(plain, K, a91); pack_bits(plain, FT8_K, a91);
// Extract CRC and check it // Extract CRC and check it
uint16_t chksum = ((a91[9] & 0x07) << 11) | (a91[10] << 3) | (a91[11] >> 5); uint16_t chksum = ((a91[9] & 0x07) << 11) | (a91[10] << 3) | (a91[11] >> 5);
a91[9] &= 0xF8; a91[9] &= 0xF8;
@ -159,16 +159,16 @@ int ft8_decode(void) {
new_decoded[indexFound].sync_score = cand.score; new_decoded[indexFound].sync_score = cand.score;
new_decoded[indexFound].freq_hz = (int)freq_hz; new_decoded[indexFound].freq_hz = (int)freq_hz;
new_decoded[indexFound].dTime = dt; new_decoded[indexFound].dTime = dt;
if(noisePeakAveRatio < 100.0f) // No big signals if(FT8noisePeakAveRatio < 100.0f) // No big signals
{ {
new_decoded[indexFound].snr = new_decoded[indexFound].snr =
cand.syncPower - (float32_t)noisePwrDBIntL + 51.0f; cand.syncPower - (float32_t)FT8noisePwrDBIntL + 51.0f;
noiseType = 'L'; noiseType = 'L';
} }
else else
{ {
new_decoded[indexFound].snr = new_decoded[indexFound].snr =
cand.syncPower - (float32_t)noisePwrDBIntH - 13.0f; cand.syncPower - (float32_t)FT8noisePwrDBIntH - 13.0f;
noiseType = 'H'; noiseType = 'H';
} }
if(new_decoded[indexFound].snr < -21) if(new_decoded[indexFound].snr < -21)
@ -197,12 +197,12 @@ int ft8_decode(void) {
strcpy(new_decoded[num_decoded].field2, field2); strcpy(new_decoded[num_decoded].field2, field2);
strcpy(new_decoded[num_decoded].field3, field3); strcpy(new_decoded[num_decoded].field3, field3);
strcpy(new_decoded[num_decoded].decode_time, rtc_string); strcpy(new_decoded[num_decoded].decode_time, rtc_string);
if(noisePeakAveRatio < 100.0f) // No big signals for quiet timing if(FT8noisePeakAveRatio < 100.0f) // No big signals for quiet timing
new_decoded[num_decoded].snr = new_decoded[num_decoded].snr =
cand.syncPower - (float32_t)noisePwrDBIntL + 51.0f; cand.syncPower - (float32_t)FT8noisePwrDBIntL + 51.0f;
else else
new_decoded[num_decoded].snr = new_decoded[num_decoded].snr =
cand.syncPower - (float32_t)noisePwrDBIntH - 13.0f; cand.syncPower - (float32_t)FT8noisePwrDBIntH - 13.0f;
if(new_decoded[num_decoded].snr < -21) if(new_decoded[num_decoded].snr < -21)
new_decoded[num_decoded].snr = -21; // It is never lower!! new_decoded[num_decoded].snr = -21; // It is never lower!!
#ifdef DEBUG_D #ifdef DEBUG_D
@ -212,9 +212,9 @@ int ft8_decode(void) {
#endif #endif
#ifdef DEBUG_N #ifdef DEBUG_N
Serial.print("syncPower, noiseL, noiseH, ratio { "); Serial.print(cand.syncPower, 1); Serial.print("syncPower, noiseL, noiseH, ratio { "); Serial.print(cand.syncPower, 1);
Serial.print(" "); Serial.print(noisePwrDBIntL); Serial.print(" "); Serial.print(FT8noisePwrDBIntL);
Serial.print(" "); Serial.print(noisePwrDBIntH); Serial.print(" "); Serial.print(FT8noisePwrDBIntH);
Serial.print(" "); Serial.print(noisePeakAveRatio, 1); Serial.print(" "); Serial.print(FT8noisePeakAveRatio, 1);
Serial.println(" }"); Serial.println(" }");
#endif #endif
char Target_Locator[] = " "; char Target_Locator[] = " ";

4
examples/FT8Receive/encodeR.ino
Unescape View File

@ -117,6 +117,10 @@ void encode174(const uint8_t *message, uint8_t *codeword) {
// [IN] num_bits - number of bits in the sequence // [IN] num_bits - number of bits in the sequence
uint16_t crc(uint8_t *message, int num_bits) { uint16_t crc(uint8_t *message, int num_bits) {
// Adapted from https://barrgroup.com/Embedded-Systems/How-To/CRC-Calculation-C-Code // Adapted from https://barrgroup.com/Embedded-Systems/How-To/CRC-Calculation-C-Code
// Define CRC parameters
uint16_t CRC_POLYNOMIAL = 0X2757; // CRC-14 polynomial without the leading (MSB) 1
int CRC_WIDTH = 14;
//constexpr uint16_t TOPBIT = (1 << (CRC_WIDTH - 1)); //constexpr uint16_t TOPBIT = (1 << (CRC_WIDTH - 1));
uint16_t TOPBIT = (1 << (CRC_WIDTH - 1)); uint16_t TOPBIT = (1 << (CRC_WIDTH - 1));
// printf("CRC, %d bits: ", num_bits); // printf("CRC, %d bits: ", num_bits);

38
examples/FT8Receive/ldpcR.ino
Unescape View File

@ -75,18 +75,18 @@ void pack_bits(const uint8_t plain[], int num_bits, uint8_t packed[]) {
// max_iters is how hard to try. // max_iters is how hard to try.
// ok == 87 means success. // ok == 87 means success.
void ldpc_decode(float codeword[], int max_iters, uint8_t plain[], int *ok) { void ldpc_decode(float codeword[], int max_iters, uint8_t plain[], int *ok) {
float m[M][N]; // ~60 kB float m[FT8_M][FT8_N]; // ~60 kB
float e[M][N]; // ~60 kB float e[FT8_M][FT8_N]; // ~60 kB
int min_errors = M; int min_errors = FT8_M;
for (int j = 0; j < M; j++) { for (int j = 0; j < FT8_M; j++) {
for (int i = 0; i < N; i++) { for (int i = 0; i < FT8_N; i++) {
m[j][i] = codeword[i]; m[j][i] = codeword[i];
e[j][i] = 0.0f; e[j][i] = 0.0f;
} }
} }
for (int iter = 0; iter < max_iters; iter++) { for (int iter = 0; iter < max_iters; iter++) {
for (int j = 0; j < M; j++) { for (int j = 0; j < FT8_M; j++) {
for (int ii1 = 0; ii1 < kNrw[j]; ii1++) { for (int ii1 = 0; ii1 < kNrw[j]; ii1++) {
int i1 = kNm[j][ii1] - 1; int i1 = kNm[j][ii1] - 1;
float a = 1.0f; float a = 1.0f;
@ -99,7 +99,7 @@ void ldpc_decode(float codeword[], int max_iters, uint8_t plain[], int *ok) {
e[j][i1] = logf((1 - a) / (1 + a)); e[j][i1] = logf((1 - a) / (1 + a));
} }
} }
for (int i = 0; i < N; i++) { for (int i = 0; i < FT8_N; i++) {
float l = codeword[i]; float l = codeword[i];
for (int j = 0; j < 3; j++) for (int j = 0; j < 3; j++)
l += e[kMn[i][j] - 1][i]; l += e[kMn[i][j] - 1][i];
@ -117,7 +117,7 @@ void ldpc_decode(float codeword[], int max_iters, uint8_t plain[], int *ok) {
} }
} }
for (int i = 0; i < N; i++) { for (int i = 0; i < FT8_N; i++) {
for (int ji1 = 0; ji1 < 3; ji1++) { for (int ji1 = 0; ji1 < 3; ji1++) {
int j1 = kMn[i][ji1] - 1; int j1 = kMn[i][ji1] - 1;
float l = codeword[i]; float l = codeword[i];
@ -143,7 +143,7 @@ void ldpc_decode(float codeword[], int max_iters, uint8_t plain[], int *ok) {
static int ldpc_check(uint8_t codeword[]) { static int ldpc_check(uint8_t codeword[]) {
int errors = 0; int errors = 0;
for (int j = 0; j < M; ++j) { for (int j = 0; j < FT8_M; ++j) {
uint8_t x = 0; uint8_t x = 0;
for (int i = 0; i < kNrw[j]; ++i) { for (int i = 0; i < kNrw[j]; ++i) {
x ^= codeword[kNm[j][i] - 1]; x ^= codeword[kNm[j][i] - 1];
@ -157,28 +157,28 @@ static int ldpc_check(uint8_t codeword[]) {
void bp_decode(float codeword[], int max_iters, uint8_t plain[], int *ok) { void bp_decode(float codeword[], int max_iters, uint8_t plain[], int *ok) {
float tov[N][3]; float tov[FT8_N][3];
float toc[M][7]; float toc[FT8_M][7];
int min_errors = M; int min_errors = FT8_M;
// initialize messages to checks // initialize messages to checks
for (int i = 0; i < M; ++i) { for (int i = 0; i < FT8_M; ++i) {
for (int j = 0; j < kNrw[i]; ++j) { for (int j = 0; j < kNrw[i]; ++j) {
toc[i][j] = codeword[kNm[i][j] - 1]; toc[i][j] = codeword[kNm[i][j] - 1];
} }
} }
for (int i = 0; i < N; ++i) { for (int i = 0; i < FT8_N; ++i) {
for (int j = 0; j < 3; ++j) { for (int j = 0; j < 3; ++j) {
tov[i][j] = 0; tov[i][j] = 0;
} }
} }
for (int iter = 0; iter < max_iters; ++iter) { for (int iter = 0; iter < max_iters; ++iter) {
float zn[N]; float zn[FT8_N];
// Update bit log likelihood ratios (tov=0 in iter 0) // Update bit log likelihood ratios (tov=0 in iter 0)
for (int i = 0; i < N; ++i) { for (int i = 0; i < FT8_N; ++i) {
zn[i] = codeword[i] + tov[i][0] + tov[i][1] + tov[i][2]; zn[i] = codeword[i] + tov[i][0] + tov[i][1] + tov[i][2];
plain[i] = (zn[i] > 0) ? 1 : 0; plain[i] = (zn[i] > 0) ? 1 : 0;
} }
@ -196,7 +196,7 @@ void bp_decode(float codeword[], int max_iters, uint8_t plain[], int *ok) {
} }
// Send messages from bits to check nodes // Send messages from bits to check nodes
for (int i = 0; i < M; ++i) { for (int i = 0; i < FT8_M; ++i) {
for (int j = 0; j < kNrw[i]; ++j) { for (int j = 0; j < kNrw[i]; ++j) {
int ibj = kNm[i][j] - 1; int ibj = kNm[i][j] - 1;
toc[i][j] = zn[ibj]; toc[i][j] = zn[ibj];
@ -210,13 +210,13 @@ void bp_decode(float codeword[], int max_iters, uint8_t plain[], int *ok) {
} }
// send messages from check nodes to variable nodes // send messages from check nodes to variable nodes
for (int i = 0; i < M; ++i) { for (int i = 0; i < FT8_M; ++i) {
for (int j = 0; j < kNrw[i]; ++j) { for (int j = 0; j < kNrw[i]; ++j) {
toc[i][j] = fast_tanh(-toc[i][j] / 2); toc[i][j] = fast_tanh(-toc[i][j] / 2);
} }
} }
for (int i = 0; i < N; ++i) { for (int i = 0; i < FT8_N; ++i) {
for (int j = 0; j < 3; ++j) { for (int j = 0; j < 3; ++j) {
int ichk = kMn[i][j] - 1; // kMn(:,j) are the checks that include bit j int ichk = kMn[i][j] - 1; // kMn(:,j) are the checks that include bit j
float Tmn = 1.0f; float Tmn = 1.0f;

Write Preview
Loading…
Cancel
Save