Gagner un épaulement sac à dos

Comment dur?

Percez un essai!

_

Appui long sur la reconnaissance

[Sujet]: analyse détaillée de la communication série basée sur FPGA

[Auteur]: LinCoding

[Heure]: 28.11.2016

communication série, avec trop large, le principe est très simple, le plus important dans la vitesse de transmission de communication série est le concept, nous ne savons pas peut Baidu, alors que le format des données, un bit de départ, 8 les bits de données, un bit de parité (facultatif) et 1 bit d'arrêt.

(Publié après les données de PC seront envoyées au FPGA, les données FPGA reçues sur les données intactes sur le côté PC) regarder les résultats:

(Source de CrazyBingo, le respect du droit d'auteur)

regard direct sur le programme ci-dessous.

1, la chaîne Module Port de réception

le module uart_receiver (inputclk, // inputrst_n d'horloge globale, // inputclk_16bps global de remise à zéro, inputrxd, outputreg rxd_data, outputregrxd_flag);

La première partie est la définition d'entrée et de sortie, il y a deux choses à noter:

1, pour le module de réception en série, à utiliser en principe à 16 fois le prélèvement de vitesse de transmission, les clk_16bps d'entrée et le signal d'entrée provenant du - « une analyse détaillée sur la base de la division FPGA » sortie divide_clken de cet article.

2, un système est composé de plusieurs modules, entre le module et le module aura certainement à communiquer, puis pour les modules d'entrée, vous ne pouvez pas échapper à « signal fin de drapeau d'entrée », et le drapeau est considéré comme des données d'entrée et de sortie en synchronisme, comme dans le présent mode de réalisation de rxd_flag, ainsi que devant l'article clé antirebond key_flag, SPI article rxd_flag est vrai, ce qui devrait être un motif fixe!

// // ----------------------------------- synchroniser le signal d'entrée regrxd_sync, toujours @ (posedge clk ou negedge rst_n) commencent if (! rst_n) rxd_sync < = 1'b1; d'autre rxd_sync < = Rxd; fin

La deuxième partie, depuis le module de réception recevant des signaux des autres domaines d'horloge, et par conséquent, il y aura besoin de frapper un signal de battement synchronisé avec son propre domaine d'horloge, bien sûr, deux beats sont possibles!

// // ----------------------------------- recevoir EFM: encode localparamR_IDLE = 4'd0; localparamR_START = 4'd1; localparamR_SAMPLE = 4'd2; localparamR_STOP = 4'd3; // ------------------------------- ---- // recevoir EFM localparamSMP_TOP = 4'd15; localparamSMP_CENTER = 4'd7; reg smp_cnt; reg rxd_cnt; reg rxd_state, toujours @ (ou posedge clk negedge rst_n) commencent if (! rst_n) commencent smp_cnt < = 4'd0; rxd_cnt < = 4'd0; rxd_state < = R_IDLE, fin autre cas (rxd_state) R_IDLE: commencer smp_cnt < = 4'd0; rxd_cnt < = 4'd0; if (! Rxd_sync) rxd_state < = R_START; d'autre rxd_state < = R_IDLE; fin R_START: if (clk_16bps) commencent smp_cnt < = Smp_cnt + 1'b1; if (smp_cnt == SMP_CENTER && rxd_sync) commencent rxd_cnt < = 4'd0; rxd_state < = R_IDLE; fin else if (smp_cnt == SMP_TOP) commencent rxd_cnt < = 4'd1; rxd_state < = R_SAMPLE; end else commencer rxd_cnt < = Rxd_cnt; rxd_state < = Rxd_state; end end else begin smp_cnt < = Smp_cnt; rxd_cnt < = Rxd_cnt; rxd_state < = Rxd_state; fin R_SAMPLE: if (clk_16bps) commencent smp_cnt < = Smp_cnt + 1'b1; if (smp_cnt == SMP_TOP) commencer si (rxd_cnt <  4'd8) commencent rxd_cnt < = Rxd_cnt + 1'b1; rxd_state < = R_SAMPLE; end else commencer rxd_cnt < = 4'd9; rxd_state < = R_STOP; end end else begin rxd_cnt < = Rxd_cnt; rxd_state < = Rxd_state; end end else begin smp_cnt < = Smp_cnt; rxd_cnt < = Rxd_cnt; rxd_state < = Rxd_state; fin R_STOP: if (clk_16bps) commencent smp_cnt < = Smp_cnt + 1'b1; if (smp_cnt == SMP_TOP) commencent rxd_cnt < = 4'd0; rxd_state < = R_IDLE; end else commencer rxd_cnt < = Rxd_cnt; rxd_state < = Rxd_state; end end else begin smp_cnt < = Smp_cnt; rxd_cnt < = Rxd_cnt; rxd_state < = Rxd_state; défaut final: commencer smp_cnt < = 4'd0; rxd_cnt < = 4'd0; rxd_state < = R_IDLE; end end endcase

La troisième partie de la machine d'état est long, trop long vraiment, mais le contenu essentiellement double, les points suivants sont à noter:

1, destiné à recevoir le module de port série, nous avons reçu des données afin de rendre le degré maximum de stabilité, d'utiliser 16 fois l'échantillonnage de la vitesse de transmission, à savoir de chaque bit de données avec 16 échantillons, dans ce cas, bien entendu, dans la plupart est le plus stable sur le principe du prélèvement point de données au milieu, le fait est également vrai. Il est nécessaire de compter le point d'échantillonnage courant du signal est le premier nombre, et lorsque le point de prélèvement 16, de sorte rxd_cnt incrémenté à un échantillon suivant de données.

2, nombre de signaux obtenus en utilisant rxd_cnt Actuellement, plusieurs échantillons de données. Notez que cela implique que rxd_cnt toujours bloquer les changements, et l'autre sera toujours les valeurs des bits respectifs de données en fonction de la situation des rxd_cnt.

3, en raison des caractéristiques de transmission série, un bit de départ va bas que le début de la transmission et, par conséquent, des moyens que le bit de départ est en fait un transfert de départ signal de validation, état si IDLE aux machines d'état d'utilisation à toujours surveiller si le bit de démarrage.

reg rxd_data_r, toujours @ (ou posedge clk negedge rst_n) commencent à se rxd_data_r (rst_n!) < = 8'd0; else if (rxd_state == R_SAMPLE && && clk_16bps smp_cnt == SMP_CENTER) cas (rxd_cnt) 4'd1: commencer rxd_data_r < = Rxd_sync; fin 4'd2: commencer rxd_data_r < = Rxd_sync; fin 4'd3: commencer rxd_data_r < = Rxd_sync; fin 4'd4: commencer rxd_data_r < = Rxd_sync; fin 4'd5: commencer rxd_data_r < = Rxd_sync; fin 4'd6: commencer rxd_data_r < = Rxd_sync; fin 4'd7: commencer rxd_data_r < = Rxd_sync; fin 4'd8: commencer rxd_data_r < = Rxd_sync; défaut final: commencer rxd_data_r < = 8'd0; fin ENDCASE else if (rxd_state == R_STOP) rxd_data_r < = Rxd_data_r; d'autre rxd_data_r < = Rxd_data_r; fin

La quatrième partie est la valeur pour différentes valeurs du bit sur les données en fonction de la valeur de rxd_cnt.

toujours @ (ou posedge clk negedge rst_n) commencent if (! rst_n) commencent rxd_data < = 8'd0; rxd_flag < = 1'b0; fin else if (rxd_state == R_STOP && && clk_16bps smp_cnt == SMP_TOP) commencent rxd_data < = Rxd_data_r; rxd_flag < = 1'b1; end else commencer rxd_data < = Rxd_data; rxd_flag < = 1'b0; end end

La cinquième partie est de synchroniser la sortie de signal rxd_data et rxd_flag. Pour synchroniser la sortie, il a adopté la même étape bascule D pour frapper un coup de rxd_data, pour synchroniser la sortie avec rxd_flag.

2, le module de port série

le module uart_transfer (inputclk, // inputrst_n d'horloge globale, // inputclk_16bps global de remise à zéro, inputtxd_en, entrée txd_data, outputreg txd, outputregtxd_flag);

La première partie est la définition d'entrée et de sortie, car il envoie le module, bien sûr, a besoin d'envoyer un signal de validation, et d'autre part, le drapeau d'achèvement de transmission signal requis. Bien sûr, comme avec le signal de validation d'émission, la machine d'état est inévitable. De même série clk_16bps et module de réception.

// // ----------------------------------- recevoir EFM: encode localparamT_IDLE = 4'd0; localparamT_SEND = 4'd1; // // ----------------------------------- recevoir FSM localparamSMP_TOP = 4 ' D15; localparamSMP_CENTER = 4'd7; reg smp_cnt; reg txd_cnt; reg txd_state, toujours @ (ou posedge clk negedge rst_n) commencent si commencer smp_cnt (rst_n!) < = 4'd0; txd_cnt < = 4'd0; txd_state < = T_IDLE, fin autre cas (txd_state) T_IDLE: commencer smp_cnt < = 4'd0; txd_cnt < = 4'd0; if (txd_en) txd_state < = T_SEND; d'autre txd_state < = T_IDLE; fin T_SEND: if (clk_16bps) commencent smp_cnt < = Smp_cnt + 1'b1; if (smp_cnt == SMP_TOP) commencer si (txd_cnt <  4'd9) commencent txd_cnt < = Txd_cnt + 1'b1; txd_state < = T_SEND; end else commencer txd_cnt < = 4'd0; txd_state < = T_IDLE; end end else begin txd_cnt < = Txd_cnt; txd_state < = Txd_state; end end else begin smp_cnt < = Smp_cnt; txd_cnt < = Txd_cnt; txd_state < = Txd_state; défaut final: commencer smp_cnt < = 4'd0; txd_cnt < = 4'd0; txd_state < = T_IDLE; end end endcase

La deuxième partie est une longue transmission machine d'état, et est relativement simple par rapport au module de réception série, mais est différent de celui-ci, parce qu'il est envoyé, il suffit d'envoyer les premières données de point d'échantillonnage du point d'échantillonnage atteint 16, remplacé une transmission de données sur elle.

toujours @ (*) commencer si (txd_state == T_SEND) cas (txd_cnt) 4'd0: commencer txd = 1'b0; fin 4'd1: commencer txd = txd_data ; fin 4'd2: commencer txd = txd_data ; fin 4'd3: commencer txd = txd_data ; fin 4'd4: commencer txd = txd_data ; fin 4'd5: commencer txd = txd_data ; fin 4'd6: commencer txd = txd_data ; fin 4'd7: commencer txd = txd_data ; fin 4'd8: commencer txd = txd_data ; fin 4'd9: commencer txd = 1'b1; défaut final: commencer txd = 1'b1, fin ENDCASE autre txd = 1'b1; fin

La troisième partie est de transmettre les données selon l'txd_cnt de comptage, il est à noter que le présent module de logique combinatoire, est de rendre l'alignement des données!

Figure 1

Figure 2

La figure 2 est une version agrandie de la figure 1, vu dans les fronts d'horloge sont alignés.

Si, au lieu de la logique séquentielle, la procédure suivante:

toujours @ (ou posedge clk negedge rst_n) commencent if (! rst_n) txd < = 1'b1; else if (txd_state == T_SEND) cas (txd_cnt) 4'd0: commencer txd = 1'b0; fin 4'd1: commencer txd = txd_data ; fin 4'd2: commencer txd = txd_data ; fin 4'd3: commencer txd = txd_data ; fin 4'd4: commencer txd = txd_data ; fin 4'd5: commencer txd = txd_data ; fin 4'd6: commencer txd = txd_data ; fin 4'd7: commencer txd = txd_data ; fin 4'd8: commencer txd = txd_data ; fin 4'd9: commencer txd = 1'b1; défaut final: commencer txd = 1'b1, fin ENDCASE autre txd = 1'b1; fin

Il est indiqué ci-dessous:

toujours @ (ou posedge clk negedge rst_n) commencent if (! rst_n) txd_flag < = 1'b0; else if (txd_state == T_SEND && && clk_16bps smp_cnt == == SMP_TOP && txd_cnt 4'd9) txd_flag < = 1'b1; d'autre txd_flag < = 1'b0; fin

La dernière partie est une fin de transmission de signaux de sortie du pavillon.

Une telle communication série à base de FPGA est terminée, le module de haut, nous pouvons diriger les données reçues au module de transmission, les données envoyées par l'assistant de débogage série côté PC, puis intact les données FPGA renvoyés à nouveau vérification complète au niveau du conseil d'administration.

Résumé:

1, destiné à recevoir le module de classe, qui après avoir reçu l'achèvement doit avoir reçu le signal d'indicateur, et pour délivrer en synchronisation avec les données reçues.

2, le module de classe pour transmettre, doit transmettre le signal de validation et le signal de fin de transmission du pavillon, et en utilisant l'état IDLE pour surveiller la machine d'état peut changer le signal de validation de transmission.