mirror of https://github.com/gnss-sdr/gnss-sdr
131 lines
3.8 KiB
C++
131 lines
3.8 KiB
C++
/*!
|
|
* \file viterbi_decoder.h
|
|
* \brief Class that implements a Viterbi decoder
|
|
* \author Carles Fernandez, 2021. cfernandez(at)cttc.es
|
|
*
|
|
* -----------------------------------------------------------------------------
|
|
*
|
|
* GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
|
* This file is part of GNSS-SDR.
|
|
*
|
|
* Copyright (C) 2010-2021 (see AUTHORS file for a list of contributors)
|
|
* SPDX-License-Identifier: GPL-3.0-or-later
|
|
*
|
|
* -----------------------------------------------------------------------------
|
|
*/
|
|
|
|
#ifndef GNSS_SDR_VITERBI_DECODER_H
|
|
#define GNSS_SDR_VITERBI_DECODER_H
|
|
|
|
#include <array>
|
|
#include <cstdint>
|
|
#include <vector>
|
|
|
|
/** \addtogroup Telemetry_Decoder
|
|
* \{ */
|
|
/** \addtogroup Telemetry_Decoder_libs
|
|
* Utilities for the decoding of GNSS navigation messages.
|
|
* \{ */
|
|
|
|
|
|
/*!
|
|
* \brief Class that implements a Viterbi decoder
|
|
*/
|
|
class Viterbi_Decoder
|
|
{
|
|
public:
|
|
/*!
|
|
* \brief Constructor of a Viterbi decoder
|
|
* \param[in] KK Constraint length
|
|
* \param[in] nn Coding rate 1/n
|
|
* \param[in] LL Data length
|
|
* \param[in] g Polynomial G1 and G2
|
|
*/
|
|
Viterbi_Decoder(int32_t KK, int32_t nn, int32_t LL, const std::array<int32_t, 2>& g);
|
|
|
|
/*!
|
|
* \brief Uses the Viterbi algorithm to perform hard-decision decoding of a convolutional code.
|
|
* \param[out] output_u_int Hard decisions on the data bits
|
|
* \param[in] input_c The received signal in LLR-form. For BPSK, must be in form r = 2*a*y/(sigma^2).
|
|
*
|
|
*/
|
|
void decode(std::vector<int32_t>& output_u_int, const std::vector<float>& input_c);
|
|
|
|
/*!
|
|
* \brief Reset internal status
|
|
*/
|
|
void reset();
|
|
|
|
private:
|
|
/*
|
|
* Function that creates the transit and output vectors
|
|
*/
|
|
void nsc_transit(std::vector<int32_t>& output_p,
|
|
std::vector<int32_t>& trans_p,
|
|
int32_t input) const;
|
|
|
|
/*
|
|
* Computes the branch metric used for decoding.
|
|
* \return (returned float) The metric between the hypothetical symbol and the received vector
|
|
* \param[in] symbol The hypothetical symbol
|
|
*
|
|
*/
|
|
float Gamma(int32_t symbol) const;
|
|
|
|
/*
|
|
* Determines if a symbol has odd (1) or even (0) parity
|
|
* Output parameters:
|
|
* \return (returned int): The symbol's parity = 1 for odd and 0 for even
|
|
*
|
|
* \param[in] symbol The integer-valued symbol
|
|
* \param[in] length The highest bit position in the symbol
|
|
*
|
|
* This function is used by nsc_enc_bit()
|
|
*/
|
|
int32_t parity_counter(int32_t symbol, int32_t length) const;
|
|
|
|
/*
|
|
* Convolutionally encodes a single bit using a rate 1/n encoder.
|
|
* Takes in one input bit at a time, and produces a n-bit output.
|
|
*
|
|
* \return (returned int): Computed output
|
|
*
|
|
* \param[in] input The input data bit (i.e. a 0 or 1).
|
|
* \param[in] state_in The starting state of the encoder (an int from 0 to 2^m-1).
|
|
* \param[out] state_out_p[] An integer containing the final state of the encoder
|
|
* (i.e. the state after encoding this bit)
|
|
*
|
|
* This function is used by nsc_transit()
|
|
*/
|
|
int32_t nsc_enc_bit(int32_t* state_out_p,
|
|
int32_t input,
|
|
int32_t state_in) const;
|
|
|
|
std::vector<float> d_prev_section{};
|
|
std::vector<float> d_next_section{};
|
|
|
|
std::vector<float> d_rec_array{};
|
|
std::vector<float> d_metric_c{};
|
|
std::vector<int32_t> d_prev_bit{};
|
|
std::vector<int32_t> d_prev_state{};
|
|
std::array<int32_t, 2> d_g{};
|
|
|
|
std::vector<int32_t> d_out0;
|
|
std::vector<int32_t> d_out1;
|
|
std::vector<int32_t> d_state0;
|
|
std::vector<int32_t> d_state1;
|
|
|
|
float d_MAXLOG = 1e7; // Define infinity
|
|
int32_t d_KK{};
|
|
int32_t d_nn{};
|
|
int32_t d_LL{};
|
|
|
|
int32_t d_mm{};
|
|
int32_t d_states{};
|
|
int32_t d_number_symbols{};
|
|
};
|
|
|
|
/** \} */
|
|
/** \} */
|
|
#endif // GNSS_SDR_VITERBI_DECODER_H
|