DE102019200256B4 - Verschachteler - Google Patents

Abstract

Ausführungsbeispiele stellen einen Verschachteler zum Verschachteln einer LDPC-codierten Bitfolge bereit, wobei der Verschachteler eine Segmentierungsstufe, die konfiguriert ist, um die LDPC-codierte Bitfolge in eine Mehrzahl von Segmenten zu segmentieren, wobei die Mehrzahl von Segmenten ein erstes Segment und ein oder mehrere andere Segmente aufweist, eine erste Verschachtelerstufe, die konfiguriert ist, um das eine oder die mehreren anderen Segmente oder eine verkettete Version derselben zu verschachteln, eine zweite Verschachtelerstufe, die konfiguriert ist, um das erste Segment der Mehrzahl von Segmenten und eine verschachtelte Bitfolge, die durch die erste Verschachtelerstufe bereitgestellt wird, blockweise zu verschachteln, um eine verschachtelte Version der LDPC-codierten Bitfolge zu erhalten, umfasst, wobei das erste Segment der Mehrzahl von Segmenten aus Bits eines ersten Typs besteht, wobei die Bits des ersten Typs Fehlerkorrekturbits der LDPC-codierten Bitfolge sind, Wiederholungsakkumulationsbits der LDPC-codierten Bitfolge sind und/oder in einer Tanner-Diagramm-Darstellung der LDPC-codierten Bitfolge durch variable Knoten dargestellt sind, die Nicht-Zufalls-Verbindungen zu mindestens zwei Fehlerkorrektur-Kontrollknoten aufweisen.

Description

• Ausführungsbeispiele beziehen sich auf einen Verschachteler (Interleaver), genauer gesagt auf einen Verschachteler für ein mit einem LDPC (LDPC = Low-Density Parity-Check Code; Paritätskontrollcode mit geringer Dichte) codiertes Codewort. Weitere Ausführungsbeispiele beziehen sich auf einen Hybrid-Blockweise-Zufalls-Verschachteler zur iterativen entscheidungsorientierten Kanalschätzung von LDPC-Codewörtern mit Treppenknotenverteilung.
• Low-Density Parity-Check Codes (LDPC; Paritätskontrollcodes mit geringer Dichte) gelten aufgrund ihrer spektakulären Leistung und relativ geringen Komplexität als Durchbruch im Bereich der digitalen Kommunikation. Ihre kapazitätsnahe Leistung macht sie für eine Mehrzahl von Anwendungen attraktiv, die Robustheit und Zuverlässigkeit erfordern. Darüber hinaus erleichtert ihre spärliche Natur die Decodierung mit Belief Propagation (BP; Glauben-Ausbreitung) in Tanner-Diagrammen.
• Ein Ausgangspunkt eines LDPC-Decodierers ist die Berechnung der apriori-Log Likelihood Ratios (-LLRs; Log-Plausibilitäts-Verhältnisse). Zu diesem Zweck sollten die Kanal-Fading-Koeffizienten (Fading = Schwund oder Abklingen) mittels einer bekannten Präambelsequenz geschätzt und dem LDPC-Decodierer zugeführt werden. Die Präambel ist jedoch nur in der Lage, kurzfristige Informationen über den Abkling-Kanal zu liefern. Das bedeutet, dass nur die ersten benachbarten Koeffizienten geschätzt werden können. Infolgedessen würden die übrigen Symbole keine Kanalzustandsinformationen (CSI; Channel State Information) enthalten. Mit anderen Worten, der LDPC-Decodierer wäre in der Lage, die apriori-LLRs der ersten paar Symbole zu berechnen, während die restlichen Symbole als Löschungen behandelt würden. Diese Löschungen machen es unmöglich, die BP-Decodierung des LDPC auszulösen.
• Einerseits würde eine Erhöhung der Anzahl von Pilotsymbolen zu einer längeren Spanne der Kanalschätzung führen. Folglich konnten mehr Abkling-Koeffizienten geschätzt und dem LDPC-Decodierer zur Verfügung gestellt werden, was zu einer besseren Leistung führt. Andererseits würde diese Leistungssteigerung zu Lasten einer reduzierten effektiven Datenrate aufgrund der Übertragung von mehr Nicht-Daten-Pilotsymbolen gehen.
• LDPC-Codes können durch ihr Tanner-Diagramm beschrieben werden. Ein (n,k)-LDPC-Code hat n variable Knoten, die die n codierten Bits darstellen, und n - k Kontrollknoten, die die Paritätskontrollgleichungen darstellen. Ein systematischer LDPC-Code würde seine k Informationsbits auf die ersten k variablen Knoten abbilden. Die restlichen n - k variablen Knoten ähneln den n - k Paritätsbits. Die Verbindungen zwischen den variablen Knoten und den Kontrollknoten erfolgen gemäß der Paritätskontrollmatrix des gegebenen LDPC-Codes.
• Eine Klasse von LDPC-Codes, wie die für das kommende IEEE 802.15.4w [1] vorgeschlagenen Codes und die im DVB-NGH-Standard übernommenen Codes, ist mit einer Treppenknotenverteilung ausgestattet. Das bedeutet, dass, mit Ausnahme der ersten k variablen Knoten, die den systematischen Informationsteil darstellen, die Verbindungen der variablen Knoten und der Kontrollknoten einer Treppenform folgen. Mit anderen Worten, jeder variable Knoten ist mit zwei aufeinanderfolgenden Kontrollknoten verbunden. Der (k + 1)^te variable Knoten ist mit dem ersten und dem zweiten Kontrollknoten verbunden. Der (k + 2)^te variable Knoten ist mit dem zweiten und dem dritten Kontrollknoten verbunden, usw. Der nte variable Knoten ist mit dem (n - k)^ten Kontrollknoten verbunden.
• 1 zeigt ein Beispiel eines Tanner-Diagramms 10 für einen (736,184)-LDPC-Code, vorgeschlagen in [3], mit einer Code-Rate r = 1/4. Es hat n = 736 variable Knoten 12 und n - k = 552 Kontrollknoten 14. Die ersten k variablen Knoten 12 entsprechen dem systematischen Informationsteil. Ihr Knotengrad steigt auf bis zu d = 10 und sie besitzen Zufalls-Verbindungen 16 zu den Kontrollknoten 14. Mit Ausnahme des letzten variablen Knotens weisen die verbleibenden 551 variablen Knoten eine Treppenverbindung zu den entsprechenden Kontrollknoten 14 auf und sind vom Grad d = 2.
• Ein LDPC-Code mit einer Treppenknotenverteilung ist anfällig für Decodierungsfehler, wenn der Kanalschätzer CSI über wenige Symbole liefert. Der Grund für diese Leistungsverschlechterung liegt im Verbindungsmuster der Kontrollknoten zu den entsprechenden variablen Knoten. Zum Beispiel ist für den (736,184)-Code, mit Ausnahme des ersten Kontrollknotens, jeder von ihnen vom Grad d = 4. Jeder Kontrollknoten ist nach dem Zufallsprinzip mit zwei variablen Knoten aus den ersten k variablen Knoten verbunden. Die restlichen beiden Ränder folgen der Treppenkonstruktion über die aufeinanderfolgenden variablen Knotenverbindungen. Das bedeutet, dass eine kurze Präambelsequenz nur Informationen über die ersten paar Bits des systematischen Teils liefern würde. Damit bleiben alle Kontrollknoten des Tanner-Diagramms mit mindestens zwei gelöschten LLRs übrig, die von ihren entsprechenden variablen Knoten empfangen werden. Folglich könnte der BP-Decodierungsalgorithmus nicht gestartet werden.
• Daher besteht die Aufgabe der vorliegenden Erfindung darin, ein Konzept bereitzustellen, das die Machbarkeit des Belief Propagation(BP)-Decodierungsalgorithmus eines LDPC auch bei einer begrenzten Anzahl von geschätzten Abkling-Koeffizienten ermöglicht.
• Die US 2018/0302107 A1 beschreibt ein Datenverarbeitungsverfahren, welches eine LDPC-Encodierung nutzt, um ein Signal-Rausch-Leistungsverhältnis zu reduzieren.
• Die WO 2018/017225 A1 beschreibt Verfahren für eine drahtlose Kommunikation, bei dem eine zweistufige Kanalverschachtelung durchgeführt wird, um Codeblöcke auf Codeblockebene und auf Symbolebene zu verschachteln.
• Die EP 2 566 057 A1 beschreibt ein Bit-Verschachtelungsverfahren zum Verschachteln von Bits eines Codeworts, das auf Grundlage eines quasizyklischen Paritätsprüfcodierungsschemas mit geringer Dichte einschließlich eines quasizyklischen Wiederhol-Akkumulations-Paritätsprüfcodierungsschemas mit geringer Dichte erzeugt ist.
• Diese Aufgabe wird durch die unabhängigen Ansprüche gelöst.
• Vorteilhafte Implementierungen sind Gegenstand der abhängigen Ansprüche.
• Ausführungsbeispielen stellen einen Verschachteler zum Verschachteln einer LDPC-codierten Bitfolge bereit, wobei der Verschachteler eine Segmentierungsstufe, die konfiguriert ist, um die LDPC-codierte Bitfolge in eine Mehrzahl von Segmenten (Chunks) [z.B. gleich lang] zu segmentieren, wobei die Mehrzahl von Segmenten ein erstes Segment und ein oder mehrere andere Segmente [z.B. ein zweites Segment und optional ein drittes Segment] umfasst, eine erste Verschachtelerstufe, die konfiguriert ist, um das eine oder die mehreren anderen Segmente oder eine verkettete Version derselben zu verschachteln [zum Beispiel, um das zweite Segment und optional das dritte Segment zu verschachteln, oder um eine verkettete Version des zweiten Segments und des dritten Segments zu verschachteln], und eine zweite Verschachtelerstufe umfasst, die konfiguriert ist, um das erste Segment der Mehrzahl von Segmenten und eine verschachtelte Bitfolge, die von der ersten Verschachtelerstufe bereitgestellt wird, blockweise zu verschachteln, um eine verschachtelte Version der LDPC-codierten Bitfolge zu erhalten, wobei das erste Segment der Mehrzahl von Segmenten aus Bits eines ersten Typs besteht [z.B. nur diese umfasst], wobei die Bits des ersten Typs
• - Fehlerkorrekturbits der LDPC-codierten Bitfolge sind,
• - Wiederholungsakkumulationsbits der LDPC-codierten Bitfolge sind und/oder
• - in einer Tanner-Diagramm-Darstellung der LDPC-codierten Bitfolge durch variable Knoten dargestellt sind, die Nicht-Zufalls-Verbindungen zu mindestens zwei Fehlerkorrektur-Kontrollknoten aufweisen [z.B. ist jeder der variablen Knoten mit zwei aufeinanderfolgenden Kontrollknoten verbunden].
• Bei Ausführungsbeispielen umgeht das erste Segment die erste Verschachtelerstufe (z.B. wird das erste Segment nicht von der ersten Verschachtelerstufe verschachtelt).
• Bei Ausführungsbeispielen besteht ein Segment [z.B. das zweite Segment] des einen oder der mehreren anderen Segmente aus Bits eines zweiten Typs, wobei die Bits des zweiten Typs
• - Informationsbits der LDPC-codierten Bitfolge sind [und z.B. verbleibende Fehlerkorrekturbits der LDPC-codierten Bitfolge] und/oder
• - in einer Tanner-Diagramm-Darstellung der LDPC-codierten Bitfolge durch variable Knoten dargestellt sind, die Pseudozufallsverbindungen zu Fehlerkorrektur-Kontrollknoten umfassen.
• Bei Ausführungsbeispielen sind das eine oder die mehreren anderen Segmente zwei oder mehr andere Segmente, wobei ein anderes Segment [z.B. das dritte Segment] der zwei oder mehr anderen Segmente aus Bits des ersten Typs besteht.
• Bei Ausführungsbeispielen ist die erste Verschachtelerstufe ein Pseudozufalls-Verschachteler.
• Bei Ausführungsbeispielen basiert der Pseudozufalls-Verschachteler auf einem linearen Schieberegister.
• Bei Ausführungsbeispielen ist der Pseudozufalls-Verschachteler ein Blockweise-Verschachteler.
• Bei Ausführungsbeispielen ist die erste Verschachtelerstufe konfiguriert, um das eine oder die mehreren anderen Segmente [z.B. eine verkettete Version der anderen Segmente] basierend auf der folgenden Syntax zu verschachteln:

  

  wobei j eine Steuervariable darstellt, wobei N_chunks die Anzahl der Mehrzahl von Segmenten darstellt, in die die LDPC-codierte Bitfolge segmentiert ist, wobei N_bits/chunk die Anzahl der Bits pro Segment darstellt, wobei ${\widetilde{\text{Ch}}}_{\text{0}\to {\text{N}}_{\text{chunks}}-1\backslash 1}$

  

  die verschachtelte Bitfolge [z.B. eine verschachtelte Version (von einer verketteten Version) des einen oder der mehreren anderen Segmente darstellt], wobei Ch_{0→N chunks-1\1} eine verkettete Version des einen oder der mehreren anderen Segmente darstellt, wobei π einen Permutationsindizes-Vektor eines Linear-Rückkopplungs-Schieberegisters darstellt.
• Bei Ausführungsbeispielen ist die zweite Verschachtelerstufe ein Blockweise-Verschachteler.
• Bei Ausführungsbeispielen ist die zweite Verschachtelerstufe konfiguriert, um die verschachtelte Version der LDPC-codierten Bitfolge über eine Mehrzahl von Teildatenpaketen zu verteilen.
• Bei Ausführungsbeispielen ist die zweite Verschachtelerstufe konfiguriert, um Bits des ersten Segments der Mehrzahl von Segmenten blockweise über die Mehrzahl von Teildatenpaketen in mindestens zwei Runden zu verteilen [z.B. so, dass in einer ersten Runde aufeinanderfolgende Blöcke von Bits [z.B. von zwei Bits] des ersten Segments zyklisch auf die Mehrzahl von Teildatenpaketen abgebildet werden, und in einer zweiten Runde weitere aufeinanderfolgende Blöcke von Bits [z.B. von zwei Bits] des ersten Segments zyklisch auf die Mehrzahl von Teildatenpaketen abgebildet werden].
• Bei Ausführungsbeispielen ist die zweite Verschachtelerstufe konfiguriert, um Bits der von der ersten Verschachtelerstufe bereitgestellten verschachtelten Bitfolge gleichmäßig blockweise über die Mehrzahl von Teildatenpaketen zu verteilen [z.B. wird die Mehrzahl von Teildatenpaketen gleichmäßig mit Bits der von der ersten Verschachtelerstufe bereitgestellten verschachtelten Bitfolge aufgefüllt].
• Bei Ausführungsbeispielen ist die zweite Verschachtelerstufe konfiguriert, um das erste Segment und die von der ersten Verschachtelerstufe bereitgestellte verschachtelte Bitfolge basierend auf der folgenden Syntax zu verschachteln:

  

  wobei i eine Steuervariable darstellt, wobei j eine Steuervariable darstellt, wobei k eine Steuervariable darstellt, wobei N_chunks eine Anzahl von Segmenten darstellt, in die die LDPC-codierte Bitfolge segmentiert ist, wobei N_hops eine Anzahl von Teildatenpaketen darstellt, über die die verschachtelte Version der LDPC-codierten Bitfolge verteilt ist, wobei ${\text{N}}_{\text{bits}/\text{round}}^{\left(1\right)}$

  

  eine Anzahl von Bits pro Runde darstellt, die aus dem ersten Segment entnommen und über die Mehrzahl von Teildatenpaketen verteilt werden, wobei N_bits/hop eine Anzahl von Bits pro Teildatenpaket darstellt, wobei ṽ die verschachtelte Version der LDPC-codierten Bitfolge darstellt, wobei Ch₁ das erste Segment darstellt, wobei ${\widetilde{\text{Ch}}}_{\text{0}\to {\text{N}}_{\text{chunks}}-1\backslash 1}$

  

  die verschachtelte Bitfolge darstellt [z.B. eine verschachtelte Version (von einer verketteten Version) des einen oder der mehreren anderen Segmente].
• Bei Ausführungsbeispielen ist eine Anzahl der Mehrzahl von Segmenten, in die die LDPC-codierte Bitfolge segmentiert ist, gleich eins geteilt durch die Code-Rate der LDPC-codierten Bitfolge N_Chunks=1/r].
• Bei Ausführungsbeispielen ist die Segmentierungsstufe konfiguriert, um die LDPC-codierte Bitfolge 102 basierend auf der folgenden Syntax in die Mehrzahl von Segmenten zu segmentieren:

  

  wobei i eine Steuervariable darstellt, wobei j eine Steuervariable darstellt, wobei N_chunks eine Anzahl von Segmenten darstellt, in die die LDPC-codierte Bitfolge segmentiert ist, wobei N_bits/chunk die Anzahl der Bits pro Segment darstellt, wobei Ch_i jedes der Mehrzahl von Segmenten darstellt, und wobei v die LDPC-codierte Bitfolge darstellt.
• Bei Ausführungsbeispielen sind das eine oder die mehreren anderen Segmente zwei oder mehr andere Segmente, wobei die erste Verschachtelerstufe konfiguriert ist, um eine verkettete Version der zwei oder mehr anderen Segmente zu verschachteln.
• Bei Ausführungsbeispielen umfasst der Verschachteler eine Verkettungsstufe, die konfiguriert ist, um die zwei oder mehr anderen Segmente zu verketten, um die verkettete Version der zwei oder mehr anderen Segmente zu erhalten.
• Bei Ausführungsbeispielen ist die Verkettungsstufe konfiguriert, um das eine oder die mehreren anderen Segmente der Mehrzahl von Segmenten basierend auf der folgenden Syntax zu verketten:

  

  wobei k eine Steuervariable darstellt, wobei i eine Steuervariable darstellt, wobei j eine Steuervariable darstellt, wobei N_bits/chunk eine Anzahl von Bits pro Segment darstellt, wobei Ch_{0,N chunks-1\1} eine verkettete Version des einen oder der mehreren anderen Segmente darstellt, wobei Ch_i jeden der Mehrzahl von Segmenten darstellt.
• Bei Ausführungsbeispielen ist der Verschachteler konfiguriert, um die LDPC-codierte Bitfolge zu verschachteln, um eine verschachtelte Version der LDPC-codierten Bitfolge basierend auf der folgenden Syntax zu erhalten:

  

  

  
• wobei i eine Steuervariable darstellt,
• wobei j eine Steuervariable darstellt,
• wobei n eine Anzahl von Bits (z.B. Informationsbits + Redundanzbits) der LDPC-codierten Bitfolge darstellt,
• wobei k eine Steuervariable darstellt,
• wobei r die Code-Rate darstellt,
• wobei N_chunks eine Anzahl von Segmenten darstellt, in die die LDPC-codierte Bitfolge segmentiert ist,
• wobei N_hops eine Anzahl von Teildatenpaketen darstellt, über die die verschachtelte Version der LDPC-codierten Bitfolge verteilt ist,
• wobei ${\text{N}}_{\text{rounds}}^{\left(1\right)}$
  
  eine Anzahl von Runden darstellt, die benötigt werden, um die Bits des ersten Segments zu verteilen,
• wobei ${\text{N}}_{\text{bits/rounds}}^{\left(1\right)}$
  
  eine Anzahl von Bits pro Runde darstellt, die aus dem ersten Segment entnommen und über die Mehrzahl von Teildatenpaketen verteilt werden,
• wobei ${\text{N}}_{\text{bits}/\text{round}}^{\left(0\to {\text{N}}_{\text{chunks}}-1\backslash 1\right)}$
  
  eine Anzahl von Bits pro Runde darstellt, die aus den anderen Segmenten entnommen und über die Mehrzahl von Teildatenpaketen verteilt werden,
• wobei N_bits/hop eine Anzahl von Bits pro Teildatenpaket darstellt,
• wobei N_bits/chunk eine Anzahl von Bits pro Segment darstellt,
• wobei N_{bits/chunk/hop} eine Anzahl von Bits pro Segment pro Sprung darstellt,
• wobei v die LDPC-codierte Bitfolge darstellt,
• wobei ṽ die verschachtelte Version der LDPC-codierten Bitfolge darstellt,
• wobei Ch_i jeden der Mehrzahl von Segmenten darstellen,
• wobei Ch₁ das erste Segment darstellt,
• wobei ${\widetilde{\text{Ch}}}_{\text{0}\to {\text{N}}_{\text{chunks}}-1\backslash 1}$
  
  die verschachtelte Bitfolge darstellt [z.B. eine verschachtelte Version [einer verketteten Version] des einen oder der mehreren anderen Segmente].
