I am become lost, confuser of words

include/encoder/Scrambler.h

@@ -15,7 +15,7 @@ public:
     /**
      * @brief Constructor initializes the scrambler with a predefined register value.
      */
-    Scrambler() : data_sequence_register(0x0BAD) {}
+    Scrambler() : data_sequence_register(0x0BAD), symbol_count(0) {}
 
     /**
      * @brief Scrambles a synchronization preamble using a fixed randomizer sequence.
@@ -60,37 +60,44 @@ public:
 
 private:
     uint16_t data_sequence_register;
+    size_t symbol_count;
 
     /**
      * @brief Generates the next value from the data sequence randomizing generator.
      * @return A 3-bit random value (0-7) from the current state of the LFSR.
      */
     uint8_t getNextRandomValue() {
-        uint8_t output = data_sequence_register & 0x07;
+        // Reset the LFSR state every 160 symbols, as per the specification
+        if (symbol_count >= 160) {
+            data_sequence_register = 0x0BAD;  // Load initial value "BAD" (hex)
+            symbol_count = 0;
+        }
+        symbol_count++;
 
+        uint8_t output = data_sequence_register & 0x07;  // Extract the lower 3 bits
+
+        // Perform 8 shifts to generate the next 3-bit random value
         for (int i = 0; i < 8; ++i) {
-            // Get the most significant bit
+            // Extract the MSB (bit 11 in a 12-bit register)
-            uint16_t msb = (data_sequence_register >> 11) & 0x01;
+            uint16_t msb = (data_sequence_register & 0x0800) ? 1 : 0;  // Bit 11 is 0x0800
 
-            // XOR taps and shift into the LFSR
+            // Shift the register left by 1 bit
-            uint16_t bit1 = (data_sequence_register & 0x01) ^ msb;
+            data_sequence_register <<= 1;
-            uint16_t bit4 = ((data_sequence_register >> 3) & 0x01) ^ msb;
-            uint16_t bit6 = ((data_sequence_register >> 5) & 0x01) ^ msb;
 
-            // Update specific bits in the shift register
+            // Apply feedback if MSB was set
-            data_sequence_register = (data_sequence_register & ~(1 << 5)) | (bit6 << 5);
+            if (msb) {
-            data_sequence_register = (data_sequence_register & ~(1 << 3)) | (bit4 << 3);
+                // XOR with the tapped bits (positions 1, 4, and 6)
-            data_sequence_register = (data_sequence_register & ~0x01) | bit1;
+                // Tap mask is 0x052 (bits 1, 4, 6): taps at positions 1, 4, 6 affect the feedback
+                data_sequence_register ^= 0x052;
+            }
 
-            // Shift left and insert the MSB
+            // Ensure the LFSR stays within 12 bits
-            data_sequence_register = (data_sequence_register << 1) | msb;
-
-            // Keep the LFSR in 12 bits
             data_sequence_register &= 0x0FFF;
         }
 
         return output;
     }
+
 };
 
 #endif

include/encoder/SymbolFormation.h

@@ -10,24 +10,6 @@
 
 #include "Scrambler.h"
 
