Vivado cordic IP core rotar y traducir explicación detallada (con código)
Tabla de contenido
2. Conocimientos preliminares necesarios para utilizar el núcleo cordic IP
3. Instrucciones de configuración del núcleo IP
Enlace de referencia: http://t.csdn.cn/pha8V
prefacio
El uso de la rotación dada puede descomponer una matriz en una matriz ortogonal y una matriz triangular. Para realizar la operación de descomposición anterior de la matriz en el FPGA, se deben usar los modos de rotación y traducción en el núcleo cordic IP. Este artículo presentará en detalle cómo usar los modos de rotación y traducción en el núcleo IP de cordic en combinación con la hoja de datos oficial de cordic y su propia experiencia.
Sugerencia: El siguiente es el texto principal de este artículo. No es fácil escribir un artículo. Espero que pueda ayudarlo. Adjunte un enlace al reimprimirlo.
1. Introducción a cordic
El algoritmo CORDIC (Ordenador digital de rotación de coordenadas) es el método de cálculo digital de rotación de coordenadas, propuesto por primera vez por JDVolder1 en 1959, y se utiliza principalmente para el cálculo de funciones trigonométricas, hipérbolas, exponentes y logaritmos. El algoritmo reemplaza la operación de multiplicación con la operación básica de suma y desplazamiento, de modo que el cálculo de la rotación y orientación del vector ya no necesita funciones como funciones trigonométricas, multiplicación, raíz cuadrada, trigonométrica inversa y exponente.
Los modos admitidos por el núcleo IP de CORDIC se muestran en la Figura 0, y este artículo presenta los dos primeros.
La introducción específica del algoritmo CORDIC y el funcionamiento del modo de raíz cuadrada se pueden encontrar en el enlace adjunto al final del artículo.Este artículo se centra en el uso del núcleo cordic IP, y el principio no se repetirá aquí.
2. Conocimientos preliminares necesarios para utilizar el núcleo cordic IP
La mayoría de las siguientes descripciones provienen del manual de datos en inglés proporcionado por el núcleo IP oficial de cordic, y aquí se brindan algunas explicaciones para ayudar a todos a comprender.
1. Puerto de datos
Mirando la Figura 1, encontrará que solo hay un puerto para los datos de entrada (independientemente de la entrada de fase) y los datos de salida, pero el número que se manipulará en los modos de rotación y traslación debe ser un vector, es decir, una coordenada, y la entrada y la salida deben tener doble emparejamiento, pero solo se muestra un puerto en la Figura 1, ¿por qué?
Aquí hay un lugar al que todos deben prestar atención al usar este núcleo de IP.Su entrada y salida de datos se empalman a un puerto. Como se muestra en la Figura 2 y la Figura 3.
Después de leer la Figura 2 y la Figura 3, debemos prestar atención a la coordenada x en la posición baja y la coordenada y o la salida de fase en la posición alta cuando se empalman los datos.
Formato de números 2.Q
Los operandos del núcleo cordic IP son números de punto fijo, y los formatos de entrada y salida de coordenadas x, y y entrada y salida de fase son diferentes.
En primer lugar, necesitamos conocer el formato XQN. El llamado formato XQN es un número binario complementario de 1+X+N bits, un bit de signo de 1 bit, seguido de X bits enteros, seguido de una mantisa de N bits ( fracción).
Las coordenadas en el núcleo cordic IP están en formato 1QN y el ángulo de fase está en formato 2QN. De hecho, este formato tiene una cierta relación con el rango de datos. El rango del ángulo de fase es más amplio que el rango de coordenadas, por lo que hay uno más entero que se interseca.
El vector de entrada (Xin, Yin) y el vector de salida (Xout, Yout) se representan como un par de números enteros en complemento a dos con un ancho de 2 bits (formato 1QN). Ángulo de rotación de entrada, pin radianes, también expresado como un número de complemento a dos fijo, pero con un ancho de 3 bits (formato 2QN).
3. Traducción de vectores
Comparando las fases en la Figura 5 y la Figura 6, se puede ver que el error de 10 bits es relativamente grande.
4. Rotación de vectores
La figura 8 gira la entrada (x, y) en -pi/2 a lo largo del eje de coordenadas.
3. Instrucciones de configuración del núcleo IP
1.traducir
Selección funcional : seleccione Traducir aquí
Configuración arquitectónica : el núcleo de CORDIC tiene dos configuraciones arquitectónicas, paralela y serie de palabras. Seleccione Paralelo aquí.
Modo de canalización : El núcleo de CORDIC proporciona tres modos de canalización: Ninguno, Óptimo y Máximo. La elección del modo de canalización se basa en la elección de la configuración funcional y la configuración arquitectónica. Los modos de canalización no disponibles están atenuados en la GUI de CORDIC.
Ninguno: el núcleo de CORDIC se implementa sin segmentación.
Optimización: el núcleo de CORDIC implementa tantas etapas de canalización como sea posible sin utilizar LUT adicionales.
Máx.: el núcleo de CORDIC tiene una implementación de tubería después de cada subfase de cambio y adición.
Elija Optimizar aquí.
Formato de datos : Traducir no es opcional por defecto.
Formato de fase : el núcleo CORDIC proporciona dos opciones de formato de fase.
Radianes: la fase se representa como un número de complemento a dos de punto fijo de ancho entero de 3 bits expresado en radianes. Por ejemplo: 01100000 representa 3,0 radianes.
Radianes escalados: la fase se representa como un número de complemento a dos de punto fijo de ancho entero de 3 bits, en unidades de π radianes. Un radián escalado equivale a π * 1 radián. Por ejemplo: 11110000 significa -0,5 * Pi radianes.
Seleccione Radianes aquí.
Ancho de entrada : ancho de bits de la coordenada de entrada.
Ancho de salida : ancho de bit de coordenadas de salida.
Modo redondo : el núcleo CORDIC proporciona cuatro modos de redondeo.
Truncar: las salidas X_OUT, Y_OUT y PHASE_OUT se truncan.
Infinito positivo: las salidas X_OUT, Y_OUT y PHASE_OUT se redondean de modo
que 1/2 se redondea hacia arriba (hacia el infinito positivo) . Es equivalente a la
función floor(x + 0.5) de MATLAB .
Pos Neg Infinity: Las salidas X_OUT, Y_OUT y PHASE_OUT se redondean de manera
que 1/2 se redondea hacia arriba (hacia el infinito positivo) y -1/2 se redondea hacia abajo
(hacia el infinito negativo). Es equivalente a la función round(x) de MATLAB .
Par más cercano: las salidas X_OUT, Y_OUT y PHASE_OUT se redondean hacia el
número par más cercano, de modo que 1/2 se redondea hacia abajo y 3/2 se redondea hacia arriba.
Aquí se selecciona Round Pos Neg Inf.
Iteraciones y precisión : si no se selecciona, establezca en 0. El núcleo de IP se establece de forma predeterminada de acuerdo con otras configuraciones.
Rotación gruesa : si la rotación gruesa está desactivada, el rango de entrada/salida se limitará al primer cuadrante (-Pi/4 a +Pi/4). Por lo tanto, debe estar marcado.
Escalamiento de compensación : método de compensación.
Sin Compensación de Escala: Las salidas X e Y no tienen compensación y son generadas, escaladas por Zi.
Basado en LUT: la compensación X e Y de salida utiliza un multiplicador de coeficiente constante basado en LUT.
BRAM: las salidas X e Y se compensan utilizando multiplicadores de coeficiente constante basados en RAM de bloque.
Multiplicador integrado: las salidas X e Y se compensan mediante DSP Slice.
Si se selecciona No aquí, no se realizará la compensación y el resultado de salida será incorrecto. Para garantizar resultados correctos, se debe seleccionar un método de compensación. Aquí, Basado en LUT está seleccionado de forma predeterminada.
La configuración en la página 2 se ignora por completo, el valor predeterminado está bien y casi no tiene efecto.
2.Rotar
La configuración de Rotar es la misma que Traducir. Seleccione Girar como el modo.
Cuatro, traducir simulación
1. Código de nivel superior
`timescale 1ns / 1ps
//
// Company: cq university
// Engineer: clg
// Create Date: 2023/01/10 13:04:52
// Design Name:
// Module Name: cordic_translate_test
// Project Name:
// Target Devices:
// Tool Versions: 2017.4
// Description:
// Dependencies:
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
module cordic_translate_test(
input clk, //输入时钟信号
input start, //输入开始计算信号
input [31:0] x_in, //输入坐标x
input [31:0] y_in, //输入坐标y
output wire over, //输出计算完成标志
output wire [31:0] x_out, //输出坐标x
output wire [31:0] pha_out //输出相角
);
cordic_translate_ip u_cordic_translate_ip(
.aclk(clk), // input wire aclk
.s_axis_cartesian_tvalid(start), // input wire s_axis_cartesian_tvalid
.s_axis_cartesian_tdata({y_in,x_in}), // input wire [63 : 0] s_axis_cartesian_tdata
.m_axis_dout_tvalid(over), // output wire m_axis_dout_tvalid
.m_axis_dout_tdata({pha_out,x_out}) // output wire [63 : 0] m_axis_dout_tdata
);
endmodule
2. Código de simulación
`timescale 1ns / 1ps
//
// Company: cq university
// Engineer: clg
// Create Date: 2023/01/10 13:06:20
// Design Name:
// Module Name: cordic_translate_test_tb
// Project Name:
// Target Devices:
// Tool Versions: 2017.4
// Description:
// Dependencies:
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
module cordic_translate_test_tb();
// cordic_translate_test Parameters
parameter PERIOD = 2;
// cordic_translate_test Inputs
reg clk = 0 ;
reg start = 0 ;
reg [31:0] x_in = 0 ;
reg [31:0] y_in = 0 ;
// cordic_translate_test Outputs
wire over ;
wire [31:0] x_out ;
wire [31:0] pha_out ;
initial
begin
forever #(PERIOD/2) clk=~clk;
end
cordic_translate_test u_cordic_translate_test (
.clk ( clk ),
.start ( start ),
.x_in ( x_in [31:0] ),
.y_in ( y_in [31:0] ),
.over ( over ),
.x_out ( x_out [31:0] ),
.pha_out ( pha_out [31:0] )
);
initial
begin
#5 start<=1;
x_in<=32'b00110000000000000000000000000000;
y_in<=32'b00110000000000000000000000000000;
#2
x_in<=32'b11100000000000000000000000000000;
y_in<=32'b11100000000000000000000000000000;
end
endmodule
Comparando la Figura 11 y la Figura 12, se puede ver que la simulación es correcta.
Cinco, rotación de simulación
1. Código de nivel superior
`timescale 1ns / 1ps
//
// Company: cq university
// Engineer: clg
// Create Date: 2023/01/10 14:40:46
// Design Name:
// Module Name: cordic_rotate_test
// Project Name:
// Target Devices:
// Tool Versions: 2017.4
// Description:
// Dependencies:
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
module cordic_rotate_test(
input clk, //输入时钟信号
input start, //输入开始计算信号
input [31:0] x_in, //输入坐标x
input [31:0] y_in, //输入坐标y
input [31:0] pha_in, //输入相角
output wire over, //输出计算完成标志
output wire [31:0] x_out, //输出坐标x
output wire [31:0] y_out //输出坐标y
);
cordic_rotate_ip u_cordic_rotate_ip (
.aclk(clk), // input wire aclk
.s_axis_phase_tvalid(start), // input wire s_axis_phase_tvalid
.s_axis_phase_tdata(pha_in), // input wire [31 : 0] s_axis_phase_tdata
.s_axis_cartesian_tvalid(start), // input wire s_axis_cartesian_tvalid
.s_axis_cartesian_tdata({y_in,x_in}), // input wire [63 : 0] s_axis_cartesian_tdata
.m_axis_dout_tvalid(over), // output wire m_axis_dout_tvalid
.m_axis_dout_tdata({y_out,x_out}) // output wire [63 : 0] m_axis_dout_tdata
);
endmodule
2. Código de simulación
`timescale 1ns / 1ps
//
// Company: cq university
// Engineer: clg
// Create Date: 2023/01/10 14:41:21
// Design Name:
// Module Name: cordic_rotate_test_tb
// Project Name:
// Target Devices:
// Tool Versions: 2017.4
// Description:
// Dependencies:
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
module cordic_rotate_test_tb();
// cordic_rotate_test Parameters
parameter PERIOD = 2;
// cordic_rotate_test Inputs
reg clk = 0 ;
reg start = 0 ;
reg [31:0] x_in = 0 ;
reg [31:0] y_in = 0 ;
reg [31:0] pha_in = 0 ;
// cordic_rotate_test Outputs
wire over ;
wire [31:0] x_out ;
wire [31:0] y_out ;
initial
begin
forever #(PERIOD/2) clk=~clk;
end
cordic_rotate_test u_cordic_rotate_test (
.clk ( clk ),
.start ( start ),
.x_in ( x_in [31:0] ),
.y_in ( y_in [31:0] ),
.pha_in ( pha_in [31:0] ),
.over ( over ),
.x_out ( x_out [31:0] ),
.y_out ( y_out [31:0] )
);
initial
begin
#5 start<=1;
pha_in<=32'b00110010010000111111011010101000;
x_in<=32'b00110000000000000000000000000000;
y_in<=32'b00110000000000000000000000000000;
#2
pha_in<=32'b10011011011110000001001010101111;
x_in<=32'b11100000000000000000000000000000;
y_in<=32'b11100000000000000000000000000000;
end
endmodule
Como se muestra en la Figura 13, (-0.5, -0.5) se rota por -pi a (0.5, 0.5).
Resumir
Hoy hablaré de lo anterior. Este artículo presenta principalmente el uso de los modos Traducir y Rotar en el núcleo IP de CORDIC proporcionado por xilinx.