• Weitere Ausführungsbeispiele stellen einen Verschachteler zum Verschachteln eines LDPC-codierten Codeworts bereit, wobei das LDPC-codierte Codewort eine Bitfolge von 736 FEC-codierten Bits, wobei der Verschachteler eine Segmentierungsstufe umfasst, die konfiguriert ist, um die Bitfolge z von 736 FEC-codierten Bits in vier gleich große Segmente zu segmentieren, wobei die vier Segmente ein Segment Nummer eins, ein Segment Nummer zwei, ein Segment Nummer drei und ein Segment Nummer vier umfassen, eine erste Verschachtelerstufe, die konfiguriert ist, um eine Folge y von Bits, bestehend aus dem Segment Nummer eins, dem Segment Nummer drei und dem Segment Nummer vier, pseudozufällig zu verwürfein, um eine verwürfelte Version y' der Bitfolge zu erhalten, wobei die Folge y pseudozufällig unter Verwendung eines Verwürfelungs-Vektors u verwürfelt wird, der von einer Pseudozufalls-Folge v abgeleitet ist, die von einem 10-Bit-Galois-LFSR mit Generatorpolynom g(x)=x¹⁰+x⁷+1 erzeugt wird, und eine zweite Verschachtelerstufe umfasst, die konfiguriert ist, um das Segment Nummer zwei über L Radio- bzw. Funk-Bursts (oder -Blitze) zu verteilen, indem jedem Bit c_n des Segments Nummer zwei (110_1) ein Radio-Burst-Index l und eine Position i innerhalb des Radio-Bursts abhängig vom Index n basierend auf der folgenden Syntax zugewiesen wird: $$\text{l}\left(\text{n}\right)=\lfloor \frac{\text{n}}{2}\rfloor \text{mod }\mathrm{23,}$$

  

  $$\text{i}\left(\text{n}\right)=2\cdot \lfloor \frac{\text{n}}{46}\rfloor +\left(\text{n mod }2\right),$$

  

  mit n ∈ {0,1,2 ... 183}, wobei n=0 sich auf das erste Bit c0 des Segments Nummer zwei (110_1) bezieht,
  wobei die zweite Verschachtelerstufe (108) konfiguriert ist, um die verwürfelte Version y' (112) der Bitfolge über die L Radio-Bursts zu verteilen durch Zuweisen eines Radioburstindex I und einer vom Index m abhängigen Position i basierend auf der folgenden Syntax: $$\text{l}\left(\text{m}\right)=\lfloor \frac{\text{m}}{24}\rfloor$$

  

  $$\text{i}\left(\text{m}\right)=8+\left(\text{m mod }24\right),$$

  

  mit m ∈ {0,1,2 ... 551}, wobei m=0 sich auf das erste Bit y'₀ der verwürfelten Version y' (112) der Bitfolge bezieht.
• Weitere Ausführungsbeispiele stellen einen Sender bereit, der einen Verschachteler gemäß einem der hierin beschriebenen Ausführungsbeispielen, einen LDPC-Codierer, der konfiguriert ist, um die LDPC-codierte Bitfolge bereitzustellen, und eine Sendeeinheit umfasst, die konfiguriert ist, um die verschachtelte Version der LDPC-codierten Bitfolge unter Verwendung einer Mehrzahl von Teildatenpaketen zu übertragen, wobei die Mehrzahl von Teildatenpaketen nicht gleichzeitig übertragen wird [z.B. unter Verwendung eines Zeit- und/oder Frequenzsprungmusters].
• Weitere Ausführungsbeispiele stellen einen Entschachteler zum Entschachteln einer verschachtelten Version einer LDPC-codierten Bitfolge bereit, wobei der Entschachteler eine erste Entschachteler-Stufe, die konfiguriert ist, um die verschachtelte Version der LDPC-codierten Bitfolge blockweise zu entschachteln, um ein erstes Segment und eine verschachtelte Bitfolge [z.B. eine verschachtelte Version eines oder mehrerer anderer Segmente [z.B. ein zweites Segment und optional ein drittes Segment] oder eine verkettete Version von zwei oder mehr anderen Segmenten [z.B. ein zweites Segment und ein drittes Segment]] zu erhalten, eine zweite Entschachteler-Stufe, die konfiguriert ist, um die verschachtelte Bitfolge zu entschachteln, um den einen oder die mehreren anderen Segmente [z.B. das zweite Segment und optional das dritte Segment] zu erhalten, und eine Verkettungsstufe umfasst, die konfiguriert ist, um das erste Segment und das eine oder die mehreren anderen Segmente zu verketten, um die LDPC-codierte Bitfolge zu erhalten, wobei das erste Segment der Mehrzahl von Segmenten besteht aus Bits eines ersten Typs [z.B. nur diese aufweist], wobei die Bits des ersten Typs
• - Fehlerkorrekturbits der LDPC-codierten Bitfolge sind,
• - Wiederholungsakkumulationsbits der LDPC-codierten Bitfolge sind und/oder
• - in einer Tanner-Diagramm-Darstellung der LDPC-codierten Bitfolge durch variable Knoten dargestellt sind, die Nicht-Zufalls-Verbindungen zu mindestens zwei Fehlerkorrektur-Kontrollknoten umfassen [z.B. ist jeder der variablen Knoten mit zwei aufeinanderfolgenden Kontrollknoten verbunden].
• Bei Ausführungsbeispielen umgeht das erste Segment die zweite Entschachteler-Stufe [z.B. wird das erste Segment von der zweiten Entschachteler-Stufe nicht entschachtelt].
• Bei Ausführungsbeispielen besteht ein Segment [z.B. das zweite Segment] des einen oder der mehreren anderen Segmente aus Bits eines zweiten Typs, wobei die Bits des zweiten Typs
• - Informationsbits der LDPC-codierten Bitfolge sind [und z.B. verbleibende Fehlerkorrekturbits der LDPC-codierten Bitfolge] und/oder
• - in einer Tanner-Diagramm-Darstellung der LDPC-codierten Bitfolge durch variable Knoten dargestellt sind, die Pseudozufallsverbindungen zu Fehlerkorrektur-Kontrollknoten umfassen.
• Bei Ausführungsbeispielen sind das eine oder die mehreren anderen Segmente zwei oder mehr andere Segmente, wobei ein anderes Segment [z.B. das dritte Segment] der zwei oder mehr anderen Segmente aus Bits des ersten Typs besteht.
• Bei Ausführungsbeispielen ist die erste Entschachtelerstufe ein Blockweise-Entschachteler.
• Bei Ausführungsbeispielen ist die zweite Entschachtelerstufe ein Pseudozufalls-Entschachteler.
• Bei Ausführungsbeispielen basiert der Pseudozufalls-Entschachteler auf einem linearen Schieberegister.
• Bei Ausführungsbeispielen ist der Pseudozufalls-Entschachteler ein Blockweise-Entschachteler.
• Bei Ausführungsbeispielen ist die verschachtelte Bitfolge eine verschachtelte Version einer verketteten Version von zwei oder mehr anderen Segmente, wobei die zweite Entschachtelerstufe konfiguriert ist, um die verschachtelte Version der verketteten Version der zwei oder mehr anderen Segmente zu entschachteln.
• Weitere Ausführungsbeispiele stellen einen Empfänger bereit, wobei der Empfänger eine Empfangseinheit, die konfiguriert ist, um eine Mehrzahl von Teildatenpaketen zu empfangen, die nicht gleichzeitig [z.B. unter Verwendung eines Zeit- und/oder Frequenzsprungmusters] von einem Sender zum Empfänger übertragen werden, einen Entschachteier nach einem der vorstehenden Ansprüche, wobei der Entschachteier konfiguriert ist, um iterativ unter Verwendung von Kanalzustandsinformationen, die einen Kanal zwischen dem Sender und dem Empfänger beschreiben, eine abgeklungene Version der LDPC-codierten Bitfolge zu entschachteln, die mit der Mehrzahl von Teildatenpaketen übertragen wird, und einen iterativen Decodierer umfasst, der konfiguriert ist, um die LDPC-codierte Bitfolge iterativ zu decodieren, die iterativ durch den Entschachteler bereitgestellt wird, wobei die Kanalzustandsinformationen basierend auf einer decodierten Bitfolge, die durch den iterativen Decodierer bereitgestellt wird, iterativ aktualisiert werden.
• Weitere Ausführungsbeispiele stellen ein Verfahren zum Verschachteln einer LDPC-codierten Bitfolge bereit. Das Verfahren umfasst einen Schritt eines Segmentierens der LDPC-codierten Bitfolge in eine Mehrzahl von Segmenten, wobei die Mehrzahl von Segmenten ein erstes Segment und ein oder mehrere andere Segmente umfasst. Weiterhin umfasst das Verfahren einen Schritt eines Verschachtelns des einen oder der mehreren anderen Segmente oder einer verketteten Version davon, um eine verschachtelte Bitfolge zu erhalten. Weiterhin umfasst das Verfahren einen Schritt eines blockweisen Verschachtelns des ersten Segments der Mehrzahl von Segmenten und der verschachtelten Bitfolge, um eine verschachtelte Version der LDPC-codierten Bitfolge zu erhalten. Dadurch besteht das erste Segment der Mehrzahl von Segmenten aus Bits eines ersten Typs, wobei die Bits des ersten Typs
• - Fehlerkorrekturbits der LDPC-codierten Bitfolge sind,
• - Wiederholungsakkumulationsbits der LDPC-codierten Bitfolge sind und/oder
• - in einer Tanner-Diagramm-Darstellung der LDPC-codierten Bitfolge durch variable Knoten dargestellt sind, die Nicht-Zufalls-Verbindungen zu mindestens zwei Fehlerkorrektur-Kontrollknoten umfassen.
• Weitere Ausführungsbeispiele stellen ein Verfahren zum Verschachteln eines LDPC-codierten Codeworts bereit, wobei das LDPC-codierte Codewort eine Bitfolge von 736 FEC-codierten Bits umfasst. Das Verfahren umfasst einen Schritt eines Segmentierens der Bitfolge z von 736 FEC-codierten Bits in vier gleich große Segmente, wobei die vier Segmente ein Segment Nummer eins, ein Segment Nummer zwei, ein Segment Nummer drei und ein Segment Nummer vier umfassen. Weiterhin umfasst das Verfahren einen Schritt eines pseudozufälligen Verwürfelns einer Bitfolge y, bestehend aus dem Segment Nummer eins, dem Segment Nummer drei und dem Segment Nummer vier, um eine verwürfelte Version y' der Bitfolge zu erhalten, wobei die Folge y pseudozufällig unter Verwendung eines Verwürfelungs-Vektors u verwürfelt wird, der von einer Pseudozufalls-Folge v abgeleitet ist, die von einem 10-Bit-Galois-LFSR mit Generatorpolynom g(x)=x¹⁰+x⁷+ 1 erzeugt wird. Weiterhin umfasst das Verfahren einen Schritt eines Verteilens des Segments Nummer zwei (110_1) über L Radio-Bursts, indem jedem Bit c_n des Segments Nummer zwei (110_1) ein Radio-Burst-Index I und eine Position i innerhalb des Radio-Bursts abhängig vom Index n basierend auf der folgenden Syntax zugewiesen wird: $$\text{l}\left(\text{m}\right)=\lfloor \frac{\text{n}}{2}\rfloor \text{mod }\mathrm{23,}$$

  

  $$\text{i}\left(\text{n}\right)=2\cdot \lfloor \frac{\text{n}}{\text{46}}\rfloor +\left(\text{n mod }2\right),$$

  

  mit n e {0,1,2 ... 183}, wobei n=0 sich auf das erste Bit c₀ des Segments Nummer zwei (110_1) bezieht. Weiterhin umfasst das Verfahren einen Schritt eines Verteilens der verwürfelten Version y' (112) der Bitfolge über die L Radiobursts durch Zuweisen eines Radioburstindex I und einer vom Index m abhängigen Position i basierend auf der folgenden Syntax: $$\text{l}\left(\text{m}\right)=\lfloor \frac{\text{m}}{24}\rfloor ,$$

  

  $$\text{i}\left(\text{m}\right)=8+\left(\text{m mod }24\right),$$

  

  mit m ∈ (0,1,2 ... 551}, wobei m=0 sich auf das erste Bit y'₀ der verwürfelten Version y' (112) der Bitfolge bezieht.