-enum class SymbolType { SYNC_PREAMBLE, UNKNOWN_DATA, PROBE_DATA };
-
-static constexpr size_t LONG_PROBE_DATA_BLOCK_SIZE = 20;
-static constexpr size_t SHORT_PROBE_DATA_BLOCK_SIZE = 16;
-static constexpr size_t LONG_UNKNOWN_DATA_BLOCK_SIZE = 32;
-static constexpr size_t SHORT_UNKNOWN_DATA_BLOCK_SIZE = 20;
-static constexpr size_t SET_SIZE_LONG = 360;
-static constexpr size_t SET_SIZE_SHORT = 32;
-
-std::vector<uint8_t> Sync_Preamble_0 = {0, 0, 0, 0, 0, 0, 0, 0};
-std::vector<uint8_t> Sync_Preamble_1 = {0, 4, 0, 4, 0, 4, 0, 4};
-std::vector<uint8_t> Sync_Preamble_2 = {0, 0, 4, 4, 0, 0, 4, 4};
-std::vector<uint8_t> Sync_Preamble_3 = {0, 4, 4, 0, 0, 4, 4, 0};
-std::vector<uint8_t> Sync_Preamble_4 = {0, 0, 0, 0, 4, 4, 4, 4};
-std::vector<uint8_t> Sync_Preamble_5 = {0, 4, 0, 4, 4, 0, 4, 0};
-std::vector<uint8_t> Sync_Preamble_6 = {0, 0, 4, 4, 4, 4, 0, 0};
-std::vector<uint8_t> Sync_Preamble_7 = {0, 4, 4, 0, 4, 0, 0, 4};
-
 std::vector<uint8_t> baud75_exceptional_0 = {0, 0, 0, 0, 4, 4, 4, 4};
 std::vector<uint8_t> baud75_exceptional_1 = {0, 4, 0, 4, 4, 0, 4, 0};
 std::vector<uint8_t> baud75_exceptional_2 = {0, 0, 4, 4, 4, 4, 0, 0};
