Low Delay Inter-Packet Coding in Vehicular Networks

Abstract

In Cooperative Intelligent Transportation Systems (C-ITSs), vehicles need to wirelessly connect with Roadside units (RSUs) over limited durations when such point-to-point connections are possible. One example of such communications is the downloading of maps to the C-ITS vehicles. Another example occurs in the testing of C-ITS vehicles, where the tested vehicles upload trajectory records to the roadside units. Because of real-time requirements, and limited bandwidths, data are sent as User Datagram Protocol (UDP) packets. We propose an inter-packet error control coding scheme that improves the recovery of data when some of these packets are lost; we argue that the coding scheme has to be one of convolutional coding. We measure performance through the session averaged probability of successfully delivering groups of packets. We analyze two classes of convolution codes and propose a low-complexity decoding procedure suitable for network applications. We conclude that Reed–Solomon convolutional codes perform better than Wyner–Ash codes at the cost of higher complexity. We show this by simulation on the memoryless binary erasure channel (BEC) and channels with memory, and through simulations of the IEEE 802.11p DSRC/ITS-G5 network at the C-ITS test track AstaZero.

1. Introduction

1.1. Safety Testing of C-ITS

The emerging concept of Cooperative Intelligent Transportation Systems (C-ITS) suggests a widespread adoption of information and communication technologies in diverse vehicular applications that aim at increasing transport safety, efficiency and comfort. C-ITS vehicles exchange information with each other as well as with roadside infrastructure over vehicular ad-hoc networks (VANETs) [1]. An important milestone for VANETs has been the worldwide allocation of reserved bandwidth for C-ITS in the 5.9 GHz spectrum. The developing communication technology is called as DSRC in USA, and ITS-G5 in Europe [2].

Intensive testing is being performed so that C-ITS systems could be introduced on public roads. AstaZero in Sweden is an advanced testbed for research and development in the area of active road safety and autonomous transport [3]. The unique capacities of the testbed offer the opportunity to support and accelerate research and development of active safety and C-ITS features through partnerships and close collaboration with vehicle manufacturers, suppliers, legislators, universities and colleges throughout the world. Different traffic and communication environments are available at the facility, and these make it possible to test and analyze systems from function level to vehicle integration—and this in all kinds of traffic and traffic situations (Figure 1).

1.2. Roadside Units and Quasi Real-Time Transfers

By leveraging remote connectivity supplied by Road-Side Units (RSUs) deployed along the road in VANETs, vehicles can retrieve/update maps or perform advertisement media downloading [4] via vehicle-to-roadside (V2R) communications. Moreover, vehicles may exploit storage and processing capabilities locally offered by RSUs, according to the recently proposed mobile edge computing (MEC) paradigm [5].

V2R communications are expected to be short-lived and intermittent, due to the high mobility of the vehicles and to the high costs to deploy a ubiquitous roadside infrastructure. Because of the huge data traffic demands of vehicles coupled with the limitations of V2R communications, a practical design must make the best of connectivity opportunities in drive-thru scenario, where moving vehicles spend at most a couple of minutes in the coverage area of a RSU [6,7,8]. When a non-reliable transport protocol is used, an application layer inter-packet coding turns out to be an attractive solution if we aim at transferring as many data as possible.

Drive-through scenario applies to C-ITS vehicular active safety testing also. At the AstaZero testing facility, one can test active safety by enacting carefully choreographed scenarios. Each scenario may involve multiple test objects such as vehicles, pedestrians, etc. During testing, each test object is fitted with a modem. The purpose is twofold. Firstly, the modems send and receive to and from the infrastructure, strictly real-time data consisting of trajectory updates to the test server, scenario abort signals from the test server, etc. Secondly the modems upload quasi-real time data consisting of sensor measurements and vehicular log information to the RSUs. In this way, some of the data inside the vehicle are available nearly real-time to the RSUs/server for diagnostics in the case a vehicle itself ends up damaged. It is this quasi real-time data transfer for which we design inter-packet coding.

1.3. Convolutional Codes for Inter-Packet Coding

A specific feature of packets transmission over wireless is that both burst and isolated packet losses (erasures) happen. Many papers address this problem (see, for example, [9,10] and references therein). However, low delay and low complexity requirements narrow down the list of coding techniques suitable for this application [11]. Moreover, the important feature of drive-thru scenario is a short residence time of a vehicle in the coverage area of the RSU. This restriction makes convolutional coding practically the only suitable solution to the problem.

Thorough analysis of state-of-the-art solutions for reliable data transmission in V2V and V2R communication scenarios is presented in [12]. Moreover, the batched sparse code (BATS code) [13] based protocol is suggested. BATS consists of an outer code and an inner code. The outer code represents matrix generalization of the fountain code (see [14]) and the inner code is random linear network code. The two classes of convolutional codes studied below can be suggested as low-delay alternatives to fountain codes in BATS code construction.

Another specific feature of drive-thru scenario is the existence of entrance and exit zones with extremely poor channel conditions which can be characterized by a high probability of communication failure. Since error correction coding at physical level cannot improve quality of communication in these areas, there is a need for packet level error correction. By recovering lost packets at this coding level, we increase a zone and/or an interval of reliable communication [6,7,8]. To take into account nonstationary channel conditions, we introduce a new performance measure called successful delivery function (SDF). In what follows, the studied codes are compared with respect to both conventional criteria, such as frame error rate (FER) and bit error rate (BER), and the SDF criterion.

In this paper, we study two classes of high-rate convolutional codes with sliding-window (SW)-decoding. The idea to apply convolutional codes to correct packet losses in different networks was previously considered in [9,11,15]. We compare the SW-decoding performance of the binary Wyner–Ash (WA) convolutional codes [16] and the Reed–Solomon (RS)-convolutional codes [17]. In particular, we analyze performances of SW-decoding based on maximum-likelihood (ML) decoding (SWML) and belief propagation (BP) decoding (SWBP) of window zero-tail terminated (ZT) convolutional codes [18]. A modified low-complexity iterative decoding procedure is suggested. It is shown that extending the parity-check matrix of the ZT code by a very limited number of redundant parity-checks (without changing the code) leads to the coincidence of the ML and BP decoding performance for this code.

