Efficient Low-Complexity Turbo-Hadamard Code in UAV Anti-Jamming Communications

Abstract

Unmanned aerial vehicle (UAV) systems undergo a period of rapid development in both civil and military scenarios. A major challenge in the malicious jamming environment is to guarantee the reliability of UAV communications links. Frequency hopping (FH) is one of the most commonly used means of combatting the influence brought about by jamming. In this paper, we integrate low-rate codes into an anti-jamming FH communications system, and propose an efficient and low-complexity turbo-Hadamard code scheme. Tail-biting is applied to design the component convolutional-Hadamard codes, and a corresponding decode algorithm is used for implementation in the UAV hardware platform. Numerical simulation results demonstrate that the anti-jamming performance of this method is improved as compared with conventional concatenated codes. Finally, we compare the complexity and transmission efficiency of the proposed algorithm with the algorithms implemented on the field programmable gate array (FPGA) platform in detail.

1. Introduction

Unmanned aerial vehicles (UAVs) have been applied extensively in a wide range of scenarios during the past decade [1,2,3,4,5,6], as they represent a promising avenue of research, providing flexible deployment and on-demand mobility in a cost-effective way. In particular, UAVs are playing increasingly crucial roles in applications in which human lives would otherwise be endangered. As for military applications, UAVs become indispensable in reconnaissance [1], surveillance [2] and strikes [3]; meanwhile, UAVs are essential in disaster relief [4], remote sensing [5] and weather forecasting [6] in civil scenarios. The performance of UAVs depends heavily on the quality of wireless communication links between UAVs.

However, UAVs’ wireless communication links are vulnerable to jamming due to their exposed nature [7]. As a result, anti-jamming performance has become an important design metric for the wireless communication systems of UAVs. However, most existing research contributions on UAVs have focused on the analysis and improvement of their links and quality of servicein conditions without jamming [8,9,10,11]. The quality of those wireless links can be particularly worsened in the complex electromagnetic environment of the battlefield. Hence, anti-jamming in UAV communications has attracted substantial research interest. At present, the frequency hopping (FH) spread spectrum technique works well in combating jamming. The FH system gains its anti-jamming performance through frequency domain diversity. The frequency bin selection mechanism of the FH communication system is pseudo-randomly varied, which produces outstanding anti-jamming performance [12]. With the development of different methods of jamming, the application of the FH scheme alone can not guarantee the quality of UAV communications links in the face of malicious jamming. Therefore, it is worthwhile to consider the use of advanced waveform design methods, such as interleaving, channel coding and efficient modulation techniques [13]. The channel coding scheme has been demonstrated to be essential in FH systems due to the high coding gain it has demonstrated.

Substantial research has been conducted with the aim of applying various coding algorithm to FH communication systems in diverse UAV scenarios. Reed–Solomon (RS) codes, convolutional codes, turbo codes and low-density parity check (LDPC) codes are widely studied in FH systems [13,14,15,16,17]. Those codes demonstrate a considerable coding gain against noise. However, since the code rates of those codes are not low enough, they cannot be used to combat malicious jamming with high power, which can cause the received symbols to be entirely suppressed by powerful interference, meaning that the receiver cannot succeed in decoding the message at all.As a result, it has become critical to combine low-rate codes with FH communication systems in UAVs for the purpose of anti-jamming.

Hadamard codes are one kind of low-rate code, which can be decoded with a rather low complexity, employing prior information by means of maximum posterior (MAP) decoding rules [18]. Meanwhile, turbo codes have been proven to achieve coding gains close to the Shannon limit [19], and have been demonstrated to combat jamming effectively due to the characteristics of their interleaving-coded bit sequence. As a consequence, a hybrid concatenation of convolutional codes and Hadamard codes called the turbo-Hadamard code was proposed in [20], featuring a low rate and anti-jamming capability. This proposed code can be treated as an approximately random code which is proven to be a “good code” when the code length becomes ∞. Low-rate codes have been employed when the complexity is acceptable in 6G UAV scenarios [21]. However, the high complexity of the decoding of turbo-Hadamard codes is one obstacle to its implementation on the platform of limited UAVs. Moreover, turbo-Hadamard codes exhibit great efficiency losses due to their trellis structure with short information bits. Therefore, it is critical to solve the problems of high decoding complexity and high efficiency losses for the platform of resource-limited UAVs.

In this paper, we focus on applying the turbo-Hadamard codes to an FH system for anti-jamming purposes. We employ approximate algorithms to greatly reduce the decoding complexity [22], which results in the effect that the usages of lookup tables (LUTs) are reduced by more than $20\%$ compared to the practical low-rate codes [23,24]. Considering the fact that the information package is usually short in UAVs [25], we proposed the use of advanced tail-biting turbo-Hadamard codes, which are constructed by concatenating several tail-biting convolutional-Hadamard codes in parallel in order to reduce the communication latency [26]. Simulation results showed that the proposed tail-biting turbo-Hadamard codes performed better than other low-rate codes when faced with various jamming conditions.

The contributions of this paper are as follows:

1.

An improved turbo-Hadamard code based on tail-biting is proposed. The proposed codes outperform the conventional terminate-state-zeroturbo-Hadamard codes in terms of the coding gain and anti-jamming performance. Since we introduced no redundant bits, our algorithm has proven to be more efficient than other low-rate codes, especially in the UAV communication scenarios requiring extremely short code lengths.

2.

