Conception et implémentation d'une communication UART entre un FPGA et un PC

Lors de la mise en œuvre initiale d'une communication UART sur une carte FPGA, il est fréquent de rencontrer des défis comme les erreurs de baudrate ou des problèmes d'alignement de données. Cet article explique comment construire un système fiable de communication FPGA-PC en résolvant les problèmes courants rencontrés dans la pratique.

1. Architecture matérielle et paramètres clés

La communication UART entre un FPGA et un PC repose sur une transmission asynchrone de données série. Trois aspects principaux doivent être pris en compte : la conversion de domaine horloge, l'analyse du cadre de données et l'adaptation au niveau physique.

• Côté FPGA : Module transmetteur/récepteur UART (implémenté en Verilog/VHDL).
• Liaison physique : Module USB vers TTL (par exemple CH340G ou CP2102).
• Côté PC : Assistant de port série (Tera Term ou Putty recommandé).

Le calcul précis du baudrate est essentiel. Avec une horloge système de 50 MHz et un baudrate de 115200, voici le coefficient de division :

localparam FREQUENCE_HORAIRE = 50_000_000; // 50 MHz
localparam BAUD_RATE = 115200;
localparam DIVISION_BAUD = FREQUENCE_HORAIRE / BAUD_RATE; // Résultat : 434

Pour améliorer la fiabilité :

1. Utilisez un échantillonnage 16x pour stabiliser la réception.
2. Implémentez des bits de parité pour détecter les erreurs.
3. Intégrez un contrôle de flux matériel (RTS/CTS) pour éviter les pertes de données.

2. Détails d'implémentation en Verilog

2.1 Module d'envoi (uart_tx)

Le module d'envoi doit contrôler avec précision le timing du bit de départ, des bits de données et du bit d'arrêt. Voici une version optimisée :

always @(posedge clk) begin
    case(état)
        INACTIF: begin
            txd <= 1'b1;
            if(démarrer_envoi) begin
                compteur_baud <= 0;
                compteur_bit <= 0;
                état <= BIT_DEPART;
            end
        end
        BIT_DEPART: begin
            txd <= 1'b0;
            if(compteur_baud == DIVISION_BAUD - 1) begin
                compteur_baud <= 0;
                état <= BITS_DONNEES;
            end else compteur_baud <= compteur_baud + 1;
        end
        // Transition des bits de données...
    endcase
end

Problèmes courants :

• Bruit lors de l'envoi : vérifiez la gestion des domaines horloges.
• Écart important du baudrate : recalculer le coefficient de division.
• Erreur d'ordre des bits : confirmez l'ordre LSB/MSB.

2.2 Module de réception (uart_rx)

Le récepteur doit gérer les décalages d'horloge et le bruit. Une solution classique est l'échantillonnage triple :

always @(posedge clk) begin
    rx_sync <= {rx_sync[0], entree_uart};
    if(&rx_sync) rx_filtré <= 1'b1;
    else if (~|rx_sync) rx_filtré <= 1'b0;
end

Améliorations recommandées :

• Détection d'erreurs de trame (vérification du bit d'arrêt).
• Détection de rupture (délai prolongé à l'état haut).
• Mécanisme de timeout de réception (réinitialisation automatique).

3. Validation par simulation et techniques de débogage

3.1 Configuration de simulation conjointe avec Modelsim

Pour configurer un environnement de test complet :

1. Écrivez des cas de teest incluant des scénarios anormaux :

initial begin
    // Trame de données normale
    envoyer_trame_uart(8'h55);
    // Simulation d'une erreur de trame
    #1000 entree_uart_force = 0; // Prolongation du bit de départ
    #20000 entree_uart_force = 1;
end

2. Configurez les signaux clés dans la fenêtre des signaux :

• Envoi : txd, état_envoi, donnée_envoi.
• Réception : rxd, donnée_valide, octet_reçu.

3. Automatisez les tests avec des scripts TCL :

vsim work.testbench_uart
add wave *
run 1ms
if {[examine indicateur_erreur] == 1} {
    echo "Test échoué !"
}

3.2 Solutions aux problèmes courants en simulation

4. Tests pratiques et optimisations

4.1 Liste de vérifictaion des connexions matérielles

• Compatibilité de niveau : Assurez-vous que l'I/O FPGA est configuré en 3.3V LVTTL.
• Vérification des câblages : Connectez TX-RX croisé (FPGA_TX → USB_RX).
• Mise à la masse commune : Assurez-vous que la carte et le convertisseur USB partagent la même masse.

Configuration matérielle recommandée :

• Carte FPGA : Série Xilinx Artix-7.
• Convertisseur USB : FT232RL (plus stable que CH340).
• Câble : Filaire blindé avec filtre magnétique.

4.2 Techniques de débogage en temps réel

En cas d'anomalie de communication, procédez ainsi :

1. Vérifiez la qualité du signal avec un oscilloscope :

• Mesurez le baudrate réel (9600 bauds correspond à 104μs/bit).
• Observez le temps de montée du signal (<1μs).

2. Validez les configurations logicielles :

• Paramètres des bits de données et d'arrêt.
• Options de contrôle de flux (généralement désactivées).

3. Débogage FPGA en ligne :

// Insertion d'un noyau ILA pour surveillance en temps réel
ila_0 u_ila (
    .clk(clk),
    .sonde0(état_rx),
    .sonde1(octet_rx),
    .sonde2(en_cours_envoi)
);

4.3 Optimisations de performance

Pour des transmissions rapides (>1 Mbps), envisagez :

1. L'utilisation de transferts DMA pour réduire la charge CPU.
2. Un mécanisme double tampon pour prévenir les pertes de données.
3. Une vérification CRC matérielle (idéale pour des protocoles comme Modbus).

// Exemple : Calcul CRC16
always @(posedge clk) begin
    if(activer_crc) begin
        sortie_crc <= prochain_crc(sortie_crc, donnée_entree);
    end
end

5. Applications avancées : Conception de protocoles personnalisés

Une fois la communication de base stabilisée, vous pouvez développer un protocole utile :

Exemple de format de trame :

Points clés :

• Implémentez un mécanisme de retransmission en cas de timeout.
• Concevez des mécanismes de confirmation (ACK/NACK).
• Supportez le fractionnement des gros fichiers.

Ce design peut fonctionner de manière stable jusqu'à 460800 bauds avec un taux d'erreur inférieur à 10^-6. Il est conseillé d'utiliser un analyseur logique lors du premier démarrage pour capturer le processus complet de communication.