1.4. Contributions

The new contributions of the paper are the following:

• New low-complexity low-delay decoding algorithm for erasure correction by the Wyner–Ash code applied in V2R scenario.
• Erasure-correcting performance analysis for Wyner–Ash and Reed–Solomon convolutional codes.
• Comparative analysis of suggested codes and decoding algorithms for: (i) memoryless channels; (ii) channels with memory described by Gilbert–Elliott model; and (iii) real-life VANET provided by AstaZero facility.

1.5. Organization of the Paper

In Section 2, we formulate the coding problem, and setup a performance measure (Equation (1)) appropriate for short sessions of quasi real-time packet transfers, especially when the channel conditions vary in an unknown deterministic way within the session. Two classes of convolutional codes are described and analyzed in Section 3. Simulation results are presented and discussed in Section 4. This section also includes the results of calculations based on packet loss measurements from the Asta-Zero test site. Finally, in Section 5, we indicate future lines of work that naturally emanate from our findings.

2. Preliminaries

2.1. Wireless Channels

Throughout the paper, we assume that at the physical layer data are protected by forward error correction. The information packet is organized as a series of codewords and data in the packet are protected by cyclic parity check (CRC). The probability of undetected error is negligible. Consequently, the decoder after computing CRC classifies each packet either as successfully delivered or as erased. Thus, we interpret packet losses as erasures and model packet transmission as a transmission over the binary erasure channel (BEC). In this channel, either all bits of a packet are successfully received or they all are erased. If an erasure correcting code is used, then all encoding and decoding operations are performed in parallel with all symbols of the packet. By default, in the coding theory literature it is assumed that BEC is a memoryless channel. However, in this paper, we consider both memoryless BEC and BEC with memory (M-BEC). One example of M-BEC model is obtained from the wireless fading channel model by applying discrete model constructing technique in [19,20].

2.2. Performance Metric

Our goal is to improve the reliability of communications by introducing redundancy into the transmitted data. When applying this commonly used approach to V2R communications, we meet specific problems which make it difficult to evaluate the system performance.

First, the packet losses cannot be modeled as a random stationary process. For a given vehicle and a given RSU, we distinguish poor communications zones (entry zone and exit zone) when the distance between the receiver and the transmitter is large, and so-called production zone with relatively good transmission conditions [7].

As a side effect of non-stationary channel conditions, the conventional criteria such as bit error rate (BER) or frame (word or packet) error rate (FER) do not make sense since these quantities change over time. The average overall error probability over the session is determined by the worst-case values.

To formalize the problem of improving reliability of V2R communications, we use the following approach. Let ${ϵ}_t$ denote the probability of the packet loss at time moment t, for $t=1,\dots ,T$ and where T is the total number of packets transmitted during one communication session. Assume that a message consisting of K packets should be transmitted, and the transmission is considered as successful only if all K packets are delivered to the receiver. To improve reliability, $N-K$ redundant packets are added to form a block of length $N\ge K$ packets, in such a way that, if the number of lost packets is $\mu \le N-K$, then K information packets can still be reconstructed by the decoder. More precisely, if $\mu$ is less than the minimum distance of the code, then lost packets can always be correctly estimated, otherwise, only some of the lost packets can be correctly estimated.

Let ${\xi }_t$ denote the indicator function of the successful delivery of the data packet number t in the coded system, with $t=1,\dots ,T^{\prime }$, and where $T^{\prime }\le T$ is the total number of transmitted information packets during the session of length T packets. By definition, ${\xi }_t$ is equal to 1 or 0 in case of success or failure of delivering packet number t, respectively. In particular, $Pr({\xi }_t=1)=1-{ϵ}_t$ is the probability of successful delivery of the tth packet. If the message consists of K packets then the success in delivering the entire message can written in terms of ${\xi }_t$ as

$$\left(\sum _{\tau =t}^{t+K-1}{\xi }_{\tau }\right)=K$$

For a sequence of the $T^{\prime }$ transmitted packets, the average probability of message delivering should be computed as average over $t=1,\dots ,T^{\prime }-K+1$.

The successful delivery function (SDF) is defined as

$$P_{\mathrm{s}}\left(K\right)\triangleq \frac{1}{T^{\prime }-K+1}\sum _{t=1}^{T^{\prime }-K+1}Pr\left\{\left(\sum _{\tau =t}^{t+K-1}{\xi }_{\tau }\right)=K\right\}.$$

(1)

This function characterizes the average (over session) probability of successful delivery of length K messages, as a function of K.

In the particular case of uncoded system, function $P_{\mathrm{s}}\left(1\right)$ equals the fraction of successfully delivered packets, and uncoded transmission is optimal. In general, $P_{\mathrm{s}}\left(K\right)$ decreases as K grows. This successful delivery function (SDF) shall be our performance measure.

In our analysis, we assume that for coverage zones of RSUs the channel parameter ${ϵ}_t$ changes slowly with t and can be approximated as a constant value for a single block of length N. This allows us to compare coding systems using different erasure correcting codes by simulating them on the BEC with a fixed symbol erasure probability.

In addition, we compare codes using simulation on the M-BEC described by the Gilbert–Eliott model whose parameters do not change during one block of erasure correcting code. For the final evaluation, to take into account specific of drive-thru scenario, we measure SDF by simulation in real-life network conditions.

2.3. Convolutional Codes for Network Applications

Generally speaking, any error-correcting code can be used for recovering lost packets in networks. However, criteria for constructing packet erasure-correcting codes for V2R networks differ significantly from those used for evaluating codes correcting or detecting errors at the physical level. The difference stems from the difference in the acceptable decoding complexity and delay. Short lifetime of the transmitted data makes these requirements much stronger than for other networks.