A corresponding decoding scheme is proposed. For easy implementation on the hardware platforms of resource-limited UAVs, we employ addition operations instead of multiplication, division, exponential and logarithm operations. We prove that the proposed algorithm consumes fewer resources than the existing concatenated low-rate codes FPGA platform.

3.

The expression of the computational complexity and transmission efficiency are given in closed form. Meanwhile, we analyze the complexity and efficiency of the proposed tail-biting turbo-Hadamard codes in detail.

The structure of this paper is organized as follows: Section 2 presents a description of the system model. Section 3 introduces the encoder and decoder of turbo-Hadamard codes based on tail-biting. Section 4 presents the simulation results and an analysis of tail-biting turbo-Hadamard codes. Section 5 summarizes the contributions of this paper.

2. System Model

As shown in Figure 1, we consider an FH communication system having one single-antenna transmitter and one single-antenna receiver, but in which the system performance is degraded by jamming methods, such as single-tone jamming, multiple tone jamming, and partial band jamming, etc.

At the transmission side, extra parity bits are added via an encoder to improve the reliability of the communication system. In light of the high performance and low complexity, we adopt turbo-Hadamard as the encoding scheme. Therefore, the N encoded bits $\mathit{c}=(c_1,c_2,\cdots ,c_N)$ can be represented as

$$\mathit{c}=\mathrm{TH}\left(\mathit{u}\right),$$

(1)

where $\mathrm{TH}(·)$ represents the turbo-Hadamard encoder function, which will be discussed in detail in Section 3, and $\mathit{u}=(u_1,u_2,\cdots ,u_W)$ denotes W uncoded bits to be transmitted. For simplicity but without the loss of generality, suppose that binary phase shift keying (BPSK) is adopted. It is worth noting that other modulation schemes are also suitable in this scenario. The transmitted symbols are then modulated by G frequency bins according to the frequency hopping pattern. To combat complex electromagnetic jamming in the UAV communication system, the number of frequency bins can be as large as hundreds or thousands. The transmitted signal ${\mathit{x}}_n,n=1,\cdots ,N,$ is thus given by

$${\mathit{x}}_n={\mathit{c}}_n{e}^{2\pi f_n+{\theta }_n},$$

(2)

where $f_n$ and ${\theta }_n$ denote the frequency and phase, respectively, for the nth encoded bit.

Considering the effect caused by jamming, we assume that $\varphi (0\le \varphi \le \mathsf{\Phi })$ frequency bins are influenced by suppressive jamming in this paper. The jammed frequency bins can be represented as a set $\mathcal{H}=\{{\widehat{f}}_j,j=1,2,\dots ,\varphi \}$, where ${\widehat{f}}_j$ denotes the jth jammed frequency bin. Consequently, the received signal ${\mathit{y}}_n,n=1,\cdots ,N,$ can be written as

