Method for realizing tail-biting Turbo code
By changing the codeword path on Trellis during the Turbo code encoding process, the component code of the Turbo code can achieve tail biting encoding, solving the problems of degradation of existing Turbo code decoding performance and low encoding efficiency, and achieving efficient tail biting encoding.
Patent Information
- Application Number
- CN202411699525.9
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2024-11-26
- Publication Date
- 2025-03-18
AI Technical Summary
During the encoding process, the decoding performance of the existing Turbo code is not accurately known, and the existing tail bit coding method requires the addition of tail bits or precoding, which affects the system efficiency and calculation amount.
By changing the codeword path on Trellis at the last moment of the Turbo code encoding process, the initial state of each component code in the Turbo code is the same as the last state, and tail biting encoding is realized without adding tail bits or pre-encoding.
The tail bit encoding of Turbo code is implemented, avoiding the addition of tail bits and the increase in the calculation amount of precoding, maintaining the decoding performance, and simplifying the encoder structure.
Smart Images
Figure CN119652327A_ABST
Abstract
Description
Technical Field
[0001] The invention belongs to the technical field of channel coding, and in particular relates to a method for realizing a tail-biting Turbo code. Background Art
[0002] In mobile communication systems, due to the diversity of communication environments and the mobility of receivers, the signals received by users are noisy signals superimposed with various noises. When the noise power of the communication link is small, the impact on the receiver is small. For example, in voice communication-based services, a small amount of error in the transmitted information will basically not affect the intelligibility of the voice; when the noise power of the communication link is large, it will have a greater impact on the receiver, and in severe cases, it may even be impossible to transmit useful information. In general, in order to solve the above problems, the information is encoded at the sending end in a way that redundancy is added to the useful information, and the errors that occur during the transmission process are corrected at the receiving end based on this redundant information.
[0003] The process of adding redundancy to information in a communication system is called channel coding, and the process of correcting errors is called channel decoding. With the development of communication systems, many channel coding standards have emerged, such as BCH code, RS code and convolutional code, etc. These codes are based on mathematical models and have rigorous algebraic structures. However, the construction of these codewords does not conform to the random coding idea proposed by Shannon, so the performance of codewords based on algebraic structure is still a certain distance away from the Shannon limit. In 1993, C. Berrou proposed Turbo code. Turbo code cleverly cascades two simple component codes in parallel through a pseudo-random interleaver to construct a code with pseudo-random characteristics, and realizes pseudo-random decoding by repeatedly iterating between the two component decoders. Its performance far exceeds that of codewords with algebraic structure.
[0004] Because Turbo codes have superior decoding performance, they are included in the standards of many communication systems. For example, 3GPP36.212 "Physical Channel Multiplexing and Channel Coding" uses Turbo codes with a code rate of 1 / 3, and Turbo codes use recursive systematic convolution codes as component codes. Unlike traditional convolution codes, this component code introduces feedback, so the final state of the component encoder is related to the input information, which means that the final state cannot be accurately known during component decoding. In this case, the decoding performance will be affected and error flattening will occur, which greatly reduces the decoding effect of the Turbo code and also causes the performance of the receiving end to deteriorate.
[0005] For the existing technical solution, 3GPP36.212 "Physical Channel Multiplexing and Channel Coding" provides a method for clearing the component code register in the Turbo encoder. This method requires adding tail bits after the information bit, so that the final state of each encoding is 0. That is, the existing tail-biting Turbo coding is mainly implemented by adding tail bits or precoding to the data information. However, there are the following defects: 1. Since data containing tail bits must be sent, the number of bits carrying valid information in the sequence is reduced, which reduces the effectiveness of the entire system and data throughput; 2. Although the method of adding tail bits can achieve tail-biting coding, it can only start coding from the initial 0 state and end at the 0 state; 3. The precoding method does not require tail bits, but it is necessary to precode the information to be coded, and the precoding process increases the amount of calculation, which means that the increase in power consumption does not meet the concept of "green communication" proposed by future mobile communications. At the same time, this precoding method has certain requirements on the length of the information bit, which further limits its application.
[0006] In view of this, the present invention is proposed. Summary of the invention
[0007] In order to solve the problems in the prior art, this invention proposes a method for implementing a tail-biting Turbo code, starting from the Trellis (grid diagram) corresponding to the Turbo code, and analyzing the path of the codeword on the Trellis. At the last moment of encoding, the corresponding Trellis is changed to change the final codeword path, and finally reach the same state as the initial moment. There is no need to add a special tail bit to clear the shift register, nor is there a need to specify the initial state of the encoding by a pre-coding method. It has the advantages of simple structure, no change in the encoder structure, and no loss of decoding performance.
[0008] The present invention provides a method for implementing a tail-biting Turbo code, which makes the initial state and final state of each component code in the Turbo code the same by changing the codeword path on the Trellis corresponding to the last moment in the Turbo code encoding process.
[0009] Furthermore, performing tail biting encoding on the component codes of the Turbo code specifically includes the following steps:
[0010] Step 1: Let the sequence to be encoded X = (x 0 ,x 1 ,L,x k-1 ), a component encoder with feedback, wherein the component encoder comprises q registers, and sets the encoding target: performing tail-biting encoding of the component code;
[0011] Step 2, initialize the sequence X to be encoded: reverse the last q bits of the sequence X to be encoded and fill them into the register as the initial state, and the encoding time t = 0;
[0012] Step 3: Encode the sequence X to be encoded:
[0013] When t>kq, encoding is performed bit by bit according to the connection characteristics of the encoder.
[0014] When t ≥ kq, the feedback connection is disconnected and encoding is performed bit by bit according to the characteristics of the disconnected connection;
[0015] Step 4: When t=k, the encoding is terminated to implement the tail-biting encoding of the component code.
[0016] Furthermore, the Trellis of the component code is constructed based on the state transition table of the register, and the Trellis of the component code is composed of the Trellis with feedback stage and the Trellis without feedback stage. The Trellis of the feedback stage is T A , the Trellis in the non-feedback stage is T B , when T B =T A When the tail biting Trellis is achieved.
[0017] Furthermore, the continuous and uninterrupted paths on the Trellis correspond to the paths corresponding to the concatenated codewords.
[0018] Furthermore, component code decoding of the Turbo code is performed on a mixed Trellis, the Trellis of the tail-biting codeword is expanded, N sections are respectively expanded on the left and right sides of the Trellis corresponding to the main codeword, and decoding is performed on the Trellis expanded by N sections.
[0019] Furthermore, during the decoding process, the initial state and the final state on the hybrid Trellis are set to be of equal probability.
[0020] Furthermore, the decoding adopts the maximum a posteriori probability decoding algorithm based on Trellis - BCJR decoding algorithm, and the decoding process includes: edge metric calculation, forward recursion, backward recursion and information extraction steps.
[0021] Furthermore, in the information extraction step, only information corresponding to the main codeword is extracted.
[0022] Compared with the prior art, the implementation method of the tail-biting Turbo code provided by the present invention does not need to add special tail bits to clear the shift register, nor does it need to specify the initial state of the encoding through a pre-coding method. It has the advantages of simple operation structure, no change in the encoder structure, and no loss in decoding performance. BRIEF DESCRIPTION OF THE DRAWINGS
[0023] Figure 1It is a schematic diagram of the structure of a Turbo encoder in the prior art;
[0024] Figure 2 is a schematic diagram of the state of the register of the component encoder when t=0 in an embodiment of the present invention;
[0025] Figure 3 1 is a schematic diagram of the state of the register of the component encoder when t=k-4 in an embodiment of the present invention;
[0026] Figure 4 1 is a schematic diagram of the state of the register of the component encoder when t=k-3 in an embodiment of the present invention;
[0027] Figure 5 1 is a schematic diagram of the state of the register of the component encoder when t=k-2 in an embodiment of the present invention;
[0028] Figure 6 1 is a schematic diagram of the state of the register of the component encoder when t=k-1 in an embodiment of the present invention;
[0029] Figure 7 1 is a schematic diagram of the state of the register of the component encoder when t=k in an embodiment of the present invention;
[0030] Figure 8 is a Trellis schematic diagram of a tail biting component encoder in an embodiment of the present invention;
[0031] Fig. 9 It is a decoding block diagram of Turbo code in the prior art;
[0032] Fig.10 It is a schematic diagram of the expansion of the tail-biting codeword of three cascaded codewords on Trellis in an embodiment of the present invention. DETAILED DESCRIPTION
[0033] The present invention is further explained below in conjunction with the drawings and specific embodiments of the specification. Obviously, the described embodiments are part of the embodiments of the present application, rather than all of the embodiments. Based on the embodiments in the present application, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present application.
[0034] Combined with Figure 1 , firstly, the Turbo encoder in the prior art is described.
[0035] The turbo encoder is obtained by parallel operation of two or more convolutional codes, and the generating polynomials of each convolutional code can be the same or different. Since the system code directly contains useful information, the information bits can be directly output when the noise is relatively small (the signal-to-noise ratio is high), so the recursive system convolutional code (RSC) is usually selected as the component code in the turbo encoder. Figure 1 The block diagram of a turbo encoder with two component codes is given. The symbols in the figure are represents modulo 2 addition. The Turbo encoder consists of an interleaver, component encoder 1 and component encoder 2. The two component encoders use the same generating polynomial. The bit vector to be encoded X = (x 0 ,x 1 ,L,x k-1 ) is divided into three paths in parallel, where k is the number of information bits. One path is directly output without any processing. Obviously C 0 =X; the other path is encoded by component encoder 1 to obtain There is also an interleaved output Then will Send to component encoder 2 for encoding C 0 It is called the information bit (systematic) vector, and C 1 and C 2 It is called the parity vector. The generated codeword matrix is
[0036]
[0037] Generally, encoding starts from the register state of all 0s (0,0,0,0), i.e., state 0. Strictly speaking, the two component encoders can start from any state, and the two can take different initial states independently of each other at the same time. For example, component encoder 1 can start encoding component code 1 from the initial state (1,0,0,0), i.e., state 8, while component encoder 2 can start encoding component code 2 from the initial state (1,0,1,0), i.e., state 10. For simplicity, the register state at time t is recorded as S t .
[0038] In the communication system, the codeword generated by the encoder is usually given in the form of a one-dimensional vector. The final codeword is output from the codeword matrix in the order from top to bottom and from left to right. The ratio of the number of information bits to the number of bits after coding is called the coding rate. According to the above coding rules, the Turbo code rate is 0.3333. In order to flexibly change the code rate to adapt to different communication scenarios, it is necessary to puncture the codeword matrix. The puncturing operation is only for the check bits. For example, the puncturing matrix is 1 means keep, 0 means remove. The punctured codeword matrix obtained after puncturing the codeword matrix is: Assuming k is an even number
[0039]
[0040] Then the final output codeword after puncturing is The bit rate is 0.5.
[0041] The function of the interleaver is to disrupt the order of the input information so that the codewords output by the two component encoders are unrelated. Figure 1 The input of the interleaver is X = (x 0 ,x 1 ,L,x k-1 ) and output have The symbol Π represents interleaving, the symbol Π -1 Although the inputs of the two component encoders are different, the amount of information contained in the encoded codewords is exactly the same.
[0042] From the coding block diagram of Turbo code, we can see that its component codes use recursive systematic convolutional codes, in which feedback is introduced, such as Figure 1 As shown by the bold arrow in the figure. That is, the variables in the register are used as input components again after operation (modulo 2 addition), so the variables at point A (point B) at a certain moment are related to the inputs at all moments before this moment. This leads to the final state S of the component encoder. k is the initial state S 0 and the entire input information X or The function of S k =f(S 0 ,X). In order to construct the tail-biting Turbo code, it is necessary to solve S k =S 0 =f(S 0 ,X), since the length and content of the input information X are unknown and the function f changes with the structure of the component encoder, there may be no solution. At the same time, there is no fixed pattern or method to solve the above function.
[0043] Based on the problems existing in the prior art, according to an embodiment of the present invention, the present invention provides a method for implementing tail-biting Turbo coding, the key of which is to implement tail-biting coding of component encoders. The following will focus on how component encoder 1 implements tail-biting coding, and the method is also applicable to component encoder 2.
[0044] The present invention is described in detail by taking the component encoder 1 having 4 registers as an example.
[0045] Assume that there is input information X=(x 0 ,x 1 ,L,x k-1 ), at time t = 0, the last few bits of information X are reversed and filled into the register, such as Figure 2 As shown. That is to say, the encoder changes from the initial state S 0 =(x k-1 ,x k-2 ,x k-3 ,x k-4 ) is encoded. Then the check bits are obtained in sequence according to the logical order of the component encoders.
[0046] When t≥k-4, the feedback connection of the component encoder is disconnected, that is, there is no feedback state, so the value of point A has nothing to do with the register state but only with the input, that is, the value of point A is equal to the input, so the final state of the component encoder can be controlled. Figures 3 to 7 It can be seen that the final state of the register after encoding is S k =(x k-1 ,x k-2 ,x k-3 ,x k-4 ) and the initial state S 0 Exactly the same, at this time, the component code of the Turbo code realizes tail-biting coding.
[0047] According to an embodiment of the present invention, for a Trellis of a component code constructed based on a state transition table of a register, a Trellis of a component code is composed of a Trellis with a feedback phase and a Trellis without a feedback phase, and the Trellis without a feedback phase is T A , the Trellis in the non-feedback stage is T B , when T B =T A When the tail biting Trellis is realized, the tail biting coding of Trellis specifically includes the following steps:
[0048] by Figure 1 Taking the component code in the given encoding block diagram as an example, the Trellis with feedback stage, the state transition table of the register with feedback is shown in Table 1. There are 4 registers in the figure, with a total of 2 4There are 3 states, namely (0000, 0001, 0010, 0011, ..., 1110, 1111). For simplicity, state 0000 is recorded as state 0, state 1000 is recorded as state 8, and so on. When the state is 0 (0000) and the input is bit 0, the output is c 1 =0, and the state of the register is updated to 0 (0000); when the state is 1 (0001) and the input is bit 1, the output is c 1 =1, and the register status is updated to 0 (0000), etc. Therefore, it can be represented by Table 1. Similarly, for Figure 3 The component code is Trellis without feedback stage, and also has 2 4 The state can be expressed by Table 2. The state transfer table of the register without feedback is shown in Table 2.
[0049]
[0050]
[0051] Trellis can be constructed based on the state transition table. The concatenation of the Trellis in the above two cases with and without feedback constitutes the Trellis of the component code. Figure 8 For the convenience of expression, the Trellis with feedback stage is denoted as T A , the Trellis without feedback is denoted as T B The codeword of the component tail-biting coding is a path on the cascaded Trellis. In order to clearly express how to implement tail-biting coding, a specific example is given here. Assuming the information to be encoded is (0 1 1 0 1 00 1 0), the tail-biting coding process is as follows:
[0052] First, the last 4 bits 0010 are inverted to get 0100, that is, the tail-biting encoding starts from state 4.
[0053] Then, based on the state transition table with feedback, referring to Table 1, it can be seen that at the initial time t=0, when the input bit is 0 in state 4, the output is 1, and the state is reached at the same time 10; when the input bit is 1 in state 10 at time t=1, the output is 1, and the state is reached at the same time 13, and so on;
[0054] Next, when t=5, there are still 4 bits to be encoded. In order to achieve tail biting, Trellis is composed of T A From to T B .
[0055] Finally, based on the state transition table without feedback, referring to Table 2, it can be seen that when the state is 9 at time t=5, if bit 0 is input, 0 is output and the state is reached at the same time; when the state is 4 at time t=6, bit 0 is input, 0 is output and the state is reached at the same time; and so on and so forth, it finally returns to state 4 at time t=9.
[0056] From the above, we can see that a codeword is a continuous and uninterrupted path on Trellis. It can also be said that all codewords corresponding to continuous and uninterrupted paths on Trellis are qualified codewords encoded from a certain information vector.
[0057] According to an embodiment of the present invention, component code decoding of a Turbo code is performed on a hybrid Trellis, the Trellis of the tail-biting codeword is expanded, N sections are expanded on the left and right sides of the Trellis corresponding to the main codeword, and decoding is performed on the Trellis expanded by N sections. The specific steps include:
[0058] First, for the decoding process of Turbo code, refer to Fig. 9 As shown, the Turbo decoder receives the log likelihood ratio (LLR) and in, The log-likelihood ratio corresponding to the system information; The log-likelihood ratio of the check bit information corresponding to component decoder 1; The log-likelihood ratio of the check bit information of the corresponding component decoder 2. MAP decoder 1 uses the system information and verification information And the prior information (Prior) provided by decoder 2 to decoder 1 Decoding is performed, and the output information is the log-likelihood ratio λ of the bit vector X given by decoder 1 (1) (x t |r), and then remove known system information and prior information After that, the external information output by decoder 1 is obtained Decoder 2 uses the external information output by decoder 1 as prior information after interleaving. Combined with the system information corresponding to component decoder 2 and verification information Decoding is performed, and the output information is the log-likelihood ratio λ of the bit vector given by decoder 2 (2) (x Π(t) |r), the difference is that the order is interleaved. Then remove the known system information and prior information After that, the external information output by decoder 2 is obtained. The information after the deinterleaver is used as the prior information of decoder 1 in the next iteration.
[0059] According to the embodiment of the present invention, the tail-biting coding method provided by the present invention needs to use two different Trellis codes, so it is different from the traditional decoding based on fixed Trellis codes. Here, the decoding of the component codes is performed on the mixed Trellis codes.
[0060] The characteristic of the tail-biting codeword is that the initial state is equal to the final state, that is, the state of the register after the encoding is completed is exactly the same as the initial encoding time. At this time, if the information to be encoded is encoded again, it is equivalent to the repetition of the complete codeword. At the same time, since the initial and final states are the same, the cascade of the two codewords is still a qualified codeword, that is, the path is continuous and uninterrupted. Figure 6 As shown in the figure, three codeword cascades are given, and the continuous and uninterrupted path in the corresponding Trellis is the path corresponding to the cascade codeword. The Trellis corresponding to the unshaded part in the figure is T A , the Trellis corresponding to the shaded part is T B .
[0061] In order to decode the tail-biting codeword, the Trellis is expanded. N sections are expanded on both sides of the Trellis corresponding to the main codeword, such as Fig.10 As shown, decoding is performed on the Trellis with N sections expanded, and finally only the information corresponding to the main codeword is extracted. The decoding adopts the BCJR decoding algorithm, a maximum a posteriori probability decoding algorithm based on Trellis with soft output. The main process is edge metric calculation, forward recursion, backward recursion and information extraction. This algorithm is a mature algorithm, and you can refer to relevant materials and will not repeat it here.
[0062] According to an embodiment of the present invention, the main codeword refers to the information to be encoded X=(x 0 ,x 1 ,L,x k-1 ) is the codeword obtained by Turbo coding. When decoding, the main codeword needs to be expanded left and right.
[0063] According to an embodiment of the present invention, during the decoding process, the initial state and the final state on the mixed Trellis are set to be equal in probability.
[0064] As can be seen from the above, the implementation method of the tail-biting Turbo code provided by the present invention starts from the Trellis (trellis diagram) corresponding to the Turbo code and analyzes the path of the codeword on the Trellis. At the last moment of encoding, the corresponding Trellis is changed to change the last codeword path, and finally reaches the same state as the initial moment.
[0065] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, rather than to limit it. Although the present invention has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or replace some or all of the technical features therein with equivalents. However, these modifications or replacements do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the embodiments of the present invention.
Claims
1. A method for implementing a tail-biting Turbo code, characterized in that: By changing the codeword path corresponding to the Trellis at the last moment in the Turbo code encoding process, the initial state and the final state of each component code in the Turbo code are made the same.
2. The method for implementing tail-biting Turbo codes according to claim 1, characterized in that: The tail biting encoding of the component codes of the Turbo code specifically includes the following steps: Step 1: Let the sequence to be encoded X = (x0, x1, L, x k-1 ), a component encoder with feedback, wherein the component encoder comprises q registers, and sets the encoding target: performing tail-biting encoding of the component code; Step 2, initialize the sequence X to be encoded: reverse the last q bits of the sequence X to be encoded and fill them into the register as the initial state, and the encoding time t = 0; Step 3: Encode the sequence X to be encoded: When t>kq, encoding is performed bit by bit according to the connection characteristics of the encoder. When t ≥ kq, the feedback connection is disconnected and encoding is performed bit by bit according to the characteristics of the disconnected connection; Step 4: When t=k, the encoding is terminated to implement the tail-biting encoding of the component code.
3. The method for implementing a tail-biting Turbo code according to any one of claims 1 to 2, characterized in that: The Trellis of the component code is constructed based on the state transition table of the register. The Trellis of the component code is composed of the Trellis with feedback stage and the Trellis without feedback stage. The Trellis of the feedback stage is T A , the Trellis in the non-feedback stage is T B , when T B =T A When the tail biting Trellis is achieved.
4. The method for implementing tail-biting Turbo codes according to claim 3, characterized in that: The continuous and uninterrupted paths on the Trellis correspond to the paths corresponding to the concatenated codewords.
5. The method for implementing tail-biting Turbo codes according to claim 1, characterized in that: The component code decoding of the Turbo code is performed on the mixed Trellis. The Trellis of the tail-biting codeword is expanded, and N sections are respectively expanded on the left and right sides of the Trellis corresponding to the main codeword, and decoding is performed on the Trellis expanded by N sections.
6. The method for implementing tail-biting Turbo codes according to claim 5, characterized in that: During the decoding process, the initial state and the final state on the mixed Trellis are set to be equally probable.
7. The method for implementing tail-biting Turbo codes according to claim 5, characterized in that: The decoding adopts the maximum a posteriori probability decoding algorithm based on Trellis - BCJR decoding algorithm. The decoding process includes: edge metric calculation, forward recursion, backward recursion and information extraction steps.
8. The method for implementing tail-biting Turbo codes according to claim 7, characterized in that: In the information extraction step, only the information corresponding to the main codeword is extracted.