Raptor codes [14] represent an efficient low-complexity network-oriented class of codes. However, they are not the best solution for the V2R application since they are meant for correcting large number of independent erasures without restriction on delay, rather than for correcting a small number of erased large packets with strictly limited delay.

Another class of codes which can be efficiently used for recovering packets of erasures are so-called codes with rank metric [21,22]. They were suggested as a generalization of codes for magnetic recording [23]. These codes protect two-dimensional data against both row and column errors and erasures. In the V2R application, it is enough to correct one-dimensional erasures which can be equally well done by the Reed–Solomon (RS)-codes [24]. The approach based on convolutional version of the RS-codes [17] is studied below as one of the solutions.

It is well known that complexity of ML decoding over the binary symmetric channel (BSC) and over the additive white Gaussian noise (AWGN) channel is, typically, an exponentially growing function of code length of block code or of constraint length of convolutional code. For this reason, usually codes with simple suboptimal decoding are preferred, e.g., concatenated codes, product codes, turbo-codes, LDPC codes, etc.

The situation is completely different for the BEC (M-BEC), where correcting of $\nu$ erasures can be reduced to solving a system of linear equations of order at most $\nu$. Thus, ML-decoding complexity is a polynomial, at most cubic, function of code length. In this case, the decoding delay becomes a basic requirement when selecting codes. Convolutional codes, the decoding delay of which is determined by the encoder memory and does not depend on the length of the code, have practically no alternative in such an application. Low-delay high-rate convolutional codes are among most promising candidates for the V2R network application.

The considered further decoding scenario is shown in Figure 2.

Data packets from the physical layer of the network include data of different priority followed by cyclic redundancy check (CRC) and parity-check bits of error detecting code used in IEEE 802.11 standard. It is assumed that highest priority bits in the sequence of these packets are encoded by a convolutional code.

Two classes of binary and nonbinary high-rate convolutional codes are analyzed and compared with block codes of the same rate and approximately the same decoding delay. We demonstrate the efficiency of these codes when correcting erasures in the BEC and M-BEC obtained from the wireless fading channel by using technique in [25]. Then, the chosen codes are simulated on the stream of packet losses provided by AstaZero.

3. Packet Recovering Codes

In this section, we analyze two solutions, based on low-delay binary and nonbinary convolutional codes, respectively. Two low-complexity sliding-window (SW)-decoding procedures are studied. The first one is based on ML-decoding applied to the ZT convolutional code inside the window and the second implies conventional BP decoding and BP decoding with using redundant parity-check (RPC) matrix of the same code [26,27]. As explained below, RPC matrix contains linear dependent rows which destroy stopping sets of the code and improve erasure correcting capability compared to BP decoding while preserving low decoding complexity.

3.1. Binary Wyner–Ash Codes

3.1.1. Code Description and Distance Properties

A binary convolutional code of rate $R=k/n$ can be characterized by its semi-infinite parity-check matrix

$$H=\left(\begin{array}{cccc}{H}_0& \mathbf{0}& \cdots & \\ H_1& H_0& \mathbf{0}& \cdots \\ H_2& H_1& H_0& \mathbf{0}& \cdots \\ \cdots & \cdots & \cdots & \cdots \\ H_m& H_{m-1}& H_{m-2}& H_1& H_0& \mathbf{0}& \cdots \\ \mathbf{0}& H_m& H_{m-1}& \cdots & H_1& H_0& \mathbf{0}& \cdots \\ \cdots & \cdots & \cdots & \cdots & \cdots & \cdots & \cdots & \cdots \end{array}\right),$$

(2)

where m denotes the code syndrome memory [18], and for each $i=0,1,\dots ,m$, the entry $H_i$ is of size $(n-k)\times n$.

Let us consider one block-column submatrix

$$H^{\left(m\right)}=\left(\begin{array}{c}{H}_0\\ H_1\\ H_2\\ \cdots \\ H_m\end{array}\right).$$

(3)

If $H^m$ is a suitably chosen parity-check matrix of the $R_b=(n-m-1)/n$ extended Hamming code of length $n=2^m$ with minimum distance $d_{min}=4$, then Equation (2) determines a subclass of Wyner–Ash codes [16] of rate $R=(n-1)/n$ with syndrome memory [18] m and free distance $d_{\mathrm{free}}=3$.

The subblock codes of the rate $R=3/4$ and $R=7/8$ Wyner–Ash codes with $m=2,3$, respectively, are determined by parity-check matrices

$$\begin{array}{ccc}\hfill H^{\left(2\right)}& =& \left(\begin{array}{cccc}1& 1& 1& 1\\ 1& 0& 1& 0\\ 1& 1& 0& 0\end{array}\right),\hfill \end{array}$$

(4)

$$\begin{array}{ccc}\hfill H^{\left(3\right)}& =& \left(\begin{array}{cccccccc}1& 1& 1& 1& 1& 1& 1& 1\\ 1& 1& 1& 1& 0& 0& 0& 0\\ 1& 1& 0& 0& 1& 1& 0& 0\\ 1& 0& 1& 0& 1& 0& 1& 0\end{array}\right).\hfill \end{array}$$

(5)

The corresponding polynomial parity-check matrix of the convolutional code for $m=2$

$$H\left(D\right)=\left(\begin{array}{cccc}1+D+D^2& 1+D^2& 1+D& 1\end{array}\right)$$

(6)

has systematic form. Its generator matrix can be written as

$$G\left(D\right)=\left(\begin{array}{cccc}1& 0& 0& 1+D+D^2\\ 0& 1& 0& 1+D^2\\ 0& 0& 1& 1+D\end{array}\right).$$

(7)

Generalization to an arbitrary m is obvious.

