WIP Channel Estimation

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "lib/ViterbiDecoderCpp"]
+	path = lib/ViterbiDecoderCpp
+	url = https://github.com/FiendChain/ViterbiDecoderCpp.git

CMakeLists.txt

@@ -8,6 +8,9 @@ add_executable(tetra
                src/main.cpp
                src/reporter.cpp
         src/decoder.cpp
+        src/streaming_ordered_output_thread_pool_executor.cpp
+        src/bit_stream_decoder.cpp
+        src/iq_stream_decoder.cpp
         src/l2/lower_mac.cpp
         src/l2/lower_mac_coding.cpp
         src/l2/upper_mac.cpp
@@ -21,7 +24,18 @@ add_executable(tetra
         src/utils/bit_vector.cpp
         src/utils/viter_bi_codec.cpp)
 
-target_compile_options(tetra PUBLIC -std=c++17 -Wall -Wno-unused-variable)
+add_executable(tetra-puncturing
+               src/examples/tetra_puncturing.cpp)
+
+add_executable(tetra-viterbi
+               src/examples/viter_bi_codec.cpp
+               src/examples/tetra_viterbi.cpp)
+
+target_compile_options(tetra PUBLIC -std=c++17 -Wall -Wno-unused-variable -msse4.1 -O3)
+target_compile_options(tetra-puncturing PUBLIC -std=c++17 -Wall -Wno-unused-variable)
+target_compile_options(tetra-viterbi PUBLIC -std=c++17 -Wall -Wno-unused-variable)
+
+include(lib/ViterbiDecoderCpp/viterbi-config.cmake)
 
 include_directories(src)
 
@@ -32,6 +46,9 @@ find_package(nlohmann_json REQUIRED)
 
 include_directories(${CMAKE_SOURCE_DIR}/include)
 
-target_link_libraries(tetra ZLIB::ZLIB fmt::fmt nlohmann_json::nlohmann_json)
+target_link_libraries(tetra ZLIB::ZLIB fmt::fmt nlohmann_json::nlohmann_json viterbi)
+target_link_libraries(tetra-viterbi viterbi)
 
 install(TARGETS tetra DESTINATION bin)
+install(TARGETS tetra-puncturing DESTINATION bin)
+install(TARGETS tetra-viterbi DESTINATION bin)

README.md

@@ -18,6 +18,7 @@ Usage:
                      with -i option)
   -d arg             <level> print debug information (default: 0)
   -P, --packed       pack rx data (1 byte = 8 bits)