• Weitere Ausführungsbeispiele stellen ein Verfahren zum Entschachteln einer verschachtelten Version einer LDPC-codierten Bitfolge bereit. Das Verfahren umfasst einen Schritt eines blockweisen Entschachtelns der verschachtelten Version der LDPC-codierten Bitfolge, um ein erstes Segment und eine verschachtelte Version eines oder mehrerer anderer Segmente zu erhalten. Weiterhin umfasst das Verfahren einen Schritt eines Entschachtelns der verschachtelten Version des einen oder der mehreren anderen Segmente, um das eine oder die mehreren anderen Segmente zu erhalten. Weiterhin umfasst das Verfahren einen Schritt eines Verkettens des ersten Segments und des einen oder der mehreren anderen Segmente, um die LDPC-codierte Bitfolge zu erhalten. Dadurch besteht das erste Segment der Mehrzahl von Segmenten aus Bits eines ersten Typs, wobei die Bits des ersten Typs
• - Fehlerkorrekturbits der LDPC-codierten Bitfolge sind,
• - Wiederholungsakkumulationsbits der LDPC-codierten Bitfolge sind und/oder
• - in einer Tanner-Diagramm-Darstellung der LDPC-codierten Bitfolge durch variable Knoten dargestellt sind, die Nicht-Zufalls-Verbindungen zu mindestens zwei Fehlerkorrektur-Kontrollknoten umfassen.
• Ausführungsbeispiele der vorliegenden Erfindung werden hierin unter Bezugnahme auf die beigefügten Zeichnungen beschrieben.
• 1 zeigt eine schematische Ansicht einer Tanner-Diagramm-Darstellung eines in [3] vorgeschlagenen LDPC-Codes,
• 2 zeigt ein schematisches Blockdiagramm eines Verschachtelers gemäß einem Ausführungsbeispiel der vorliegenden Erfindung,
• 3 zeigt ein schematisches Blockdiagramm eines Systems, das einen Sender und einen Empfänger umfasst, gemäß einem Ausführungsbeispiel,
• 4 zeigt ein schematisches Blockdiagramm eines Verschachtelers zum Verschachteln einer von einem LDPC-Codierer bereitgestellten LDPC-codierten Bitfolge gemäß einem Ausführungsbeispiel der vorliegenden Erfindung,
• 5 zeigt ein schematisches Blockdiagramm eines Verschachtelers zum Verschachteln einer von einem LDPC-Codierer bereitgestellten LDPC-codierten Bitfolge gemäß einem Ausführungsbeispiel der vorliegenden Erfindung,
• 6 zeigt ein Flussdiagramm eines Segmentierungsverfahrens, das von der Segmentierungsstufe durchgeführt wird, gemäß einem Ausführungsbeispiel der vorliegenden Erfindung,
• 7 zeigt ein Flussdiagramm eines Verkettungsverfahrens, das von der Verkettungsstufe durchgeführt wird, gemäß einem Ausführungsbeispiel der vorliegenden Erfindung,
• 8 zeigt ein schematisches Blockdiagramm eines 10-Bit-Galois-Linear-Rückkopplungs-Schieberegisters (-LFSR),
• 9 zeigt ein Flussdiagramm eines Verfahrens eines Erzeugens eines Pseudozufallsindex basierend auf einem LFSR gemäß einem Ausführungsbeispiel der vorliegenden Erfindung,
• 10 zeigt ein Flussdiagramm eines Verfahrens zum zufälligen Verschachteln, das von der ersten Verschachtelerstufe durchgeführt wird, gemäß einem Ausführungsbeispiel der vorliegenden Erfindung,
• 11 zeigt ein Flussdiagramm eines Verfahrens zum blockweisen Verschachteln, das von der zweiten Verschachtelerstufe durchgeführt wird, gemäß einem Ausführungsbeispiel der vorliegenden Erfindung,
• 12 zeigt ein schematisches Blockdiagramm eines Entschachtelers zum Entschachteln einer verschachtelten Version einer LDPC-codierten Bitfolge gemäß einem Ausführungsbeispiel der vorliegenden Erfindung,
• 13 zeigt ein schematisches Blockdiagramm eines iterativen Decodierers gemäß einem Ausführungsbeispiel der vorliegenden Erfindung,
• 14 zeigt ein Flussdiagramm eines Decodierverfahrens gemäß einem Ausführungsbeispiel der vorliegenden Erfindung,
• 15 zeigt ein Flussdiagramm eines Verfahrens zum Verschachteln einer LDPC-codierten Bitfolge gemäß einem Ausführungsbeispiel der vorliegenden Erfindung,
• 16 zeigt ein Flussdiagramm eines Verfahrens zum Entschachteln einer verschachtelten Version einer LDPC-codierten Bitfolge gemäß einem Ausführungsbeispiel der vorliegenden Erfindung und
• 17 zeigt ein schematisches Blockdiagramm eines 10-Bit-Galois-Linear-Rückkopplungs-Schieberegisters (-LFSR) in einem Ausgangszustand.
• Gleiche oder gleichwertige Elemente oder Elemente mit gleicher oder gleichwertiger Funktionalität werden in der folgenden Beschreibung durch gleiche oder gleichwertige Bezugszeichen gekennzeichnet.
• In der folgenden Beschreibung wird eine Mehrzahl von Details dargelegt, um eine gründlichere Erläuterung der Ausführungsbeispiele der vorliegenden Erfindung zu ermöglichen. Für einen Fachmann wird es jedoch offensichtlich sein, dass Ausführungsbeispiele der vorliegenden Erfindung ohne diese spezifischen Details praktiziert werden können. In anderen Fällen werden bekannte Strukturen und Vorrichtungen nicht im Detail, sondern im Blockdiagramm dargestellt, um zu vermeiden, dass die Ausführungsbeispiele der vorliegenden Erfindung verschleiert werden. Darüber hinaus können Merkmale der verschiedenen im Folgenden beschriebenen Ausführungsbeispiele miteinander kombiniert werden, sofern nicht ausdrücklich anders angegeben.
• 2 zeigt ein schematisches Blockdiagramm eines Verschachtelers 100 zum Verschachteln einer LDPC-codierten Bitfolge 102 gemäß einem Ausführungsbeispiel der vorliegenden Erfindung. Der Verschachteler 100 umfasst eine Segmentierungsstufe 104, eine erste Verschachtelerstufe 108 und eine zweite Verschachtelerstufe 110.
• Die Segmentierungsstufe 104 kann konfiguriert sein, um die LDPC-codierte Bitfolge 102 in eine Mehrzahl von Segmenten 110_0 bis 110_N_chunks-1 (z.B. gleicher Länge) zu segmentieren (z.B. zu teilen), wobei N_chunks ≥ 2 gilt, wobei die Mehrzahl von Segmenten ein erstes Segment 110_1 und ein oder mehrere andere Segmente, wie ein nulltes Segment 110_0 und optional ein zweites Segment 110_2 umfasst.
• Dabei besteht (z.B. kann die Segmentierungsstufe 104 konfiguriert sein, um die LDPC-codierte Bitfolge 102 in die Mehrzahl von Segmenten 110_0 bis 110_N_chunks-1 so zu segmentieren, dass) das erste Segment 110_1 aus Bits eines ersten Typs (z.B. weist nur diese auf), wobei die Bits des ersten Typs mindestens eines von Folgenden sind
• - Fehlerkorrekturbits der LDPC-codierten Bitfolge 102,
• - Wiederholungsakkumulationsbits der LDPC-codierten Bitfolge 102,
• - dargestellt, in einer Tanner-Diagramm-Darstellung der LDPC-codierten Bitfolge 102, durch variable Knoten, die Nicht-Zufalls-Verbindungen zu mindestens zwei Fehlerkorrektur-Kontrollknoten umfassen (z.B. ist jeder der variablen Knoten mit zwei aufeinanderfolgenden Kontrollknoten verbunden).
• Die erste Verschachtelerstufe 108 kann konfiguriert sein, um das eine oder die mehreren anderen Segmente, die von der Segmentierungsstufe 106 bereitgestellt werden, wie das nullte Segment 110_0 und optional das zweite Segment 110_2, zu verschachteln oder, falls zwei oder mehr andere Segmente von der Segmentierungsstufe 104 bereitgestellt werden, eine verkettete Version der zwei oder mehr anderen Segmente zu verschachteln, zum Beispiel eine verkettete Version des nullten Segments 110_0 und des zweiten Segments 110_2, um eine verschachtelte Bitfolge 112 zu erhalten.
• Die zweite Verschachtelerstufe 110 kann konfiguriert sein, um das von der Segmentierungsstufe 104 bereitgestellte erste Segment 110_1 und die von der ersten Verschachtelerstufe 106 bereitgestellte verschachtelte Bitfolge 112 blockweise zu verschachteln, um eine verschachtelte Version 116 der LDPC-codierten Bitfolge zu erhalten.
• Wie in 2 dargestellt, umgeht das erste Segment 110_1 die erste Verschachtelerstufe 106, d.h. das erste Segment 110_1 wird nicht von der ersten Verschachtelerstufe 106 verschachtelt.
• Es ist zu beachten, dass sich das erste Segment 110_1 bei Ausführungsbeispielen nicht auf ein bestimmtes Segment einer Ordnung (oder Folge) der Mehrzahl von Segmenten bezieht, wie z.B. Segment Nummer eins, das der Anfang oder Beginn der Ordnung (oder Folge) der Mehrzahl von Segmenten ist, d.h. gefolgt von Segment Nummer zwei und optional Segment Nummer drei, wie in 2 durch die Zahlen 1, 2 und 3 innerhalb der Segmente angegeben ist. Ganz im Gegenteil, das erste Segment 110_1 bezieht sich auf das Segment der Mehrzahl von Segmenten, das aus den Bits des ersten Typs besteht, d.h. Fehlerkorrekturbits der LDPC-codierten Bitfolge, Wiederholungsakkumulationsbits der LDPC-codierten Bitfolge und/oder Bits, die in einer Tanner-Diagramm-Darstellung der LDPC-codierten Bitfolge durch variable Knoten dargestellt sind, die Nicht-Zufalls- Verbindungen zu mindestens zwei Fehlerkorrektur-Kontrollknoten umfassen. Zum Beispiel unter Bezugnahme auf den (736,184) - LDPC-Code, der in [3] vorgeschlagen wird, und unter der Annahme, dass der LDPC-Code in vier gleich große Segmente unterteilt ist: Segment Nummer eins (z.B. mit den Bits 1 bis 184 der Bits 1 bis 736), gefolgt von Segment Nummer zwei (z.B. mit den Bits 185 bis 368 der Bits 1 bis 736), gefolgt von Segment Nummer drei (z.B. mit den Bits 369 bis 552 der Bits 1 bis 736), gefolgt von Segment Nummer vier (z.B. mit den Bits 553 bis 736 der Bits 1 bis 736); das erste Segment 110_1 bezeichnet (oder bezieht sich auf) das Segment Nummer zwei, da das Segment Nummer zwei aus Fehlerkorrekturbits der LDPC-codierten Bitfolge, Wiederholungsakkumulationsbits der LDPC-codierten Bitfolge und/oder Bits besteht, die in einer Tanner-Diagramm-Darstellung der LDPC-codierten Bitfolge durch variable Knoten dargestellt sind, die Nicht-Zufalls-Verbindungen zu mindestens zwei Fehlerkorrektur-Kontrollknoten umfassen.
• Bei Ausführungsbeispielen besteht (z.B. kann die Segmentierungsstufe 104 konfiguriert sein, um die LDPC-codierte Bitfolge 102 in die Mehrzahl von Segmenten 110_0 bis 110_Nchunks-1 so zu segmentieren, dass) ein Segment des einen oder der mehreren anderen Segmente, wie beispielsweise das nullte Segment 110_0, aus Bits eines zweiten Typs, wobei die Bits des zweiten Typs mindestens eines von Folgenden sind:
• - Informationsbits der LDPC-codierten Bitfolge, und/oder
• - Dargestellt, in einer Tanner-Diagrammdarstellung der LDPC-codierten Bitfolge, durch variable Knoten, die Pseudozufallsverbindungen zu Fehlerkorrektur-Kontrollknoten umfassen.
• Bei Ausführungsbeispielen besteht (z.B. kann die Segmentierungsstufe 104 konfiguriert sein, um die LDPC-codierte Bitfolge 102 in die Mehrzahl von Segmenten 110_0 bis 110_Nchunks-1 so zu segmentieren, dass) ein anderes Segment der anderen Segmente, wie beispielsweise das zweite Segment 110_2, aus Bits des ersten Typs(z.B. weist nur diese auf), d.h. mindestens einem der Folgenden:
• - Fehlerkorrekturbits der LDPC-codierten Bitfolge 102,
• - Wiederholungsakkumulationsbits der LDPC-codierten Bitfolge 102,
• - dargestellt, in einer Tanner-Diagramm-Darstellung der LDPC-codierten Bitfolge 102, durch variable Knoten, die Nicht-Zufalls-Verbindungen zu mindestens zwei Fehlerkorrektur-Kontrollknoten umfassen (z.B. ist jeder der variablen Knoten mit zwei aufeinanderfolgenden Kontrollknoten verbunden).
• Bei Ausführungsbeispielen kann die erste Verschachtelerstufe 106 ein Pseudozufalls-Verschachteler sein, wie beispielsweise ein Verschachteler auf Linear-Rückkopplungs-Schieberegister-Basis oder ein Blockverschachteler.
• Bei Ausführungsbeispielen kann die zweite Verschachtelerstufe 108 ein Blockweise-Verschachteler sein. Der Blockweise-Verschachteler 108 kann konfiguriert sein, um die verschachtelte Version der LDPC-codierten Bitfolge 116 über eine Mehrzahl von Teildatenpaketen 120_0 bis 120_N_hops-1, wobei N_hops ≥ 2, zu verteilen.
• Dabei kann der Blockweise-Verschachteler 108 konfiguriert sein, um Bits des ersten Segments 110_1 der Mehrzahl von Segmenten blockweise über die Mehrzahl von Teildatenpaketen 120_0 bis 120_N_hops-1 in mindestens zwei Runden zu verteilen, z.B. so, dass in einer ersten Runde aufeinanderfolgende Blöcke von Bits (z.B. von zwei aufeinanderfolgenden Bits) des ersten Segments 110_1 zyklisch auf die Mehrzahl der Teildatenpakete 120_0 bis 120_N_hops-1 abgebildet werden, und in einer zweiten Runde weitere aufeinanderfolgende Bits (z.B. von zwei aufeinanderfolgenden Bits) des ersten Segments 110_1 zyklisch auf die Mehrzahl der Teildatenpakete 120_0 bis 120_N_hops-1 abgebildet werden, und so weiter, bis alle Bits des ersten Segments 110_1 blockweise über die Mehrzahl der Teildatenpakete 120_0 bis 120_N_hops-1 verteilt sind.
• Unter der exemplarischen Annahme, dass die verschachtelte Version 116 der LDPC-codierten Bitfolge über drei Teildatenpakete 120_0 bis 120_2 verteilt ist, kann der Blockweise-Verschachteler 108 konfiguriert sein, um in einer ersten Runde ein nulltes und ein erstes Bit des ersten Segments 110_1 auf das nullte Teildatenpaket 120_0 abzubilden, ein zweites und ein drittes Bit des ersten Segments 110_1 auf das erste Teildatenpaket 120_1 und ein viertes und ein fünftes Bit des ersten Segments 110_1 auf das zweite Teildatenpaket 120_2. Weiterhin kann der Blockweise-Verschachteler 108 konfiguriert sein, um in einer zweiten Runde ein sechstes und ein siebtes Bit des ersten Segments 110_1 auf das nullte Teildatenpaket 120_0 abzubilden, ein achtes und ein neuntes Bit des ersten Segments 110_1 auf das erste Teildatenpaket 120_1 und ein zehntes und ein elftes Bit des ersten Segments 110_1 auf das zweite Teildatenpaket 120_2. Dieser Vorgang kann wiederholt werden, bis alle Bits des ersten Segments 110_1 über die Mehrzahl der Teildatenpakete verteilt sind.
• Weiterhin kann der Blockweise-Verschachteler 108 konfiguriert sein, um Bits der verschachtelten Bitfolge 112, die von der ersten Verschachtelerstufe 106 bereitgestellt wird, blockweise über die Mehrzahl von Teildatenpaketen gleichmäßig zu verteilen (z.B. wird die Mehrzahl von Teildatenpaketen 120_0 bis 120_N_hops-1 gleichmäßig mit Bits der verschachtelten Bitfolge 112 aufgefüllt, die von der ersten Verschachtelerstufe 106 bereitgestellt wird).
• Wenn man beispielsweise mit dem Beispiel fortfährt, dass die verschachtelte Version 116 der LDPC-codierten Bitfolge auf drei Teildatenpakete 110_0 bis 110_2 verteilt ist, kann der Blockweise-Verschachteler 108 konfiguriert sein, um das nullte Teildatenpaket 120_0 aufzufüllen, indem ein nullter Bitblock der verschachtelten Bitfolge 112 auf das nullte Teildatenpaket 120_0 abgebildet wird, um das erste Teildatenpaket 120_1 durch Abbilden eines ersten Bitblocks der verschachtelten Bitfolge 112 auf das erste Teildatenpaket 120_1 aufzufüllen, und um das zweite Teildatenpaket 120_2 durch Abbilden eines zweiten Bitblocks der verschachtelten Bitfolge 112 auf das zweite Teildatenpaket 120_2 aufzufüllen.
• Im Folgenden werden die Ausführungsbeispiele des Verschachtelers 100 näher beschrieben.
• Hybrid-Blockweise-Zufalls-Verschachteler
• Um die nachteilige Wirkung der begrenzten Kanalkenntnis, wie im einleitenden Teil der vorliegenden Patentanmeldung beschrieben, zu überwinden, werden bei Ausführungsbeispielen die Bits des LDPC-Codeworts so sortiert, dass eine verbesserte (z.B. die beste) Nutzung der anfänglich geschätzten Abkling-Koeffizienten möglich ist. Dies bedeutet, dass der BP-Algorithmus des LDPC-Decodierers auch mit wenigen geschätzten Abkling-Koeffizienten noch ausgelöst werden kann. So kann beispielsweise eine entscheidungsorientierte Kanalschätzung (DDCE - Decision Directed Channel Estimation) [2] mit Hilfe des anfänglich decodierten LDPC-Codeworts eingeleitet werden. Ein iterativer Decodierer kann die Informationen zwischen dem Kanalschätzer und dem LDPC-Decodierer so lange durchlaufen, bis das vollständige LDPC-Codewort erfolgreich decodiert ist.
• Ausführungsbeispiele stellen einen Verschachteler 100 bereit, der darauf abzielt, das Tanner-Diagramm von LDPC-Codes mit einer Code-Rate r ≤ 1/2 neu zu strukturieren, die eine Treppenstruktur aufweisen. Der Anreiz des Verschachtelers 100 gemäß Ausführungsbeispielen besteht darin, die Machbarkeit des BP-Decodierungsalgorithmus mit einer begrenzten Anzahl von geschätzten Abkling-Koeffizienten zu ermöglichen. Da die Präambelsequenz nur die ersten paar benachbarten Symbole schätzen kann, sortiert der Verschachteler 100 die LDPC-Bits so aus, dass die anfänglich geschätzten Abkling-Koeffizienten den minimalen Auslöseschwellenwert des LDPC-Decodierers erreichen. Mit anderen Worten, der Verschachteler 100 ermöglicht es, die Wahrscheinlichkeit zu erhöhen, Kontrollknoten zu haben, bei denen nur eine gelöschte LLR von ihren entsprechenden variablen Knoten empfangen wurde.
• Bei Ausführungsbeispielen werden zwei Strategien angewendet. Die erste Strategie ist der Austausch von k variablen Knoten, die Zufalls-Verbindungen aufweisen, durch die ersten k variablen Knoten, die Treppenverbindungen haben. Dies geschieht für die systematischen Codes, bei denen die k Informationsbits auf die ersten k Bits des codierten Codeworts abgebildet sind. Falls die systematischen Informationsbits nicht am Anfang des Codeworts stehen, entfällt dieser Austauschschritt. Mit anderen Worten, das Ziel ist es, mit k variablen Knoten zu beginnen, die eine Treppenverbindung haben. Die zweite Strategie besteht darin, die Bits über die Übertragungssprünge zu verteilen. Für das vertauschte Treppensegment wird ein Blockweise-Verschachteler verwendet. Dieser Blockweise-Verschachteler verteilt die Bits des Treppensegments über die Sprünge in aufeinanderfolgenden Runden. Jede Runde setzt zwei aufeinanderfolgende Bits auf einen Sprung. Die restlichen Codewortbits werden durch einen Zufalls-Verschachteler verschachtelt. Schließlich werden sie über die Sprünge nach den blockweise verteilten Bits verteilt.
• Die Essenz des Hybrid-Verschachtelers gemäß den Ausführungsbeispielen ist zweifach: Zuerst zerlegt er die Treppenstruktur des codierten Codeworts. Zweitens verteilt er den systematischen Teil über die Sprünge. Das bedeutet, dass die ersten geschätzten Abkling-Koeffizienten über das Codewort hinweg verwürfelt werden und nicht in einem Segment gestapelt werden. Somit kann der LDPC-Decodierer auch bei minimalen geschätzten Abkling-Koeffizienten ausgelöst werden.
• 3 zeigt ein schematisches Blockdiagramm eines Systems 200, das einen Sender 202 und einen Empfänger 204 umfasst, gemäß einem Ausführungsbeispiel.
• Der Sender 202 umfasst einen LDPC-Codierer 206, der konfiguriert ist, um das LDPC-codierte Codewort 102 (z.B. die LDPC-codierte Bitfolge) bereitzustellen, den Verschachteler 100, der konfiguriert ist, um das LDPC-codierte Codewort 102 zu verschachteln, um die verschachtelte Version 116 des LDPC-codierten Codeworts zu erhalten, und eine Pilotsequenz-Einfügeeinheit 208, die konfiguriert ist, um der verschachtelten Version 116 des LDPC-codierten Codeworts eine Pilotsequenz 210 hinzuzufügen (z.B. anzuhängen).
• Der Empfänger 204 umfasst einen Kanalschätzer 212, einen Entschachteler 140, einen iterativen LDPC-Decodierer 214 und einen Verschachteler 100, wobei der Verschachteler 100 und der Entschachteler komplementär zueinander sind.
• Mit anderen Worten, 3 zeigt das Systemmodell des (Hybrid-)Verschachtelers 100 gemäß Ausführungsbeispielen. Ein Informationsvektor der Länge k Bits wird von einem LDPC-Codierer 206 mit einer Rate r codiert, um ein Ausgabe-Codewort v = [v₀ v₁ ... v_n-1] 102 der Länge n Bits zu erzeugen, wobei n = k/r. Das codierte Codewort 102 wird dann vom Verschachteler 100 gemäß Ausführungsbeispielen verschachtelt, um ein verschachteltes Codewort ṽ = [v₀ ṽ₁ ... ṽ_n-1] 116 gleicher Länge zu erzeugen. Danach wird eine Präambelsequenz 210 der Länge 210 L_p an den verschachtelten Vektor 116 angehängt. Schließlich werden die Daten moduliert und über den Abkling-Kanal übertragen.
• Auf der Seite des Empfängers 204 wird die Präambelsequenz 210 extrahiert und dem Kanalschätzer 212 zugeführt. Aufgrund der begrenzten Präambelgröße ist der Kanalschätzer 212 zunächst nur in der Lage, CSI über die ersten benachbarten Symbole bereitzustellen. Sowohl die empfangene Sequenz bzw. Folge als auch der teilweise geschätzte Abkling-Vektor werden entschachtelt und dem LDPC-Decodierer 214 zugeführt. Trotz der anfänglichen Knappheit von CSI ermöglicht der vorgeschlagene Verschachteler-Entwurf das Auslösen des LDPC-Decodierers 214. Somit ist der LDPC-Decodierer 214 weiterhin in der Lage, extrinsische Informationen bereitzustellen. Diese decodierten Informationen werden dann verschachtelt und als ergänzende Pilotsymbole an den Kanalschätzer 212 zurückgegeben. Dies ermöglicht die Schätzung von mehr Abkling-Koeffizienten, um die Glauben-Ausbreitung-Decodierung von LDPC mit zusätzlichen apriori-Wahrscheinlichkeiten auszulösen. Der iterative Decodierungsprozess wird nacheinander wiederholt, bis das gesamte LDPC-Codewort decodiert ist.
• 4 zeigt ein schematisches Blockdiagramm eines Verschachtelers zum Verschachteln einer von einem LDPC-Codierer 206 bereitgestellten LDPC-codierten Bitfolge 102 gemäß einem Ausführungsbeispiel der vorliegenden Erfindung. Der Verschachteler 100 umfasst eine Segmentierungsstufe 104, eine Verkettungsstufe 105, eine erste Verschachtelerstufe 106 und eine zweite Verschachtelerstufe 108.
• Die Segmentierungsstufe 104 kann konfiguriert sein, um die LDPC-codierte Bitfolge 102 in eine Mehrzahl von Segmenten 110_0 bis 110_N_chunks-1 (z.B. gleich lang), wobei N_chunks ≥ 2, zu segmentieren (z.B. zu teilen), wobei die Mehrzahl von Segmenten ein erstes Segment 110_1 und zwei oder mehr andere Segmente 110_0, 110_2 bis 110_N_chunks-1 umfasst.
• Dabei kann (z.B. die Segmentierungsstufe 104 konfiguriert sein, um die LDPC-codierte Bitfolge 102 in die Mehrzahl der Segmente 110_0 bis 110_N_chunks-1 so zu segmentieren, dass) das erste Segment 110_1 aus Bits eines ersten Typs bestehen (weist z.B. nur diese auf), wobei die Bits des ersten Typs mindestens eines von folgenden sind
• - Fehlerkorrekturbits der LDPC-codierten Bitfolge 102,
• - Wiederholungsakkumulationsbits der LDPC-codierten Bitfolge 102,
• - dargestellt, in einer Tanner-Diagramm-Darstellung der LDPC-codierten Bitfolge 102, durch variable Knoten, die Nicht-Zufalls-Verbindungen zu mindestens zwei Fehlerkorrektur-Kontrollknoten umfassen (z.B. ist jeder der variablen Knoten mit zwei aufeinanderfolgenden Kontrollknoten verbunden).
• Die Verkettungsstufe ist konfiguriert, um die zwei oder mehr anderen Segmente 110_0, 110_2 bis 110_N_chunks-1 zu verketten, um eine verkettete Version 111 der zwei oder mehr anderen Segmente 110_0, 110_2 bis 110_N_chunks-1 zu erhalten.
• Die erste Verschachtelerstufe 108, z.B. ein (Pseudo-)Zufalls-Verschachteler, z.B. basierend auf einem Linear-Rückkopplungs-Schieberegister (LFSR) 107, kann konfiguriert sein, um die verkettete Version 111 der zwei oder mehr anderen Segmente 110_0, 110_2 bis 110_N_chunks-1 zu verschachteln.
• Die zweite Verschachtelerstufe 110, z.B. ein Blockweise-Verschachteler, kann konfiguriert sein, um das von der Segmentierungsstufe 104 bereitgestellte erste Segment 110_1 und die von der ersten Verschachtelerstufe 106 bereitgestellte verschachtelte Bitfolge 112 blockweise zu verschachteln, um eine verschachtelte Version 116 der LDPC-codierten Bitfolge zu erhalten.
• Mit anderen Worten, 4 zeigt ein Blockdiagramm eines Hybrid-Blockweise-Zufalls-Verschachtelers 100 gemäß einem Ausführungsbeispiel. Der Verschachteler 100 nimmt ein LDPC-codiertes Codewort v 102 der Länge n Bits und gibt eine verschachtelte Version ṽ 116 gleicher Länge aus. Der Verschachtelungsprozess besteht aus vier Schritten: Segmentierung (z.B. durchgeführt durch die Segmentierungsstufe 104), Verkettung (z.B. durchgeführt durch die Verkettungsstufe 105), Zufalls-Permutation (z.B. durchgeführt durch die erste Verschachtelerstufe 106) und blockweise Zuweisung (z.B. durchgeführt durch die zweite Verschachtelerstufe 108). Erstens impliziert der Segmentierungsschritt die Aufteilung des n-Bit-Codeworts 102 in N_chunks = 1/r Segmente 110_0 bis 110_N_chunks-1 gleicher Länge, wobei r die Code-Rate ist. Das erste Segment 110_1 wird beiseite gelegt, während die restlichen Segmente (N_chunks - 1) Segmente 110_0, 110_2 bis 110_N_chunks-1 wieder verkettet werden. Danach wird ein Pseudozufalls-Verschachteler 106, der mittels eines Linear-Rückkopplungs-Schieberegisters (LFSR) 107 erzeugt werden könnte, auf die verkettete Sequenz 111 angewendet. Daraus ergibt sich eine neue Sequenz 112 mit den Elementen der verketteten Sequenz 111, die entsprechend den Permutationsindizes des LFSR 107 platziert sind. Schließlich wird die verschachtelte Sequenz 112 zusammen mit dem getrennten Segment 110_1 einem Blockweise-Verschachteler 108 zugeführt. Ziel ist es, die Bits gleichmäßig über die übertragenen Sprünge (oder Teildatenpakete 120_0 bis 120_N_hops-1) zu verteilen. Es beginnt zunächst damit, zwei Bits aus dem getrennten Segment 110_1 auf jeden Sprung 120_0 bis 120_N_hops-1 zu setzen.
• Nachdem alle Sprünge 120_0 bis 120_N_hops-1 durchlaufen wurden, beginnt eine weitere Runde durch Zuweisen zweier weiterer Bits für jeden Sprung. Dieser Vorgang wird wiederholt, bis alle Bits des getrennten Segments 110_1 aufgebraucht sind. Inzwischen ist die zufällig verschachtelte Sequenz 112 gleichmäßig über die Sprünge 120_0 bis 120_N_hops-1 verteilt. Das bedeutet, dass jeder Sprung blockweise Bits aus dem getrennten Segment 110_1 umfasst, gefolgt von den Bits der zufällig verschachtelten Segmente jeweils in einem Verhältnis von 1: N_chunks - 1. Diese vier Schritte werden in den folgenden Abschnitten ausführlich beschrieben.
• 5 zeigt ein schematisches Blockdiagramm eines Verschachtelers zum Verschachteln einer von einem LDPC-Codierer 206 bereitgestellten LDPC-codierten Bitfolge 102 gemäß einem Ausführungsbeispiel der vorliegenden Erfindung. Der Verschachteler 100 umfasst eine Segmentierungsstufe 104, eine Verkettungsstufe 105, eine erste Verschachtelerstufe 106 und eine zweite Verschachtelerstufe 108.
• Die Segmentierungsstufe 104 kann konfiguriert sein, um die LDPC-codierte Bitfolge 102 in vier Segmente 110_0 bis 110_3 (z.B. gleicher Länge) zu segmentieren (z.B. zu teilen), wobei die vier Segmente ein erstes Segment 110_1 und drei weitere Segmente 110_0, 110_2, 110_3 umfassen.
• Dabei kann (z.B. die Segmentierungsstufe 104 konfiguriert sein, um die LDPC-codierte Bitfolge 102 so in die vier Segmente 110_0 bis 110_3 zu segmentieren, dass) das erste Segment 110_1 aus Bits eines ersten Typs bestehen (z.B. nur diese aufweisen), wobei die Bits des ersten Typs mindestens eines von folgenden sind
• - Fehlerkorrekturbits der LDPC-codierten Bitfolge 102,
• - Wiederholungsakkumulationsbits der LDPC-codierten Bitfolge 102,
• - dargestellt, in einer Tanner-Diagramm-Darstellung der LDPC-codierten Bitfolge 102, durch variable Knoten, die Nicht-Zufalls-Verbindungen zu mindestens zwei Fehlerkorrektur-Kontrollknoten umfassen (z.B. ist jeder der variablen Knoten mit zwei aufeinanderfolgenden Kontrollknoten verbunden).
• Die Verkettungsstufe 105 kann konfiguriert sein, um die drei anderen Segmente 110_0, 110_2, 110_3 zu verketten, um eine verkettete Version 111 der drei anderen Segmente 110_0, 110_2, 110_3 zu erhalten.
• Die erste Verschachtelerstufe 108, z.B. ein (Pseudo-)Zufalls-Verschachteler, z.B. basierend auf einem Linear-Rückkopplungs-Schieberegister (LFSR) 107, kann konfiguriert sein, um die verkettete Version 111 der drei anderen Segmente 110_0, 110_2, 110_3 zu verschachteln.
• Die zweite Verschachtelerstufe 110, z.B. ein Blockweise-Verschachteler, kann konfiguriert sein, um das von der Segmentierungsstufe 104 bereitgestellte erste Segment 110_1 und die von der ersten Verschachtelerstufe 106 bereitgestellte verschachtelte Bitfolge 112 blockweise zu verschachteln, um eine verschachtelte Version 116 der LDPC-codierten Bitfolge zu erhalten.
• Mit anderen Worten, 5 zeigt ein Beispiel für den (Hybrid-)Verschachteler 100 gemäß einem Ausführungsbeispiel, der auf den (736,184) LDPC-Code gemäß [3] angewendet wird. Da die Code-Rate 1/4 ist, sollte das LDPC-Codewort 102 segmentiert werden in N_chunks = 4 Segmente. Jedes Segment hat $\raisebox{1ex}{$\text{n}$}\!\left/ \!\raisebox{-1ex}{${\text{N}}_{\text{chunks}}$}\right.=184$

  

  Segmente. Das erste Segment 110_1 wird getrennt, während das nullte, zweite und dritte Segment 110_0, 110_2, 110_3 zurück verkettet werden, um einen Vektor 111 der Länge 3 × 184 = 552 Bits zu bilden. Dieser verkettete Vektor 111 wird zufällig verschachtelt (z.B. durch die erste Verschachtelerstufe 106) und einem Blockweise-Verschachteler 108 mit dem getrennten ersten Segment 110_1 zugeführt. Unter der Annahme, dass die Daten übertragen werden müssen über N_hops = 23, sollte der Blockweise-Verschachteler 108 die Daten blockweise auf die 23 Sprünge 120_0 bis 120_22 abbilden. Es beginnt damit, dass zwei Bits aus dem ersten Segment 110_1 auf jeden Sprung abgebildet werden. Nach 23 Sprüngen 120_0 bis 120_22 wären 46 Bits des ersten Segments 110_1 abgebildet. Dieser Vorgang kann viermal wiederholt werden, um alle 184 Bits des ersten Segments 110_1 abzubilden. Danach können die 552 Bits des zufällig verschachtelten Vektors 112 auf die Sprünge 120_0 bis 120_22 abgebildet werden, wobei jeder Sprung 24 Bits in einer Runde enthält.