$${\mathit{y}}_n= \left\{\begin{array}{cc}{\mathit{x}}_n+\omega +i,\hfill & f_n\in \mathcal{H},\hfill \\ {\mathit{x}}_n+\omega ,\hfill & f_n\notin \mathcal{H},\hfill \end{array}\right.$$

(3)

where $\omega$ denotes the additive Gaussian white noise (AWGN) with a power spectral density of ${\omega }_0$, and i represents the suppressive jamming, with a power spectral density of $i_0$. Usually, the strength of the implemented jamming strength is much larger than that of the UAV communication signal and noise. As a result, we assume that the received signals are superimposed on additional noise with high power once the frequency bin is jammed, whereas the signals on the other frequency bins are treated as normal.

Since there is an obvious strength gap between signals with and without jamming, the receiver can easily find out which frequency bins are jammed based on the received power. Therefore, the receiver can set the power of signal on the jammed frequency bins to zero by employing notch filter on account of the detection of the whole spectrum. As it is not possible to know which frequency bins are jammed before communication, the transmitted encoded bits are interleaved as randomly as possible before modulation in order to lower the impact of jamming. Each bit is modulated onto every frequency bin in the same probability due to the above interleaving operation. Therefore, the probability of received signals in the jammed frequency bins is $\varphi /\mathsf{\Phi }$, whereas the probability of normal received signals is $1-\varphi /\mathsf{\Phi }$. Hence, the received signal ${\widehat{\mathit{y}}}_n,n=1,\cdots ,N,$ can be represented as

$${\widehat{\mathit{y}}}_n= \left\{\begin{array}{cc}0,\hfill & \mathrm{probability}\varphi /\mathsf{\Phi },\hfill \\ {\mathit{x}}_n+\omega ,\hfill & \mathrm{probability}1-\varphi /\mathsf{\Phi }.\hfill \end{array}\right.$$

(4)

Admittedly, the performance of the BPSK/FH demodulator depends heavily on both a reliable capture progress and a precise synchronization progress. Since our emphasis in this paper is on improving the FH code scheme, the received signal is assumed to be demodulated and synchronized perfectly. As a consequence, the sequence to be decoded ${\widehat{\mathit{c}}}_n,n=1,\cdots ,N$ can be represented equivalently as

$${\widehat{\mathit{c}}}_n= \left\{\begin{array}{cc}0,\hfill & \mathrm{probability}\varphi /\mathsf{\Phi },\hfill \\ {\mathit{c}}_n+\widehat{\omega },\hfill & \mathrm{probability}1-\varphi /\mathsf{\Phi },\hfill \end{array}\right.$$

(5)

where ${\mathit{c}}_n$ denotes the ideal demodulated result, and $\widehat{\omega }$ is the equivalent AWGN of which the power spectral density is ${\omega }_0$ due to the application of the optimum receiver. Finally, the receiver in the UAV communication system can obtain the decoded bits $\widehat{\mathit{u}}$ after the turbo-Hadamard decoder progress.

3. Low-Complexity Turbo-Hadamard Codes Based on Tail-Biting

The turbo-Hadamard code is a kind of hybrid concatenation code, which consist of convolutional codes and Hadamard codes [20]. As illustrated in [27,28], the turbo-Hadamard code performs well in the case of narrow-band interference suppression since it can achieve relatively high code gains at great lengths due to its low-rate structure.However, in the scenario of UAV communications, the payload is usually low, and the turbo-Hadamard code will thus exhibit high efficiency losses, especially at a relatively short code length. As a result, we propose an improved turbo-Hadamard code based on tail-biting in the convolutional process, in order to make it more available for UAV communication systems. In this section, we will discuss the structure of the component codes firstly, and then discuss the overall codes.

3.1. The Tail-Biting Convolutional-Hadamard Encoder

To avoid the rate loss caused by zero-tail termination in the convolutional coding part of the scheme, a modified convolutional-Hadamard encoder based on tail-biting is proposed to improve the coding rate, which is described in Algorithm 1 in detail.

Algorithm 1 Tail-Biting Convolutional-Hadamard Encoder Algorithm.

Input: Block information bit $\left\{{\mathit{d}}_k\right\}$ of size $K\times r$. Tail-biting convolutional generator $g\left(x\right)$. Output: Tail-biting convolutional-Hadamard code $\mathit{C}$.   1: Initialize the state of convolutional encoder into all zeros.   2: Get the parity check bit of ${\mathit{d}}_k$ as $q_k^{\prime }$.   3: Calculate the cyclic state $s_c$ based on $g\left(x\right)$ and ${\mathit{q}}^{\prime }=\left\{q_k^{\prime }\right\}$.   4: Encode ${\mathit{q}}^{\prime }$ using the convolutional code generated by $g\left(x\right)$ with the cyclic state $s_c$, and get the parity check bit stream $\mathit{q}$.   5: Encode the $\{{\mathit{d}}_k,q_k\}$ using an order-r Hadamard code as ${\mathit{c}}_k=\{{\mathit{d}}_k,q_k,{\mathit{p}}_k\}$.   6: Arrange ${\mathit{c}}_k$ as the the kth row of $\mathit{C}$.

• Input: For ease of description, the length-W uncoded bits $\mathit{u}$ are segmented into $\left\{{\mathit{d}}_k\right\},k=1,2,\cdots ,K$. Each row ${\mathit{d}}_k$ consists of r bits, where r is the order of Hadamard codes. It is worth noting that $W=K\times r$.
• Line 3: Cyclic state $s_c$ is the key to keeping the convolutional trellis start state $s_i$ and end state $s_t$ once the input is ${\mathit{q}}^{\prime }$. $s_c$ is calculated by $g\left(x\right)$ with the initial state being all zeros. The details of how to generate $s_c$ are as follows, and as illustrated in Figure 2.
  The feedback coefficients of convolutional generator $g\left(x\right)$ can be represented as the state recursive matrix $\mathit{G}$. Moreover, if the generator is described in the mode of a fraction, the denominator of $g\left(x\right)$ is denoted as $\mathit{G}$. For example, the state recursive matrix of $g\left(x\right)=1/\left(1+x+x^2\right)$ can be given by

  $$\mathit{G}= \left[\begin{array}{cc}1& 1\\ 1& 0\end{array}\right].$$

  It is essential to guarantee that the matrix ${\left(\mathit{I}+{\mathit{G}}^K\right)}^{-1}$ is nonsingular, where $\mathit{I}$ denotes the order-$(\eta +1)$ identity matrix, $\eta$ denotes the memory depth of convolutional generator $g\left(x\right)$ and ${(·)}^{-1}$ denotes the inverse operator. Thus, we can obtain the final state $s_{0K}$ after K-step precoding with ${\mathit{q}}^{\prime }$ from the state-0. The cyclic state $s_c$ is calculated by

  $$s_c={\left(\mathit{I}+{\mathit{G}}^K\right)}^{-1}{s}_{0K}.$$

  (6)

  Since the precoder calculates the cyclic state of the convolutional code, the initial state and the terminal state of the convolutional code trellis are same. The states are explained as follows,

  $$s_i=s_t=s_c\in \{s_0,\dots ,s_{2^{\eta }-1}\}.$$

  (7)
• Line 5: Encode length-$(r+1)$ using order-r Hadamard code, which outputs the length-$2^r$ bitstream ${\mathit{c}}_k$.

As shown in Figure 3, the component codewords $\mathit{C}$ can be expressed as $\mathit{C}=\{\mathit{D},\mathit{q},\mathit{P}\}$, where $\mathit{D}$ denotes the $K\times r$ matrix with rows being ${\mathit{d}}_k$, and $\mathit{P}$ denotes the $K\times (2^r-r-1)$ matrix with rows being ${\mathit{p}}_k$.

Compared with the algorithm [20] in which the trellis state terminates at all zeros, there are no extra redundant bits in our improved algorithm. As a consequence, the code rate of the proposed tail-biting convolution-Hadamard code is

$$R_{\mathrm{TB}}^{\mathrm{c}}=\frac{r}{2^r},$$

(8)

whereas that of the convolution-Hadamard code scheme with the terminating state at zero is

$$R_{\mathrm{T}0}^c=\frac{Kr}{\left(K+\eta \right)2^r}.$$

(9)

3.2. The Tail-Biting Turbo-Hadamard Encoder

As mentioned above, the component codes are constructed. To achieve higher code gains and better performance when combating jamming, the overall tail-biting turbo-Hadamard codes are made up of M component convolutional-Hadamard codes. As for each component code, the output bits of different interleavers are entered into the same tail-biting convolutional-Hadamard encoder; thus, the mth component tail-biting convolutional codewords can be given by ${\mathit{C}}^{\left(m\right)}=\{{\mathit{D}}^{\left(m\right)},{\mathit{q}}^{\left(m\right)},{\mathit{P}}^{\left(m\right)}\},m=1,2,\cdots ,M$. Moreover, the transmitter only sends the $\{{\mathit{q}}^{\left(m\right)},{\mathit{P}}^{\left(m\right)}\}$ part of each component code to avoid reducing the transmission efficiency. Meanwhile, considering the complexity of the decoder, the value of M should not be too large. The overall codewords $\mathit{C}$ of the tail-biting turbo-Hadamard can be written in

$$\mathit{C}=\{\mathit{D},{\mathit{q}}^{\left(1\right)},{\mathit{P}}^{\left(1\right)},{\mathit{q}}^{\left(2\right)},{\mathit{P}}^{\left(2\right)},\dots ,{\mathit{q}}^{\left(M\right)},{\mathit{P}}^{\left(M\right)}\}.$$

(10)

As shown in Figure 4, the uncoded bits are interleaved via each interleaver ${\pi }^{\left(m\right)},m=1,2,\cdots ,M$. It is worth noting that the performance of the improved tail-biting turbo-Hadamard codes are related to the correlation of each interleaver.

The code rate of the tail-biting turbo-Hadamard code is

$$R_{\mathrm{TB}}=\frac{r}{r+M\left(2^r-r\right)},$$

(11)

whereas that of the terminate-state-zeroturbo-Hadamard code is given by

$$R_{\mathrm{T}0}=\frac{r}{\left(1+\eta /K\right)\left(r+M\left(2^r-r\right)\right)}.$$

(12)

The efficiency loss in the terminate-state-zero turbo-Hadamard scheme is $\eta /K$. When the information stream is very short, for instance, 100 bits, the efficiency loss is 10% ($r=5,\eta =2$). However, the tail-biting turbo-Hadamard code does not exhibit this efficiency loss at all.

3.3. The Tail-Biting Turbo-Hadamard Decoder

The tail-biting turbo-Hadamard code is kind of multiple turbo-code which can be APP-decoded by means of the Bahl, Cocke, Jelinek and Raviv (BCJR) algorithm [29]. The decoder structure is shown in Figure 5. The M component tail-biting convolutional-Hadamard decoder is involved in dealing with each component code. The log likelihood ratio (LLR) of every information bit is calculated and exchanged from one component decoder to another during decoding. The LLR of parity bits will not be calculated or exchanged.

The received symbols $\widehat{\mathit{c}}$ can be rearranged as a symbol block $\widehat{\mathit{C}}$, which can be written by

$$\widehat{\mathit{C}}=\{{\mathit{D}}_r,{\mathit{P}}_r^{\left(1\right)},\dots ,{\mathit{P}}_r^{\left(M\right)}\},$$

(13)

where ${\mathit{D}}_r$ denotes the information bit block of the received symbols, and ${\mathit{P}}_r^{\left(m\right)},m=1,\dots ,M$ denotes the $m\mathrm{th}$ component parity bit block (note that ${\mathit{P}}_r^{\left(m\right)}$ corresponds to $\{{\mathit{q}}^{\left(m\right)},{\mathit{P}}^{\left(m\right)}\}$).

In the beginning of the iteration, the initial prior LLR of information bits ${\mathit{L}}^0={\mathit{D}}_r$ is entered into DEC-1. As the iteration progresses, in the $m\mathrm{th}$ APP decoder, the non-self prior LLR of information bits ${\mathit{L}}_a^{\left(m\right)}$ is calculated by

$${\mathit{L}}_a^{\left(m\right)}={\tilde{\mathit{L}}}^{\left(m\right)}-{\mathit{E}}_{pre}^{\left(m\right)},$$

(14)

where ${\tilde{\mathit{L}}}^{\left(m\right)}$ denotes the prior LLR of information bits fed into the DEC-m, and ${\mathit{E}}_{pre}^{\left(m\right)}$ denotes the extrinsic LLR of information bits in previous iteration (initialized by zeros).

The APP decoder processes the non-self prior LLR of information bits ${\mathit{L}}_a^{\left(m\right)}$ and the prior LLR of parity bits ${\tilde{\mathit{P}}}^{\left(m\right)}={\mathit{P}}_r^{\left(m\right)}$ into the posterior LLR of information bits ${\mathit{L}}^{\left(m\right)}$ based on the BCJR algorithm (See details in Algorithm 2).

Algorithm 2 Tail-Biting Convolutional-Hadamard APP Decoder Algorithm.

Input: Block extrinsic prior LLR of information bits ${\mathit{L}}_a$ of size $K\times r$, and block prior LLR of parity bits $\tilde{\mathit{P}}$ of size $K\times \left(2^r-r\right)$. Output: Block extrinsic LLR of information bits $\mathit{E}$ of size $K\times r$, and block posterior LLR of information bits $\mathit{L}$ of size $K\times r$.   1: Initialize $k_1=1$, $k_2=1$, $k_3=1=$, $k_4=1$, ${\mathit{a}}_0=0$, ${\mathit{b}}_K=0$.   2: repeat   3:     Calculate ${\mathit{g}}_{k_1}$ with ${\mathit{L}}_{a_{k_1}}$ and ${\tilde{\mathit{P}}}_{k_1}$ according to (17) in GCU.   4:     $k_1=k_1+1$.   5: until $k_1=K$.   6: repeat   7:     Calculate ${\mathit{a}}_{k_2}$ with ${\mathit{g}}_{k_2}$ and ${\mathit{a}}_{k_2-1}$ according to (21) in ACU1.   8:     Calculate ${\mathit{b}}_{K-k_2}$ with ${\mathit{g}}_{K-k_2+1}$ and ${\mathit{b}}_{K-k_2+1}$ according to (23) in BCU1.   9:     $k_2=k_2+1$.   10: until  $k_2=K$   11: ${\mathit{a}}_0={\mathit{a}}_K$, ${\mathit{b}}_K={\mathit{b}}_0$ according to [30].   12: repeat   13:     Calculate ${\mathit{a}}_{k_3}$ with ${\mathit{g}}_{k_3}$ and ${\mathit{a}}_{k_3-1}$ according to (21) in ACU2.   14:     Calculate ${\mathit{b}}_{K-k_3}$ with ${\mathit{g}}_{K-k_3+1}$ and ${\mathit{b}}_{K-k_3+1}$ according to (23) in BCU2.   15:     $k_3=k_3+1$.   16: until  $k_3=K$   17: repeat   18:     Calculate ${\mathit{L}}_{k_4}$ with ${\mathit{g}}_{k_4}$, ${\mathit{a}}_{k_4}$ and ${\mathit{b}}_{k_4+1}$ according to (25) in LCU.   19:     Calculate ${\mathit{E}}_{k_4}$ with ${\mathit{L}}_{k_4}$ and ${\mathit{L}}_{a_{k_4}}$ according to (15) in ECU.   20:     $k_4=k_4+1$.   21: until  $k_4=K$

The extrinsic LLR of information bits $E^{\left(m\right)}$ is calculated in an extrinsic LLR computing unit (ECU) by

$${\mathit{E}}^{\left(m\right)}={\mathit{L}}^{\left(m\right)}-{\mathit{L}}_a^{\left(m\right)}.$$

(15)

The partial branch metric $\gamma$ is defined as

$${\gamma }_k\left(\pm {\mathit{h}}^j\right) =A\exp \left(\frac{1}{2}〈\pm {\mathit{h}}^j,\{{{\mathit{L}}_{\mathit{a}}}_k,{\tilde{\mathit{P}}}_k\}〉\right),$$

(16)

where ${\mathit{h}}^j$ is the $j\mathrm{th}$ column of the Hadamard matrix, A is a constant, ${{\mathit{L}}_{\mathit{a}}}_k$ is the $k\mathrm{th}$ row of ${\mathit{L}}_a$, and ${\tilde{\mathit{P}}}_k$ is denoted as the $k\mathrm{th}$ row of $\tilde{\mathit{P}}$.

The logarithm partial branch metric g is calculated in the g computing unit (GCU) and defined as

$$\begin{array}{cc}\hfill g_k(\pm {\mathit{h}}^j)& =log\left({\gamma }_k(\pm {\mathit{h}}^j)\right)\hfill \\ & =log\left(A\right)+\frac{1}{2}〈\pm {\mathit{h}}^j,\{{{\mathit{L}}_{\mathit{a}}}_k,{\tilde{\mathit{P}}}_k\}〉,\hfill \end{array}$$

(17)

where $log\left(A\right)$ can be omitted as a constant.

The full branch metric $\lambda$ is defined as

$$\lambda \left(s_{k-1},s_k\right) =\sum _{\left(s_{k-1},s_k\right)}{\gamma }_k(\pm {\mathit{h}}^j),$$

(18)

where $\lambda \left(s_{k-1},s_k\right)$ denotes all parallel branches between $s_{k-1}$ and $s_k$. The logarithm’sfully branch metric l is defined as

$$\begin{array}{cc}\hfill l\left(s_{k-1},s_k\right)& =log\left(\sum _{\left(s_{k-1},s_k\right)}\exp \left(g_k(\pm {\mathit{h}}^j)\right)\right)\hfill \\ & \approx \underset{\left(s_{k-1},s_k\right)}{max}\left(g_k(\pm {\mathit{h}}^j)\right).\hfill \end{array}$$

(19)

The forward recursive metric $\alpha$ in forward recursion is defined as

$$\alpha \left(s_k\right) =\sum _{\forall s_{k-1}}\lambda \left(s_{k-1},s_k\right)\alpha \left(s_{k-1}\right).$$

(20)

The logarithm’s forward recursive metric a is calculated in the a computing unit (ACU) and defined as

$$\begin{array}{cc}\hfill a\left(s_k\right)& =log\left(\sum _{\left(s_{k-1},s_k\right)}\exp \left(l\left(s_{k-1},s_k\right)+a\left(s_{k-1}\right)\right)\right)\hfill \\ & \approx \underset{s_{k-1}}{max}\left(l\left(s_{k-1},s_k\right)+a\left(s_{k-1}\right)\right).\hfill \end{array}$$

(21)

Correspondingly, the backward recursive metric b is defined as

$$\beta \left(s_k\right) =\sum _{\forall s_{k+1}}\lambda \left(s_k,s_{k+1}\right)\beta \left(s_{k+1}\right),$$

(22)

and the logarithm’s backward recursive metric b is calculated in b computing units (BCU) and defined as

$$b\left(s_k\right) \approx \underset{s_{k+1}}{max}\left(l\left(s_k,s_{k+1}\right)+b\left(s_{k+1}\right)\right).$$

(23)

The $k\mathrm{th}$ row’s $i\mathrm{th}$ bit of the posterior LLR of information bits $L_k\left[i\right]$ is calculated in the LLR computing unit (LCU) and defined as

$$L_k\left[i\right]=log\frac{{\displaystyle \sum _{H[i,j]=\pm 1}}\left({\gamma }_k\left(\pm {\mathit{h}}^j\right){\displaystyle \sum _{\forall s_k,s_{k+1}}}\alpha \left(s_k\right)\beta \left(s_{k+1}\right)\right)}{{\displaystyle \sum _{H[i,j]=\mp 1}}\left({\gamma }_k\left(\pm {\mathit{h}}^j\right){\displaystyle \sum _{\forall s_k,s_{k+1}}}\alpha \left(s_k\right)\beta \left(s_{k+1}\right)\right)},$$

(24)

and this can then be simplified to

$$\begin{array}{cc}\hfill L_k\left[i\right]& \approx \underset{H[i,j]=\pm 1}{max}\left(g_k\left(\pm {\mathit{h}}^j\right)+\underset{\left(s_k,s_{k+1}\right)}{max}\left(a\left(s_k\right)+b\left(s_{k+1}\right)\right)\right)\hfill \\ & -\underset{H[i,j]=\mp 1}{max}\left(g_k\left(\pm {\mathit{h}}^j\right)+\underset{\left(s_k,s_{k+1}\right)}{max}\left(a\left(s_k\right)+b\left(s_{k+1}\right)\right)\right).\hfill \end{array}$$

(25)

r denotes the order of the Hadamard code, $k=K\times r$ denotes the length of information bits and $\eta$ represents the memory depth of the convolutional code. The maximum value of $\delta$ elements can be obtained by calculating the $\delta$ maximum value of $(\delta -1)$ pairs’ elements. Moreover, the maximum value of an element pair can be evaluated by a subtraction and all subtraction can be evaluated by addition. Thus, calculating the maximum value of $\delta$ elements requires $(\delta -1)$ additions. In each iteration, the proposed turbo-Hadamard codes based on tail-biting need to calculate K times, whereas the turbo-Hadamard codes [20] need to calculate $(K+\eta )$ times. Therefore, we can obtain the computation complexity estimation of the decoder through (17) to (25). The computational complexity of each iteration is shown in

Table 1. Comparison of decoder complexity *.

Calculation Process	The Proposed Code	Code in [20]	Code in [31]
Branch Metric	ADD:$K(2^{r+1}-2)$	ADD:$(K+\eta )(2^{r+1}-2)$	ADD:$3K(2^{r+1}-2)$
		EXP:$(K+\eta )2^{r+1}$	EXP:$3K·2^{r+1}$
Full Branch Metric	ADD:$K(2^{r+1}-4)$	ADD:$(K+\eta )(2^{r+1}-4)$	-
Forward Recursion	ADD:$2K·2^{\eta +2}$	ADD:$(K+\eta )2^{\eta }$	ADD:$K(2^{r+1}-2)$
		MULT:$3(K+\eta )2^{\eta }$	DIV:K
			LOG:K
Backward Recursion	ADD:$2K·2^{\eta +2}$	ADD:$(K+\eta )2^{\eta }$	ADD:$K(2^{r+1}-2)$
		MULT:$3(K+\eta )2^{\eta }$	DIV:K
			LOG:K
LLR of Information Bits	ADD:$K(2^{r+2}-1)$	ADD:$(K+\eta )(3·2^{r+1}+2^{\eta +1}-2r-10)$	ADD:$Kr(2^{r}r+1-2)$
		MULT:$(K+\eta )\left(2^{r+1}\right)$	DIV:$Kr$
		DIV:$(K+\eta )r$	LOG:$Kr$
		LOG:$(K+\eta )r$
Total	ADD:$K(2^{r+3}+2^{\eta +4}-7)$	ADD:$(K+\eta )(5·2^{r+1}+2^{\eta +2}-2r-16)$	ADD:$K(r+5)(2^{r+1}-2)$
		MULT:$(K+\eta )(2^{r+1}+3·2^{\eta +1})$	DIV:$K(r+2)$
		DIV:$(K+\eta )r$	EXP:$3K·2^{r+1}$
		EXP:$(K+\eta )2^{r+1}$	LOG:$K(r+2)$
		LOG:$(K+\eta )r$

* The abbreviations in the table are as follows: addition (ADD), multiplication (MULT), division (DIV), exponent (EXP), logarithm (LOG).

.

We use LUTs to execute addition and multiplication operations (we treat division as multiplication) and use read-only memory (ROM) to execute exponent and logarithm operations. In the operating environment of Xilinx Vivado 2019.1, a 10-bit input takes up the resources of 10 LUTs, a 10-bit input multiplication takes up 116 LUTs, and a 10-bit exponent or logarithm takes up 0.5 Block RAMs (BRAMs). As a result, we can obtain the comparison of hardware resources occupied in our proposed algorithm and the conventional algorithm in

Table 2. LUTs used in the decoder hardware implementation.

Code Parameters	The Proposed Code	Code in [20]	Code in [31]
k = 200, r = 4, $\eta$ = 2	370,000 LUTs	1,712,960 LUTs	679,200 LUTs
		1.0 BRAMs	1.0 BRAMs
k = 200, r = 5, $\eta$ = 2	626,000 LUTs	2,805,376 LUTs	1,402,400 LUTs
		1.0 BRAMs	1.0 BRAMs
k = 200, r = 4, $\eta$ = 3	498,000 LUTs	2,319,072 LUTs	679,200 LUTs
		1.0 BRAMs	1.0 BRAMs
k = 200, r = 5, $\eta$ = 3	754,000 LUTs	3,416,896 LUTs	1,402,400 LUTs
		1.0 BRAMs	1.0 BRAMs

.

4. Simulation Results

In this section, simulation results are provided to illustrate the bit error rate (BER) and frame error rate (FER) performance of the proposed tail-biting turbo-Hadamard codes, the turbo-Hadamard codes reported in [20] and the concatenated zigzag Hadamard codes reported in [31]. Meanwhile, the performance of our proposed algorithm is analyzed with and without jamming. Since the concatenated codes were implemented on the FPGA platform in [23,24], the computational complexity comparison of our proposed algorithm and codes [23,24] is illustrated from the perspective of implementation. Particularly, the trellis terminal state of turbo-Hadamard codes return to zeros; however, the trellis terminal state of our proposed algorithm is based on a cyclic state. Supposing that the capture process and synchronization process are perfect, we simulate a digital baseband FH system. The common FH system parameters are shown in the following

Table 3. Core FH system simulation parameters.

Parameter	Value
System Clock	245.76 MHz
Symbol Rate	0.96 MHz
Interpolation Rate	256
Modulation Filter	Root Raised Cosine
Roll-Off Factor	0.35
Frequency Hopping Numbers	200
Frequency Hopping Rate	960,000 hop/s
Total Bandwidth	192 MHz
Interference Bandwidth	38.4 MHz, 76.8 MHz
Proportion of Jammed Frequency Bins	20%, 40%

.

In Figure 6, we show the BER performance of the proposed tail-biting turbo-Hadamard codes and terminate-state-zeroturbo-Hadamard codes in [20] considering different numbers of component coders. We set the length of uncoded bits $k=200$, the order of Hadamard matrix $r=5$, the memory depth of convolutional code $\eta =2$ and the number of component encoders $M=2$ or $M=3$. We observed that tail-biting turbo-Hadamard codes outperformed terminate state-zero turbo-Hadamard codes regardless of whether M equaled 2 or 3. This is because for each component coder, the starting state and terminating state were the same. However, only the terminating of the first component coder is a state of zero and the other is unknown in the terminate-state-zero turbo-Hadamard codes [20].The terminating state of every component coder in our proposed algorithm is determinant. This means that our proposed algorithm has more prior status information than the codes presented in [20]. Furthermore, our algorithm’s performance with regard to $M=3$ exceeded that regarding $M=2$ in every turbo-Hadamard code.The reason for this is that the codes with three component codes have more constraints on the information bits than those with only two component codes.

The impact of the order of Hadamard codes on the BER performance of turbo-Hadamard codes is illustrated in Figure 7. We considered 200 information bits with $r=2$, $r=4$ and $r=5$, respectively. All cases were evaluated using the $M=3$ component encoder. We observe that our proposed tail-biting turbo-Hadamard codes outperformed the terminate state-zero turbo-Hadamard codes [20] in all conditions of $r=2$, $r=4$ and $r=5$. Similarly to Figure 6, this is because the improved code scheme provided more prior information than that of the terminate state-zero turbo-Hadamard codes [20]. Additionally, we observed that a larger order of Hadamard codes leads to better BER performance.

Figure 8 compares the BER performance against the different memory depths of convolutional codes when the overall coded length is 200 and the order of Hadamard codes is set at 5. It shows that the BER performance of all algorithms improved with the increase in the number representing the memory depth of the convolutional code. Moreover, as memory depth $\eta$ increased, the BER performance of tail-biting turbo-Hadamard codes and terminate state-zero turbo-Hadamard codes became closer. This is because when memory depth $\eta$ increases, the number of terminate states increases. Since it is confirmed that the start state and the terminate state are the same in our proposed algorithm, it is impossible to confirm the concrete cyclic state when the $\eta$ is sufficiently large.

Figure 9 and Figure 10 show the performance of the proposed algorithm considering an FH system influenced by jamming. We compared the anti-jamming ability by evaluating the BER and FER performance of the tail-biting turbo-Hadamard codes, terminate-state-zero turbo-Hadamard codes [20], concatenated zigzag Hadamard codes [31] and turbo codes with repeating. The code length was set to be $k=200$, the component encoder number was assumed to be $M=3$ and the memory length was $\eta =2$.

Figure 9 illustrates the anti-jamming performance with $r=4$. To evaluate the anti-jamming ability at the same level, considering the structure of all the mentioned codes, the code rates of tail-biting turbo-Hadamard codes and terminate-state-zero turbo-Hadamard codes were set to be $1/11.8$, and the code rate of concatenated zigzag Hadamard codes was $1/11.2$. It should be noted that the total equivalent rate was $1/12$ when the $1/3$ turbo codes were transmitted 4 times. We observed that the BER performance of all codes decreased, which was because the receiver detected the jammed symbol through the received power threshold, and then deleted the jammed frequency bins. Those operations result in less information being available for decoding, which thus reduces the coding gain. When the BER performance is e${}^{-5}$, the anti-jamming performance of our codes was degraded by 1.1 dB under $20\%$ jamming and $2.6$ dB under $40\%$ jamming, compared with the conditions without jamming, respectively. Moreover, we can observe that the performance of the proposed algorithm and that of the turbo-Hadamard codes [20] are very similar. This result implies that when the value of r is small, the gain provided by Hadamard codes is insignificant, which leads to the fact that the performance gap between the two codes is small.

To compare the anti-jamming performance against the order of Hadamard codes, the simulation setup in Figure 10 was $r=5$, and other simulation conditions were similar to those presented in Figure 9. Therefore, the code rates of the tail-biting turbo-Hadamard codes and terminate-state-zero turbo-Hadamard codes were $1/17.2$, and the code rate of concatenated zigzag Hadamard codes was $1/16.6$. In this simulation, we repeated the $1/6$ turbo codes 3 times, by which we obtained an equivalent of $1/18$ overall codes. We can see that our proposed algorithm obviously outperformed the turbo-Hadamard codes [20] with and without jamming. This is because the gain brought by Hadamard codes is considerable when $r=5$. When BER performance reaches e${}^{-5}$, the proposed codes are worsened by 1.1 dB under $20\%$ jamming and $2.5$ dB under $40\%$ jamming compared with the conditions without jamming. It is worth noting that although there is little difference in the relative performance degradation between $r=5$ and $r=4$, the BER performance of $r=5$ under the same SNR condition is much better than that of $r=4$. Moreover, we observe that the scheme of the turbo codes transmitted repeatedly showed the same coding gain as the normal turbo codes. However, repetitive coding can decentralize the jamming power to each decoded symbol, which results in a considerable anti-jamming performance.

The decoding complexity performance of the proposed codes and other codes [23,24] is shown in Figure 11. The parameters of codes are set as $k=200$, $r=4,5$ and $\eta =2,3$. Since there are no multiplication or division operations in our proposed codes, the usage of LUTs is far less than that of terminate-state-zero turbo-Hadamard codes. We observed that when $r=4$ changed into $r=5$, the usage of LUTs increased by 1092 k in the terminate-state-zero codes, the usage of LUTs increased by 723 k in the sigzag-Hadamard codes, whereas the usage increased by 256 k in our proposed codes. We also noted that when $\eta =2$ became $\eta =3$, the usage of LUTs increased by 606 k in codes [23], whereas the usage increased by 128 k in our proposed codes. Moreover, the computational complexity of our proposed codes was much smaller than those of the terminate-state-zero codes. In the case of $r=5,\eta =2$, the complexity of our codes was only $22.3\%$ of that of terminate state-zero turbo-Hadamard codes, and $44.6\%$ of that of zigzag-Hadamard codes.

The transmitting efficiency of our proposed codes and other codes [23,24] is shown in Figure 12. Since the tail-biting turbo-Hadamard method does not need to transmit extra bits for its terminating state, the actual coding efficiency is $100\%$ in all simulation conditions. It was observed that when $r=4,\eta =2$, the transmission efficiency was reduced by $7.4\%$ in terminate-state-zero codes. In the condition of $r=5,\eta =2$, the transmission efficiency was reduced by $9.1\%$ in codes [23]. Furthermore, as the memory depth $\eta$ increased, the transmission efficiency was also degraded in the algorithm reported in [23]. The reasons for this are that the canonical turbo-Hadamard codes need to transmit $M\eta (2^r-r)$ bits for their termination. However, the efficiency of zigzag-Hadamard codes was $100\%$, as in the tail-biting turbo-Hadamard codes, although the performance regarding coding gains and the complexity of the tail-biting turbo-Hadamard codes was much better than that of the zigzag-Hadamard codes.

5. Conclusions

In this paper, an improved turbo-Hadamard code based on tail-biting is proposed for anti-jamming in a UAV FH system. For the encoder side, the proposed overall turbo-Hadamard codes are constructed by concatenating several tail-biting convolutional-Hadamard codes in parallel. For the decoder side, we proposed a low-complexity decoding algorithm for tail-biting turbo-Hadamard codes. Simulation results showed that the proposed encoder scheme can achieve a significant performance in transmission efficiency over the canonical turbo-Hadamard codes, and the corresponding decoder can achieve an outstanding performance in terms of the hardware implementation complexity over the existing low-rate codes. Furthermore, based on the simulation results, our proposed tail-biting turbo-Hadamard codes can help to combat malicious jamming in the UAV communication scenario. In our future work, we will continue to improve the tail-biting turbo-Hadamard codes, making them suitable for more complex UAV communication scenarios with strong anti-jamming ability. It would also be interesting to design a more efficient algorithm of even lower complexity which could take advantage of prior knowledge regarding the channel state information by employing machine learning.