+      --iq           Receive IQ instead of bitstream
       --uplink arg   <scrambling code> enable uplink parsing with
                      predefined scrambilng code
 ```

flake.nix

@@ -1,6 +1,6 @@
 {
   inputs = {
-    nixpkgs.url = github:NixOS/nixpkgs/nixos-22.11;
+    nixpkgs.url = github:NixOS/nixpkgs/nixos-23.05;
 
     utils.url = "github:numtide/flake-utils";
   };

include/bit_stream_decoder.hpp

@@ -0,0 +1,114 @@
+/*
+ * Copyright (C) 2022 Transit Live Mapping Solutions
+ * All rights reserved.
+ *
+ * Authors:
+ *   Marenz Schmidl
+ *   Tassilo Tanneberger
+ */
+
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include <l2/lower_mac.hpp>
+
+/**
+ * Tetra downlink decoder for PI/4-DQPSK modulation
+ *
+ * Following downlink burst types for Phase Modulation are supported: (See TSI
+ * EN 300 392-2 V3.8.1 (2016-08) Table 9.2)
+ *
+ * normal continuous downlink burst (NDB)
+ *
+ * synchronization continuous downlink burst (SB)
+ *
+ * Follawing downlink burst types for Phase Modulation are not supported:
+ * discontinuous downlink burst (NDB)
+ * synchronization discontinuous downlink burst (SB)
+ *
+ * Uplink burst types are not supported:
+ * control uplink burst (CB)
+ * normal uplink burst (NUB)
+ */
+class BitStreamDecoder {
+  public:
+    BitStreamDecoder(std::shared_ptr<LowerMac> lower_mac, bool is_uplink)
+        : lower_mac_(lower_mac)
+        , is_uplink_(is_uplink){};
+    ~BitStreamDecoder() = default;
+
+    /**
+     * @brief Process a received symbol.
+     *
+     * This function is called by "physical layer" when a bit is ready
+     * to be processed.
+     *
+     * Note that "frame" is actually called "burst" in Tetra doc
+     *
+     * @return true if frame (burst) found, false otherwise
+     *
+     */
+    void process_bit(uint8_t symbol) noexcept;
+
+  private:
+    std::shared_ptr<LowerMac> lower_mac_{};
+
+    bool is_synchronized_ = false;
+    bool is_uplink_{};
+    std::size_t sync_bit_counter_ = 0;
+
+    const std::size_t kFRAME_LEN = 510;
+
+    std::vector<uint8_t> frame_{};
+
+    // 9.4.4.3.2 Normal training sequence
+    const std::vector<uint8_t> kNORMAL_TRAINING_SEQ_1 = {1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1,
+                                                         0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0}; // n1..n22
+    const std::vector<uint8_t> kNORMAL_TRAINING_SEQ_2 = {0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0,
+                                                         0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0};          // p1..p22
+    const std::vector<uint8_t> kNORMAL_TRAINING_SEQ_3_BEGIN = {0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1}; // q11..q22
+    const std::vector<uint8_t> kNORMAL_TRAINING_SEQ_3_END = {1, 0, 1, 1, 0, 1, 1, 1, 0, 0};         // q1..q10
+
+    // 9.4.4.3.3 Extended training sequence
+    const std::vector<uint8_t> kEXTENDED_TRAINING_SEQ = {1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1,
+                                                         0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1}; // x1..x30
+
+    // 9.4.4.3.4 Synchronisation training sequence
+    const std::vector<uint8_t> kSYNC_TRAINING_SEQ = {1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0,
+                                                     1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1}; // y1..y38
+
+    /**
+     * @brief Reset the synchronizer
+     *
+     * Burst was matched, we can reset the synchronizer to allow 50 missing frames
+     * (expressed in burst units = 50 * 510 bits)
+     *
+     */
+    void reset_synchronizer() noexcept;
+
+    /**
+     * @brief Process frame to decide which type of burst it is then service lower
+     * MAC
+     *
+     */
+    void process_downlink_frame() noexcept;
+
+    /**
+     * @brief Return pattern/data comparison errors count at position in data
+     * vector
+     *
+     * @param data      Vector to look in from pattern
+     * @param pattern   Pattern to search
+     * @param position  Position in vector to start search
+     *
+     * @return Score based on similarity with pattern (differences count between
+     * vector and pattern)
+     *
+     */
+    static auto pattern_at_position_score(const std::vector<uint8_t>& data, const std::vector<uint8_t>& pattern,
+                                          std::size_t position) noexcept -> std::size_t;
+};

include/decoder.hpp

@@ -7,14 +7,15 @@
  *   Tassilo Tanneberger
  */
 
-#ifndef TETRA_DECODER_DECODER_HPP
-#define TETRA_DECODER_DECODER_HPP
+#pragma once
 
 #include <memory>
 #include <optional>
 #include <string>
 #include <vector>
 
+#include <bit_stream_decoder.hpp>
+#include <iq_stream_decoder.hpp>
 #include <l2/lower_mac.hpp>
 #include <reporter.hpp>
 
@@ -39,18 +40,19 @@
 class Decoder {
   public:
     Decoder(unsigned int receive_port, unsigned int send_port, bool packed, std::optional<std::string> input_file,
-            std::optional<std::string> output_file, std::optional<unsigned int> uplink_scrambling_code);
+            std::optional<std::string> output_file, bool iq_or_bit_stream,
+            std::optional<unsigned int> uplink_scrambling_code);
     ~Decoder();
 
     void main_loop();
 
   private:
-    std::unique_ptr<LowerMac> lower_mac_{};
+    std::shared_ptr<LowerMac> lower_mac_{};
     std::shared_ptr<Reporter> reporter_{};
+    std::shared_ptr<BitStreamDecoder> bit_stream_decoder_{};
+    std::unique_ptr<IQStreamDecoder> iq_stream_decoder_{};
 
     bool packed_ = false;
-    bool is_synchronized_ = false;
-    std::size_t sync_bit_counter_ = 0;
 
     // input and output file descriptor
     int input_fd_ = 0;
@@ -61,70 +63,9 @@ class Decoder {
     // uplink ?
     std::optional<unsigned int> uplink_scrambling_code_;
 
-    const std::size_t kRX_BUFFER_SIZE = 4096;
-    const std::size_t kFRAME_LEN = 510;
-
-    std::vector<uint8_t> frame_{};
-
-    // 9.4.4.3.2 Normal training sequence
-    const std::vector<uint8_t> kNORMAL_TRAINING_SEQ_1 = {1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1,
-                                                         0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0}; // n1..n22
-    const std::vector<uint8_t> kNORMAL_TRAINING_SEQ_2 = {0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0,
-                                                         0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0};          // p1..p22
-    const std::vector<uint8_t> kNORMAL_TRAINING_SEQ_3_BEGIN = {0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1}; // q11..q22
-    const std::vector<uint8_t> kNORMAL_TRAINING_SEQ_3_END = {1, 0, 1, 1, 0, 1, 1, 1, 0, 0};         // q1..q10
-
-    // 9.4.4.3.3 Extended training sequence
-    const std::vector<uint8_t> kEXTENDED_TRAINING_SEQ = {1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1,
-                                                         0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1}; // x1..x30
-
-    // 9.4.4.3.4 Synchronisation training sequence
-    const std::vector<uint8_t> kSYNC_TRAINING_SEQ = {1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0,
-                                                     1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1}; // y1..y38
+    // IQ stream -> true
+    // bit stream -> false
+    bool iq_or_bit_stream_;
 
-    /**
-     * @brief Process a received symbol.
-     *
-     * This function is called by "physical layer" when a bit is ready
-     * to be processed.
-     *
-     * Note that "frame" is actually called "burst" in Tetra doc
-     *
-     * @return true if frame (burst) found, false otherwise
-     *
-     */
-    void process_bit(uint8_t symbol) noexcept;
-
-    /**
-     * @brief Reset the synchronizer
-     *
-     * Burst was matched, we can reset the synchronizer to allow 50 missing frames
-     * (expressed in burst units = 50 * 510 bits)
-     *
-     */
-    void reset_synchronizer() noexcept;
-
-    /**
-     * @brief Process frame to decide which type of burst it is then service lower
-     * MAC
-     *
-     */
-    void process_downlink_frame() noexcept;
-
-    /**
-     * @brief Return pattern/data comparison errors count at position in data
-     * vector
-     *
-     * @param data      Vector to look in from pattern
-     * @param pattern   Pattern to search
-     * @param position  Position in vector to start search
-     *
-     * @return Score based on similarity with pattern (differences count between
-     * vector and pattern)
-     *
-     */
-    static auto pattern_at_position_score(const std::vector<uint8_t>& data, const std::vector<uint8_t>& pattern,
-                                          std::size_t position) noexcept -> std::size_t;
+    const std::size_t kRX_BUFFER_SIZE = 4096;
 };
-
-#endif // TETRA_DECODER_DECODER_HPP

include/fixed_queue.hpp

@@ -0,0 +1,39 @@
+#include <deque>
+#include <iostream>
+#include <queue>
+
+template <typename T, int MaxLen, typename Container = std::deque<T>> class FixedQueue {
+  private:
+    Container queue{};
+
+  public:
+    using const_iterator = typename Container::const_iterator;
+    using const_reverse_iterator = typename Container::const_reverse_iterator;
+    using const_reference = typename Container::const_reference;
+
+    FixedQueue() {
+        for (auto i = 0; i < MaxLen; i++) {
+            T default_value{};
+            queue.push_back(default_value);
+        }
+    }
+
+    void push(const T& value) {
+        if (queue.size() == MaxLen) {
+            queue.pop_front();
+        }
+        queue.push_back(value);
+    }
+
+    void pop(const T& value) { std::logic_error("Function not implemented"); }
+
+    typename Container::const_iterator cbegin() { return queue.cbegin(); }
+
+    typename Container::const_reverse_iterator crbegin() { return queue.crbegin(); }
+
+    typename Container::const_iterator cend() { return queue.cend(); }
+
+    typename Container::const_reverse_iterator crend() { return queue.crend(); }
+
+    typename Container::const_reference operator[](typename Container::size_type pos) const { return queue[pos]; }
+};