Close connection to the Hamming codes allows to compute the exact spectrum of the convolutional code determined by Equation (2) through the known spectra of Hamming codes and their cosets. This analysis was performed in [28]. For example, in case $m=2$, the spectrum generating function is

$$g\left(D\right)=D^3\frac{6+5D-D^2-2D^3-3D^4+3D^6-D^7}{1-3D-2D^2-D^3+D^5-D^7}.$$

In

Table 1. Weight enumerators for Wyner–Ash codes.

m	R	Spectrum Coefficients ${\mathit{g}}_3,\dots ,{\mathit{g}}_{12}$
2	3/4	6, 23, 80, 290, 1050, 3804, 13782, 49929, 180888, 655334
3	7/8	28, 275, 2456, 22468, 205826, 1885187, 17266158, 158138208, 1448368114, 13265417898
4	15/16	120, 2644, 52456, 1066592, 21738992, 442834486, 9021091078, 183772934474, 3743704654772, 76264411563598

, we present the first 10 coefficients of $g\left(D\right)$ from this paper to further use them for bounding the error probability.

3.1.2. Encoding

From Equation (7) follows a simple implementation of the systematic encoder. This encoder contains in total five delay elements, whereas for the minimal non-systematic encoder only two delay elements are required (see [18] for details). However, for the considered application, it is not important since we do not use a trellis representation of the code for ML-decoding over the BEC. The decoding complexity is at most ${\nu }^3$, where $\nu$ is the number of corrected erasures.

Encoding delay is equal to the encoder block length $n=2^m$ since each parity-check bit is computed immediately after receiving a new block of $k=n-1$ latest information bits.

3.1.3. Decoding

As mentioned above, we study two decoding algorithms: SW-decoding and its simplified version SWBP decoding. A low-complexity modification of SWBP decoding whose error performance tends to that of SW-decoding is suggested. First, we reformulate the problem of decoding over the BEC to the problem of solving a system of linear equations.

Consider a BEC with erasure probability $ϵ$. Let H be an $r_{\mathrm{B}}\times n_{\mathrm{B}}$ parity-check matrix of a binary $(n_{\mathrm{B}},n_{\mathrm{B}}-r_{\mathrm{B}})$ block code, with the minimum Hamming distance $d_{min}$. An ML decoder corrects any pattern of $\nu$ erasures if $\nu \le d_{min}-1$. If $d_{min}\le \nu \le r_{\mathrm{B}}$, then a unique correct decision can be obtained for some erasure patterns. The number of such correctable patterns depends on the code structure.

Let $\mathit{y}=(y_1,y_2,\dots ,y_{n_{\mathrm{B}}})$ be a received vector, where $y_i\in \{0,1,\varphi \}$, and the symbol $\varphi$ represents an erasure. We denote by $\mathit{e}=(e_1,e_2,\dots ,e_{n_{\mathrm{B}}})$ a binary vector, such that for all $i=1,2,\dots ,n_{\mathrm{B}}$, $e_i=1$ if $y_i=\varphi$, and $e_i=0$ if $y_i\in \{0,1\}$. Let $I\left(\mathit{e}\right)$ be the set of nonzero coordinates of $\mathit{e}$, $\left|I\right(\mathit{e}\left)\right|=\nu \left(\mathit{e}\right)$, and let $\mathit{z}=(z_1,z_2,\dots ,z_{\nu })$ be a vector of unknowns located in positions of $I\left(\mathit{e}\right)$.

Consider a system of linear equations $\mathit{y}{H}^{\mathrm{T}}=\mathbf{0}$ which can be reduced to

$$\mathit{z}{H}_{I\left(\mathit{e}\right)}^{\mathrm{T}}=\mathit{s}\left(\mathit{e}\right),$$

(8)

where the syndrome vector $\mathit{s}\left(\mathit{e}\right)={\mathit{y}}_{I^{\mathrm{c}}\left(\mathit{e}\right)}{H}_{I^{\mathrm{c}}\left(\mathit{e}\right)}^{\mathrm{T}}$ is computed using the nonerased positions of $\mathit{y}$ and $I^{\mathrm{c}}\left(\mathit{e}\right)=\{1,2,\dots ,n_{\mathrm{B}}\}\backslash I\left(\mathit{e}\right)$. ML decoding over the BEC is reduced to solving Equation (8).

Next, we explain SW-decoding of the convolutional code by example of the Wyner–Ash code with memory $m=2$.

Let L denote the decoding delay in blocks. At each step of the decoding procedure, the SW-decoder uses a $(W-m)\times Wn$ sized parity-check matrix which determines a ZT convolutional code

(9)

where $W=L+m+1$ is the decoding window size in n-blocks.

Let $\mathit{y}=(y_1,y_2,\cdots )$ be a semi-infinite input vector of the SW-decoder. Assuming m first blocks known (for example, all-zero) we start decoding with $(m+1)$th block. The decision is made about $W-m$ blocks. After decoding (solving the system of linear equations), the recovered symbols are substituted into input sequence $\mathit{y}$, the decoder outputs the ($m+1)$th block and the window slides by one block. At the ith step of the decoding procedure the decoder decides about ${\mathit{y}}_{\mathrm{W}}$

$${\mathit{y}}_{\mathrm{W}}=\left(\begin{array}{ccc}{y}_{(m+i-1)n}& \dots & y_{(i-1+W)n}\end{array}\right)$$

bits and outputs bits $(y_{(m+i-1)n},\dots ,y_{(m+i)n})$.

Example 1.

Let $L=2$. Then, a parity-check matrix of the ZT code has the form

$$H_{\mathrm{ZT}}=\left(\begin{array}{cccc}1100& 1010& 1111& \\ & 1100& 1010& 1111\\ & & 1100& 1010& 1111\end{array}\right).$$

(10)

