WIP Channel Estimation

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,11 @@ add_executable(tetra
         src/utils/bit_vector.cpp
         src/utils/viter_bi_codec.cpp)
 
+add_executable(tetra-puncturing
+               src/examples/tetra_puncturing.cpp)
+
 target_compile_options(tetra PUBLIC -std=c++17 -Wall -Wno-unused-variable)
+target_compile_options(tetra-puncturing PUBLIC -std=c++17 -Wall -Wno-unused-variable)
 
 include_directories(src)
 
@@ -35,3 +42,4 @@ include_directories(${CMAKE_SOURCE_DIR}/include)
 target_link_libraries(tetra ZLIB::ZLIB fmt::fmt nlohmann_json::nlohmann_json)
 
 install(TARGETS tetra DESTINATION bin)
+install(TARGETS tetra-puncturing 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
 ```

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,31 @@
+#include <deque>
+#include <iostream>
+#include <queue>
+
+template <typename T, int MaxLen, typename Container = std::deque<T>>
+class FixedQueue : public std::queue<T, Container> {
+  public:
+    FixedQueue() {
+        for (auto i = 0; i < MaxLen; i++) {
+            T default_value{};
+            std::queue<T, Container>::push(default_value);
+        }
+    }
+
+    void push(const T& value) {
+        if (this->size() == MaxLen) {
+            this->c.pop_front();
+        }
+        std::queue<T, Container>::push(value);
+    }
+
+    void pop(const T& value) { std::logic_error("Function not implemented"); }
+
+    typename Container::const_iterator cbegin() { return this->c.cbegin(); }
+
+    typename Container::const_reverse_iterator crbegin() { return this->c.crbegin(); }
+
+    typename Container::const_iterator cend() { return this->c.cend(); }
+
+    typename Container::const_reverse_iterator crend() { return this->c.crend(); }
+};

include/iq_stream_decoder.hpp

@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2022 Transit Live Mapping Solutions
+ * All rights reserved.
+ *
+ * Authors:
+ *   Marenz Schmidl
+ *   Tassilo Tanneberger
+ */
+
+#pragma once
+
+#include <complex>
+#include <memory>
+#include <thread>
+
+#include <bit_stream_decoder.hpp>
+#include <fixed_queue.hpp>
+#include <l2/lower_mac.hpp>
+#include <streaming_ordered_output_thread_pool_executor.hpp>
+
+/**
+ * Tetra downlink decoder for PI/4-DQPSK modulation
+ *
+ * Implements Channel Estimation
+ */
+class IQStreamDecoder {
+  public:
+    IQStreamDecoder(std::shared_ptr<LowerMac> lower_mac, std::shared_ptr<BitStreamDecoder> bit_stream_decoder,
+                    bool is_uplink);
+    ~IQStreamDecoder() = default;
+
+    void process_complex(std::complex<float> symbol) noexcept;
+
+  private:
+    void upperMacWorker();
+
+    std::complex<float> hard_decision(std::complex<float> symbol);
+    std::vector<uint8_t> symbols_to_bitstream(std::vector<std::complex<float>> const& stream);
+
+    std::vector<std::complex<float>> convolve_valid(std::vector<std::complex<float>> const& a,
+                                                    std::vector<std::complex<float>> const& b);
+
+    std::vector<std::complex<float>> channel_estimation(std::vector<std::complex<float>> const& stream,
+                                                        std::vector<std::complex<float>> const& pilots);
+
+    FixedQueue<std::complex<float>, 300> symbol_buffer_;
+    FixedQueue<std::complex<float>, 300> symbol_buffer_hard_decision_;
+
+    // 9.4.4.3.2 Normal training sequence
+    const std::vector<std::complex<float>> training_seq_n_ = {{-1, -1}, {-1, 1}, {1, 1},   {1, 1},  {-1, -1}, {1, -1},
+                                                              {1, -1},  {-1, 1}, {-1, -1}, {-1, 1}, {1, 1}};
+    std::vector<std::complex<float>> training_seq_n_reversed_conj_{};
+    const std::vector<std::complex<float>> training_seq_p_ = {{-1.0, 1.0}, {-1.0, -1.0}, {1.0, -1.0}, {1.0, -1.0},
+                                                              {-1.0, 1.0}, {1.0, 1.0},   {1.0, 1.0},  {-1.0, -1.0},
+                                                              {-1.0, 1.0}, {-1.0, -1.0}, {1.0, -1.0}};
+    std::vector<std::complex<float>> training_seq_p_reversed_conj_{};
+    // 9.4.4.3.3 Extended training sequence
+    const std::vector<std::complex<float>> training_seq_x_ = {
+        {1.0, -1.0}, {-1.0, 1.0}, {-1.0, -1.0}, {-1.0, 1.0}, {1.0, 1.0}, {1.0, 1.0}, {-1.0, -1.0}, {1.0, -1.0},
+        {1.0, -1.0}, {-1.0, 1.0}, {-1.0, -1.0}, {-1.0, 1.0}, {1.0, 1.0}, {1.0, 1.0}, {-1.0, -1.0}};
+    std::vector<std::complex<float>> training_seq_x_reversed_conj_{};
+
+    const float SEQUENCE_DETECTION_THRESHOLD = 1.5;
+
+    std::shared_ptr<LowerMac> lower_mac_{};
+    std::shared_ptr<BitStreamDecoder> bit_stream_decoder_{};
+
+    bool is_uplink_{};
+
+    std::shared_ptr<StreamingOrderedOutputThreadPoolExecutor<std::vector<std::function<void()>>>> threadPool_;
+
+    std::thread upperMacWorkerThread_;
+};

include/l2/logical_link_control.hpp

@@ -35,6 +35,7 @@ class LogicalLinkControl {
     void process_bl_adata_without_fcs(const AddressType address, BitVector& vec);
     // Basic link (acknowledged service in connectionless mode) without Frame Check Sequence
     void process_bl_data_without_fcs(const AddressType address, BitVector& vec);
+    void process_supplementary_llc_pdu(const AddressType address, BitVector& vec);
 
     std::shared_ptr<Reporter> reporter_{};
     std::shared_ptr<MobileLinkEntity> mle_{};