• Segmentierung
• 6 zeigt ein Flussdiagramm eines Segmentierverfahrens 400, das von der Segmentierungsstufe 104 durchgeführt wird, gemäß einem Ausführungsbeispiel der vorliegenden Erfindung.
  Bei einem ersten Schritt 402 wird eine Eingabe bereitgestellt, wobei die Eingabe die LDPC-codierte Bitfolge v eine Anzahl n von Bits (z.B. Informationsbits + Redundanzbits) der LDPC-codierten Bitfolge, eine Anzahl k von Informationsbits der LDPC-codierten Bitfolge, eine Code-Rate r und eine Anzahl von N_chunks von Segmenten umfasst, in die die LDPC-codierte Bitfolge segmentiert werden soll.
  Bei einem zweiten Schritt 404 wird eine Zahl von N_bits/chunk von Bits pro Segment basierend auf der Gleichung N_bits/chunk = n/N_chunks.bestimmt.
  Bei einem dritten Schritt 406 wird eine Steuervariable i auf null gesetzt, i = 0.
  Bei einem vierten Schritt 408 wird eine Steuervariable j auf null gesetzt, j = 0.
  Bei einem fünften Schritt 410 werden Bits der LDPC-codierten Bitfolge v dem i-ten Segment Ch_i basierend auf der Gleichung Ch_i(j) = v(j + iN_bits / chunk) zugeordnet.
• Bei einem sechsten Schritt 412 wird die Steuervariable j um eins erhöht, j = j + 1.
  Bei einem siebten Schritt 414 wird geprüft, ob die Steuervariable j kleiner ist als die Zahl N_bits/chunk von Bits pro Segment, wobei j < N_bits/chunk, und wenn ja, wird mit dem fünften Schritt 410 fortgefahren, ansonsten mit einem achten Schritt 416.
  Bei dem achten Schritt 416 wird die Steuervariable i um eins erhöht, i = i + 1.
  Bei einem neunten Schritt 418 wird geprüft, ob die Steuervariable i kleiner ist als die Zahl N_chunks von Segmenten, in die die LDPC-codierte Bitfolge segmentiert werden soll, i < N_chunks, und wenn ja, wird mit dem vierten Schritt 408 fortgefahren, ansonsten mit einem zehnten Schritt 420.
  Bei dem zehnten Schritt 420 wird die Mehrzahl der Segmente Ch_i ∀ 0 ≤ i ≤ N_chunks als Ausgabe bereitgestellt.
• Bei Ausführungsbeispielen soll der erste Schritt (=Segmentierungsschritt, z.B. durchgeführt durch die Segmentierungsstufe 104) das LDPC-codierte Codewort 102 unterteilen in N_chunks Segmente 110_0 bis 110_N_chunks-1 gleicher Länge. 6 zeigt das Flussdiagramm des Segmentierungsprozesses. Der Segmentierungsblock 104 nimmt das Eingangscodewort v 102 der Länge n Bits und gibt N_chunks Segmente 110_0 bis 110_N_chunks-1, Ch_i ∀ i = 0, ..., N_chunks - 1, aus, wobei N_chunks = 1/r und r = k/n die Code-Rate ist. Jedes Segment hat N_bits/chunk = n/N_chunks Bits, die seriell aus (dem LDPC-codierten Codewort 102) v entnommen wurden. Jedes Segment Ch_i ist gegeben durch: $$C{h}_i\left(j\right)=v\left(j+i{N}_{bits/chunk}\right)\forall i=\mathrm{0,}\dots ,N_{chunks}-\mathrm{1,}j=\mathrm{0,}\dots ,N_{bits/chunk}-1$$

  
• Unter Annahme des (736,184)-LDPC-Codes als Beispiel wird das codierte Codewort 102 in vier Segmente 110_0 bis 110_3 der Länge N_bits/chunk = 736/4 = 184 Bits unterteilt.
• Bei Ausführungsbeispielen kann die Segmentierungsstufe 104 konfiguriert sein, um die LDPC-codierte Bitfolge 102 basierend auf der folgenden Syntax in die Mehrzahl von Segmenten zu segmentieren (z.B. durch Ausführen (z.B. Laufenlassen) des folgenden Pseudocodes):

  

  wobei i eine Steuervariable darstellt, wobei j eine Steuervariable darstellt, wobei N_chunks eine Anzahl von Segmenten darstellt, in die die LDPC-codierte Bitfolge segmentiert ist, wobei N_bits/chunk die Anzahl der Bits pro Segment darstellen, wobei Ch_i jedes der Mehrzahl von Segmenten darstellt, und wobei v die LDPC-codierte Bitfolge darstellt.
• Verkettung
• 7 zeigt ein Flussdiagramm eines Verkettungsverfahrens 500, das von der Verkettungsstufe 105 durchgeführt wird, gemäß einem Ausführungsbeispiel der vorliegenden Erfindung. Bei einem ersten Schritt 502 wird eine Eingabe bereitgestellt, wobei die Eingabe das eine oder die mehreren anderen Segmente Ch_i, ∀i = 0,..., N_chunks - 1, i ≠ 1, die Anzahl n von Bits (z.B. Informationsbits + Redundanzbits) der LDPC-codierten Bitfolge und die Anzahl N_chunks von Segmenten umfasst, in die die LDPC-codierte Bitfolge segmentiert werden soll.
  Bei einem zweiten Schritt 504 wird eine Anzahl N_bits/chunk von Bits pro Segment basierend auf der Gleichung N_bits/chunk = n/N_chunks bestimmt.
  Bei einem dritten Schritt 506 wird eine Stellgröße i auf null gesetzt, i = 0.
  Bei einem vierten Schritt 508 wird eine Steuervariable k auf null gesetzt, k = 0.
  Bei einem fünften Schritt 510 wird eine Steuervariable j auf null gesetzt, j = 0.
  Bei einem sechsten Schritt 512 werden das eine oder die mehreren anderen Segmente basierend auf der Gleichung Ch_{0→N chunks-1\1} (j + kN_bits/chunk) = Ch_i(j) verkettet.
  Bei einem siebten Schritt 514 wird die Steuervariable j um eins erhöht, j = j + 1.
  Bei einem achten Schritt 516 wird geprüft, ob die Steuervariable j kleiner ist als die Zahl j N_bits/chunk von Bits pro Segment, j < N_bits/chunk , und wenn ja, werden der sechste bis achte Schritt 512 bis 516 wiederholt, ansonsten wird mit einem neunten Schritt 518 fortgefahren. Bei dem neunten Schritt 518 wird die Steuervariable i um eins erhöht, i = i + 1.
  Bei einem zehnten Schritt 520 wird geprüft, ob die Steuervariable i kleiner ist als die Zahl N_chunks von Segmenten, in die die LDPC-codierte Bitfolge segmentiert werden soll, i < N_chunks, und wenn ja, wird mit einem elften Schritt 522 fortgefahren, ansonsten mit einem zwölften Schritt 524.
  Bei dem elften Schritt 522 wird geprüft, ob die Steuervariable i mit eins identisch ist, i == 1, und wenn ja, wird mit dem neunten Schritt 518 fortgefahren, andernfalls mit dem dreizehnten Schritt 526.
  Bei dem dreizehnten Schritt 526 wird die Steuervariable k um eins erhöht, k = k + 1, und wird mit dem fünften Schritt 510 fortgefahren.
  Bei dem zwölften Schritt 524 wird eine verkettete Version des einen oder der mehreren anderen Segmente Ch_{0→N chunks-1\1} als Ausgabe bereitgestellt.
• Bei Ausführungsbeispielen wird, nach der Segmentierung des LDPC-Codeworts 102 in N_chunks Segmente 110_0 bis 110_N_chunks-1, das erste Segment 110_1 getrennt, während die restlichen N_chunks - 1 Segmente 110_0, 110_2 bis 110_N_chunks-1 wieder verkettet werden können. 7 zeigt den Verkettungsprozess. Das Verkettungselement nimmt Ch_i, ∀i = 0,..., N_chunks - 1, i ≠ 1 (d.h. das eine oder die mehreren anderen Segmente 110_0, 110_2 bis 110_N_chunks-1) und verkettet sie zu einem zusammengesetzten Vektor Ch_{0,N chunks-1\1} 111 der Länge (N_chunks - 1) × N_bits/chunk. Der verkettete Vektor ist gegeben durch: $$\begin{array}{l}C{h}_{0\to N_{chunks}-1\backslash 1}\left(j+max\left(i-\mathrm{1,0}\right)\times N_{bits/chunks}\right)=C{h}_i\left(j\right)\\ \forall i=\mathrm{0,}\dots ,{\text{N}}_{\text{chunks}}-\mathrm{1,}\text{i}\ne \mathrm{1,}\text{j}=\mathrm{0,}\dots ,{\text{N}}_{\text{bits}/\text{chunk}}-\mathrm{1,}\end{array}$$

  
• Bei Ausführungsbeispielen kann die Verkettungsstufe 105 konfiguriert sein, um das eine oder die mehreren anderen Segmente 110_0, 110_2 bis 110_N_chunks-1 der Mehrzahl von Segmenten 110_0 bis 110_N_chunks-1 basierend auf der folgenden Syntax (z.B. durch Ausführen (z.B. Laufenlassen) des folgenden Pseudocodes) zu verketten:

  

  wobei k eine Steuervariable darstellt, wobei i eine Steuervariable darstellt, wobei j eine Steuervariable darstellt, wobei N_chunks eine Anzahl von Segmenten darstellt, in die die LDPC-codierte Bitfolge segmentiert ist, wobei N_bits/chunk eine Anzahl von Bits pro Segment darstellt, wobei Ch_{0→N chunks-1\1} eine verkettete Version des einen oder der mehreren anderen Segmente darstellt, wobei Ch_i jeden der Mehrzahl von Segmenten darstellt.
• Zufalls-Verschachteler
• Bei Ausführungsbeispielen besteht der nächste Schritt (= Zufalls-Verschachtelungsschritt, z.B. durchgeführt von der ersten Verschachtelerstufe 106) darin, den verketteten Vektor Ch_{0→N chunks-1\1} 111 zufällig zu verschachteln. Zu diesem Zweck besteht eine Möglichkeit darin, ein Linear-Rückkopplungs-Schieberegister (LFSR) 107 zu verwenden, um die Pseudozufallsindizes zu erzeugen. Die Anzahl der Register N_R des eingesetzten LFSR 107 muss die folgende Ungleichung erfüllen: $$2^{N_R}-1\ge \left(N_{chunks}-1\right)\times N_{bits/chunk}$$

  
• Für das (736,184)-LDPC-Beispiel hat der verkettete Vektor Ch_0→3\1 111 3 × 184 Bits. Dies bedeutet, dass ein LFSR 107 von mindestens N_R = 10 Register notwendig ist, um eindeutige Permutationsindizes zu erhalten. Die zyklischer Redundanzkontrolle (CRC - Cyclic Redundancy Check) könnte ein effizienter potenzieller Kandidat für die Initialisierung eines solchen LFSR 107 sein. Sie wird berechnet, indem der verkettete Vektor Ch_0→3\1 111 seriell verschoben wird zu dem LFSR, gefolgt von der N_R Nullen.
• 8 zeigt ein Beispiel für ein 10-Bit-Galois-LFSR 107 mit Generatorpolynom g(x) = x¹⁰ + x⁷ + 1= 0x240, und einen Anfangszustand, der einer Kontrollsumme von 0x2D7 entspricht. Das LFSR 107 durchläuft alle Z^{N R} - 1 Zustände mit Ausnahme des Alles-Null-Zustandes. Der nächste Zustand eines solchen LFSR ist 0x32B, was dem Dezimalindex 811 entspricht. Dieser Indexwert ist größer als die Anzahl der erforderlichen Permutationsindizes. Dadurch wird der Index verworfen und das LFSR fährt mit der nächsten Iteration fort.
• 9 zeigt ein Flussdiagramm eines Verfahrens 600 zum Erzeugen eines Pseudozufallsindex basierend auf einem LFSR gemäß einem Ausführungsbeispiel der vorliegenden Erfindung.
  Bei einem ersten Schritt 602 wird eine Eingabe bereitgestellt, wobei die Eingabe ein Generatorpolynom gen, einen Anfangszustand initial des LFSR, die Anzahl n von Bits (z.B. Informationsbits + Redundanzbits) der LDPC-codierten Bitfolge und die Anzahl N_chunks von Segmenten umfasst, in die die LDPC-codierte Bitfolge segmentiert werden soll.
  Bei einem zweiten Schritt 604 wird eine Anzahl N_bits/chunk von Bits pro Segment basierend auf der Gleichung N_bits/chunk = n/N_chunksund eine Länge L der erforderlichen Indizes basierend auf der Gleichung L = (N_chunks - 1) × N_bits/chunk bestimmt.
  Bei einem dritten Schritt 606 wird eine Steuervariable j auf null gesetzt, j = 0.
  Bei einem vierten Schritt 608 wird eine feedback (Rückmeldung) des LFSR in den Anfangszustand initial & eins gesetzt, feedback = initial & 1, d.h. das letzte Bit (niederwertigstes Bit) des Ausgangszustandes wird bereitgestellt als feedback.
• Bei einem fünften Schritt 610 wird der Anfangszustand initial des LFSR um eine Position nach rechts verschoben wird, inital >> 1.
  Bei einem sechsten Schritt 612 wird geprüft, ob die feedback des LFSR ist gleich eins, feedback = 1, und wenn ja, wird mit einem siebten Schritt 614 fortgefahren, ansonsten mit einem achten Schritt 616.
  Bei dem siebten Schritt 614 wird der Anfangszustand initial des LFSR XOR-verarbeitet mit dem Generatorpolynom des LFSR, um einen neuen Anfangszustand zu erhalten, initial = initial ⊕ gen.
  Bei dem achten Schritt 616 wird geprüft, ob das Dezimal-Äquivalent des Anfangszustandes initial des LFSR gleich oder kleiner ist als die Länge L der erforderlichen Indizes, und wenn ja, wird mit einem neunten Schritt 618 fortgefahren, ansonsten mit dem vierten Schritt 608. Bei dem neunten Schritt 618 wird der Permutationsindexvektor π an der Stelle j auf initial minus eins gesetzt, π(j) = initial - 1.
  Bei einem zehnten Schritt 620 wird die Steuervariable j um eins erhöht, j = j + 1.
  Bei einem elften Schritt 622 wird geprüft, ob die Steuervariable j kleiner ist als L, j < L, und wenn ja, wird mit dem vierten Schritt 608 fortgefahren, ansonsten mit einem zwölften Schritt 624.
  Bei dem zwölften Schritt 624 wird der Permutationsindizes-Vektor π als Ausgabe bereitgestellt.
• Mit anderen Worten, das Flussdiagramm des Pseudozufallsindexgenerators mittels LFSR 107 ist in 9 dargestellt. Das LFSR 107 wird durch ein primitives Generatorpolynom des Grads N_R erzeugt und durch die CRC-Kontrollsumme initialisiert oder durch einen beliebigen Initialzustand innerhalb seiner Z^{N R} - 1 Zyklusspanne. Nach jeder Iteration hat der LFSR einen neuen Zustand, der einem Kandidaten-Permutationsindex entspricht. Dieser Index ist mit der Länge der benötigten Indizes zu vergleichen, L = (N_chunks - 1) × N_bits/chunk. Wenn der generierte Index kleiner ist als L, wird er an den Permutationsindizes-Vektor π angehängt. Andernfalls wird der Zustand verworfen und das LFSR geht zum nächsten Zustand über. Der Algorithmus stoppt, wenn die Anzahl der erzeugten Indizes in π L erreicht.
• 10 zeigt ein Flussdiagramm eines Verfahrens 700 für die zufällige Verschachtelung, das von der ersten Verschachtelerstufe 106 (z.B. einem LFSR-Zufallsverschachtelung) durchgeführt wird, gemäß einem Ausführungsbeispiel der vorliegenden Erfindung.
  Bei einem ersten Schritt 702 wird eine Eingabe bereitgestellt, wobei die Eingabe eine verkettete Version der anderen Segmente Ch_{0→N chunks-1\1} den Permutationsindizes-Vektor π, die Anzahl n von Bits (z.B. Informationsbits + Redundanzbits) der LDPC-codierten Bitfolge und die Anzahl N_chunks von Segmenten umfasst, in die die LDPC-codierte Bitfolge zu segmentieren ist.
  Bei einem zweiten Schritt 704 wird eine Anzahl N_bits/chunk von Bits pro Segment basierend auf der Gleichung N_bits/chunk = n/N_chunks bestimmt und eine Länge L der erforderlichen Indizes basierend auf der Gleichung L = (N_chunks - 1) × N_bits/chunk bestimmt.
  Bei einem dritten Schritt 706 wird eine Steuervariable j auf null gesetzt, j = 0.
  Bei einem vierten Schritt 708 werden die anderen Segmente Ch_{0→N chunks-1\1} pseudozufällig basierend auf dem Permutationsindizes-Vektor π verschachtelt, um eine verschachtelte Bitfolge ${\widetilde{Ch}}_{0\to N_{chunks}-1\backslash 1}$

  

  (z.B. eine verschachtelte Version einer verketteten Version der anderen Segmente), ${\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\backslash 1}\left(\text{j}\right)={\text{Ch}}_{0\to {\text{N}}_{\text{chunks}}-1\backslash 1}\left(\mathrm{\pi }\left(\text{j}\right)\right),$

  

  zu erhalten.
  Bei einem fünften Schritt 710 wird die Steuervariable j um eins erhöht, j = j + 1.
  Bei einem sechsten Schritt 712 wird geprüft, ob die Steuervariable j kleiner als L, j < L, ist und wenn ja, wird mit dem vierten Schritt 708 fortgefahren, ansonsten mit einem siebten Schritt 714.
  Bei dem siebten Schritt 714 wird die verschachtelte Bitfolge ${\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\backslash 1}$

  

  als Ausgabe bereitgestellt.
• Bei Ausführungsbeispielen können nach der Generierung der Pseudozufalls-Indizes diese verwendet werden, um den verketteten (N_chunks - 1) Segment-Vektor Ch_{0→N chunks-1\1} (d.h. die verkettete Version des einen oder mehrerer anderer Segmente 110_0, 110_2 bis 110_N_chunks 1) einer Permutation zu unterziehen. Der Zufalls-Verschachteler 106 berücksichtigt sowohl den Permutationsvektor π als auch den verketteten Vektor Ch_{0→N chunks-1\1} 111. Er erzeugt einen verschachtelten Vektor ${\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\backslash 1}$

  

  112 mit der gleichen Länge wie bei Ch_{0→N chunks-1\1.} Die Zuordnung von Elementen aus Ch_{0→N chunks-1\1} zu ${\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\backslash 1}$

  

  erfolgt nach den Permutationsindizes in der Datei π folgendermaßen: $${\widetilde{Ch}}_{0\to {\text{N}}_{\text{chunks}}-1\backslash 1}\left(j\right)=C{h}_{0\to {\text{N}}_{\text{chunks}}-1\backslash 1}\left(\pi \left(j\right)\right)\forall j=\mathrm{0,}\dots ,L-\mathrm{1,}$$

  

  wobei L = (N_chunks - 1) × N_bits/chunk die Länge des verketteten Vektors ist. Der Zufalls-Verschachtelungsprozess ist in 10 dargestellt.
• Bei Ausführungsbeispielen kann die erste Verschachtelerstufe 106 konfiguriert sein, um die verkettete Version der anderen Segmente 110_0, 110_2 bis 110_N_chunks-1 aus der Mehrzahl der Segmente 110_0 bis 110_N_chunks 1 basierend auf der folgenden Syntax (z.B. durch Ausführen (z.B. Laufenlassen) des folgenden Pseudocodes) zu verschachteln:

  

  wobei j eine Steuervariable darstellt, wobei N_chunks eine Anzahl von Segmenten darstellt, in die die LDPC-codierte Bitfolge segmentiert ist, wobei N_bits/chunk eine Anzahl von Bits pro Segment darstellt, wobei ${\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\backslash 1}$

  

  die verschachtelte Bitfolge (z.B. eine verschachtelte Version (einer verketteten Version) des einen oder der mehreren anderen Segmente) darstellt, wobei Ch_{0→N chunks-1\1} eine verkettete Version des einen oder der mehreren anderen Segmente darstellt, wobei π einen Permutationsindizes-Vektor eines Linear-Rückkopplungs-Schieberegisters darstellt.