Let $\mathit{v}=(110110001000101\dots )$ be the information sequence. By using the generator matrix in Equation (7) we obtain the corresponding codeword $\mathit{u}=(11001101001000011010\dots )$. Assume that the received sequence is $\mathit{y}=\left(\begin{array}{cccccc}1100& 1\varphi 0\varphi & 001\varphi & 0001& 1010& \dots \end{array}\right)$.

The SW-decoder starts decoding with the sequence ${\mathit{y}}_{\mathrm{W}}=\left(\begin{array}{ccccc}0000& 0000& 1100& 1\varphi 0\varphi & 001\varphi \end{array}\right)$.

The goal is to find codeword bits $[z_1,z_2,z_3]$ at the erased positions.

Step 1.

Compute syndrome. The syndrome is equal to [0 0 1]. From Equation (8) follows

$$\left(\begin{array}{ccc}0& 0& 0\\ 1& 1& 0\\ 0& 0& 1\end{array}\right)\left(\begin{array}{c}{z}_1\\ z_2\\ z_3\end{array}\right)=\left(\begin{array}{c}0\\ 0\\ 1\end{array}\right).$$

The number of unknowns is larger than the rank of the system which is equal to 2, that is, a unique solution does not exists. The decoder outputs only the information part of the first erasure-free block [1 1 0 0], i.e., output bits at this step are [1 1 0].

Step 2.

Shift the window. Input now is ${\mathit{y}}_{\mathrm{W}}=\left(\begin{array}{ccccc}0000& 1100& 1\varphi 0\varphi & 001\varphi & 0001\end{array}\right)$.

The syndrome is equal to [0 0 1]. From Equation (8) follows

$$\left(\begin{array}{ccc}1& 1& 0\\ 0& 0& 1\\ 1& 0& 0\end{array}\right)\left(\begin{array}{c}{z}_1\\ z_2\\ z_3\end{array}\right)=\left(\begin{array}{c}0\\ 0\\ 1\end{array}\right).$$

The unique solution is $[z_1,z_2,z_3]$ = [1 1 0]. The decoder decision is [1 1 0 1] and the output is [1 1 0]. At the next step the decoder will recover block [0 0 1 0] and the output bits are [0 0 1].

Notice that, in general, we have to perform Gaussian elimination to solve the system of linear equations. However, in our example it was not necessary. The variable $z_1$ is the only variable of the third equation and we found immediately that $z_1=1$. Similarly, from the second equation, we have $z_3=0$. Excluding known variable from the first equation, we obtain $z_2=0$. This algorithm coincides with BP decoding used for decoding LDPC codes over the BEC. The formal description of the decoding procedure is given below as Algorithm 1. When applying Algorithm 1 to a sliding window, we obtain SWBP decoding. Next, we modify the SWBP algorithm in order to increase its erasure-correcting capability while keeping its low complexity.

Algorithm 1 BP-BEC.

while there exist parity checks with only one erased symbol do

Assign to the erased symbol the modulo-2 sum of all  nonerased symbols participating in the same parity check.

end while

Since the free distance of the convolutional code is $d_{\mathrm{free}}=3$, not every combination of three erasures can be corrected by ML decoding. Thus, not every combination of three erasures can be corrected by the SW or SWBP decoding procedures. When the decoding delay L grows, the performance of SW decoder tends to the performance of the ML decoder. It means that any erasure pattern which is not a codeword and does not cover any codeword can be corrected by the SW decoder.

This is not true for SWBP decoding even if L tends to infinity. An erasure pattern cannot be corrected if it is a stopping set or it covers a stopping set [27].

The stopping set is defined as a subset of indices of columns in its parity-check matrix, such that a matrix constructed from these columns does not have a row of weight one. The size of the smallest stopping set is called stopping distance $d_{\mathrm{stop}}$.

In general, $d_{\mathrm{stop}}\le d_{min}$, for the Wyner–Ash convolutional code $d_{\mathrm{stop}}=d_{\mathrm{free}}$. However, there are many combinations of weight 3 which are not codewords but are stopping sets. For example, consider the column block

$$\left(\begin{array}{c}{H}_0\\ H_1\\ H_2\end{array}\right)=\left(\begin{array}{ccc}1& 1& 1\\ 1& 0& 1\\ 1& 1& 0\\ 0& 0& 0\\ \dots & \dots & \dots \end{array}\right)$$

The corresponding positions of the codeword form a stopping set.

Notice, that spectrum of stopping sets is determined not by code, but by its parity-check matrix. We can modify a parity-check matrix to eliminate some stopping sets, and thereby make performance of BP decoding close to that of ML decoding (see [27,29]). To do this, an additional (redundant) parity-check should be added to the code parity-check matrix.

For each window, we suggest to use the extended parity-check matrix

$$H_{\mathrm{EZT}}=\left(\begin{array}{cccc}1100& 1010& 1111& \\ & 1100& 1010& 1111\\ & & 1100& 1010& 1111\\ 1100& 0110& 1001& 0101& 1111\end{array}\right)$$

(11)

instead of Equation (10). The additional row is obtained as modulo 2 sum of all previous rows. It is easy to see that the former stopping set consisting of positions 9–11 (as well as many others) is not a stopping set for this matrix.

The efficiency of the decoding technique based on using the redundant parity-check (RPC) matrix will be demonstrated in Section 4.

3.2. Nonbinary Convolutional Codes

3.2.1. Code Description and Error-Correcting Properties

The advantage of the binary Wyner–Ash codes is high efficiency under very short decoding delay and extremely simple decoding algorithm.

Error-correcting properties can be further improved at the cost of additional decoding complexity if instead of binary digits we consider c-tuples of bits or even entire packets as message symbols.

The corresponding convolutional code will be a code over the Galois field extension GF($2^c$). Generalization of the Wyner–Ash construction to nonbinary alphabets for correcting independent errors and error bursts was presented in [17], where these codes are called “Reed–Solomon (RS) convolutional codes”. Here, we analyze efficiency of these codes when used for correcting erasures or recovering lost packets in the network.

