CORDIC NCO pour Digital Up conversion

[mbalakr2]

Salut tout le monde,

Je travaille sur la conception d'un convertisseur numérique Down et numériques Jusqu'à convertisseur.J'ai commencé par la conception de sous-officiers en utilisant l'algorithme CORDIC pour Digital conversion descendante.J'ai écrit le code VHDL pour le sous-officier en qu (at) RTUs II et j'ai obtenu des résultats approximatifs pour la conversion vers le bas.Je suis en train de mettre en œuvre le sous-officier même CORDIC jusqu'à la conversion.Je suis de le tester en se nourrissant dans les sorties des sous-officiers que j'ai conçu pour down conversion.Je régler l'entrée x en tant que 0.309 (Cos 72) et l'entrée y en 0.951 (Sin 72).Je m'attends à une production de 0,607 qui est la grandeur des deux entrées et un angle de phase de 72 ans.Mais je ne suis pas en mesure d'obtenir cela.Quelqu'un pourrait m'aider s'il vous plaît avec le code??Je n'ai aucune idée comment procéder ..Le code que j'ai écrit est donnée ci-dessous:

Code:library ieee;

utilisation ieee.std_logic_1164.all;

utilisation IEEE.STD_LOGIC_ARITH.ALL;

utilisation ieee.std_logic_unsigned.all;entité est BND - Entité de haut niveau

génériques

(

taille: integer: = 20

);port

(

CLK: in std_logic;

reset: in std_logic;

x0: in std_logic_vector (taille-1 downto 0);

y0: in std_logic_vector (taille-1 downto 0);

z0: in std_logic_vector (taille-1 downto 0);

phase: out std_logic_vector (taille-1 downto 0);

Quad: out std_logic_vector (taille-1 downto 0);

angle: buffer std_logic_vector (taille-1 downto 0);

start: in std_logic;

c'est fait: out std_logic

);fin BND;Arch architecture du BND estsignal CNT: std_logic_vector (4 downto 0);

signal newx: std_logic_vector (taille-1 downto 0);

signal newy: std_logic_vector (taille-1 downto 0);

signal Newz: std_logic_vector (taille-1 downto 0);

signal XReg: std_logic_vector (taille-1 downto 0);

signal yreg: std_logic_vector (taille-1 downto 0);

signal zreg: std_logic_vector (taille-1 downto 0);

signal sxreg: std_logic_vector (taille-1 downto 0);

signal SYREG: std_logic_vector (taille-1 downto 0);

signal d'atan: std_logic_vector (taille-1 downto 0);

signal de fin: std_logic;

signal NXT: std_logic;

signal: std_logic;

nas signal: std_logic;- Composante déclarationscomposante addsubR - Adder

génériques

(

taille: integer: = 20

);port

(

dataa: in std_logic_vector (taille-1 downto 0);

datab: in std_logic_vector (taille-1 downto 0);

Résultat: out std_logic_vector (taille-1 downto 0);

: dans std_logic

);

end component;composante anglelut - Angle Look-Up Table

génériques

(

taille: integer: = 20

);port

(

Index: in std_logic_vector (4 downto 0);

atan: out std_logic_vector (taille-1 downto 0)

);

end component;composante fsmR - Finite State Machineport

(

CLK: in std_logic;

reset: in std_logic;

start: in std_logic;

CNT: std_logic_vector (4 downto 0);

initiale: out std_logic;

NXT: out std_logic;

c'est fait: out std_logic

);end component;composante ShiftR - Shifter

génériques

(

taille: integer: = 20

);port

(

données: dans std_logic_vector (taille-1 downto 0);

sdata: out std_logic_vector (taille-1 downto 0);

N: in std_logic_vector (4 downto 0)

);

end component;commencerprocess (clk, newx, newy, newz, z0, NXT, FIN)

commencer

if (rising_edge (clk)) then

si fin = '1 'alors

XReg <= x0;

yreg <= y0;

zreg <= z0;

cnt <= (others => '0 ');

elsif nxt = '1 'alors

XReg <= newx;

yreg <= newy;

zreg <= Newz;

cnt <= cnt '1 ';

End If;

End If;

Terminer le processus;que <= yreg (taille-1); - MSB du registre Y

phase <= yreg;

Quad <= XReg;

angle <= zreg;

nas <= not (as);addx: addsubR - Accumulateur pour x registre

Plan du générique

(

size => taille

)Plan du port

(

dataa => XReg,

datab => SYREG,

result => newx,

AS => en tant que

);Addy: addsubR - Accumulateur pour y inscrire

Plan du générique

(

size => taille

)Plan du port

(

dataa => yreg,

datab => sxreg,

result => newy,

AS => NAS

);addz: addsubR - Accumulateur pour z registre

Plan du générique

(

size => taille

)Plan du port

(

dataa => zreg,

datab => atan,

result => Newz,

AS => en tant que

);Lut: anglelut

Plan du générique

(

size => taille

)Plan du port

(

index => CNT,

= atan> atan

);state_mach: fsmR

Plan du port

(

clk => clk,

reset => reset,

start => démarrage,

cnt => CNT,

initial => FIN,

nxt => NXT,

done => Fait

);decalagex: ShiftR - Shifting x valeur

Plan du générique

(

size => taille

)Plan du port

(

data => XReg,

sdata => sxreg,

n => cnt

);sournois: ShiftR - Shifting valeur y

Plan du générique

(

size => taille

)Plan du port

(

data => yreg,

sdata => SYREG,

n => cnt

);fin arcade;Lookup tableBibliothèque IEEE;

utilisation IEEE.std_logic_1164.all;

utilisation IEEE.STD_LOGIC_ARITH.ALL;anglelut entité estgénériques

(

taille: Positive: = 20

);

port

(

Index: in std_logic_vector (4 downto 0);

atan: out std_logic_vector (taille-1 downto 0)

);fin anglelut;table architecture de anglelut Estsignal TINFO: std_logic_vector (19 downto 0);commenceratan <= TINFO;

(processus d'index)

commencerIndex affaire est

quand "00000" => TINFO <= X "3243F"; - 45

quand "00001" => TINFO <= X "1DAC6", - 26,565

quand "00010" => TINFO <= X "0FADB", - 14,036

quand "00011" => TINFO <= X "07F56", - 7.125

quand "00100" => TINFO <= X "03FEA", - 3.576

quand "00101" => TINFO <= X "01FFD", - 1.789

quand "00110" => TINFO <= X "00FFF", - 0,8951

quand "00111" => TINFO <= X "007FF", - 0,4476

quand "01000" => TINFO <= X "003FF", - 0,2238

quand "01001" => TINFO <= X "001FF", - 0,1119

quand "01010" => TINFO <= X "000 FF", - 0,0559

quand "01011" => TINFO <= X "0007F", - 0,0279

quand "01100" => TINFO <= X "0003F", - 0,0139

quand "01101" => TINFO <= X "0001F", - 0,00699

quand "01110" => TINFO <= X "0000f", - 0,00349

quand "01111" => TINFO <= X "00007", - 0,00174

quand "10000" => TINFO <= X "00003", - 0,00087

quand "10001" => TINFO <= X "00001", - 0,00043

lorsque «10010» => TINFO <= X "00000", - 0,00021

quand "10011" => TINFO <= X "00000", - 0,00010

quand les autres => TINFO <= "--------------------";Fin de cas;

Terminer le processus;

end table;