Compter le nombre de 1

C

cnivaz

Guest
Chère équipe,
J'ai besoin pour faire le design, que comptera le nombre de 1 dans un registre 32 bits.
Je fait cela en utilisant le comptoir, mais qui a eu 32 impulsions d'horloge pour produire le résultat.

Sans consommer 32 horloge, comment faire cette conception.

Observe
Nivaz

 
Vous pouvez faire une instruction CASE ... avec tous les cas de '1 's vous pouvez avoir
mais puisque vous avez un registre 32 bits ... ce serait vraiment fastidieux ...

ainsi vous pouvez les avoir sur pièces ... comme prendre toutes les 4 bits
puis en ajoutant ceux de chaque partie ...

par ex: vous en avez un '1 'en 1, 2, 4 et 8 (vous pourrez les réunir en une seule déclaration dans un cas)

 
Vous pourriez envisager de chaque bit d'être un entier, et calculer leur somme:
ones = bit0 Bit1 Bit2 bit3 ...Bit31.

 
Une déclaration de cas ou une Look Up Table est hors de question!
2 ^ 32 = 4294967296.

Je pense que le mieux que vous pouvez faire est de passage et d'ajouter, mais il faudra> 32 cycles.Ajouté après 11 minutes:Code:unsigned int ones32 (unsigned int x)

(

x -= ((x>> 1) & 0x55555555);

x = (((x>> 2) & 0x33333333) (x & 0x33333333));

x = (((x>> 4) x) & 0x0f0f0f0f);

x = (x>> 8);

x = (x>> 16);

return (x & 0x0000003F);

)

 
Voici un non en pipeline version de ma proposition résumant en Verilog.Il effectue le calcul complet en un seul cycle d'horloge, et tourne à environ 100 MHz dans un XC3S200 petit-4-FG256 Spartan-3 FPGA.Il utilise une bande de petits additionneurs, et occupe environ 1% du FPGA.Les registres d'entrée et de sortie ne sont pas nécessaires pour le calcul, mais j'ai ajouté à aider à estimer la vitesse.
Code:

module supérieur (clk, en, ones);

entrée CLK;

input [31:0] in;

reg [31:0] D;

sortie reg [5:0] ones;always @ (CLK posedge) commencent

d <= en;

les <= (((d [0] d [1] d [2] d [3]) (D [4] d [5] d [6] d [7]))

((D [8] d [9] d [10] d [11]) (D [12] d [13] d [14] d [15])))

(((D [16] d [17] d [18] d [19]) (D [20] d [21] d [22] d [23]))

((D [24] d [25] d [26] d [27]) (D [28] d [29] d [30] d [31 ])));

fin

endmodule
 
Si le langage Verilog est utilisé, la méthode prévue par echo47 est plus simple.

Pour btbass, si le langage C est utilisé, il ya une autre façon de calculer le nombre.

Code:

unsigned int ones32 (unsigned int num)

(

return num - (num <<1) - (num <<2) - (num <<3) - (num <<4)

- (Num <<5) - (num <<6) - (num <<7) - (num <<8)

- (Num <<9) - (num <<10) - (num <<11) - (num <<12)

- (Num <<13) - (num <<14) - (num <<15) - (num <<16)

- (Num <<17) - (num <<18) - (num <<19) - (num <<20)

- (Num <<21) - (num <<22) - (num <<23) - (num <<24)

- (Num <<25) - (num <<26) - (num <<27) - (num <<28)

- (Num <<29) - (num <<30) - (num <<31);

)
 
ne pouvons-nous utiliser une boucle et ensuite utiliser une instruction if et incrémenter le compteur de trouver 1??

 
Vous mai utiliser la technique qui suit

Diviser les 32 bits, c'est à dire,
1.
D'abord prendre 16 bits initial, le comparer avec 0,, si elles sont égales à zéro, alors U Save cycles de 15 clkSi ce n'est pas égal à nouveau le diviser en deux octets, comparez les octets séparément à zéro, si tout octet est égal à zéro, vous économisez encore près de six cycles de CLK.
Répétez jusqu'à ce que viennent à un seul bit ...

2.Prenez les 16 bits les autres et répétez l'.........!!!!!!!!! procédure

Ce sera certainement donner un rendement élevé lorsque vous avez nda large.compter pour 1s .....

Ishan
L'électronique et les télécommunications.IngénieurAjouté après 4 minutes:smileysam a écrit:

ne pouvons-nous utiliser une boucle et ensuite utiliser une instruction if et incrémenter le compteur de trouver 1??
 
Je préfère utiliser la logique combinatoire (I just love it) ...

nous allons utiliser une entrée 2 ou une barrière, en contact l'un de la broche d'entrée à GND, un autre pour le bit de l'un des 32 bits.si c'est un '1 'en bit THT, il va afficher un 1 ...Après que vous ayez fait cela avec tous les 32 bits, vous pouvez utiliser un additionneur pour ajouter tous les 32 bits de sortie des portes OU

<img src="http://www.edaboard.com/images/smiles/icon_smile.gif" alt="Sourire" border="0" />hehe ...ok? ..

sp

 
Probablement vous avez besoin d'un FPGA, comptés à l'aide matérielle, donc pas beaucoup de retard que les micros.

 
A 8-bit address with 4-LUT largeur de bit et 4 pipelines niveau sera ok pour vous.

Ou une adresse de 16 bits avec le 5-LUT largeur de bit et 2 pipelines niveau?

Hope this helps

 
Salut Essayez ceci

Le premier module (nombre, x);
input [31:0] x;
sortie reg [4:0] count;
entier i;
always @ (x)
commencer
count_one (count, x);
fin

count_one tâche;
sortie [4:0] count;
input [31:0] x;
entier i;
commencer
count = 5'b0;
for (i = 1; i <= 32; i = i 1)
if (x == 1)
count = count 1 b1;
autre
count = count;
fin
endtask
endmodule

 
Salut research_vlsi, Votre exemple sera parfois donner des résultats incorrects.
'count' devrait avoir six bits, et le "pour" boucle doit passer de 0 à 31.

 
ya il devrait être compris entre 0 à 31 en boucle for

 
Prenez un compteur en tant que nombre entier.

counter = reg (0) reg (2 ) ... 31 (reg);

mai il donne la solution.
profiter!

 
Simple Man,
utilisation et portes-xor échelle.Chaque porte d'entrée sera de 2.U will need 16et "et 16" portes XOR.Résultat final sera le comte «d'aucune de 1s.
observe

 
anoop12, je ne vois pas comment le construire avec des portes si peu nombreux.S'il vous plaît montrent un diagramme ou un code.

 
You must log in or register to reply here.

Welcome to EDABoard.com

Sponsor

Back
Top