For simplicity, we consider rate $R=(n-1)/n$ codes with memory $m=2$. A semi-infinite parity-check matrix of the code has the form of Equation (2), where the main submatrix in Equation (3) is equal to

$$H^{\left(m\right)}=\left(\begin{array}{c}{H}_0\\ H_1\\ H_2\end{array}\right)=\left(\begin{array}{cccc}1& 1& \cdots & 1\\ 1& \alpha & \cdots & {\alpha }^{n-1}\\ 1& {\alpha }^2& \cdots & {\alpha }^{2(n-1)}\end{array}\right)$$

(12)

and $\alpha$ denotes a primitive element of the field GF($2^c$).

Theorem 1.

If the parity-check matrix of $R=(n-1)/n$, $n\ge 4$ convolutional code over GF($2^c$), $c>{log}_{2}n$, is defined by Equation (2) with submatrices defined by Equation (12), then free distance of the convolutional code is $d_{\mathrm{free}}=4$.

Proof. 

Let $\nu =({\nu }_1,{\nu }_2,.\cdots )$ denote a sequence of numbers of the erased positions on the 1st, 2nd, etc. subblocks of length n. It is enough to prove that any erasure pattern such that

$$\sum _{i=1}^{\infty }{\nu }_i\le 3$$

will be recovered using SW decoding, and there exists an uncorrectable erasure pattern of weight 4. To prove the negative statement, consider the sequence $\mathit{\nu }=(4,0,0,\dots )$. Three parity checks of the matrix in Equation (12) will contain four unknown variables and, therefore, a unique decision does not exist.

To prove that all erasure patterns of three or fewer erasures will be corrected, we show that the following two statements are true:

1.

Any erasure pattern $\mathit{\nu }=({\nu }_1,{\nu }_2,\dots ,{\nu }_N)$ such that ${\nu }_1\le 3$ and ${\nu }_i=0$, $i\ne 1$ for any N will be corrected.

2.

Any erasure pattern $\mathit{\nu }=({\nu }_1,{\nu }_2,\dots ,{\nu }_N)$ such that ${\nu }_i<3$, ${\sum }_i{\nu }_i=3$ will be corrected.

The first property follows from the fact that the corresponding subblock codes are the RS-codes of length $n\ge 4$ and $d_{min}=4$. The second property follows from the fact that any three columns belonging to different subblocks are linearly independent if $c>{log}_{2}n$ and the Vandermond matrix in Equation (12) is non-degenerate [24].

In other words, for the worst case $\mathit{\nu }=(2,1,0,\dots )$, the corresponding columns of the parity-check matrix have the form

$$\left(\begin{array}{ccc}1& 1& 0\\ {\alpha }^i& {\alpha }^j& 1\\ {\alpha }^{2i}& {\alpha }^{2j}& {\alpha }^h\\ 0& 0& {\alpha }^{2h}\end{array}\right)$$

where $i<j<n$, $h<n$. These columns are linearly independent, therefore, correction of such erasure pattern is guaranteed. □

We already proved that uncorrectable erasure patterns of weight four having their ones in one subblock cannot be corrected. In what follows, we show that if four erasures are located in different subblocks then such erasure patterns can always be corrected.

Theorem 2.

If the parity-check matrix of $R=(n-1)/n$, $n\ge 4$ convolutional code over GF($2^c$), $c>2n$, is defined by Equation (2) with submatrices defined by Equation (12), then all erasure patterns of weight four except for the $\left(\genfrac{}{}{0pt}{}{n}{4}\right)$ erasure patterns can be corrected.

Proof. 

According to Property 1 of Theorem 1, all correctable erasure patterns of weight four having their ones in one block cannot be corrected. Thus, there are $\left(\genfrac{}{}{0pt}{}{n}{4}\right)$ uncorrectable erasure patterns.

Now, consider erasure patterns of weight four whose erasures are located in different subblocks. According to the listed above code properties, only combination $\mathit{\nu }=(2,2,0,0\dots )$ requires an additional analysis. The corresponding equations with respect to the unknowns $(z_1,z_2,z_3,z_4)$ are determined by the parity-check matrix

$$\left(\begin{array}{cccc}1& 1& 0& 0\\ {\alpha }^i& {\alpha }^{i\prime }& 1& 1\\ {\alpha }^{2i}& {\alpha }^{2i\prime }& {\alpha }^j& {\alpha }^{j\prime }\\ 0& 0& {\alpha }^{2j}& {\alpha }^{2j\prime }\end{array}\right)$$

(13)

The determinant of Equation (13) is

$$\Delta =({\alpha }^i+{\alpha }^{i\prime })({\alpha }^j+{\alpha }^{j\prime })({\alpha }^i+{\alpha }^{i\prime }+{\alpha }^{j+j\prime })$$

The equality $\Delta =0$ is equivalent to the equality

$${\alpha }^i+{\alpha }^{i\prime }+{\alpha }^{j+j\prime }=0,$$

(14)

and never happens if $c>2n$ since ${\alpha }^{j+j^{\prime }}$, $j+j^{\prime }<2n<c$ is a basis field element and, consequently, it has binary representation of Hamming weight 1. Then, the Hamming weight of the binary representation of the LHS of Equation (14) is equal to either 1 or 3. Therefore, determinant of the system is nonzero and there are no nontrivial solutions of weight less or equal to four. □

More detailed analysis for the case $n=4$ allows computing the generating function of weights of unrecoverable erasure patterns as a function of formal variable D

$$f\left(D\right)=\frac{a\left(D\right)}{b\left(D\right)},$$

where $a\left(D\right)$ and $b\left(D\right)$ are polynomials of degree 20 and 16, respectively. Probability of packet loss after decoding can be expressed via $f\left(D\right)$ as follows

$$P_e=\frac{1}{n}{f\left(D\right)|}_{D=ϵ},$$

(15)

