# 🧭 Ordre d’implémentation d’une chaîne de réception QAM (réelle)

## **Étape 0 — Environnement et base de test**

🎯 Objectif : avoir une base stable de simulation avant toute boucle adaptative.

**À faire :**

* Lire un **flux IQ** (fichier ou SDR)
* Implémenter un **filtre RRC de réception**
* Visualiser constellations, spectre, symboles

🧠 But : voir des symboles flous mais reconnaissables — aucun algorithme adaptatif encore.

---

## **Étape 1 — Correction de fréquence (CFO / Carrier Recovery)**

🎯 Objectif : supprimer le décalage de fréquence de la porteuse avant le timing recovery.

**Pourquoi en premier ?**

* Si ton signal tourne dans le plan complexe, **Mueller & Müller échouera** complètement.
* Il faut un signal “quasistationnaire” avant de chercher le bon instant d’échantillonnage.

**Méthodes à implémenter :**

* Estimation grossière de CFO (par corrélation / FFT)
* Boucle de Costas ou PLL de phase

📘 Résultat attendu : constellation QAM fixe mais “floue” (problème de timing restant).

---

## **Étape 2 — Synchronisation temporelle (Timing Recovery : M&M)**

🎯 Objectif : trouver l’instant exact d’échantillonnage par symbole.

**Tu connais déjà :**

* Interpolateur fractionnaire
* Détecteur d’erreur M&M
* Boucle PI

💡 Astuce : commence avec un signal *parfaitement corrigé en fréquence* avant d’activer la boucle timing.

📘 Résultat attendu : points de constellation bien centrés, toujours un peu brouillés (canal non corrigé).

---

## **Étape 3 — Égalisation adaptative (FFE / CMA / DD-LMS)**

🎯 Objectif : supprimer l’ISI et compenser la distorsion de canal.

**Méthodes typiques :**

* **CMA** (Constant Modulus Algorithm) pour pré-verrouillage (aveugle)
* Puis **DD-LMS** (Decision Directed) une fois la décision fiable

💡 L’égaliseur doit venir **après** le timing (sinon le signal est mal échantillonné).

📘 Résultat attendu : constellation nette, points regroupés correctement autour des symboles 16-QAM.

---

## **Étape 4 — Décision + Mapping**

🎯 Objectif : convertir les symboles QAM en bits.

**À faire :**

* Implémenter la décision dure (±1, ±3)
* Mapping / demapping Gray
* Vérifier BER par rapport à trame connue

💡 Teste d’abord sans bruit pour valider le mapping bit ↔ symbole.

---

## **Étape 5 — Boucles de phase fines (Costas loop fine)**

🎯 Objectif : corriger la phase résiduelle après timing et égalisation.

* Souvent intégrée dans la boucle M&M ou séparée (PLL de phase fine)
* Sert à verrouiller la dernière rotation du plan IQ

---

## **Étape 6 — Correction d’erreurs / décodage (FEC)**

🎯 Objectif : terminer la chaîne par le décodage des bits.

* LDPC, Viterbi, Turbo selon ton système
* C’est la couche “bitstream”, plus logique que DSP

---

## **Étape 7 — Optimisation et intégration**

🎯 Objectif : passer du prototype à la version embarquée.

* Conversion float → fixe (Q-format)
* Pipeline temps réel (DMA, buffers circulaires)
* Profiling CPU / mémoire
* Test sur matériel SDR, puis en RF réelle

---

# ⚙️ En résumé — Ordre d’implémentation

| Étape | Bloc                                 | Type            | Pourquoi cet ordre          |
| ----- | ------------------------------------ | --------------- | --------------------------- |
| 0     | RRC + acquisition IQ                 | statique        | Base stable et visualisable |
| 1     | **Correction de fréquence (CFO)**    | boucle 1        | sinon M&M échoue            |
| 2     | **Synchronisation temporelle (M&M)** | boucle 2        | aligner les symboles        |
| 3     | **Égalisation adaptative**           | boucle 3        | corriger canal              |
| 4     | **Décision + mapping bits**          | logique         | extraire données            |
| 5     | **Boucle de phase fine (Costas)**    | ajustement      | phase finale                |
| 6     | **Décodage FEC**                     | post-traitement | fiabiliser le bitstream     |
| 7     | **Optimisation C/FPGA**              | système         | rendre temps réel           |

---

# 🧠 Ordre de test conseillé

1. Simule tout en **float** dans Python/MATLAB
2. Valide chaque bloc **indépendamment**
3. Assemble et teste avec bruit / décalage
4. **Ensuite seulement**, porte en C (ou sur DSP/FPGA)

---

---

| # | Bloc / Étape                            | Objectif principal                              | Priorité   | Ce qu’il faut coder / comprendre                | Test / Validation                                |
| - | --------------------------------------- | ----------------------------------------------- | ---------- | ----------------------------------------------- | ------------------------------------------------ |
| 0 | **Acquisition & Filtrage RRC**          | Lire le signal IQ et filtrer pour limiter l’ISI | Très haute | FIR RRC, buffer IQ                              | Visualiser constellation, spectre                |
| 1 | **Correction de fréquence (CFO)**       | Supprimer offset de fréquence de la porteuse    | Très haute | PLL / Costas loop, corrélation, FFT             | Constellation immobile, pas de rotation          |
| 2 | **Synchronisation temporelle (M&M)**    | Aligner échantillons sur symboles               | Très haute | Interpolateur fractionnaire, TED M&M, boucle PI | Points centrés, vérification de tau_hat          |
| 3 | **Égalisation adaptative**              | Supprimer ISI et compenser canal                | Haute      | FFE ou DFE, algorithme CMA / DD-LMS             | Constellation nette, erreur moyenne faible       |
| 4 | **Décision symbolique et mapping**      | Convertir symbole → bits                        | Haute      | Hard decision QAM, Gray mapping                 | Vérifier BER avec trame connue                   |
| 5 | **Boucle de phase fine (Costas / PLL)** | Corriger la phase résiduelle                    | Moyenne    | PLL numérique, phase fine                       | Points de constellation fixes, phase verrouillée |
| 6 | **Décodage FEC**                        | Extraire flux de bits fiable                    | Moyenne    | LDPC / Viterbi / Turbo                          | Comparer bits reçus / transmis, BER              |
| 7 | **Optimisation & passage temps réel**   | Adapter pour C / DSP / FPGA                     | Moyenne    | Point fixe, buffers circulaires, pipeline       | Profil CPU / mémoire, latence, test en SDR réel  |

---

### 💡 Notes pratiques :

* **Test bloc par bloc** avant d’intégrer la chaîne complète
* Toujours **simuler en float** avant passage en C ou point fixe
* Chaque boucle (CFO, Timing, Phase) doit être **réglée indépendamment** pour éviter l’instabilité
* Commencer avec **trames simples** avant bruit réel, puis ajouter AWGN / jitter / offsets

---