• Blockweise-Verschachteler
• 11 zeigt ein Flussdiagramm eines Verfahrens 800 zur blockweisen Verschachtelung, das von der zweiten Verschachtelerstufe 108 durchgeführt wird, gemäß einem Ausführungsbeispiel der vorliegenden Erfindung.
• Bei einem ersten Schritt 802 wird eine Eingabe bereitgestellt, wobei die Eingabe das erste Segment Ch₁, die verschachtelte Bitfolge ${\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\backslash 1},$

  

  ie Anzahl n von Bits (z.B. Informationsbits + Redundanzbits) der LDPC-codierten Bitfolge, die Anzahl N_chunks von Segmenten, in die die LDPC-codierte Bitfolge segmentiert ist, die gleich 1/r ist, die Anzahl N_hops von Teildatenpaketen ist, über die die verschachtelte Version der LDPC-codierten Bitfolge verteilt werden soll, und eine Anzahl ${\text{N}}_{\text{bits}/\text{round}}^{\left(1\right)}$

  

  von Bits pro Runde umfasst, die aus dem ersten Segment entnommen und über die Mehrzahl von Teildatenpaketen verteilt sind. bei einem zweiten Schritt 804 wird eine Anzahl N_bits/chunk von Bits pro Segment basierend auf der Gleichung N_bits/chunk = n/N_chunks bestimmt, eine Zahl N_bits/hop von Bits pro Teildatenpaket wird basierend auf der Gleichung N_bits/hop = n/N_hop bestimmt, eine Zahl N_{bits/chunk/hop} von Bits pro Segment pro Teildatenpaket wird basierend auf der Gleichung N_{bits/chunk/hop} = N_bits/chunk/N_hop bestimmt, eine Zahl ${\text{N}}_{\text{rounds}}^{\left(1\right)}$

  

  von Runden, die zur Verteilung der Bits des ersten Segments erforderlich sind, wird basierend auf der Gleichung ${\text{N}}_{\text{rounds}}^{\left(1\right)}={\text{N}}_{\text{bits}/\text{chunk}/\text{hop}}/{\text{N}}_{\text{bits}/\text{round}}^{\left(1\right)}$

  

  bestimmt, und eine Zahl ${\text{N}}_{\text{bits}/\text{round}}^{\left(0\to {\text{N}}_{\text{chunks}}-1\backslash 1\right)}$

  

  von Bits pro Runde, die aus den anderen Segmente entnommen und über die Mehrzahl von Teildatenpaketen verteilt sind, wird basierend auf der Gleichung ${\text{N}}_{\text{bits}/\text{round}}^{\left(0\to {\text{N}}_{\text{chunks}}-1\backslash 1\right)}=\left({\text{N}}_{\text{chunks}}-1\right)\times {\text{N}}_{\text{bits}/\text{chunk}/\text{hop}}$

  

  bestimmt.
  Bei einem dritten Schritt 806 wird eine Steuervariable i auf null gesetzt, i = 0.