where $ϵ$ is the channel erasure probability. The series expansion of Equation (15) is

$$P_e=\frac{1}{n}\sum _{i=d_{\mathrm{free}}}^{\infty }{f}_i{ϵ}^i,$$

(16)

where $f_i$ denotes the ith coefficient in series expansion of $f\left(D\right)$, that is, the number of uncorrectable erasure patterns of weight i. It was found numerically that for $ϵ\le 1/4$ the first eight coefficients are enough to compute $P_e$ with high precision. The first coefficients $f_i$ in Equation (16) are given in

Table 2. Coefficients of series expansion of $f\left(D\right)$ for the RS convolutional code of rate $R=3/4$.

m	R	Series Expansion Coefficients ${\mathit{f}}_4,\dots ,{\mathit{f}}_{11}$
2	3/4	1, 32, 342, 2282, 8756, 9657, −102562, −773838

.

In what follows, Equation (16), which does not take into account the decoding delay and computed with coefficients from Table 2, is interpreted as the lower bound on the packet loss probability for the RS convolutional codes on the BEC.

3.2.2. Encoding and Decoding for the RS-Convolutional Codes

We do not obtain a generator matrix of the RS-convolutional code. Instead, we construct a codeword in the systematic form calculating a single parity-check symbol of each subblock recursively.

A semi-infinite parity-check matrix of the RS-convolutional code is defined by Equations (2) and (12). The encoding procedure can be simplified by rewriting columns of $H^{\left(m\right)}$ in Equation (12) in the reverse order. In particular, for $R=3/4$ and $n=4$, the reordered matrix has the form

$$H^{\left(m\right)}=\left(\begin{array}{c}{H}_0\\ H_1\\ H_2\end{array}\right)=\left(\begin{array}{cccc}1& 1& 1& 1\\ {\alpha }^3& {\alpha }^2& \alpha & 1\\ {\alpha }^6& {\alpha }^4& {\alpha }^2& 1\end{array}\right)$$

(17)

Denote by

$$\tilde{H}=\left(\begin{array}{ccc}1& 1& 1\\ {\alpha }^3& {\alpha }^2& \alpha \\ {\alpha }^6& {\alpha }^4& {\alpha }^2\end{array}\right)$$

the information part of $H^{\left(m\right)}$. The codeword of the RS-convolutional code over GF($2^c$) can be written in the form ${\mathit{u}}_1,v_1,{\mathit{u}}_2,v_2,\dots$ where ${\mathit{u}}_i=(u_{i1},u_{i2},u_{i3})$ are message blocks consisting of three information symbols from GF($2^c$) and $v_i$ are the corresponding parity-check symbols. Denote by ${\mathit{s}}_i=(s_{i1},s_{i2},s_{i3})={\mathit{u}}_i{\tilde{H}}^{\mathrm{T}}$ a partial syndrome computed for the information block. It is easy to see that the first check symbol $v_1=s_{11}$, the next one depends on $s_{12}$, etc. The following recurrent equations describe encoding for the RS-convolutional code.

$$v_1=s_{1,1},v_2=v_1+s_{1,2}+s_{2,1},$$

$$v_i=v_{i-2}+v_{i-1}+s_{i-2,3}+s_{i-1,2}+s_{i,1},i=3,4,\dots$$

(18)

Notice that, if the field extension parameter $c>n$, then all elements of parity-check matrix in Equation (12) have the Hamming weight 1 and all multiplications in Equation (18) are implemented as simple cyclic shifts.

For the RS-convolutional codes SWML-decoding is implemented similarly to that for the binary WA codes. The difference is that the parity-check matrix is more dense (does not contain zeros on non-trivial positions) and arithmetic operations are performed over the field GF($2^c$).

4. Numerical Results

In this section, we compare the codes and coding techniques described in Section 3. Only $R=3/4$ codes with syndrome memory $m=2$ are studied since they provide the smallest delay and lowest complexity requirements. First, in Section 4.1, we consider a memoryless channel (BEC) and study influence of the code and decoder parameters on the packet-recovering performance. In Section 4.2, we investigate performance of the Wyner–Ash and the RS-convolutional codes in the channel with memory (M-BEC) where packet losses are generated according to the Gilber–Elliott model obtained from the fading channel model as explained in [19,20].

4.1. Memoryless Channel (BEC)

As a channel model, we consider the BEC with erasure (packet loss) probability $ϵ$.

In Figure 3, we compare the probability of packet loss after decoding the Wyner–Ash code by using two decoding methods: the maximum-likelihood SW-decoder (SWML decoder) with delay $L=4$ and subblock length $n=4$ and the SWBP-decoder with one redundant parity check (SWBP-RPC decoding) with delays $L=2$, 3, 4. We do not show the SWML decoding performance for $L=2$ and 3 since the corresponding plots differ negligibly from the plot for $L=4$.

In addition, we present a lower bound on the decoding performance without restrictions on the decoding delay. This bound is obtained from the spectrum of the Wyner–Ash code presented in Table 1. Only the first term is taken into account, and this gives:

$$P_e\ge 18{ϵ}^3/4.$$

(19)

The plots shown in Figure 3 demonstrate that both SWBP-RPC and SWML decoding provide the packet recovering performance rather close to the lower bound. Therefore, the delay value $L=4$ is enough for achieving near optimum performance almost in the entire range of packet loss rates $ϵ$. In addition, we noticed that the decoding performance is not critical with respect to the decoding delay and $L=2$ is an acceptable value. Moreover, a very simple SWBP-RPC decoder performs almost as good as the more complicated (yet simple) SWML decoder requiring Gaussian elimination for correcting erasures.

In Figure 4, we analyze the coding gain from using SWBP-RPC decoding compared to SWBP decoding. We chose decoding delay $L=2$ since it follows from the previous plot that increasing delay does not improve the performance significantly. We conclude from this plot that even the SWBP decoder works very well. However, it is worth using the SWBP-RPC decoder because of an additional gain in performance which can be obtained at the cost of negligible increase in decoding complexity.

