Verilog signé / non signé échantillons et les premières

En supposant que j'ai un registre reg [15:0] my_reg, qui contient 16 bits signé exemple:

Comment puis-je convertir l'échantillon signé non signé?
J'ai lu cet article de Wikipédia, et je suis conscient de l'2 bits complément pour les nombres signés, mais comment dois-je effectuer cette conversion en Verilog efficacement?
(Je ne sais pas si my_reg est positif ou negatve, et elle change à chaque cycle d'horloge = je reçois un nouvel échantillon sur chaque positive de l'horloge de bord).

Le but ultime (pour ajouter un peu de contexte) est de mettre en œuvre un numérique FPGA intégré de contrôle automatique de gain (AGC).

EDIT: comme l'a suggéré, j'ai divisé les deux questions dans deux différents postes. Voir l'autre ici

Voulez-vous dire que vous voulez prendre la valeur absolue de my_reg? Différent de celui de la conversion de signé non signé. E. g. si my_reg = -154 voulez-vous my_reg_unsigned +154?
pas exactement, comme je veux être en mesure de différence de valeurs positives et négatives. Je pense que, en valeur absolue, ne va pas aider. Dire que j'ai des valeurs de -10 à 10, je veux juste une carte à 0 à 20.

OriginalL'auteur titus.andronicus | 2014-06-11

6

En Verilog reg contient des données binaires, signé unsigned sont juste une question d'interprétation. Les valeurs des bits restent les mêmes, la soustraction et l'addition sont toujours effectuées à l'aide de complément à deux.

Par exemple, nous pouvons regarder les 4 bits de la valeur et de voir comment les chiffres peuvent être interprétés:
```
  Binary Unsigned  signed  
  1000          8      -8
  1110         14      -2
  1111         15      -1    
  0001          1       1
  0010          2       2
  0111          7       7
```
Je pense que vous voulez calibrer ces numéros sur le positif de l'échelle, -8 devient 0, 0 devient 8, 7 devient 15. Cela serait fait par ajoutant 1 à l'ESM position. Dans nos 4 bits exemple:
```
  Binary   Signed  Addition Unsigned result
  1000         -8  +1000    0000   0
  1110         -2  +1000    0110   6
  1111         -1  +1000    0111   7
  0001          1  +1000    1001   9
  0010          2  +1000    1010   10  
  0111          7  +1000    1111   15
```
Il y a quelques questions étroitement liées:

1. Verilog: comment prendre la valeur absolue.

2. Verilog Construction de Complément à Deux de Comparaison.

Si votre registre vraiment ne contiennent des informations signées puis sémantiquement vous devez définir comme :
```
reg signed [15:0] my_reg;
```
De la valeur absolue:
```
reg signed [15:0] my_reg;
reg        [15:0] my_reg_unsigned;

always @* begin
  if (my_reg < 16'd0) begin
    my_reg_unsigned = -my_reg ;
  end
  else begin
    my_reg_unsigned = my_reg ;
  end
end
```
Si vous n'avez pas besoin d'absolu, mais voulez juste utiliser le numéro de lecteur quelque chose, c'est valide il suffit de connecter signé pour un entier non signé, c'est à dire:
```
always @* begin
  my_reg_unsigned = my_reg ;
end
```
Cela va copier les valeurs des bits, my_reg_unsigned peut être interprété comme signé à l'aide de $signed(my_reg_unsigned)

Merci. Les opérateurs de synthétiser différentes logique basée sur l'signée " de leurs opérandes? Certainement < <= >= > viennent à l'esprit. Vous avez déjà dit l'addition et la soustraction de rester le même. Qu'en est multiplicateurs? Et est unaire - même permis sur unsigned fils/registres?
tous les travaux naturellement sur unsigned et des nombres signés. unaire ~ effectue un peu sage inverser (complément) , c'est à dire ne se soucie pas de signe. Unaire - effectue un complément à deux inverser +1, il ne se soucie pas de l'signé ness de l'entrée. Les seules fonctions qui viennent à l'esprit sont des comparaisons > >= <= < la multiplication et la diviser

OriginalL'auteur Morgan

Vous devez vous connecter pour publier un commentaire.