@@ -46,8 +28,10 @@ class SymbolFormation {
         std::vector<uint8_t> sync_preamble = generateSyncPreamble();
         sync_preamble = scrambler.scrambleSyncPreamble(sync_preamble);
 
-        size_t unknown_data_block_size = (baud_rate >= 2400) ? LONG_UNKNOWN_DATA_BLOCK_SIZE : SHORT_UNKNOWN_DATA_BLOCK_SIZE;
+        // Determine the block sizes
+        size_t unknown_data_block_size = (baud_rate >= 2400) ? 32 : 20;
         size_t interleaver_block_size;
+
         if (baud_rate == 2400) {
             interleaver_block_size = (interleave_setting == 2) ? (40 * 576) : (40 * 72);
         } else if (baud_rate == 1200) {
@@ -64,13 +48,14 @@ class SymbolFormation {
 
         size_t current_index = 0;
         while (current_index < symbol_data.size()) {
-            // Process unknown data block
+            // Determine the size of the current unknown data block
             size_t block_size = std::min(unknown_data_block_size, symbol_data.size() - current_index);
             std::vector<uint8_t> unknown_data_block(symbol_data.begin() + current_index, symbol_data.begin() + current_index + block_size);
             current_index += block_size;
 
+            // Map the unknown data based on baud rate
             if (baud_rate == 75) {
-                size_t set_size = (interleave_setting == 2) ? SET_SIZE_LONG : SET_SIZE_SHORT;
+                size_t set_size = (interleave_setting == 2) ? 360 : 32;
                 for (size_t i = 0; i < unknown_data_block.size(); i += set_size) {
                     bool is_exceptional_set = (set_count % ((interleave_setting == 1) ? 45 : 360)) == 0;
                     std::vector<uint8_t> mapped_set = map75bpsSet(unknown_data_block, i, set_size, is_exceptional_set);
@@ -78,14 +63,16 @@ class SymbolFormation {
                     set_count++;
                 }
             } else {
+                // For baud rates greater than 75 bps
                 std::vector<uint8_t> mapped_unknown_data = mapUnknownData(unknown_data_block);
                 symbol_count += mapped_unknown_data.size();
                 data_stream.insert(data_stream.end(), mapped_unknown_data.begin(), mapped_unknown_data.end());
             }
 
+            // Insert probe data if we are at an interleaver block boundary
             if (baud_rate > 75) {
-                bool inside_block = (symbol_count % interleaver_block_size) != 0;
+                bool is_at_boundary = (symbol_count % interleaver_block_size) == 0;
-                std::vector<uint8_t> probe_data = generateProbeData(inside_block);
+                std::vector<uint8_t> probe_data = generateProbeData(!is_at_boundary);
                 data_stream.insert(data_stream.end(), probe_data.begin(), probe_data.end());
             }
         }
@@ -108,113 +95,57 @@ class SymbolFormation {
     bool is_frequency_hopping;
     Scrambler scrambler = Scrambler();
 
-    void appendProbeMapping(std::vector<uint8_t>& symbol_stream, uint8_t symbol, size_t repeat_count) {
+    std::vector<uint8_t> mapChannelSymbolToTribitPattern(uint8_t symbol, bool repeat_twice = false) {
+        std::vector<uint8_t> tribit_pattern;
+
         switch (symbol) {
-            case 0:
+            case 0b000: // 000
-                for (int i = 0; i < repeat_count; ++i) {
+                tribit_pattern = {0, 0, 0, 0, 0, 0, 0, 0};
-                    symbol_stream.insert(symbol_stream.end(), Sync_Preamble_0.begin(), Sync_Preamble_0.end());
-                }
                 break;
-            case 1:
+            case 0b001: // 001
-                for (int i = 0; i < repeat_count; ++i) {
+                tribit_pattern = {0, 4, 0, 4, 0, 4, 0, 4};
-                    symbol_stream.insert(symbol_stream.end(), Sync_Preamble_1.begin(), Sync_Preamble_1.end());
-                }
                 break;
-            case 2:
+            case 0b010: // 010
-                for (int i = 0; i < repeat_count; ++i) {
+                tribit_pattern = {0, 0, 4, 4, 0, 0, 4, 4};
-                    symbol_stream.insert(symbol_stream.end(), Sync_Preamble_2.begin(), Sync_Preamble_2.end());
-                }
                 break;
-            case 3:
+            case 0b011: // 011
-                for (int i = 0; i < repeat_count; ++i) {
+                tribit_pattern = {0, 4, 4, 0, 0, 4, 4, 0};
-                    symbol_stream.insert(symbol_stream.end(), Sync_Preamble_3.begin(), Sync_Preamble_3.end());
-                }
                 break;
-            case 4:
+            case 0b100: // 100
-                for (int i = 0; i < repeat_count; ++i) {
+                tribit_pattern = {0, 0, 0, 0, 4, 4, 4, 4};
-                    symbol_stream.insert(symbol_stream.end(), Sync_Preamble_4.begin(), Sync_Preamble_4.end());
-                }
                 break;
-            case 5:
+            case 0b101: // 101
-                for (int i = 0; i < repeat_count; ++i) {
+                tribit_pattern = {0, 4, 0, 4, 4, 0, 4, 0};
-                    symbol_stream.insert(symbol_stream.end(), Sync_Preamble_5.begin(), Sync_Preamble_5.end());
-                }
                 break;
-            case 6:
+            case 0b110: // 110
-                for (int i = 0; i < repeat_count; ++i) {
+                tribit_pattern = {0, 0, 4, 4, 4, 4, 0, 0};
-                    symbol_stream.insert(symbol_stream.end(), Sync_Preamble_6.begin(), Sync_Preamble_6.end());
-                }
                 break;
-            case 7:
+            case 0b111: // 111
-                for (int i = 0; i < repeat_count; ++i) {
+                tribit_pattern = {0, 4, 4, 0, 4, 0, 0, 4};
-                    symbol_stream.insert(symbol_stream.end(), Sync_Preamble_7.begin(), Sync_Preamble_7.end());
-                }
                 break;
             default:
                 throw std::invalid_argument("Invalid channel symbol");
         }
-    }
 
-    void append75bpsMapping(std::vector<uint8_t>& symbol_stream, uint8_t symbol, bool is_exceptional_set) {
+        if (repeat_twice) {
-        if (is_exceptional_set) {
+            // Repeat the pattern twice instead of four times for known symbols
-            switch (symbol) {
+            tribit_pattern.insert(tribit_pattern.end(), tribit_pattern.begin(), tribit_pattern.end());
-                case 0:
-                    for (int i = 0; i < 4; ++i) {
-                        symbol_stream.insert(symbol_stream.end(), baud75_exceptional_0.begin(), baud75_exceptional_0.end());
-                    }
-                    break;
-                case 1:
-                    for (int i = 0; i < 4; ++i) {
-                        symbol_stream.insert(symbol_stream.end(), baud75_exceptional_1.begin(), baud75_exceptional_1.end());
-                    }
-                    break;
-                case 2:
-                    for (int i = 0; i < 4; ++i) {
-                        symbol_stream.insert(symbol_stream.end(), baud75_exceptional_2.begin(), baud75_exceptional_2.end());
-                    }
-                    break;
-                case 3:
-                    for (int i = 0; i < 4; ++i) {
-                        symbol_stream.insert(symbol_stream.end(), baud75_exceptional_3.begin(), baud75_exceptional_3.end());
-                    }
-                    break;
-                default:
-                    throw std::invalid_argument("Invalid channel symbol");
-            }
         } else {
-            switch (symbol) {
+            // Repeat the pattern four times as per Table XIII
-                case 0:
+            tribit_pattern.insert(tribit_pattern.end(), tribit_pattern.begin(), tribit_pattern.end());
-                    for (int i = 0; i < 8; ++i) {
+            tribit_pattern.insert(tribit_pattern.end(), tribit_pattern.begin(), tribit_pattern.end());
-                        symbol_stream.insert(symbol_stream.end(), baud75_normal_0.begin(), baud75_normal_0.end());
+            tribit_pattern.insert(tribit_pattern.end(), tribit_pattern.begin(), tribit_pattern.end());
-                    }
-                    break;
-                case 1:
-                    for (int i = 0; i < 8; ++i) {
-                        symbol_stream.insert(symbol_stream.end(), baud75_normal_1.begin(), baud75_normal_1.end());
-                    }
-                    break;
-                case 2:
-                    for (int i = 0; i < 8; ++i) {
-                        symbol_stream.insert(symbol_stream.end(), baud75_normal_2.begin(), baud75_normal_2.end());
-                    }
-                    break;
-                case 3:
-                    for (int i = 0; i < 8; ++i) {
-                        symbol_stream.insert(symbol_stream.end(), baud75_normal_3.begin(), baud75_normal_3.end());
-                    }
-                    break;
-                default:
-                    throw std::invalid_argument("Invalid channel symbol");
-            }
         }
+
+        return tribit_pattern;
     }
 
     std::vector<uint8_t> generateSyncPreamble() {
         std::vector<uint8_t> preamble;
 
-        size_t num_segments = (interleave_setting == 0) ? 3 : 24;
+        size_t num_segments = (interleave_setting == 2) ? 24 : 3;
 
-        std::vector<uint8_t> segment_sequence = {0,1,3,0,1,3,1,2,0};
+        std::vector<uint8_t> segment_sequence = {0, 1, 3, 0, 1, 3, 1, 2, 0};
 
         uint8_t D1, D2;
         if (baud_rate == 4800) {
@@ -256,16 +187,15 @@ class SymbolFormation {
         for (size_t i = 0; i < num_segments; i++) {
             std::vector<uint8_t> full_segment_sequence = segment_sequence;
 
-            C1 = (1 << 2) | C1;
-            C2 = (1 << 2) | C2;
-            C3 = (1 << 2) | C3;
-            
             full_segment_sequence.push_back(C1);
             full_segment_sequence.push_back(C2);
             full_segment_sequence.push_back(C3);
             full_segment_sequence.push_back(0);
 
-            preamble.insert(preamble.end(), full_segment_sequence.begin(), full_segment_sequence.end());
+            for (uint8_t symbol : full_segment_sequence) {
+                std::vector<uint8_t> mapped_tribit = mapChannelSymbolToTribitPattern(symbol);
+                preamble.insert(preamble.end(), mapped_tribit.begin(), mapped_tribit.end());
+            }
 
             if (C3 > 0) {
                 C3--;
@@ -279,16 +209,13 @@ class SymbolFormation {
             }
         }
 
-        std::vector<uint8_t> final_preamble;
+        return preamble;
-        for (auto& symbol : preamble) {
-            appendProbeMapping(final_preamble, symbol, 4);
-        }
-
-        return final_preamble;
     }
 
     std::vector<uint8_t> generateProbeData(bool is_inside_block) {
         std::vector<uint8_t> probe_data;
+
+        // Determine interleaver block size based on baud rate and interleave setting
         size_t interleaver_block_size;
         if (baud_rate == 2400) {
             interleaver_block_size = (interleave_setting == 2) ? (40 * 576) : (40 * 72);
@@ -300,10 +227,11 @@ class SymbolFormation {
             interleaver_block_size = (interleave_setting == 2) ? (20 * 36) : (10 * 9);
         }
 
+        // If we are inside an interleaver block, the probe data is filled with zeros
+        if (is_inside_block) {
             probe_data.resize(interleaver_block_size, 0x00);
-
+        } else {
-        if (!is_inside_block) {
+            // Set the known symbol patterns for D1 and D2 based on Table XI
-            // Set the known symbol patterns for D1 and D2 based on Table XI and Table XIII
             uint8_t D1, D2;
             if (baud_rate == 4800) {
                 D1 = 7; D2 = 6;
@@ -324,24 +252,94 @@ class SymbolFormation {
             } else if (baud_rate == 150) {
                 D1 = (interleave_setting <= 1) ? 7 : 5;
                 D2 = 4;
+            } else if (baud_rate == 75) {
+                D1 = (interleave_setting <= 1) ? 7 : 5;
+                D2 = 5;
             } else {
                 throw std::invalid_argument("Invalid baud rate for generateProbeData");
             }
 
-            std::vector<uint8_t> final_probe_data;
+            // Generate the known symbol patterns D1 and D2, repeated twice
-            for (auto symbol : probe_data) {
+            std::vector<uint8_t> d1_pattern = mapChannelSymbolToTribitPattern(D1, true);
-                appendProbeMapping(final_probe_data, symbol, 2);
+            std::vector<uint8_t> d2_pattern = mapChannelSymbolToTribitPattern(D2, true);
-            }
+
+            probe_data.insert(probe_data.end(), d1_pattern.begin(), d1_pattern.end());
+            probe_data.insert(probe_data.end(), d2_pattern.begin(), d2_pattern.end());
         }
 
         return probe_data;
     }
 
+    void append75bpsMapping(std::vector<uint8_t>& symbol_stream, uint8_t symbol, bool is_exceptional_set) {
+        if (is_exceptional_set) {
+            switch (symbol) {
+                case 0:
+                    // Exceptional set mapping for symbol 00: (0000 4444) repeated 4 times
+                    for (int i = 0; i < 4; ++i) {
+                        symbol_stream.insert(symbol_stream.end(), baud75_exceptional_0.begin(), baud75_exceptional_0.end());
+                    }
+                    break;
+                case 1:
+                    // Exceptional set mapping for symbol 01: (0404 4040) repeated 4 times
+                    for (int i = 0; i < 4; ++i) {
+                        symbol_stream.insert(symbol_stream.end(), baud75_exceptional_1.begin(), baud75_exceptional_1.end());
+                    }
+                    break;
+                case 2:
+                    // Exceptional set mapping for symbol 10: (0044 4400) repeated 4 times
+                    for (int i = 0; i < 4; ++i) {
+                        symbol_stream.insert(symbol_stream.end(), baud75_exceptional_2.begin(), baud75_exceptional_2.end());
+                    }
+                    break;
+                case 3:
+                    // Exceptional set mapping for symbol 11: (0440 4004) repeated 4 times
+                    for (int i = 0; i < 4; ++i) {
+                        symbol_stream.insert(symbol_stream.end(), baud75_exceptional_3.begin(), baud75_exceptional_3.end());
+                    }
+                    break;
+                default:
+                    throw std::invalid_argument("Invalid channel symbol for exceptional set mapping");
+            }
+        } else {
+            switch (symbol) {
+                case 0:
+                    // Normal set mapping for symbol 00: (0000) repeated 8 times
+                    for (int i = 0; i < 8; ++i) {
+                        symbol_stream.insert(symbol_stream.end(), baud75_normal_0.begin(), baud75_normal_0.end());
+                    }
+                    break;
+                case 1:
+                    // Normal set mapping for symbol 01: (0404) repeated 8 times
+                    for (int i = 0; i < 8; ++i) {
+                        symbol_stream.insert(symbol_stream.end(), baud75_normal_1.begin(), baud75_normal_1.end());
+                    }
+                    break;
+                case 2:
+                    // Normal set mapping for symbol 10: (0044) repeated 8 times
+                    for (int i = 0; i < 8; ++i) {
+                        symbol_stream.insert(symbol_stream.end(), baud75_normal_2.begin(), baud75_normal_2.end());
+                    }
+                    break;
+                case 3:
+                    // Normal set mapping for symbol 11: (0440) repeated 8 times
+                    for (int i = 0; i < 8; ++i) {
+                        symbol_stream.insert(symbol_stream.end(), baud75_normal_3.begin(), baud75_normal_3.end());
+                    }
+                    break;
+                default:
+                    throw std::invalid_argument("Invalid channel symbol for normal set mapping");
+            }
+        }
+    }
+
     std::vector<uint8_t> map75bpsSet(const std::vector<uint8_t>& data, size_t start_index, size_t set_size, bool is_exceptional_set) {
         std::vector<uint8_t> mapped_set;
 
-        for (auto symbol : data) {
+        // Make sure we do not exceed the size of the data vector
-            append75bpsMapping(mapped_set, symbol, is_exceptional_set);
+        size_t end_index = std::min(start_index + set_size, data.size());
+
+        for (size_t i = start_index; i < end_index; ++i) {
+            append75bpsMapping(mapped_set, data[i], is_exceptional_set);
         }
 
         return mapped_set;
@@ -351,23 +349,22 @@ class SymbolFormation {
         std::vector<uint8_t> mapped_data;
 
         for (auto symbol : data) {
-
             if (baud_rate >= 2400) {
                 // Pass tribit symbols as-is
                 mapped_data.push_back(symbol);
             } else if (baud_rate == 1200) {
                 // Map dibit symbols to tribit symbols 0, 2, 4, 6
                 switch (symbol) {
-                    case 0:
+                    case 0b00:
                         mapped_data.push_back(0);
                         break;
-                    case 1:
+                    case 0b01:
                         mapped_data.push_back(2);
                         break;
-                    case 2:
+                    case 0b10:
                         mapped_data.push_back(4);
                         break;
-                    case 3:
+                    case 0b11:
                         mapped_data.push_back(6);
                         break;
                     default:
@@ -375,7 +372,13 @@ class SymbolFormation {
                 }
             } else if (baud_rate >= 150 && baud_rate <= 600) {
                 // Map binary symbols to tribit symbols 0 and 4
-                mapped_data.push_back(symbol == 0 ? 0 : 4);
+                if (symbol == 0) {
+                    mapped_data.push_back(0);
+                } else if (symbol == 1) {
+                    mapped_data.push_back(4);
+                } else {
+                    throw std::invalid_argument("Invalid binary symbol for baud rates 150 to 600 bps");
+                }
             } else {
                 throw std::invalid_argument("Invalid baud rate for mapUnknownData");
             }