Compréhension du signal de synchronisation dans Xilinx Simulink

Question

J'ai du mal à comprendre le concept de signaux de synchronisation dans Simulink (bibliothèque Xilink).

Je vais expliquer avec un exemple,

Supposons que vous ayez un flux de tits de série et que vous aimeriez prendre la somme de bits étranges et même,

Donc, vous écririez probablement du code MATLAB quelque chose comme ceci:

Data_Bits=[1 2 3 0 4 5 1 2 0 9];

Sum_Bits=[];
for i=1:length(Data_Bits)/2
    Sum_Bits=[Sum_Bits Data_Bits(2*i-1)+Data_Bits(2*i)]
end

Supposons un instant, nous ignorons tous les cas d'optimisation et de coin, où ce code pourrait ne pas fonctionner.

En supposant que nous devons implémenter cela dans un matériel, le Data_Bits arrive en série, donc vous attendez essentiellement 2 cycles d'horloge pour obtenir 2 bits d'entrée et l'ajouter et générer la sortie.

Donc, pour chaque 2 cycles d'horloge, vous avez une sortie.

Il est donc possible de gérer le signal de synchronisation dans Xilinx afin que nous ayons une sortie valide.

Je ne veux donc pas avoir un résultat intermédiaire à la sortie.

Comment pouvons-nous y parvenir? Je pense utiliser une sorte d'entrée d'activation avec une horloge de course libre (compteur).

Mais comment gérons-nous cela lors de la conception d'un système vraiment compliqué?

Je n'ai pas tellement d'expérience dans la conception matérielle. Donc, si ma question est dangereusement frontière simple et stupide, je suis désolé pour mon intelligence.

Merci d'avoir lu

Kiran

Answer 1

Si vous voulez que votre sortie ne change que lorsqu'elle est "valide", vous utilisez un registre activé à la broche de sortie avec le signal Activer connecté à quelque chose qui est élevé pour une seule horloge en même temps que la valeur vers le registre dans le registre est celui que vous souhaitez présenter à la sortie.

Dans votre cas, votre signal "valide" bascule entre '1' et '0' sur des cycles d'horloge alternatifs, vous pouvez donc simplement utiliser un flipflop avec sa sortie renvoyée par un onduleur. (Dans le code de Davidd, vous pouvez voir cela sur la ligne commenté avec //tflipflop).

Si vous aviez un système plus complexe qui n'est valable qu'une seule fois n cycles, vous pouvez utiliser un compteur qui réinitialise chaque n cycles et utilisez l'impulsion de réinitialisation comme signal "valide".

Answer 2

Input stream -------------> AddSub -> register -> output stream
Input stream -> register -> AddSub    register
                                      register
                           counter -> register(enable)

Ajoutez le flux d'entrée et le flux d'entrée retardé de 1 cycle. Utilisez un compteur 1 bits (ou un flop en T-flip) pour activer un registre sur la sortie de l'additionneur.

C'est ce que vous recherchez?

Qu'entendez-vous également par "gérer" cela tout en exécutant un système complexe? Le Verilog ou VHDL pour cette construction serait très simple et pourrait être utilisé à la place des blocs de générateurs de systèmes.

//note: initialization/reset and limit handling is not included and would need to be considered.
always@(posedge clk)
begin
    databits_1dly <= databits;  //create a once cycle delayed version of databits
    sum <= databits_1dly + databits; //adder
    every_other <= !every_other //t flip flop.
    if (every_other)  //invert if you want the other every_other
       sum_every_other <= sum
end