• Bei einem vierten Schritt 808 wird eine Steuervariable j auf null gesetzt, j = 0.
  Bei einem fünften Schritt 810 wird eine Steuervariable k auf null gesetzt, k = 0.
  Bei einem sechsten Schritt 812 werden Bits des ersten Segments Ch₁ auf die verschachtelte Version ṽ der LDPC-codierten Bitfolge basierend auf der Gleichung $\tilde{\text{v}}\left(\text{j}+\text{i}\times {\text{N}}_{\text{bits}/\text{hop}}+\text{k}\times {\text{N}}_{\text{bits}/\text{round}}^{\left(\text{1}\right)}\right)={\text{CH}}_1\left(\text{j}+\text{i}\times {\text{N}}_{\text{bits}/\text{round}}^{\left(\text{1}\right)}+\text{k}\times {\text{N}}_{\text{hops}}\times {\text{N}}_{\text{bits}/\text{round}}^{\left(\text{1}\right)}\right)$

  

  abgebildet.
  Bei einem siebten Schritt 814 wird die Steuervariable k um eins erhöht, k = k + 1.
  Bei einem achten Schritt 816 wird geprüft, ob k kleiner als die ermittelte Zahl ${\text{N}}_{\text{rounds}}^{\left(1\right)}$

  

  von Runden ist, die benötigt werden, um die Bits des ersten Segments zu verteilen, $\text{k}<{\text{N}}_{\text{rounds}\text{'}}^{\left(1\right)}$

  

  und wenn ja, wird mit dem sechsten Schritt 812 fortgefahren, ansonsten mit einem neunten Schritt 818.
  Bei dem neunten Schritt 818 wird die Steuervariable j um eins erhöht, j = j + 1.
  Bei einem zehnten Schritt 820 wird geprüft, ob j kleiner als die Zahl ${\text{N}}_{\text{bits}/\text{round}}^{\left(\text{1}\right)}$

  

  von Bits pro Runde ist, die aus dem ersten Segment entnommen und über die Mehrzahl von Teildatenpaketen verteilt sind, $\text{j}<{\text{N}}_{\text{bits}/\text{round'}}^{\left(\text{1}\right)}$

  

  und wenn ja, wird mit dem fünften Schritt 810 fortgefahren, ansonsten mit einem elften Schritt 822.
  Bei dem elften Schritt 822 wird die Steuervariable j auf null gesetzt, j = 0.
  Bei einem zwölften Schritt 824 wird die verschachtelte Bitfolge ${\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\backslash 1}$

  

  auf die verschachtelte Version ṽ der LDPC-codierten Bitfolge basierend auf der Gleichung $\tilde{\text{v}}\left(\text{j}+\text{i}\times {\text{N}}_{\text{bits}/\text{hop}}+{\text{N}}_{\text{bits}/\text{chink}/\text{hop}}\right)={\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\backslash 1}\left(\text{j}+\text{i}\times {\text{N}}_{\text{bits}/\text{round}}^{\left(0\to {\text{N}}_{\text{chunks}}-1/1\right)}\right)$

  

  abgebildet.
  Bei einem dreizehnten Schritt 826 wird die Steuervariable j um eins erhöht, j = j + 1.
  Bei einem vierzehnten Schritt 828 wird geprüft, ob die Steuervariable j kleiner als die ermittelte Zahl ${\text{N}}_{\text{bits/round}}^{\left(0\to {\text{N}}_{\text{chunks}}-1\backslash 1\right)}$

  

  von Bits pro Runde ist, die aus den anderen Segmente entnommen und über die Mehrzahl von Teildatenpaketen verteilt sind, $\text{j}<{\text{N}}_{\text{bits/round}}^{\left(0\to {\text{N}}_{\text{chunks}}-1\backslash 1\right)},$

  

  und wenn ja, wird mit dem zwölften Schritt 824 fortgefahren, ansonsten mit einem fünfzehnten Schritt 830.
  Bei dem fünfzehnten Schritt 830 wird die Steuervariable i um eins erhöht, i = i + 1.
  Bei einem sechzehnten Schritt 832 wird geprüft, ob die Steuervariable i kleiner ist als die Zahl N_hops von Teildatenpaketen, über die die verschachtelte Version der LDPC-codierten Bitfolge verteilt werden soll, und wenn ja, wird mit dem vierten Schritt 808 fortgefahren, ansonsten mit einem siebzehnten Schritt 834.
  Bei dem siebzehnten Schritt 834 wird die verschachtelte Version ṽ der LDPC-codierten Bitfolge als Ausgabe bereitgestellt.
• Bei Ausführungsbeispielen beinhaltet der letzte Schritt (=zweiter Verschachtelungsschritt, z.B. durchgeführt durch die zweite Verschachtelerstufe 108) die Blockweise-Verschachtelung des extrahierten Segments Ch₁ (d.h. des ersten Segments 110_1) zusammen mit dem zufällig verschachtelten Vektor ${\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\backslash 1}$

  

  (d.h. die verschachtelte Bitfolge 112). Die Idee ist, die codierten Bits gleichmäßig auf die übertragenen Sprünge 120_1 bis 120_N_hops-1 zu verteilen. Jeder Sprung umfasst Bits aus (dem ersten Segment 110_1) Ch₁ und (den anderen Segmenten 110_0, 110_2 bis 110_N_chunks 1) ${\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\setminus 1}$

  

  mit einem Verhältnis von 1: N_chunks - 1. Das bedeutet, dass, wenn die n Datenbits zu übertragen sind über N_hops mit N_bits/round = n/N_hops, 1/N_chunks der Bits aus (dem ersten Segment 110_1) Ch₁ entnommen werden würden, während die restlichen (N_chunks - 1)/N_chunks aus (den anderen Segmentes 110_0, 110_2 bis 110_N_chunks 1) ${\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\setminus 1}$

  

  entnommen werden sollten. Außerdem sollten die Bits (des ersten Segments 110_1) Ch₁, die auf jeden Sprung abgebildet sind, in einer sprungweisen zyklischen Weise genommen werden mit ${\text{N}}_{\text{bits/round}}^{\left(1\right)}=2.$

  

  Das bedeutet, dass die ersten beiden Bits (des ersten Segments 110_1) C_h1 auf den ersten Sprung 120_0 abgebildet werden. Die nächsten beiden Bits werden auf den zweiten Sprung 120_1 gesetzt, und so weiter. Nach N_hops beginnt eine weitere Runde mit dem Abbilden von zwei Bits (des ersten Segments 110_1) Ch₁ auf jeden Sprung. Alle N_bits/chunk Bits (des ersten Segments 110_1) Ch₁ werden vollständig auf die N_hops nach ${\text{N}}_{\text{rounds}}^{\left(1\right)}=\text{n/}\left({\text{N}}_{\text{chunks}}\times {\text{N}}_{\text{hops}}\times {\text{N}}_{\text{bits/round}}^{\left(1\right)}\right)$

  

  abgebildet. Schließlich werden die Bits des verschachtelten ${\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\setminus 1}$

  

  Vektors 112 auf die Sprünge 120_0 bis 120_N_hops-1 über eine Runde abgebildet, wobei eine Runde ${\text{N}}_{\text{bits/round}}^{\left(0\to {\text{N}}_{\text{chunks}}-1\setminus 1\right)}=\left({\text{N}}_{\text{chunks}}-1\right)\times {\text{N}}_{\text{bits/chunk/hop}}=\left({\text{N}}_{\text{chunks}}-1\right)\times \text{N}{}_{\text{bits/chunk}})/{\text{N}}_{\text{hops}}$

  

  Bits auf jedem Sprung umfasst.
• Das Flussdiagramm des Blockweise-Zufalls-Verschachtelers ist in 11 dargestellt. Beide (das erste Segment 110_1) Ch₁ und (die verschachtelte Bitfolge 112) ${\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\setminus 1}$

  

  werden dem Verschachteler 108 zugeführt, der einen Ausgangsvektor ṽ 116 erzeugt, der der verschachtelten Version des LDPC-codierten Vektors v 102 entspricht. Der Verschachteler 108 läuft schleifenmäßig über die N_hops und weist N_bits/hop Bits für jeden Sprung zu. Zuerst beginnt er mit dem Abbilden von ${\text{N}}_{\text{bits/round}}^{\left(1\right)}=2$

  

  Bits aus (dem ersten Segment 110_1) Ch₁ auf jeden Sprung über ${\text{N}}_{\text{rounds}}^{\left(1\right)}$

  

  Runden. Dies kann dargestellt werden durch: $$\tilde{v}\left(j+i\times N_{bits/hop}+k\times N_{bits/round}^{\left(1\right)}\right)=C{h}_1\left(j+i\times N_{bits/round}^{\left(1\right)}+k\times N_{hops}\times N_{bits/round}^{\left(1\right)}\right),$$

  

  wobei
• N_hops die Anzahl der Sprünge ist,
• N_bits/hop = n/N_hops die Anzahl der übertragenen Bits über jeden Hop ist,
• ${\text{N}}_{\text{bits/round}}^{\left(1\right)}=2$
  
  die Anzahl der Bits ist, die von Ch₁ auf jedem Sprung jede Runde, abgebildet werden,
• ${\text{N}}_{\text{rounds}}^{\left(1\right)}$
  
  die Gesamtzahl der Runden ist, die benötigt werden, um alle Bits von Ch₁ zu leeren,
• i = 0, •••, N_hops - 1 der Sprungindex ist,
• j = 0,..., ${\text{N}}_{\text{bits/round}}^{\left(1\right)}-1$
  
  der Bitindex innerhalb der Runde ist und
• k = 0,..., ${\text{N}}_{\text{rounds}}^{\left(1\right)}-1$
  
  der Rundenindex ist
• Nach ${\text{N}}_{\text{rounds}}^{\left(1\right)}$

  

  wird jeder Sprung ${\text{N}}_{\text{rounds}}^{\left(1\right)}\times {\text{N}}_{\text{bits/round}}^{\left(1\right)}$

  

  Bits aus (dem ersten Segment 110_1) Ch₁ haben. Der Rest der N_bits/hop Bits auf jedem Sprung sollte entnommen werden aus (der verschachtelten Bitfolge 112) ${\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\setminus 1}.$

  

  Weil (die verschachtelte Bitfolge 112) ${\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\setminus 1}$

  

  bereits pseudozufällig verschachtelt ist, werden die Bits auf den Sprung 120_1 bis 120_N_hops-1 über eine Runde verteilt (d.h_. ${\text{N}}_{\text{rounds}}^{\left(0\to {\text{N}}_{\text{chunks}}-1\setminus 1\right)}=1$

  

  ). Das bedeutet, dass für jeden Sprung ${\text{N}}_{\text{bits/rounds}}^{\left(0\to {\text{N}}_{\text{chunks}}-1\setminus 1\right)}=\left({\text{N}}_{\text{chunks}}-1\right)\times {\text{N}}_{\text{bits/chunk}}/{\text{N}}_{\text{hops}}$

  

  Bits seriell entnommen werden sollten aus (der verschachtelten Bitfolge 112) ${\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\setminus 1}.$

  

  Dies kann beschrieben werden durch: $$\tilde{v}\left(j+i\times N_{bits/hop}+N_{bits/chunk/hop}\right)={\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\setminus 1}\left(j+i\times {\text{N}}_{\text{bits/rounds}}^{\left(0\to {\text{N}}_{\text{chunks}}-1\setminus 1\right)}\right),$$

  

  wobei
• N_{bits/chunk/hop} = N_bits/chunk/N_hops ungefähr die Anzahl der übertragenen Bits von jedem Segment über jeden Sprung ist,
• ${\text{N}}_{\text{bits/rounds}}^{\left(0\to {\text{N}}_{\text{chunks}}-1\setminus 1\right)}=\left({\text{N}}_{\text{chunks}}-1\right)\times {\text{N}}_{\text{bits/chunk}}{}_{/\text{hop}}$
  
  die Anzahl der Bits ist, die von ${\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\setminus 1}$
  
  auf jeden Sprung abgebildet werden,
• i = 0, •••, N_hops - 1 der Sprungindex ist und
• j = 0,..., ${\text{N}}_{\text{bits/rounds}}^{\left(0\to {\text{N}}_{\text{chunks}}-1\setminus 1\right)}-1$
  
  der Bitindex innerhalb von ${\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\setminus 1}$
  
  ist
• Bei Ausführungsbeispielen kann die zweite Verschachtelerstufe 108 konfiguriert sein, um das erste Segment 110_1 und die verschachtelte Bitfolge 112 basierend auf der folgenden Syntax zu verschachteln, z.B. durch Ausführen (z.B. Laufenlassen) des folgenden Pseudocodes):

  

  wobei i eine Steuervariable darstellt, wobei j eine Steuervariable darstellt, wobei k eine Steuervariable darstellt, wobei N_chunks eine Anzahl von Segmenten darstellt, in die die LDPC-codierte Bitfolge segmentiert ist, wobei N_hops eine Anzahl von Teildatenpaketen darstellt, über die die verschachtelte Version der LDPC-codierten Bitfolge verteilt ist, wobei ${\text{N}}_{\text{bits/round}}^{\left(1\right)}$

  

  eine Anzahl von Bits pro Runde darstellt, die aus dem ersten Segment entnommen und über die Mehrzahl von Teildatenpaketen verteilt sind, wobei N_bits/hop eine Anzahl von Bits pro Teildatenpaket darstellt, wobei ṽ die verschachtelte Version der LDPC-codierten Bitfolge darstellt, wobei Ch₁ das erste Segment darstellt, wobei ${\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\setminus 1}$

  

  die verschachtelte Bitfolge (z.B. eine verschachtelte Version (einer verketteten Version) des einen oder der mehreren anderen Segmente) darstellt.
• Entschachteler
• 12 zeigt ein schematisches Blockdiagramm eines Entschachtelers 140 zum Entschachteln einer verschachtelten Version einer LDPC-codierten Bitfolge gemäß einem Ausführungsbeispiel der vorliegenden Erfindung. Der Entschachteler 140 umfasst eine erste Entschachtelerstufe 142, eine zweite Entschachtelerstufe 144 und eine Verkettungsstufe 146.
• Die erste Entschachtelerstufe 142 kann konfiguriert sein, um eine verschachtelte Version 116 der LDPC-codierten Bitfolge blockweise zu entschachteln, um ein erstes Segment 110_1 und eine verschachtelte Bitfolge 112 zu erhalten, wie beispielsweise eine verschachtelte Version eines oder mehrerer anderer Segmente oder einer verketteten Version von zwei oder mehr anderen Segmenten.
• Dadurch besteht das erste Segment 110_1 aus Bits eines ersten Typs(weist z.B. nur diese auf), wobei die Bits des ersten Typs mindestens eines von folgenden sind:
• - Fehlerkorrekturbits der LDPC-codierten Bitfolge,
• - Wiederholungsakkumulationsbits der LDPC-codierten Bitfolge,
• - dargestellt, in einer Tanner-Diagramm-Darstellung der LDPC-codierten Bitfolge, durch variable Knoten, die Nicht-Zufalls-Verbindungen zu mindestens zwei Fehlerkorrektur-Kontrollknoten umfassen (z.B. ist jeder der variablen Knoten mit zwei aufeinanderfolgenden Kontrollknoten verbunden).
• Die zweite Entschachtelerstufe 144 kann konfiguriert sein, um die verschachtelte Bitfolge 112 zu entschachteln, um ein oder mehrere andere Segmente zu erhalten, wie beispielsweise ein nulltes Segment 110_0 und optional ein zweites Segment 110_2.
• Die Verkettungsstufe 146 kann konfiguriert sein, um das erste Segment 110_1 und das eine oder die mehreren anderen Segmente, wie beispielsweise das nullte Segment 110_0 und optional das zweite Segment 110_2, zu verketten, um die LDPC-codierte Bitfolge 102 zu erhalten.
• Wie in 12 gezeigt ist, umgeht das erste Segment 110_1 die zweite Entschachtelerstufe 144, oder anders ausgedrückt wird das erste Segment 110_1 nicht von der zweiten Entschachtelerstufe 144 entschachtelt.
• Bei Ausführungsbeispielen besteht ein Segment des einen oder der mehreren anderen Segmente, wie beispielsweise das nullte Segment 110_0, aus Bits eines zweiten Typs, wobei die Bits des zweiten Typs mindestens eines von folgenden sind:
• - Informationsbits der LDPC-codierten Bitfolge, und/oder
• - dargestellt, in einer Tanner-Diagrammdarstellung der LDPC-codierten Bitfolge, durch variable Knoten dargestellt werden, die Pseudozufallsverbindungen zu Fehlerkorrektur-Kontrollknoten umfassen.
• Bei Ausführungsbeispielen besteht ein weiteres Segment der anderen Segmente, wie beispielsweise das zweite Segment 110_2, aus Bits des ersten Typs (weist z.B. nur dies auf), d.h. mindestens einem der folgenden:
• - Fehlerkorrekturbits der LDPC-codierten Bitfolge 102,
• - Wiederholungsakkumulationsbits der LDPC-codierten Bitfolge 102,
• - dargestellt, in einer Tanner-Diagramm-Darstellung der LDPC-codierten Bitfolge 102, durch variable Knoten, die Nicht-Zufalls-Verbindungen zu mindestens zwei Fehlerkorrektur-Kontrollknoten umfassen (z.B. ist jeder der variablen Knoten mit zwei aufeinanderfolgenden Kontrollknoten verbunden).
• Bei Ausführungsbeispielen kann die erste Entschachtelerstufe 142 ein Blockweise-Entschachteler sein. So kann beispielsweise die erste Entschachtelerstufe 142 komplementär zur zweiten Verschachtelerstufe 108 sein (siehe 2).
• Bei Ausführungsbeispielen kann die zweite Entschachtelerstufe 144 ein Pseudozufalls-Entschachteler sein, wie beispielsweise ein Entschachteler auf Linear-Rückkopplungs-Schieberegister-Basis oder ein Blockweise-Entschachteler.
• Iterativer Decodierer
• 13 zeigt ein schematisches Blockdiagramm eines iterativen Decodierers gemäß einem Ausführungsbeispiel der vorliegenden Erfindung. Der iterative Decodierer 204 umfasst einen Kanalschätzer, den oben beschriebenen Entschachteler 140, einen LDPC-Decodierer 214 und den oben beschriebenen Verschachteier 100.
• Mit anderen Worten, 11 stellt das Blockdiagramm des iterativen Decodierers 204 des verschachtelten LDPC-Codeworts 116 dar. Ein empfangenes Signal auf der Empfängerseite besteht aus einer abgeklungenen Version des übertragenen Signals, die eine Präambel 210 und ein verschachteltes LDPC-Codewort 116 umfasst. Die Präambel 210 wird dem Kanalschätzer 212 zugeführt, der im Gegenzug eine Schätzung der ersten D_L Abkling-Koeffizienten erzeugt. Die restlichen n - D_L Koeffizienten bleiben vage. Sowohl das empfangene Codewort 116 als auch der teilweise geschätzte Abkling-Vektor werden entschachtelt (z.B. durch den Entschachteler 140) und dem LDPC-Decodierer 214 zugeführt, der die apriori-LLRs der Symbole entsprechend den geschätzten Koeffizienten berechnet, während die verbleibenden Symbole als Löschungen behandelt werden. Diese apriori-LLRs lösen die Glauben-Ausbreitung-Decodierung des LDPC aus.
• Da die Treppenstruktur des LDPC-Codewortes 102 durch den Verschachteler 100 aufgebrochen wird, kann der LDPC-Decodierer 214 auch mit nur D_L verfügbaren geschätzten Abkling-Koeffizienten ausgelöst werden. Dies führt zu einem vorläufig decodierten Vektor, der als zusätzliches Pilotsignal für die Kanalschätzung 212 dient. Eine weitere Decodierungsiteration wird dann ausgelöst, indem der teilweise decodierte Vektor verschachtelt und zusammen mit der ursprünglichen Präambel an den Kanalschätzer 212 zurückgegeben wird. Infolgedessen kann ein längeres Segment von 2D_L Abkling-Koeffizienten geschätzt werden. Der neu geschätzte Abkling-Vektor wird noch einmal entschachtelt und an den LDPC-Decodierer 214 übergeben, so dass er ein größeres Segment des empfangenen Codeworts decodieren kann. Dieser Vorgang wird iterativ wiederholt, bis alle n Bits des empfangenen Codeworts decodiert sind.
• 14 zeigt ein Flussdiagramm eines Decodierverfahrens 900 gemäß einem Ausführungsbeispiel der vorliegenden Erfindung.
  Bei einem ersten Schritt 902 wird eine Eingabe bereitgestellt, wobei die Eingabe die Referenzpilotsequenz (z.B. Präambel) p_ref, die empfangene Pilotsequenz (z.B. Präambel) prec , die Code-Rate r, die Anzahl n von Bits (z.B. Informationsbits + Redundanzbits) der LDPC-codierten Bitfolge und die Anzahl D_L der geschätzten Koeffizienten bei der Iteration i, ∀i = 0,•••, N_iter - 1, umfasst.
  Bei einem zweiten Schritt 904 wird eine Anzahl N_iter von Iterationen basierend auf der Gleichung N_iter = n/D_L bestimmt, der Abkling-Schätzvektor h wird auf null ĥ = [0]_1×n initialisiert, das decodierte Codewort v wird auf Null, v̂ = [0]_1×n initialisiert.
  Bei einem dritten Schritt 906 wird eine Steuervariable i auf null gesetzt, i = 0.
  Bei einem vierten Schritt 908 wird der Abkling-Schätzvektor ĥ_i basierend auf der Gleichung ĥ_i = estimate (p_ref,p_rec) geschätzt.
  Bei einem fünften Schritt 910 wird der Abkling-Schätzvektor fi so aktualisiert, dass er ĥ_i beinhaltet, so dass $\widehat{\text{h}}\left(\text{i}\times {\text{D}}_{\text{L}}:\left(\left(\text{i}+1\right)\times {\text{D}}_{\text{L}}\right)-1\right)={\widehat{\text{h}}}_{\text{i}}.$

  

  .
  Bei einem sechsten Schritt 912 werden ĥ und r entschachtelt und dem LDPC-Decodierer zugeführt, wobei der LDPC-Decodierer zuerst die apriori-LLRs berechnet und dann den Belief Propagation-Algorithmus auslöst, um zu versuchen, das empfangene Codewort teilweise zu decodieren, v̂ = LDPCdecode(ξ^-1(r),ξ^-1(ĥ)).
  Bei einem siebten Schritt 914 wird die Referenzpräambel aktualisiert, um das verschachtelte, decodierte LDPC-Segment zu beinhalten, $$p_{ref}=\left[p_{ref}\xi \left(\widehat{v}\left(i\times D_L:\left(\left(i+1\right)\times {\text{D}}_{\text{L}}\right)-1\right)\right)\right].$$

  

  Bei einem achten Schritt 916 wird die empfangene Version der Referenzpräambel aktualisiert, um die abgeklungene empfangene Version des decodierten LDPC-Segments zu beinhalten, ${\text{p}}_{\text{prec}}=\left[{\text{p}}_{\text{rec}}\text{ r}\left(\text{i}\times {\text{D}}_{\text{L}}:\left(\left(\text{i}+1\right)\times {\text{D}}_{\text{L}}\right)-1\right)\right].$

  

  
  Bei einem neunten Schritt 918 wird die Steuervariable i um eins erhöht, i = i + 1.
• Bei einem zehnten Schritt 920 wird geprüft, ob die Steuervariable i kleiner als die ermittelte Anzahl N_iter von Iterationen ist, und wenn ja, wird mit dem vierten Schritt 908 fortgefahren, ansonsten mit einem elften Schritt 922.
  Bei dem elften Schritt 922 wird das decodierte Codewort v̂ als Ausgabe zur Verfügung gestellt.
• Mit anderen Worten, eine detaillierte Beschreibung des Decodiermechanismus ist in 14 dargestellt. Bei der ersten Decodier-Iteration wird die Präambel auf die empfangene Präambelsequenz initialisiert, und sowohl der Abkling-Schätzvektor fi als auch das decodierte Codewort v̂ werden auf Null initialisiert. ĥ_i soll den Vektor von D_L geschätzten Koeffizienten bei der Iteration i, ∀i = 0, •••, N_iter - 1, bezeichnen, wobei N_iter die Anzahl der Decodierungs-Iterationen ist. Der Schätzvektor ĥ wird so aktualisiert, dass er ĥ_i beinhaltet, so dass: $$\widehat{\text{h}}\left(\text{i}\times D_L:\left(\left(i+1\right)\times D_L\right)-1\right)={\widehat{h}}_i.$$

  
• Danach werden ĥ und r entschachtelt und dem LDPC-Decodierer 214 zugeführt. Der Decodierer berechnet zunächst die apriori-LLRs und löst dann den Belief Propagation-Algorithmus aus, um zu versuchen, das empfangene Codewort teilweise zu decodieren.
• Nach jeder Iteration werden sowohl die Referenzpräambel als auch die empfangene Version derselben aktualisiert, um das verschachtelte decodierte LDPC-Segment bzw. seine abgeklungene empfangene Version zu beinhalten. Dies kann beschrieben werden durch: $$p_{ref}=\left[p_{ref}\xi \left(\widehat{v}\left(i\times D_L:\left(\left(i+1\right)\times {\text{D}}_{\text{L}}\right)-1\right)\right)\right],$$

  

  $$p_{prec}=\left[p_{rec}r\left(i\times D_L:\left(\left(i+1\right)\times D_L\right)-1\right)\right],$$

  

  wobei
  ξ(x), ξ^-1(x) der verschachtelten bzw. entschachtelten Version des Vektors, x entsprechen, ξ(x(a:b)), ξ^-1(x(a:b)) den Werten des a-ten bis b-ten Index der verschachtelten bzw. entschachtelten Versionen von x entsprechen,
  p_ref und p_rec die Referenz- bzw. die empfangene Präambel bezeichnen.
• Weitere Ausführungsbeispiele
• 15 zeigt ein Flussdiagramm eines Verfahrens 300 zum Verschachteln einer LDPC-codierten Bitfolge gemäß einem Ausführungsbeispiel der vorliegenden Erfindung. Das Verfahren 300 umfasst einen Schritt 302 eines Segmentierens der LDPC-codierten Bitfolge in eine Mehrzahl von Segmenten, wobei die Mehrzahl von Segmenten ein erstes Segment und ein oder mehrere andere Segmente umfasst, wobei das erste Segment aus der Mehrzahl von Segmenten aus Bits eines ersten Typs besteht, wobei die Bits des ersten Typs
• Fehlerkorrekturbits der LDPC-codierten Bitfolge sind,
• Wiederholungsakkumulationsbits der LDPC-codierten Bitfolge sind und/oder
• in einer Tanner-Diagramm-Darstellung der LDPC-codierten Bitfolge durch variable Knoten dargestellt sind, die Nicht-Zufalls-Verbindungen zu mindestens zwei Fehlerkorrektur-Kontrollknoten umfassen.

Weiterhin umfasst das Verfahren 300 einen Schritt 304 eines Verschachtelns des einen oder der mehreren anderen Segmente oder einer verketteten Version derselben, um eine verschachtelte Bitfolge zu erhalten. Weiterhin umfasst das Verfahren 300 einen Schritt 303 eines blockweisen Verschachtelns des ersten Segments der Mehrzahl von Segmenten und der verschachtelten Bitfolge, um eine verschachtelte Version der LDPC-codierten Bitfolge zu erhalten.
• 16 zeigt ein Flussdiagramm eines Verfahrens 320 zum Entschachteln einer verschachtelten Version einer LDPC-codierten Bitfolge gemäß einem Ausführungsbeispiel der vorliegenden Erfindung. Das Verfahren 320 umfasst einen Schritt 322 eines blockweisen Entschachtelns der verschachtelten Version der LDPC-codierten Bitfolge, um ein erstes Segment und eine verschachtelte Version eines oder mehrerer anderer Segmente zu erhalten, wobei das erste Segment der Mehrzahl von Segmenten aus Bits eines ersten Typs besteht, wobei die Bits des ersten Typs
• Fehlerkorrekturbits der LDPC-codierten Bitfolge sind,
• Wiederholungsakkumulationsbits der LDPC-codierten Bitfolge sind und/oder
• in einer Tanner-Diagramm-Darstellung der LDPC-codierten Bitfolge durch variable Knoten dargestellt sind, die Nicht-Zufalls-Verbindungen zu mindestens zwei Fehlerkorrektur-Kontrollknoten umfassen.
Weiterhin umfasst das Verfahren 320 einen Schritt 324 eines Entschachtelns der verschachtelten Version des einen oder der mehreren anderen Segmente, um den einen oder die mehreren anderen Segmente zu erhalten. Weiterhin umfasst das Verfahren 320 einen Schritt 326 eines Verkettens des ersten Segments und des einen oder der mehreren anderen Segmente, um die LDPC-codierte Bitfolge zu erhalten.
• Anschließend werden weitere Ausführungsbeispiele der vorliegenden Erfindung beschrieben, die einzeln oder in Kombination mit in dieser Patentanmeldung beschriebenen Ausführungsbeispielen implementiert werden können.
• Ausführungsbeispiele stellen einen Hybrid-Verschachteler für LDPC-Codes bereit, die eine Treppenknotenverteilung aufweisen, wie beispielsweise die für das kommende IEEE 802.15.4w [1] vorgeschlagenen Codes, und die im DVB-NGH-Standard übernommenen Codes. Der Verschachteler ermöglicht es, dem Kanalschätzer zusätzliche Pilotsymbole zur Verfügung zu stellen, um einen entscheidungsorientierten Kanalschätz(DDCE)-Ansatz [2] bereitzustellen. Der Verschachteler zerlegt das LDPC-Codewort in N_chunks Segmente. Er beginnt mit dem Segment, das den Anfang der Treppenkonstruktion markiert. Dieses Treppen-Segment ist blockweise über die Sprünge verteilt. Danach werden die restlichen N_chunks - 1 Segmente zufällig verschachtelt und an den Sprüngen montiert, die den blockweise verschachtelten Treppenbits folgen. Die Essenz des Hybrid-Blockweise-Zufalls-Verschachtelers gemäß Ausführungsbeispielen liegt in der Machbarkeit des neu strukturierten LDPC-Codeworts, um den Belief Propagation (BP)-Decodierungsalgorithmus auszulösen, selbst wenn eine begrenzte Anzahl von geschätzten Abkling-Koeffizienten vorhanden ist. Das bedeutet, dass der LDPC-Decodierer noch in der Lage wäre, einige Bits zu decodieren. Diese Bits würden als zusätzliche Pilotsymbole dienen, die zusammen mit der ursprünglichen Präambelsequenz an den Kanalschätzer zurückgegeben werden könnten. Dies würde im Gegenzug die Erfassung zusätzlicher Abkling-Koeffizienten ermöglichen, die an den LDPC-Decodierer zurückgegeben werden. Der Prozess des Hin- und Herleitens von Informationen zwischen dem LDPC-Decodierer und dem entscheidungsorientierten Kanalschätzer wird fortgesetzt, bis das gesamte LDPC-Codewort decodiert ist.
• Ausführungsbeispiele strukturieren das Tanner-Diagramm von LDPC-Codes mit der Code-Rate r ≤ 1/2 um, die eine Treppenstruktur aufweisen.
• Ausführungsbeispiele verwenden das LDPC-Codewort so, dass seine Decodierfähigkeit maximiert wird (z.B. auch bei einer begrenzten Anzahl von geschätzten Abkling-Koeffizienten).
• Ausführungsbeispiele sortieren die LDPC-Bits so aus, dass die ursprünglich geschätzten Abkling-Koeffizienten den minimalen Auslöseschwellenwert des LDPC-Decodierers erreichen würden.
• Ausführungsbeispiele erhöhen die Wahrscheinlichkeit, Kontrollknoten zu haben, bei denen nur eine gelöschte LLR von ihren entsprechenden variablen Knoten empfangen wurde.
• Ausführungsbeispiele brechen die Treppenstruktur des codierten Codeworts auf.
• Ausführungsbeispiele verteilen die systematischen Informationsbits ohne Treppe über die Sprünge.
• Ausführungsbeispiele verwürfeln indirekt die ersten geschätzten Abkling-Koeffizienten über das Codewort hinweg (z.B. anstatt sie in ein Segment zu stapeln).
• Ausführungsbeispiele ermöglichen die Machbarkeit des Glauben-Ausbreitung-Decodierungsalgorithmus des LDPC mit einer begrenzten Anzahl von geschätzten Abkling-Koeffizienten.
• Ausführungsbeispiele weisen die LDPC-decodierten Bits als zusätzliche Pilotsymbole zu, die zusammen mit der ursprünglichen Präambelsequenz an den Kanalschätzer zurückgegeben werden könnten.
• Ausführungsbeispiele ermöglichen die Erfassung zusätzlicher Abkling-Koeffizienten, die an den LDPC-Decodierer zurückgegeben werden.
• Ausführungsbeispiele leiten Informationen zwischen dem LDPC-Decodierer und dem entscheidungsorientierten Kanalschätzer hin und her.
• Ausführungsbeispiele fördern eine verbesserte Kanalschätzung mit einer relativ kurzen Präambelsequenz.
• Ausführungsbeispiele lassen das Bedürfnis aus, eine lange, datenfreie Präambelsequenz zu senden, um einen bestimmten Zuverlässigkeitsschwellenwert zu gewährleisten.
• Ausführungsbeispiele erhöhen relativ die effektive Datenrate im Vergleich zur herkömmlichen pilotgestützten Kanalschätzung, wenn der gleiche Zuverlässigkeitsgrad erreicht werden soll.
• Ausführungsbeispiele bieten alternativ eine höhere Robustheit gegenüber der herkömmlichen pilotgestützten Kanalschätzung bei Annahme gleicher Präambelgröße.
• Bei Ausführungsbeispielen besteht der Verschachteler (z.B. Hybrid-Blockweise-Zufalls-Verschachteler) aus vier Stufen (oder Blöcken): (1) Segmentierung, (2) Verkettung, (3) Pseudozufalls-Verschachtelung und (4) Blockweise-Verschachtelung.
• Bei Ausführungsbeispielen nimmt der Segmentierungsblock das Eingangscodewort v der Länge n Bits auf und gibt N_chunks Segmente aus, Ch_i ∀ i = 0, ..., N_chunks - 1, wobei N_chunks = 1/r, und r = k/n die Code-Rate ist, wobei jedes Segment N_bits/chunk = n/N_chunks Bits aufweist, die seriell aus v genommen werden, wobei jedes Segment Ch_i gegeben ist durch: $$C{h}_i\left(j\right)=\nu \left(j+i{N}_{bits/chunk}\right)\forall i=\mathrm{0,}\dots ,N_{chunks}-\mathrm{1,}j=\mathrm{0,}\dots ,N_{bits/chunk}-1$$

  
• Bei Ausführungsbeispielen nimmt der Verketter Ch_i, ∀i = 0,..., N_chunks - 1, i≠ 1 und verknüpft diese zu einem zusammengesetzten Vektor Ch_0→Nchunks-1\1 der Länge $\left({\text{N}}_{\text{chunks}}-1\right)\times {\text{N}}_{\text{bits}/\text{chunk}},$

  

  wobei der verkettete Vektor gegeben ist durch: $$\begin{array}{c}{\widetilde{Ch}}_{0\to N_{chunks}-1\setminus 1}\left(j+max\left(i-\mathrm{1,0}\right)\times N_{bits/chunk}\right)=C{h}_i\left(j\right)\\ \forall \text{i}=\mathrm{0,}\cdots ,{\text{N}}_{\text{chunks}}-\mathrm{1,}\text{i}\ne \text{1}\text{,j}=\text{0}\text{,}\dots {\text{,N}}_{\text{bits/chunk}}-\mathrm{1,}\end{array}$$

  
• Bei Ausführungsbeispielen nimmt der Zufalls-Verschachteler sowohl den Permutationsvektor π, der durch das LFSR erzeugt ist, als auch den verketteten Vektor Ch_{0→N chunks} -_1\1, wobei der Zufalls-Verschachteler einen verschachtelten Vektor ${\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\setminus 1}$

  

  erzeugt, wobei die Abbildung von Elementen aus Ch_{0→N chunks-1\1} bis ${\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\setminus 1}$

  

  gemäß den Permutationsindizes in π so erfolgt, dass: $${\widetilde{Ch}}_{0\to {\text{N}}_{\text{chunks}}-1\setminus 1}\left(j\right)=C{h}_{0\to {\text{N}}_{\text{chunks}}-1\setminus 1}\left(\pi \left(j\right)\right)\forall j=\mathrm{0,}\dots ,L-\mathrm{1,}$$

  

  wobei $\text{L}=\left({\text{N}}_{\text{chunks}}-1\right)\times {\text{N}}_{\text{bits/chunk}}$

  

  die Länge des verketteten Vektors ist.
• Bei Ausführungsbeispielen werden Ch₁ und ${\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\setminus 1}$

  

  dem Blockweise-Verschachteler zugeführt und erzeugen einen Ausgabevektor v̂, der der verschachtelten Version des LDPC-codierten Vektors v entspricht. Der Verschachteler läuft schleifenmäßig über die N_hops und weist N_bits/round Bits für jeden Sprung zu. Zuerst beginnt er mit dem Abbilden von ${\text{N}}_{\text{bits/round}}^{\left(1\right)}=2$

  

  Bits aus Ch₁ auf jeden Sprung über ${\text{N}}_{\text{rounds}}^{\left(1\right)}$

  

  Runden. Dies kann dargestellt werden durch: $$\begin{array}{c}\tilde{v}\left(j+i\times N_{bits/hop}+k\times {\text{N}}_{bits/round}^{\left(1\right)}\right)=C{h}_1(j+i\times N_{bits/round}^{\left(1\right)}+k\times N_{hops}\times \\ N_{bits/round}^{\left(1\right)}),\end{array}$$

  

  wobei
  N_hops die Anzahl der Sprünge ist,
  N_bits/hop = n/N_hops die Anzahl der übertragenen Bits über jeden Sprung ist, ${\text{N}}_{\text{bits/rounds}}^{\left(1\right)}=2$

  

  die Anzahl der Bits ist, die aus Ch₁ auf jeden Sprung jede Runde abgebildet werden, ${\text{N}}_{\text{rounds}}^{\left(1\right)}$

  

  die Gesamtzahl der Runden ist, die benötigt werden, um alle Bits aus Ch₁ zu leeren,
  i = 0, •••, N_hops - 1 der Sprungindex ist,
  j = 0, •••, ${\text{N}}_{\text{bits/round}}^{\left(1\right)}$

  

  - 1 der Bitindex innerhalb der Runde ist und
  k = 0, ••• , ${\text{N}}_{\text{rounds}}^{\left(1\right)}$

  

  - 1 der Rundenindex ist.
• Bei Ausführungsbeispielen wird nach ${\text{N}}_{\text{rounds}}^{\left(1\right)}$

  

  jeder Sprung ${\text{N}}_{\text{rounds}}^{\left(1\right)}\times {\text{N}}_{\text{bits/rounds}}^{\left(1\right)}$

  

  Bits aus Ch₁ haben. Der Rest der N_bits/hop Bits auf jedem Sprung sollten entnommen werden aus ${\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\backslash 1}$

  

  über eine Runde. Das bedeutet, dass für jeden Sprung ${\text{N}}_{\text{bits/round}}^{\left(0\to {\text{N}}_{\text{chunks}}-1/1\right)}=\left({\text{N}}_{\text{chunks}}-1\right)\times {\text{N}}_{\text{bits/chunk}}/{\text{N}}_{\text{hops}}$

  

  Bits sollten seriell aus ${\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\backslash 1}$

  

  entnommen werden sollten. Dies kann beschrieben werden durch: $$\tilde{v}\left(j+i\times N_{bits/hop}+N_{bits/chunk/hop}\right)={\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\backslash 1}\left(j+i\times {\text{N}}_{bits\text{/}round}^{\left(0\to {\text{N}}_{\text{chunks}}-1\backslash 1\right)}\right),$$

  

  wobei
  N_{bits/chunk/hop} = N_bits/chunk/N_hops, ungefähr die Anzahl der übertragenen Bits aus jedem Segment über jeden Sprung ist, ${\text{N}}_{\text{bits/round}}^{\left(0\to {\text{N}}_{\text{chunks}}-1\backslash 1\right)}=\left({\text{N}}_{\text{chunks}}-1\right)\times {\text{N}}_{\text{bits}/\text{chunk}/\text{hop}}$

  

  die Anzahl der Bits ist, die aus ${\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\backslash 1}$

  

  bei jedem Sprung abgebildet werden,
  i = 0, •••, N_hops - 1 der Sprungindex ist und
  j = 0, •••, ${\text{N}}_{\text{bits/round}}^{\left(0\to {\text{N}}_{\text{chunks}}-1\backslash 1\right)}-1$

  

  der Bitindex innerhalb von ${\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\backslash 1}$

  

  ist.
• Weitere Ausführungsbeispiele stellen einen Verschachteler zum Verschachteln einer LDPC-codierten Bitfolge bereit, um eine verschachtelte Version der LDPC-codierten Bitfolge zu erhalten, wobei der Verschachteler konfiguriert ist, um die LDPC-codierte Bitfolge basierend auf der folgenden Syntax zu verschachteln (z.B. durch Ausführen (z.B. Laufenlassen) des folgenden Pseudocodes):

  

  

  

  wobei i eine Steuervariable darstellt, wobei j eine Steuervariable darstellt, wobei n eine Anzahl von Bits (z.B. Informationsbits + Redundanzbits) der LDPC-codierten Bitfolge darstellt, wobei k eine Steuervariable darstellt, wobei r die Code-Rate darstellt, wobei N_chunks eine Anzahl von Segmenten darstellt, in die die LDPC-codierte Bitfolge segmentiert ist, wobei N_hops eine Anzahl von Teildatenpaketen darstellt, über die die verschachtelte Version der LDPC-codierten Bitfolge verteilt ist, wobei ${\text{N}}_{\text{rounds}}^{\left(1\right)}$

  

  eine Anzahl von Runden darstellt, die erforderlich sind, um die Bits des ersten Segments zu verteilen, wobei ${\text{N}}_{\text{bits}/\text{rounds}}^{\left(1\right)}$

  

  eine Anzahl von Bits pro Runde darstellt, die aus dem ersten Segment entnommen und über die Mehrzahl von Teildatenpaketen verteilt werden, wobei N_bits/hop eine Anzahl von Bits pro Teildatenpaket darstellt, wobei N_bits/chunk eine Anzahl von Bits pro Segment darstellt, wobei N_{bits/chunk/hop} eine Anzahl von Bits pro Segment pro Sprung darstellt, wobei v die LDPC-codierte Bitfolge darstellt, wobei ṽ die verschachtelte Version der LDPC-codierten Bitfolge darstellt, wobei Ch_i jedes der Mehrzahl von Segmenten repräsentiert, wobei Ch₁ das erste Segment darstellt, wobei ${\widetilde{\text{Ch}}}_{0\to {\text{N}}_{\text{chunks}}-1\backslash 1}$

  

  die verschachtelte Bitfolge (z.B. eine verschachtelte Version (einer verketteten Version) des einen oder der mehreren anderen Segmente) darstellt.
• Die Kanalschätzung ist ein entscheidender. Faktor für die erfolgreiche Decodierung von LDPC-Codewörtern. Um eine ausreichende Schätzung des Kanals zu ermöglichen, ist eine lange Präambelsequenz erforderlich. Dies führt wiederum zu einer Verringerung der effektiven Datenrate. Wird dagegen eine kurze Präambel eingefügt, fehlt dem LDPC-Decodierer die ausreichende Anzahl von geschätzten Abkling-Koeffizienten. Infolgedessen würde der LDPC-Decodierer die Symbole, die den nicht geschätzten Koeffizienten entsprechen, als Löschung behandeln. Dies würde folglich das Auslösen des LDPC-Decodierers unmöglich machen.
• Ausführungsbeispiele stellen einen Hybrid-Verschachteler bereit, der darauf abzielt, das Dilemma des Kompromisses zwischen Rate und Zuverlässigkeit zu lösen. Der Hybrid-Verschachteler greift die LDPC-Codes auf, die eine Treppenknotenstruktur aufweisen, wie die für das kommende IEEE 802.15.4w vorgeschlagenen Codes und die im DVB-NGH-Standard übernommenen Codes. Er zielt auf die Umstrukturierung des LDPC-Codeworts ab, so dass die Decodierfähigkeit auch bei begrenzten geschätzten Abkling-Koeffizienten maximiert wird. Der Verschachteler zerlegt das LDPC-Codewort in N_chunks Segmente. Er beginnt mit dem Segment, das den Anfang der Treppenstruktur markiert. Dieses Treppensegment ist blockweise über die Sprünge verteilt. Danach werden die restlichen (N_chunks - 1) Segmente pseudozufällig verschachtelt und werden an den Sprüngen angebracht, die den blockweise verschachtelten Treppenbits folgen.
• Die Essenz des Hybrid-Blockweise-Zufalls-Verschachtelers gemäß Ausführungsbeispielen liegt in der Machbarkeit des neu strukturierten LDPC-Codeworts, den BP-Decodierungsalgorithmus selbst dann auszulösen, wenn eine begrenzte Anzahl von geschätzten Abkling-Koeffizienten vorhanden ist. Das bedeutet, dass der LDPC-Decodierer noch in der Lage wäre, einige Bits zu decodieren. Diese Bits würden als zusätzliche Pilotsymbole dienen, die zusammen mit der ursprünglichen Präambelsequenz an den Kanalschätzer zurückgegeben werden könnten. Dies würde im Gegenzug die Erfassung zusätzlicher Abkling-Koeffizienten ermöglichen, die an den LDPC-Decodierer zurückgegeben werden. Der Prozess des Hin- und Hertransfers von Informationen zwischen dem LDPC-Decodierer und dem entscheidungsorientierten Kanalschätzer wird fortgesetzt, bis das gesamte LDPC-Codewort decodiert ist.
• Weitere Ausführungsbeispiele stellen einen Verschachteler (100) zum Verschachteln eines LDPC-codierten Codeworts bereit, wobei das LDPC-codierte Codewort eine Bitfolge z (102) von 736 FEC-codierten Bits (FEC = forward error correction = Vorwärtsfehlerkorrektur) umfasst.
• Die Folge z von 736 FEC-codierten Bits eines einzelnen Codeworts (102) des LDPC-Gebers soll in 4 gleich große Segmente C_i segmentiert werden: $$\text{z}=\left\{{\text{C}}_0,{\text{C}}_1,{\text{C}}_2,{\text{C}}_3\right\}=\left\{{\text{z}}_0,{\text{z}}_1,{\text{z}}_2,\dots ,{\text{z}}_{735}\right\},$$

  

  $${\text{C}}_{\text{i}}=\left\{{\text{z}}_{\text{i}\cdot \text{184}},{\text{z}}_{\text{i}\cdot 184+1},{\text{z}}_{\text{i}\cdot 184+2},\dots ,{\text{z}}_{\left(\text{i}+1\right)\cdot 184-1}\right\}.$$

  

  Das zweite Segment C₁ (110_1) [z.B. das Segment Nummer zwei der Folge von vier Segmenten 110_0 bis 110_3, das hierin als erstes Segment 110_1 bezeichnet wird (vgl. z.B. mit 2)] ist aus der Folge zu entfernen. Die verbleibende Sequenz y (111) [z.B. die (verkettete Version der) drei anderen Segmente 110_0, 110_2 und 110_3, d.h. das Segment Nummer eins, das Segment Nummer drei und das Segment Nummer vier (vgl. z.B. mit 2)] ist gegeben durch: $$\text{y}=\left\{{\text{C}}_0,{\text{C}}_2,{\text{C}}_3\right\}=\left\{{\text{y}}_0,{\text{y}}_1,{\text{y}}_2,\dots ,{\text{y}}_{551}\right\}.$$

  
• Die Sequenz bzw. Folge y (111) soll pseudozufällig unter Verwendung des Verwürfelungs-Vektors u, der von der Pseudozufalls-Folge v abgeleitet ist, die durch das 10-Bit-Galois-LFSR mit Generatorpolynom g(x)=x10+x7+1 erzeugt wird, pseudozufällig verwürfelt werden. Der Anfangswert des LFSR-Schieberegisters (107) bei Iteration 0 soll v₀ = 469 sein, wobei die Rückmeldeausgabe des LFSR (107) das niederwertigste Bit darstellt. Das LFSR (107) in seinem Ausgangszustand bei der Iteration 0 ist in 17 dargestellt.
• Der Wert bei der Iteration v_i+1 wird durch erneutes Iterieren des Schieberegisters hergeleitet. Wenn der Wert dieser Iteration des LFSR 552 überschreitet, wird der Wert übersprungen und das LFSR erneut iteriert, bis der Wert 552 nicht mehr überschreitet. Dieser Wert wird dann v_i+1 zugewiesen.
  Ein Beispiel für die ersten Werte von v ist in Tabelle 1 aufgeführt: Tabelle 1 Beispiel für die Generierung von Verwürfelungs-Vektoren.

  LFSR-Iteration	LFSR-Wert Int.	LFSR-Wert Bit	Gültig	V zygewiesen
  0	469	01 1101 0101	Ja	v0
  1	682	10 1010 1010	Nein	-
  2	341	01 0101 0101	Ja	v1
  3	746	10 1110 1010	Nein	-
  4	373	01 0111 0101	Ja	v2
  5	...	...	...	...

• Der Vektor u ist durch u_i=v_l-1 gegeben und die verwürfelte Version von y, y' (112) [z.B. die verschachtelte Bitfolge 112] ist gegeben durch: $$y\text{'}=\left\{y_{u_0},y_{u_1},\dots ,y_{u_{N_{FEC}}\cdot \left(1-R\right)-1}\right\}$$

  

  Das zweite Segment _c1 (110_1) soll über die L Radio-Bursts (z.B. Teildatenpakete) verteilt werden, indem jedem Bit c_n des Segments ein Radio-Burst-Index / und eine Position i innerhalb des Radio-Bursts abhängig vom Index n zugewiesen wird. $$l\left(n\right)=\lfloor \frac{n}{2}\rfloor \text{mod }\mathrm{23,}$$

  

  $$i\left(n\right)=2\cdot \lfloor \frac{n}{46}\rfloor +\left(n\text{ mod }2\right),$$

  

  mit n ∈ {0,1,2 ... 183}, wobei n=0 sich auf das erste Bit c₀ von C₁ bezieht.
  Den Bits von y' (112)[z.B. die verschachtelte Bitfolge 112] soll wie folgt ein Radio-Burst-Index / und eine vom Index m abhängige Position i zugeordnet werden: $$\text{l}\left(\text{m}\right)=\lfloor \frac{\text{m}}{\text{24}}\rfloor ,$$

  

  $$\text{i}\left(\text{m}\right)=8+\left(\text{m mod 2}4\right),$$

  

  mit m ∈ {0,1,2 ... 551}, wobei m=0 sich auf das erste Bit y'₀ von y' bezieht.
• In beiden Fällen bezieht sich i=0 auf das erste Bit der Radio-Burst-Nutzlast. Werden mehrere Codewörter übertragen, bezieht sich i=0 für das nächste Codewort auf das erste Bit nach den bereits platzierten Bits.
• Obwohl einige Aspekte im Rahmen einer Vorrichtung beschrieben wurden, ist klar, dass diese Aspekte auch eine Beschreibung des entsprechenden Verfahrens darstellen, wobei ein Block oder eine Vorrichtung einem Verfahrensschritt oder einem Merkmal eines Verfahrensschritts entspricht. Analog dazu stellen Aspekte, die im Rahmen eines Verfahrensschritts beschrieben werden, auch eine Beschreibung eines entsprechenden Blocks oder Gegenstands oder Merkmals einer entsprechenden Vorrichtung dar. Einige oder alle Verfahrensschritte können durch (oder unter Verwendung) eine Hardwarevorrichtung ausgeführt werden, wie zum Beispiel einen Mikroprozessor, einen programmierbaren Computer oder eine elektronische Schaltung. Bei einigen Ausführungsbeispielen können ein oder mehrere der wichtigsten Verfahrensschritte durch eine solche Vorrichtung ausgeführt werden.
• Abhängig von bestimmten Implementierungsanforderungen können Ausführungsbeispiele der Erfindung in Hardware oder Software implementiert sein. Die Implementierung kann mit einem digitalen Speichermedium, beispielsweise einer Diskette, einer DVD, einem Blu-Ray, einer CD, einem ROM, einem PROM, einem EPROM, einem EEPROM oder einem FLASH-Speicher, durchgeführt werden, auf dem elektronisch lesbare Steuersignale gespeichert sind, die mit einem programmierbaren Computersystem derart zusammenwirken (oder zusammenwirken können), dass das jeweilige Verfahren durchgeführt wird. Daher kann das digitale Speichermedium computerlesbar sein.
• Einige Ausführungsbeispiele gemäß der Erfindung umfassen einen Datenträger mit elektronisch lesbaren Steuersignalen, die mit einem programmierbaren Computersystem zusammenwirken können, so dass eines der hierin beschriebenen Verfahren durchgeführt wird.
• Im Allgemeinen können Ausführungsbeispiele der vorliegenden Erfindung als Computerprogrammprodukt mit einem Programmcode implementiert sein, wobei der Programmcode für die Ausführung eines der Verfahren wirksam ist, wenn das Computerprogrammprodukt auf einem Computer läuft. Der Programmcode kann beispielsweise auf einem maschinenlesbaren Träger gespeichert sein.
• Weitere Ausführungsbeispiele umfassen das Computerprogramm zur Durchführung eines der hierin beschriebenen Verfahren, das auf einem maschinenlesbaren Träger gespeichert ist.
• Mit anderen Worten, ein Ausführungsbeispiel des erfindungsgemäßen Verfahrens ist daher ein Computerprogramm mit einem Programmcode zur Durchführung eines der hierin beschriebenen Verfahren, wenn das Computerprogramm auf einem Computer läuft.
• Ein weiteres Ausführungsbeispiel des erfindungsgemäßen Verfahrens ist daher ein Datenträger (oder ein digitales Speichermedium oder ein computerlesbares Medium), der darauf aufgezeichnet das Computerprogramm zur Durchführung eines der hierin beschriebenen Verfahren umfasst. Der Datenträger, das digitale Speichermedium oder das Aufzeichnungsmedium sind in der Regel greifbar und/oder nicht flüchtig.
• Ein weiteres Ausführungsbeispiel des erfindungsgemäßen Verfahrens ist daher ein Datenstrom oder eine Signalfolge, der/die das Computerprogramm zur Durchführung eines der hierin beschriebenen Verfahren darstellt. Der Datenstrom oder die Signalfolge kann beispielsweise so konfiguriert sein, dass er/sie über eine Datenkommunikationsverbindung, beispielsweise über das Internet, übertragen wird.
• Ein weiteres Ausführungsbeispiel umfasst eine Verarbeitungseinrichtung, zum Beispiel einen Computer oder ein programmierbares Logikbauelement, die konfiguriert oder angepasst ist, um eines der hierin beschriebenen Verfahren auszuführen.
• Ein weiteres Ausführungsbeispiel umfasst einen Computer, auf dem das Computerprogramm zum Ausführen eines der hierin beschriebenen Verfahren installiert ist.
• Ein weiteres Ausführungsbeispiel gemäß der Erfindung umfasst eine Vorrichtung oder ein System, das konfiguriert ist, um (zum Beispiel elektronisch oder optisch) ein Computerprogramm zum Ausführen eines der hierin beschriebenen Verfahren an einen Empfänger zu übertragen. Der Empfänger kann beispielsweise ein Computer, eine mobile Vorrichtung, eine Speichervorrichtung oder dergleichen sein. Die Vorrichtung oder das System kann beispielsweise einen Dateiserver zum Übertragen des Computerprogramms an den Empfänger umfassen.
• Bei einigen Ausführungsbeispielen kann ein programmierbares Logikbauelement (z.B. ein frei programmierbares Gate-Array) verwendet werden, um einige oder alle Funktionalitäten der hierin beschriebenen Verfahren auszuführen. Bei einigen Ausführungsbeispielen kann ein frei programmierbares Gate-Array mit einem Mikroprozessor zusammenarbeiten, um eines der hierin beschriebenen Verfahren durchzuführen. Im Allgemeinen werden die Verfahren vorzugsweise durch eine beliebige Hardwarevorrichtung durchgeführt.
• Die hierin beschriebene Vorrichtung kann mit einer Hardwarevorrichtung oder mit einem Computer oder mit einer Kombination aus einer Hardwarevorrichtung und einem Computer implementiert sein.
• Die hierin beschriebene Vorrichtung oder Teile der hierin beschriebenen Vorrichtung kann/können zumindest teilweise in Hardware und/oder Software implementiert sein.
• Die hierin beschriebenen Verfahren können mit einer Hardwarevorrichtung oder mit einem Computer oder mit einer Kombination aus einer Hardwarevorrichtung und einem Computer durchgeführt werden.
• Die hierin beschriebenen Verfahren oder Komponenten der hierin beschriebenen Vorrichtung können zumindest teilweise durch Hardware und/oder Software durchgeführt werden.
• Die vorstehend beschriebenen Ausführungsbeispiele dienen lediglich der Veranschaulichung der Prinzipien der vorliegenden Erfindung. Es versteht sich, dass Änderungen und Abweichungen der Anordnungen und der hierin beschriebenen Details für andere Fachkräfte ersichtlich sind. Daher soll sie nur durch den Schutzumfang der beigefügten Patentansprüche eingeschränkt sein, und nicht durch die spezifischen Details, die zur Beschreibung und Erläuterung der Ausführungsbeispiele hierin enthalten sind.
• Literaturverzeichnis

[1]

IEEE P802.15.4w Low Power Wide Area

[2]

DE 10 2018 206 132

[3]

S. Kobayashi, N. Loghin, R. Ikegaya, „proposal-of-ldpc-low density-parity-code-for-Ipwa“, 15-18-0289-01-004w

Claims (35)

1. Ein Verschachteler (100) zum Verschachteln einer LDPC-codierten Bitfolge (102), wobei der Verschachteler (100) folgende Merkmale aufweist: eine Segmentierungsstufe (104), die konfiguriert ist, um die LDPC-codierte Bitfolge (102) in eine Mehrzahl von Segmenten (110_0-110_N_chunks-1) zu segmentieren, wobei die Mehrzahl von Segmenten (110_0-110_N_Chunks-1) ein erstes Segment (110_1) und ein oder mehrere andere Segmente (110_0,110_2-110_N_chunks-1) aufweist, eine erste Verschachtelerstufe (106), die konfiguriert ist, um das eine oder die mehreren anderen Segmente (110_0,110_2-110_N_chunks-1) oder eine verkettete Version derselben zu verschachteln, eine zweite Verschachtelerstufe (108), die konfiguriert ist, um das erste Segment (110_1) der Mehrzahl von Segmenten 1(110_0-110_N_chunks-1) und eine von der ersten Verschachtelerstufe (106) bereitgestellte verschachtelte Bitfolge (112) blockweise zu verschachteln, um eine verschachtelte Version (116) der LDPC-codierten Bitfolge zu erhalten, wobei das erste Segment (110_1) der Mehrzahl von Segmenten (110_0-110_N_chunks-1) aus Bits eines ersten Typs besteht, wobei die Bits des ersten Typs - Fehlerkorrekturbits der LDPC-codierten Bitfolge (102) sind, - Wiederholungsakkumulationsbits der LDPC-codierten Bitfolge (102) sind und/oder - in einer Tanner-Diagramm-Darstellung der LDPC-codierten Bitfolge (102) durch variable Knoten dargestellt sind, die Nicht-Zufalls-Verbindungen zu mindestens zwei Fehlerkorrektur-Kontrollknoten aufweisen.
2. Der Verschachteler (100) nach dem vorstehenden Anspruch, wobei das erste Segment (110_1) die erste Verschachtelerstufe (106) umgeht.
3. Der Verschachteler (100) nach einem der vorstehenden Ansprüche, wobei ein Segment des einen oder der mehreren anderen Segmente (110_0,110_2-110_N_chunk-1) aus Bits eines zweiten Typs besteht, wobei die Bits des zweiten Typs - Informationsbits der LDPC-codierten Bitfolge (102) sind und/oder - in einer Tanner-Diagramm-Darstellung der LDPC-codierten Bitfolge (102) durch variable Knoten dargestellt sind, die Pseudozufallsverbindungen zu Fehlerkorrektur-Kontrollknoten aufweisen.
4. Der Verschachteler (100) nach Anspruch 3, wobei das eine oder die mehreren anderen Segmente (110_0,110_2-110_N_chunks-1) zwei oder mehr andere Segmente sind, wobei ein anderes Segment der zwei oder mehr anderen Segmente (110_0,110_2-110_N_chunks-1) aus Bits des ersten Typs besteht.
5. Der Verschachteler (100) nach einem der vorstehenden Ansprüche, wobei die erste Verschachtelerstufe (106) ein Pseudozufalls-Verschachteler ist.
6. Der Verschachteler (100) nach Anspruch 5, wobei der Pseudozufalls-Verschachteler (106) auf einem linearen Schieberegister basiert.
7. Der Verschachteler (100) nach Anspruch 5, wobei der Pseudozufalls-Verschachteler (106) ein Blockweise-Verschachteler ist.
8. Der Verschachteler (100) nach einem der vorstehenden Ansprüche, wobei die erste Verschachtelerstufe (106) konfiguriert ist, um das eine oder die mehreren anderen Segmente (110_0,110_2-110_N_chunks-1) oder eine verkettete Version (111) derselben basierend auf der folgenden Syntax zu verschachteln:

   

   wobei j eine Steuervariable darstellt, wobei N_chunks die Anzahl der Mehrzahl von Segmenten darstellt, in die die LDPC-codierte Bitfolge segmentiert ist, wobei N_bits/chunk die Anzahl der Bits pro Segment darstellt, wobei ${\widetilde{Ch}}_{0\to N_{chunks}-1\backslash 1}$

   

   die verschachtelte Bitfolge darstellt, wobei Ch_{0→N chunks} -_1/1 eine verkettete Version des einen oder der mehreren anderen Segmente darstellt, wobei π einen Permutationsindizes-Vektor eines Linear-Rückkopplungs-Schieberegisters darstellt.
9. Der Verschachteler (100) nach einem der vorstehenden Ansprüche, wobei die zweite Verschachtelerstufe (108) ein Blockweise-Verschachteler ist.
10. Der Verschachteler (100) nach einem der vorstehenden Ansprüche, wobei die zweite Verschachtelerstufe (108) konfiguriert ist, um die verschachtelte Version (116) der LDPC-codierten Bitfolge über eine Mehrzahl von Teildatenpaketen (120_0-120_N_hops-1) zu verteilen.
11. Der Verschachteler (100) nach Anspruch 10, wobei die zweite Verschachtelerstufe (108) konfiguriert ist, um blockweise Bits des ersten Segments (110_1) der Mehrzahl von Segmenten (110_0-110_N_chunks-1) über die Mehrzahl von Teildatenpaketen (120_0-120_N_hops-1) in mindestens zwei Runden zu verteilen.
12. Der Verschachteler (100) nach einem der Ansprüche 10 bis 11, wobei die zweite Verschachtelerstufe (108) konfiguriert ist, um blockweise Bits der verschachtelten Bitfolge (112), die von der ersten Verschachtelerstufe (106) bereitgestellt wird, gleichmäßig über die Mehrzahl von Teildatenpaketen (120_0-120_N_hops-1) zu verteilen.
13. Der Verschachteler (100) nach einem der vorstehenden Ansprüche, wobei die zweite Verschachtelerstufe (108) konfiguriert ist, um das erste Segment (110_1) und die verschachtelte Bitfolge (112), die von der ersten Verschachtelerstufe (106) bereitgestellt wird, basierend auf der folgenden Syntax zu verschachteln:

    

    

    wobei i eine Steuervariable darstellt, wobei j eine Steuervariable darstellt, wobei k eine Steuervariable darstellt, wobei N_chunks eine Anzahl von Segmenten darstellt, in die die LDPC-codierte Bitfolge segmentiert ist, wobei N_hops eine Anzahl von Teildatenpaketen darstellt, über die die verschachtelte Version der LDPC-codierten Bitfolge verteilt ist, wobei $N_{bits/rounds}^{\left(1\right)}$

    

    eine Anzahl von Bits pro Runde darstellt, die aus dem ersten Segment (110_1) entnommen und über die Mehrzahl von Teildatenpaketen verteilt werden, wobei N_bits/hop eine Anzahl von Bits pro Teildatenpaket darstellt, wobei ṽ die verschachtelte Version der LDPC-codierten Bitfolge darstellt, wobei Ch₁ das erste Segment darstellt, wobei ${\widetilde{Ch}}_{0\to N_{chunks}-1\backslash 1}$

    

    die verschachtelte Bitfolge darstellt.
14. Der Verschachteler (100) nach einem der vorstehenden Ansprüche, wobei eine Anzahl der Mehrzahl von Segmenten (110_0-110_N_chunks-1), in die die LDPC-codierte Bitfolge (102) segmentiert ist, gleich eins ist dividiert durch die Code-Rate der LDPC-codierten Bitfolge (102).
15. Der Verschachteler (100) nach einem der vorstehenden Ansprüche, wobei die Segmentierungsstufe (104) konfiguriert ist, um die LDPC-codierte Bitfolge (102) basierend auf der folgenden Syntax in die Mehrzahl von Segmenten (110_0-110_N_chunks-1) zu segmentieren:

    

    

    wobei i eine Steuervariable darstellt, wobei j eine Steuervariable darstellt, wobei N_chunks eine Anzahl von Segmenten darstellt, in die die LDPC-codierte Bitfolge segmentiert ist, wobei N_bits/chunk die Anzahl der Bits pro Segment darstellt, wobei Ch_i jedes der Mehrzahl von Segmenten darstellt, und wobei v die LDPC-codierte Bitfolge darstellt.
16. Der Verschachteler (100) nach einem der vorstehenden Ansprüche, wobei das eine oder die mehreren anderen Segmente (110_0,110_2-110_N_chunks-1) zwei oder mehr andere Segmente sind, wobei die erste Verschachtelerstufe (106) konfiguriert ist, um eine verkettete Version (111) der zwei oder mehr anderen Segmente zu verschachteln.
17. Der Verschachteler (100) nach Anspruch 16, wobei der Verschachteler eine Verkettungsstufe aufweist, die konfiguriert ist, um die zwei oder mehr anderen Segmente (110_0,110_2-110_N_chunks-1) zu verketten, um die verkettete Version (111) der zwei oder mehr anderen Segmente zu erhalten.
18. Der Verschachteler (100) nach dem vorstehenden Anspruch, wobei die Verkettungsstufe konfiguriert ist, um das eine oder die mehreren anderen Segmente (110_0,110_2-110_N_chunks-1) der Mehrzahl von Segmenten (110_0-110_N_chunks-1) basierend auf der folgenden Syntax zu verketten:

    

    

    wobei k eine Steuervariable darstellt, wobei i eine Steuervariable darstellt, wobei j eine Steuervariable darstellt, wobei N_bits/chunk eine Anzahl von Bits pro Segment darstellt, wobei Ch_{0→N chunks} -_1/1 eine verkettete Version des einen oder der mehreren anderen Segmente darstellt, wobei Ch_i jedes der Mehrzahl von Segmenten darstellt.
19. Ein Verschachteler (100) zum Verschachteln einer LDPC-codierten Bitfolge, wobei der Verschachteler (100) konfiguriert ist, um die LDPC-codierte Bitfolge (102) zu verschachteln, um eine verschachtelte Version (116) der LDPC-codierten Bitfolge basierend auf der folgenden Syntax zu erhalten:

    

    

    wobei i eine Steuervariable darstellt, wobei j eine Steuervariable darstellt, wobei n eine Anzahl von Bits (z.B. Informationsbits + Redundanzbits) der LDPC-codierten Bitfolge darstellt, wobei k eine Steuervariable darstellt, wobei r die Code-Rate darstellt, wobei N_chunks eine Anzahl von Segmenten darstellt, in die die LDPC-codierte Bitfolge segmentiert ist, wobei N_hops eine Anzahl von Teildatenpaketen darstellt, über die die verschachtelte Version der LDPC-codierten Bitfolge verteilt ist, wobei $N_{rounds}^{\left(1\right)}$

    

    eine Anzahl von Runden darstellt, die benötigt werden, um die Bits des ersten Segments zu verteilen, wobei $N_{bits/rounds}^{\left(1\right)}$

    

    eine Anzahl von Bits pro Runde darstellt, die aus dem ersten Segment (110_1) entnommen und über die Mehrzahl von Teildatenpaketen verteilt werden, wobei $N_{bits/round}^{\left(0\to N_{chunks}-1\backslash 1\right)}$

    

    eine Anzahl von Bits pro Runde darstellt, die aus den anderen Segmenten entnommen und über die Mehrzahl von Teildatenpaketen verteilt werden, wobei N_bits/hop eine Anzahl von Bits pro Teildatenpaket darstellt, wobei N_bits/chunk eine Anzahl von Bits pro Segment darstellt, wobei N_{bits/chunk/hop} eine Anzahl von Bits pro Segment pro Sprung darstellt, wobei v die LDPC-codierte Bitfolge darstellt, wobei ṽ die verschachtelte Version der LDPC-codierten Bitfolge darstellt, wobei Ch_i jeden der Mehrzahl von Segmenten darstellen, wobei Ch₁ das erste Segment repräsentiert, wobei ${\widetilde{Ch}}_{0\to N_{chunks}-1\backslash 1}$

    

    die verschachtelte Bitfolge darstellt.
20. Ein Verschachteler (100) zum Verschachteln eines LDPC-codierten Codeworts, wobei das LDPC-codierte Codewort eine Bitfolge (102) von 736 FEC-codierten Bits aufweist, wobei der Verschachteler (100) folgende Merkmale aufweist: eine Segmentierungsstufe (104), die konfiguriert ist, um die Bitfolge z (102) von 736 FEC-codierten Bits in vier gleich große Segmente zu segmentieren, wobei die vier Segmente ein Segment Nummer eins (110_0), ein Segment Nummer zwei (110_1), ein Segment Nummer drei (110_2) und ein Segment Nummer vier (110_3) aufweisen, eine erste Verschachtelerstufe (106), die konfiguriert ist, um eine Sequenz y (111) von Bits, die aus dem Segment Nummer eins (110_0), dem Segment Nummer drei (110_2) und dem Segment Nummer vier (110_3) besteht, pseudozufällig zu verwürfeln, um eine verwürfelte Version y' (112) der Bitfolge zu erhalten, wobei die Folge y (111) pseudozufällig unter Verwendung eines Verwürfelungs-Vektors u, der von einer Pseudozufalls-Folge v hergeleitet ist, die von einem 10-Bit-Galois-LFSR mit Generatorpolynom g(x)=x¹⁰+x⁷+1 erzeugt wird, verwürfelt wird, eine zweite Verschachtelerstufe (108), die konfiguriert ist, um das Segment Nummer zwei (110_1) über L Radio-Bursts zu verteilen, indem jedem Bit c_n des Segments Nummer zwei (110_1) ein Radio-Burst-Index / und eine Position i innerhalb des Radio-Bursts abhängig vom Index n basierend auf der folgenden Syntax zugewiesen wird: $$\text{l}\left(\text{n}\right)=\lfloor \frac{\text{n}}{\text{2}}\rfloor \text{ mod }\mathrm{23,}$$

    

    $$\text{i}\left(\text{n}\right)=2\cdot \lfloor \frac{\text{n}}{46}\rfloor +\left(\text{n mod }24\right),$$

    

    mit n ∈ {0,1,2 ... 183}, wobei n=0 sich auf das erste Bit c₀ des Segments Nummer zwei (110_1) bezieht, wobei die zweite Verschachtelerstufe (108) konfiguriert ist, um die verwürfelte Version y' (112) der Bitfolge über die L Radio-Bursts zu verteilen durch Zuweisen eines Radio-Burst-Index / und einer vom Index m abhängigen Position i basierend auf der folgenden Syntax: $$\text{l}\left(\text{m}\right)=\lfloor \frac{\text{m}}{24}\rfloor ,$$

    

    $$\text{i}\left(\text{m}\right)=8+\left(\text{m mod 2}4\right),$$

    

    mit m ∈ {0,1,2 ... 551}, wobei m=0 sich auf das erste Bit y'₀ der verwürfelten Version y' (112) der Bitfolge bezieht.
21. Ein Sender (202), der folgende Merkmale aufweist: einen Verschachteler (100) nach einem der vorstehenden Ansprüche, einen LDPC-Codierer (206), der konfiguriert ist, um die LDPC-codierte Bitfolge (102) bereitzustellen, und eine Sendeeinheit, die konfiguriert ist, um die verschachtelte Version (116) der LDPC-codierten Bitfolge unter Verwendung einer Mehrzahl von Teildatenpaketen (120_0-120_N_hops-1) zu übertragen, wobei die Mehrzahl von Teildatenpaketen (120_0-120_N_hops-1) nicht gleichzeitig übertragen wird.
22. Ein Entschachteler (140) zum Entschachteln einer verschachtelten Version (116) einer LDPC-codierten Bitfolge, wobei der Entschachteler (140) folgende Merkmale aufweist: eine erste Entschachtelerstufe (142), die konfiguriert ist, um die verschachtelte Version (116) der LDPC-codierten Bitfolge blockweise zu entschachteln, um ein erstes Segment (110_1) und eine verschachtelte Bitfolge (112) zu erhalten, eine zweite Entschachtelerstufe (144), die konfiguriert ist, um die verschachtelte Bitfolge (112) zu entschachteln, um das eine oder die mehreren anderen Segmente (110_0,110_2-110_N_chunks-1) zu erhalten, eine Verkettungsstufe (146), die konfiguriert ist, um das erste Segment (110_1) und das eine oder die mehreren anderen Segmente (110_0,110_2-110_N_chunks-1) zu verketten, um die LDPC-codierte Bitfolge (102) zu erhalten, wobei das erste Segment (110_1) der Mehrzahl von Segmenten (110_0-110_N_chunks-1) aus Bits eines ersten Typs besteht, wobei die Bits des ersten Typs - Fehlerkorrekturbits der LDPC-codierten Bitfolge (102) sind, - Wiederholungsakkumulationsbits der LDPC-codierten Bitfolge (102) sind und/oder - in einer Tanner-Diagramm-Darstellung der LDPC-codierten Bitfolge (102) durch variable Knoten dargestellt sind, die Nicht-Zufalls-Verbindungen zu mindestens zwei Fehlerkorrektur-Kontrollknoten umfassen.
23. Der Entschachteler (140) nach dem vorstehenden Anspruch, wobei das erste Segment (110_1) die zweite Entschachtelerstufe (144) umgeht.
24. Der Entschachteler (140) nach einem der vorstehenden Ansprüche, wobei ein Segment des einen oder der mehreren anderen Segmente (110_0,110_2-110_N_chunks-1) aus Bits eines zweiten Typs besteht, wobei die Bits des zweiten Typs - Informationsbits der LDPC-codierten Bitfolge (102) sind und/oder - in einer Tanner-Diagramm-Darstellung der LDPC-codierten Bitfolge (102) durch variable Knoten dargestellt sind, die Pseudozufallsverbindungen zu Fehlerkorrektur-Kontrollknoten aufweisen.
25. Der Entschachteler (140) nach Anspruch 24, wobei das eine oder die mehreren anderen Segmente (110_0,110_2-110_N_chunks-1) zwei oder mehr andere Segmente sind, wobei ein anderes Segment der zwei oder mehr anderen Segmente (110_0,110_2-110_N_chunks-1) aus Bits des ersten Typs besteht.
26. Der Entschachteler (140) nach einem der vorstehenden Ansprüche, wobei die erste Entschachtelerstufe (142) ein Blockweise-Entschachteler ist.
27. Der Entschachteler (140) nach einem der vorstehenden Ansprüche, wobei die zweite Entschachtelerstufe (144) ein Pseudozufalls-Entschachteler ist.
28. Der Entschachteler (140) nach Anspruch 27, wobei der Pseudozufalls-Entschachteler (144) auf einem linearen Schieberegister basiert.
29. Der Entschachteler (140) nach Anspruch 27, wobei der Pseudozufalls-Entschachteler (144) ein Blockweise-Entschachteler ist.
30. Der Entschachteler (140) nach einem der vorstehenden Ansprüche, wobei die verschachtelte Bitfolge (112) eine verschachtelte Version einer verketteten Version von zwei oder mehr anderen Segmenten (110_0,110_2-110_N_chunks-1) ist, wobei die zweite Entschachtelerstufe (144) konfiguriert ist, um die verschachtelte Version der verketteten Version der zwei oder mehr anderen Segmente (110_0,110_2-110_N_chunks-1) zu entschachteln.
31. Ein Empfänger (204), der folgende Merkmale aufweist: eine Empfangseinheit, die konfiguriert ist, um eine Mehrzahl von Teildatenpaketen (120_0-120_N_hops-1) zu empfangen, die nicht gleichzeitig von einem Sender (202) zu dem Empfänger (204) übertragen werden, einen Entschachteler (140) nach einem der vorstehenden Ansprüche, wobei der Entschachteler (140) konfiguriert ist, um unter Verwendung von Kanalzustandsinformationen, die einen Kanal zwischen dem Sender (202) und dem Empfänger (204) beschreiben, eine abgeklungene Version der LDPC-codierten Bitfolge, die mit der Mehrzahl von Teildatenpaketen (120_0-120_N_hops-1) übertragen wird, iterativ zu entschachteln, und einen iterativen Decodierer (214), der konfiguriert ist, um die LDPC-codierte Bitfolge iterativ zu decodieren, die durch den Entschachteler (140) iterativ bereitgestellt wird, wobei die Kanalzustandsinformationen basierend auf einer decodierten Bitfolge, die durch den iterativen Decodierer (214) bereitgestellt wird, iterativ aktualisiert werden.
32. Ein Verfahren (300) zum Verschachteln einer LDPC-codierten Bitfolge (102), wobei das Verfahren (300) folgende Schritte aufweist: Segmentieren (302) der LDPC-codierten Bitfolge (102) in eine Mehrzahl von Segmenten (110_0-110_N_chunks-1), wobei die Mehrzahl von Segmenten (110_0-110_N_chunks-1) ein erstes Segment (110_1) und ein oder mehrere andere Segmente (110_0,110_2-110_N_chunks-1) aufweist, Verschachteln (304) des einen oder der mehreren anderen Segmente (110_0,110_2-110_N_chunks-1) oder einer verketteten Version (111) derselben, um eine verschachtelte Bitfolge (112) zu erhalten, blockweises Verschachteln (306) des ersten Segments (110_1) der Mehrzahl von Segmenten (110_0-110-N_chunks-1) und der verschachtelten Bitfolge (112), um eine verschachtelte Version (116) der LDPC-codierten Bitfolge zu erhalten, wobei das erste Segment (110_1) der Mehrzahl von Segmenten (110_0-110_N_chunks-1) aus Bits eines ersten Typs besteht, wobei die Bits des ersten Typs - Fehlerkorrekturbits der LDPC-codierten Bitfolge (102) sind, - Wiederholungsakkumulationsbits der LDPC-codierten Bitfolge (102) sind und/oder - in einer Tanner-Diagramm-Darstellung der LDPC-codierten Bitfolge (102) durch variable Knoten dargestellt sind, die Nicht-Zufalls-Verbindungen zu mindestens zwei Fehlerkorrektur-Kontrollknoten aufweisen.
33. Ein Verfahren (320) zum Verschachteln eines LDPC-codierten Codeworts, wobei das LDPC-codierte Codewort eine Bitfolge (102) von 736 FEC-codierten Bits aufweist, wobei das Verfahren folgende Schritte aufweist: Segmentieren der Bitfolge z (102) von 736 FEC-codierten Bits in vier gleich große Segmente, wobei die vier Segmente ein Segment Nummer eins (110_0), ein Segment Nummer zwei (110_1), ein Segment Nummer drei (110_2) und ein Segment Nummer vier (110_3) aufweisen, pseudozufälliges Verschlüsseln einer Sequenz y (111) von Bits, die aus dem Segment Nummer eins (110_0), dem Segment Nummer drei (110_2) und dem Segment Nummer vier (110_3) besteht, um eine verwürfelte Version y' (112) der Bitfolge zu erhalten, wobei die Folge y (111) pseudozufällig unter Verwendung eines Verwürfelungs-Vektors u, der von einer Pseudozufalls-Folge v abgeleitet ist, die von einem 10-Bit-Galois-LFSR mit Generatorpolynom g(x)=x¹⁰+x⁷+1 erzeugt wird, verwürfelt wird, Verteilen des Segments Nummer zwei (110_1) über L Radio-Bursts durch Zuweisen, zu jedem Bit c_n des Segments Nummer zwei (110_1), eines Radio-Burst-Index / und einer Position i innerhalb des Radio-Bursts abhängig vom Index n basierend auf der folgenden Syntax: $$\text{l}\left(\text{n}\right)=\lfloor \frac{\text{n}}{\text{2}}\rfloor \text{mod }\mathrm{23,}$$

    

    $$\text{i}\left(\text{n}\right)=2\cdot \lfloor \frac{\text{n}}{46}\rfloor +\left(\text{n mod }2\right)$$

    

    mit n ∈ {0,1,2 ... 183}, wobei n=0 sich auf das erste Bit c₀ des Segments Nummer zwei (110_1) bezieht, Verteilen der verwürfelten Version y' (112) der Bitfolge über die L Radio-Bursts durch Zuweisen eines Radio-Burst-Index / und einer vom Index m abhängigen Position i basierend auf der folgenden Syntax: $$\text{l}\left(\text{m}\right)=\lfloor \frac{\text{m}}{24}\rfloor ,$$

    

    $$\text{i}\left(\text{m}\right)=8+\left(\text{m mod }24\right),$$

    

    mit m ∈ {0,1,2... 551}, wobei m=0 sich auf das erste Bit y'₀ der verwürfelten Version y' (112) der Bitfolge bezieht.
34. Ein Verfahren (320) zum Entschachteln einer verschachtelten Version (116) einer LDPC-codierten Bitfolge (102), wobei das Verfahren (320) folgende Schritte aufweist: blockweises Entschachteln (322) der verschachtelten Version (116) der LDPC-codierten Bitfolge (102), um ein erstes Segment (110_1) und eine verschachtelte Version eines oder mehrerer anderer Segmente (110_0,110_2-110_N_chunks-1) zu erhalten, Entschachteln (324) der verschachtelten Version (112) des einen oder der mehreren anderen Segmente (110_0,110_2-110_N_chunks-1), um das eine oder die mehreren anderen Segmente (110_0,110_2-110_N_chunks-1) zu erhalten, Verketten (326) des ersten Segments (110_1) und des einen oder der mehreren anderen Segmente (110_0,110_2-110_N_chunks-1), um die LDPC-codierte Bitfolge (102) zu erhalten, wobei das erste Segment (110_1) der Mehrzahl von Segmenten (110_0-110_N_chunks-1) aus Bits eines ersten Typs besteht, wobei die Bits des ersten Typs - Fehlerkorrekturbits der LDPC-codierten Bitfolge (102) sind, - Wiederholungsakkumulationsbits der LDPC-codierten Bitfolge (102) sind und/oder - in einer Tanner-Diagramm-Darstellung der LDPC-codierten Bitfolge (102) durch variable Knoten dargestellt sind, die Nicht-Zufalls-Verbindungen zu mindestens zwei Fehlerkorrektur-Kontrollknoten aufweisen.
35. Ein Computerprogramm zum Durchführen eines Verfahrens nach einem der vorstehenden Ansprüche, wenn das Computerprogramm auf einem Computer oder Mikroprozessor läuft.

Images