In Figure 5, binary and nonbinary (RS) convolutional coding efficiency is compared. Surprisingly, when the decoding delay is small, $L=2$, the two codes have near the same efficiency. However, if the allowed decoding delay grows, the RS convolutional codes become more efficient. We also compare the packet loss probability with the lower bound in Equation (16) achievable without restriction on the decoding delay. Again, we can see that the SWML-decoder for the RS convolutional code achieves near optimal performance already for $L=4$. Notice that, if L grows, then the decoding complexity grows approximately proportional to $L^3$.

It is interesting to compare efficiency of the considered convolutional codes to block codes under the same delay constraints. Delay $L=2$ and 4 correspond to the length of block codes $N=12$ and 20, respectively. The block codes of rate $R_b=3/4$ with the best minimum distance for given length and rate were chosen for comparison.

In Figure 6, the comparison is done for binary codes. The convolutional code with delay $L=2$ provides almost the same efficiency as the block code with code length $N=20$. Moreover, typically, if one erasure occurs, then the SWML decoder outputs the result with delay at most 4, whereas the decoder of block code processes the entire codeword of length 20.

In Figure 7, we can see that the relation between nonbinary RS-block and RS-convolutional codes differs from that for binary codes. The RS-block code of length 12 loses very little compared to the RS-convolutional code. With increasing delay, the advantage of convolutional codes increases. Notice that the decoding complexity for the convolutional code is less than that for the block codes since its parity-check matrix is more sparse.

4.2. Channel with Memory (M-BEC)

In this subsection, we compare performance of the binary WA codes and the RS-convolutional codes on the erasure channel with memory. We model this channel as a discrete approximation of the fading channel. The Rice fading channel model is determined by signal-to-noise ratio $E/N_0$, correlation coefficient $\rho$ and coefficient $k^2$ characterizing the ratio of energies of regular and random components of the received signal. If $k=0$, we obtain the Rayleigh fading channel. We approximate this channel by the Gilbert–Elliott model using technique in [19,20]. See also the tutorial in [30] for overview of approaches to constructing finite-state discrete approximations of analog wireless channel models.

In Figure 8, the same codes with SWML-decoding are compared over the Gilbert–Elliott model approximating the Rayleigh fading with $\rho =0.8$, $\rho =0.9$, and $\rho =0.95$ [19,25]. The decoding performance rapidly degrades with increasing correlation coefficient. Larger delay codes are superior with respect to the codes with $L=2$. The obtained coding gain decreases from 2 dB to 1 dB with increasing $\rho$ from 0.8 to 0.95.

4.3. Probability of Message Successful Delivering for AstaZero Scenario

In Figure 9, the general view of the rural test area of AstaZero is shown. We consider two RSUs that are placed such that, together, they cover most of the test track.

Simulation parameters for Figure 10 are as follows: transmission power 200 mW (23 dBm—maximum allowed power on control ITS-G5 channel), datarate 6 Mbit/s, packet size 400 Bytes, ITS-s generates 1500 msg/s, m = 1 in the Nakagami-m model, simulation time 425 s (time for one full circuit drive on the test track with the constant speed of 50 km/h), and the code rate $R=3/4$. In Figure 10, blue circles demonstrate the packets received before decoding, and red crosses depict packets additionally recovered by the decoder. (For representational purposes, all the points for recovered packets were moved 20 m to the left.) Predictably, the demonstrated performance is best next to each RSU, when ITS-s resides in the production zone. Here, we present the simulated probability of successful delivering $P_{\mathrm{s}}\left(K\right)$ (SDF) determined by Equation (1) as a function of message length K. The WA and RS convolutional codes under SWML decoding are considered. In Figure 11 and Figure 12, we show the SDFs for the WA binary convolutional codes used over the production zone and over the entire session, respectively. In Figure 11 and Figure 12, the SDFs obtained for different code rates and for uncoded transmission are compared. As follows from the presented plots, the lower is the code rate, the better is the reliability of packet delivery that can be achieved. However, it seems that decreasing the code rate below $R=7/8$ does not lead to a significant improvement and this rate can be considered as a reasonable choice. During the production zone, successful delivering of message of length up to 1000 packets is highly probable. For the entire session, only about 10% of long messages will be delivered even for the coded system.

In Figure 13 and Figure 14, we compare the WA codes versus the RS codes for the production zone and for the entire session, respectively. We conclude that the RS codes provide better reliability of the transmission compared to the WA codes but at the cost of higher computational complexity.

Both classes of codes demonstrate high reliability of delivering long message during the production zone.

5. Conclusions

In summary, we have shown that significant gains come through our proposed erasure codes. From the figures of the previous section, it is clear that there is a significant difference in the probability of successful delivery, between codes and uncoded transmissions. Our new algorithm has low delay and low complexity, and is based on Wyner–Ash convolutional codes. We conducted an erasure performance analysis for both these Wyner–Ash convolutional codes, and also for corresponding ones based on Reed–Solomon convolutional codes. Thus, our main recommendation for V2R communications is to apply erasure codes for boosting packet reception rates.

Our future work towards the support of C-ITS safety testing is planned in three main directions.

First is the experimental proof-of-concept validation of the developed inter-packet coding scheme, to be performed at AstaZero.

Secondly, we are planning to propose such inter-packet coding in the ongoing ISO 22133-1 standardization of messages formats and communication protocols for automotive testing facilities.

Finally, we intend to address tighter requirements on decoding delays. The studied coding scheme introduces some delays which are acceptable for non-critical (quasi real-time) VANET scenarios such as maps updates, but these delays are not acceptable for hard real-time data traffic (e.g., the tracking of objects under test). Therefore, designing of appropriate coding schemes which meet the reliability requirements for hard real-time C-ITS applications will be a subject of our future work.