Práctica 8. Diseño en VHDL de un modulador BPSK

Transcripción

1 Práctica 8. Diseño en VHDL de un modulador BPSK 8.1. Objetivos Diseñar un sistema de modulación por desplazamiento de fase binaria (BPSK) mediante VHDL e implementarlo en una FPGA. Aprender a llevar a cabo la comunicación con periféricos, en este caso el DAC LTC Conversor digital a analógico LTC 2624 La tarjeta de desarrollo Spartan-3A/3AN Starter Kit Board dispone de un convertidor digital a analógico (DAC, Digital-to-Analog Converter) serie de cuatro canales y compatible con el bus SPI (Serial Peripheral Interface). Las cuatro salidas del DAC son accesibles en el conector J21, el cual se encuentra, junto con el DAC, justo al lado del conector RJ-45 de la tarjeta, tal como se puede observar en la figura. Figura 8.1. Ubicación del DAC LTC 2624 y del conector J21 en la tarjeta de desarrollo El SPI es un bus síncrono full-duplex orientado a carácter que utiliza únicamente cinco líneas de comunicación. En la figura se muestra la conexión de la FPGA con la interfaz del bus SPI y la de ésta a su vez con el DAC. Figura 8.2. Esquema de conexiones del convertidor digital-analógico 1/13

2 En la siguiente tabla se muestran las líneas de comunicación utilizadas por el bus SPI, donde la FPGA actúa como dispositivo maestro (master) de la comunicación y el DAC actúa como esclavo (slave). Las señales SPI_MOSI, SPI_SCK y DAC_OUT están compartidas con otros dispositivos en la tarjeta, por lo que debe hacerse uso de la señal DAC_CS para indicar que la comunicación que desea establecerse es con el DAC. La señal DAC_CLR es activa a baja y permite inicializar a cero la entrada del DAC. Tabla 8.1. Señales de interfaz del DAC El protocolo de comunicación del bus SPI es el que se muestra en la figura siguiente, donde se observa que una vez se activa la señal DAC_CS a baja, a cada flanco de subida de la señal SPI_SCK, el dato enviado por la línea SPI_MOSI es cargado en la memoria de entrada del dispositivo, en este caso el DAC. Asimismo, la línea DAC_OUT devuelve los datos cargados en su memoria durante la comunicación previa. Estos datos enviados desde el DAC pueden ignorarse en la mayoría de las aplicaciones, pero sirven como mecanismo de control para comprobar que la comunicación se está llevando a cabo de manera correcta. Figura 8.3. Protocolo de comunicación del bus SPI En la figura 8.4 se muestra la estructura de datos que debe presentar la línea SPI_MOSI para el caso de trabajar con el DAC LTC2624. Podemos observar que los primeros cuatro bits de datos son indiferentes (don t care), al igual que los ocho últimos. Téngase en cuenta, sin embargo, que según la figura precedente, los bits son enviados en orden descendente, desde el más significativo hasta el menos significativo, por lo que los primeros bits en ser enviados serían los ocho bits don t care (desde el bit 31 hasta el 24). Los bits 23 a 20 contienen el comando que generalmente será la palabra c3c2c1c0 = 0011, para indicar que la salida del DAC se actualice inmediatamente con la palabra recibida. Los bits 19 a 16 contienen la dirección del canal a utilizar tal como se indica en la tabla incluida en la figura, mientras que los bits 15 a 4 contienen la palabra de datos a cargar 2/13

3 en el DAC desde el bit más significativo al menos significativo. El valor de salida del DAC seleccionado por la dirección (ADDRESS) vendrá dado por la siguiente expresión en función de la palabra de datos (DATA): V DATA[11: 0] OUT V REF Por tanto, el DAC sólo trabaja con valores positivos (enteros sin signo), característica que hemos de tener en cuenta a la hora de enviarle la palabra de datos a representar Realización práctica Figura 8.4. Protocolo de comunicación con el DAC LTC2624 En esta práctica se pretende diseñar un modulador BPSK mediante VHDL constituido por un generador de datos pseudoaleatorios, el modulador BPSK propiamente dicho y el dispositivo de interfaz con el DAC, tal como se esquematiza en la figura 8.5. Como podemos apreciar en la figura, el generador de datos posee dos entradas (reloj y reset) y dos salidas (datos y sinc), mientras que el modulador BPSK posee tres entradas (reloj, reset y datos_serie) y tres salidas (clk_datos, clk_spi y datos). Asimismo, la salida clk_datos está realimentada a la entrada de reloj del generador de datos, mientras que la salida de datos del generador se conecta a la entrada de datos serie del modulador BPSK. Figura 8.5. Esquema de bloques del sistema modulador BPSK 3/13

4 Dado que la salida del modulador BPSK debe ser de tipo analógica, se hace uso de la interfaz con el DAC a través del bus SPI para conseguir dicho objetivo. El modulador BPSK debe suministrarle la señal de reloj de referencia al bus, así como los datos digitales a ser convertidos en un valor analógico. Por tanto, todo el sincronismo tanto del bus SPI como del generador de datos será llevado a cabo por el dispositivo modulador BPSK Interfaz con el DAC El dispositivo de interfaz con el DAC tiene tres entradas (reset, reloj y datos) y cuatro salidas que se corresponden básicamente con las líneas de comunicación con el bus SPI (spi_mosi, spi_sck, dac_cs, dac_clr). A continuación se va a diseñar una interfaz con el DAC que permita la representación de una señal haciendo uso del canal DAC A. 1. Diseñar un código en VHDL para la interfaz de conexión con el DAC a través del bus SPI. Un posible ejemplo sería el siguiente: use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity com_dac is Port ( reloj : in STD_LOGIC; reset : in STD_LOGIC; dac_cs : out STD_LOGIC; dac_clr : out STD_LOGIC; spi_mosi : out STD_LOGIC; spi_sck : out STD_LOGIC; datos : in STD_LOGIC_VECTOR(11 downto 0); cuenta_sal : out std_logic_vector(6 downto 0)); end com_dac; architecture Behavioral of com_dac is signal memoria_dac : std_logic_vector(31 downto 0) := (others => '0'); process(reloj,reset) variable cuenta : natural range 0 to 100 := 0; if reset = '1' then -- Establece el comando por defecto memoria_dac(23 downto 20) <= "0011"; -- Direcciona al DAC A por defecto memoria_dac(19 downto 16) <= "0000"; cuenta := 0; dac_cs <= '1'; elsif reloj'event and reloj = '1' then cuenta := cuenta + 1; case cuenta is when 1 => dac_cs <= '0'; memoria_dac(15 downto 4) <= datos; -- Carga los -- datos -- Direcciona al DAC A memoria_dac(19 downto 16) <= "0000"; spi_mosi <= memoria_dac(31); when 33 => dac_cs <= '1'; when 64 => cuenta := 0; when others => 4/13

5 spi_mosi <= memoria_dac(31-((cuenta-1) mod 32)); end case; cuenta_sal <= std_logic_vector(conv_unsigned(cuenta,7)); end process; spi_sck <= not(reloj); dac_clr <= not(reset); end Behavioral; Obsérvese que el controlador de la interfaz con el DAC consta básicamente de una máquina de estados controlados por la variable cuenta. Cada vez que se produce un flanco de subida en la señal de reloj se incrementa dicha variable y se van comprobando una serie de condiciones. Si cuenta es igual a uno, se cargan los datos en la memoria de la interfaz (memoria_dac) y se prepara para la transmisión de los mismos a través del bus SPI direccionados hacia el canal DAC A. Una vez se han transmitido los 32 bits de datos, se activa a alta la señal dac_cs a fin de que el DAC lleve a cabo la conversión, y todo el proceso vuelve a reiniciarse a continuación. Este proceso se repetirá una y otra vez, a menos que sea interrumpido por una señal de reset, que inicializaría la interfaz. Podemos comprobar que las señales spi_sck y dac_clr se obtienen simplemente mediante la inversión de la señal de reloj y de reset, respectivamente. 2. A continuación, vamos a llevar a cabo una simulación con el ISE Simulator a fin de comprobar el correcto funcionamiento de la interfaz con el DAC. Obsérvese que se ha incluido una señal de tipo std_logic_vector denominada cuenta_sal, simplemente a efectos de facilitar el análisis de las señales a la salida del dispositivo. 3. Probar en la tarjeta el correcto funcionamiento de la interfaz con el DAC, utilizando como entradas de datos los interruptores SW0 a SW3 de la tarjeta de desarrollo (representarán a los bits más significativos). Para el reset utilizar un pulsador cualquiera y para la entrada de reloj utilizar el de la tarjeta. Un posible fichero de configuración de pines es el siguiente: NET "reset" CLOCK_DEDICATED_ROUTE = FALSE; NET "datos<11>" LOC = T9; NET "datos<10>" LOC = U8; NET "datos<9>" LOC = U10; NET "datos<8>" LOC = V8; NET "reloj" LOC = E12; NET "reset" LOC = T15; NET "spi_mosi" LOC = AB14; NET "spi_sck" LOC = AA20; NET "dac_cs" LOC = W7; NET "dac_clr" LOC = AB13; Generador de datos Para el diseño del generador de datos pseudoaleatorio podemos hacer uso del ya implementado en la práctica anterior. Dicho generador de datos requiere de una serie de definiciones de constantes y de un componente que actúe como un 5/13

6 registro. A continuación se muestran los códigos en VHDL necesarios en cada caso. 1. Crear el paquete denominado constantes que contenga todas las constantes que vamos a utilizar durante el desarrollo de esta práctica. El código en VHDL sería el siguiente: use IEEE.STD_LOGIC_1164.all; use IEEE.STD_LOGIC_ARITH.all; use IEEE.MATH_REAL.all; package constantes is constant N : positive := 4; constant M : positive := 32; constant nbits : positive := 12; constant ndec : positive := 10; subtype palabra is signed(nbits-1 downto 0); type tabla is array (M-1 downto 0) of palabra; constant Pi : real := ; constant delta_fi : real := 2.0*Pi/real(M); function and_vector (vector : in std_logic_vector(0 to N-1)) return std_logic; end constantes; package body constantes is function and_vector (vector : in std_logic_vector(0 to N-1)) return std_logic is variable resultado : std_logic; resultado := vector(0); for I in 1 to N-1 loop resultado := vector(i) and resultado; end loop; return resultado; end and_vector; end constantes; Obsérvese que, aparte de la constante N que se referirá a la longitud (número de registros) del generador de datos y de la función and_vector que determina la función y-lógica de un vector de datos, se definen también la constante M para el número de posiciones de la tabla que contendrá la función senoidal (véase sección 8.3.3), el número de bits (nbits) de cada palabra de la tabla, así como el número de bits utilizados como decimales (ndec), además de dos constantes reales (Pi y delta_fi). Estas dos últimas constantes son utilizadas por la función de inicialización de la tabla y se refieren al número y al incremento de fase que se produce a cada paso de una posición a la siguiente en la tabla y que vendrá dado por 2 /M. En la sección incidiremos nuevamente sobre esto. La librería MATH_REAL de IEEE se incluye para poder trabajar con números reales. 2. Crear un dispositivo que actúe como registro a fin de que pueda ser utilizado por el generador de datos. Un posible código VHDL sería el siguiente: 6/13

7 use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity registro is Port ( clk,preset,d : in STD_LOGIC; Q : out STD_LOGIC); end registro; architecture Behavioral of registro is process(clk,preset) if preset='1' then Q <= '1'; elsif clk'event and clk='1' then Q <= D; end process; end Behavioral; Obsérvese que el registro responde a los cambios de las señales de entrada clk (señal de reloj) y preset (señal de set que pondrá el registro a nivel lógico 1 cuando se active a alta). Toda vez que se produzca un flanco de subida de la señal de reloj clk, el dato a la entrada D del registro pasará a la salida Q del mismo. 3. En la figura 8.6 se muestra la estructura de un generador de datos pseudoaleatorio constituido por cuatro registros, lo que dará lugar a una secuencia pseudoaleatoria de longitud = 15. Figura 8.6. Estructura interna de un generador de datos pseudoaleatorio Un posible código en VHDL que nos permite implementar el generador de datos pseudoaleatorio de la figura 8.6 es el siguiente: use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; use work.constantes.all; entity gen_datos is generic (Nreg : positive := N); port (clk,reset : in STD_LOGIC; 7/13

8 datos,sinc : out STD_LOGIC); end gen_datos; architecture Behavioral of gen_datos is component registro is port (clk,preset,d : in std_logic; Q : out std_logic); end component registro; signal sig_xor : std_logic; signal Q_int : std_logic_vector(0 to Nreg-1); Generador_datos: for I in 0 to Nreg-1 generate Reg00: if (I=0) generate Reg0: Registro port map (clk,reset,sig_xor,q_int(0)); end generate; Regs: if I>0 generate Reg: Registro port map (clk,reset,q_int(i-1),q_int(i)); end generate; end generate; datos <= Q_int(Nreg-1); sig_xor <= Q_int(0) xor Q_int(Nreg-1); sinc <= and_vector(q_int); end Behavioral; Modulador BPSK En este apartado procederemos al diseño del modulador BPSK. Para ello debemos tener en cuenta que, tal como se ha definido el bloque Interfaz DAC, dicho dispositivo requiere de 64 ciclos de la señal de reloj para llevar a cabo la transmisión del dato a representar en el DAC y enviarlo a la salida analógica del canal correspondiente. Por tanto, el reloj utilizado por dicho dispositivo será el más rápido posible, en este caso el reloj de 50 MHz de la tarjeta. Durante esos 64 ciclos de la señal de reloj, el dato suministrado al DAC no puede cambiar, por lo que el reloj del modulador que da lugar al direccionamiento en la tabla que contiene la función seno debe tener una frecuencia 64 veces menor que la señal de reloj base. Asimismo, el dato suministrado por el generador, que es el que se encarga de modular la señal senoidal, no puede cambiar durante todo el ciclo de representación de la función seno, que consta de M muestras, por lo que dicho reloj de datos del generador deberá ir a una frecuencia M veces inferior a la del direccionamiento a la tabla. Con todo esto, es posible definir la cadencia de las distintas señales de reloj dentro del bloque modulador BPSK, pero también es necesario crear la tabla que contenga los valores para las distintas muestras de la función seno. Por ello, crearemos un paquete, que denominaremos real2bit, que contenga las funciones necesarias para la generación de dicha tabla. 1. Añadir al diseño el siguiente paquete real2bit: use IEEE.STD_LOGIC_1164.all; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.MATH_REAL.ALL; use work.constantes.all; 8/13

9 package real2bit is subtype doble is signed(2*nbits-1 downto 0); function truncar (a: real; numdec : natural := ndec) return signed; function extraer (a: doble; numdec : natural := ndec) return signed; function inicializar_tabla return tabla; constant tabla_onda : tabla := inicializar_tabla; end real2bit; package body real2bit is function truncar (a: real; numdec : natural := ndec) return signed is variable resultado: signed(nbits-1 downto 0); variable tmp, comp : real := 0.0; variable comp_int, signo : integer := 0; -- numdec indica el numero de bits dedicados a decimales tmp := abs(a*(2.0**numdec)); if a < 0.0 then signo:= -1; else signo:= 1; for I in nbits-2 downto 0 loop comp := comp + 2.0**I; comp_int := comp_int + 2**I; if tmp < comp then comp := comp - 2.0**I; comp_int := comp_int - 2**I; end loop; resultado := conv_signed(comp_int*signo,nbits); return resultado; end truncar; function extraer (a: doble; numdec : natural := ndec) return signed is variable resultado : signed(nbits-1 downto 0); resultado := signed(a(numdec+nbits-1 downto numdec)); return resultado; end function extraer; function inicializar_tabla return tabla is variable resultado : tabla; for I in 0 to M-1 loop resultado(i) := truncar(2.0*sin(delta_fi*real(i))); end loop; return resultado; end function inicializar_tabla; end real2bit; En este paquete se han definido dos funciones para trabajar con números reales, que son truncar y extraer, así como una función para la inicialización de la tabla que contiene las distintas muestras de la función seno. La función truncar permite convertir un número real a un entero con signo de nbits, donde los numdec bits menos significativos representan los valores decimales. Por ejemplo, si le suministramos el valor 1,5 a la función truncar, teniendo en cuenta 9/13

10 que, según las definiciones en el paquete constantes, nbits = 12 y ndec = 7 (valor que toma por defecto numdec si no se le suministra ningún valor como argumento en la función), ésta nos devolvería (el punto decimal ha sido añadido para una mejor comprensión del resultado). Por el contrario, truncar(-1.5) devolvería La función extraer permite obtener nuevamente un resultado de tipo palabra (definido en el paquete constantes) a partir de un tipo doble, resultado que se produce al multiplicar dos datos de tipo palabra. Esta función no será utilizada en esta práctica, pero es útil cuando se produce la multiplicación de valores de tipo palabra y se desea recuperar nuevamente un resultado de tipo palabra. Como se sabe, multiplicar un dato binario de nbits con otro también de nbits da lugar a un resultado de 2nbits, con un desplazamiento del punto decimal a 2ndec. La función extraer no hace más que recuperar la parte central del resultado producido tras la multiplicación, para obtener nuevamente un valor de tipo palabra. Por último, se ha definido una función inicializar_tabla, que no hace más que inicializar con la función seno las muestras, de manera consecutiva, de un array de enteros con signo (signed) de M posiciones, definido con el tipo tabla en el paquete constantes. La tabla resultante, denominada tabla_onda, es una constante que podrá ser indexada para extraerle los valores necesarios en todo momento. 2. Teniendo en cuenta todo lo expuesto anteriormente, vamos a proceder al diseño del modulador BPSK. Un posible código en VHDL sería el siguiente: use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use work.constantes.all; use work.real2bit.all; entity bpsk is Port ( reloj : in STD_LOGIC; reset : in STD_LOGIC; datos_serie : in STD_LOGIC; clk_datos : out STD_LOGIC; clk_spi : out STD_LOGIC; clk_bpsk : out STD_LOGIC; datos : out STD_LOGIC_VECTOR (11 downto 0)); end bpsk; architecture Behavioral of bpsk is signal puntero : natural range 0 to (M-1) := M-1; signal valor : palabra := (others => '0'); signal reloj_bpsk : std_logic := '0'; process(reset,reloj,reloj_bpsk) variable cuenta : natural range 0 to (64*M-1) := 0; if reset = '1' then reloj_bpsk <= '0'; clk_datos <= '0'; cuenta := 0; 10/13

11 elsif reloj'event and reloj = '1' then if cuenta = 0 then reloj_bpsk <= '1'; clk_datos <= '1'; elsif cuenta mod 64 = 0 then reloj_bpsk <= '1'; else reloj_bpsk <= '0'; clk_datos <= '0'; cuenta := (cuenta + 1) mod (64*M); end process; process(reset,reloj_bpsk) if reset = '1' then puntero <= M-1; elsif reloj_bpsk'event and reloj_bpsk = '1' then puntero <= (puntero + 1) mod M; end process; clk_spi <= reloj; valor <= -tabla_onda(puntero) when datos_serie = '1' else tabla_onda(puntero); -- Utilizar la siguiente línea para simulación datos <= std_logic_vector(valor); -- Utilizar la siguiente línea para la síntesis y comentar la anterior --datos <= valor + conv_signed(2**(nbits-1),nbits); clk_bpsk <= reloj_bpsk; end Behavioral; Obsérvese que existe un primer proceso que se encarga de la generación de las señales de reloj (clk_datos, reloj_bpsk) en base a las consideraciones indicadas anteriormente. Asimismo, a la señal de reloj de la interfaz con el DAC, clk_spi, se le asigna directamente la señal de entrada reloj, que será la de 50 MHz de la tarjeta. Un segundo proceso se encarga de ir modificando el valor de un puntero, que indexa la tabla con las muestras de la función seno, tabla_onda, a cada flanco de subida de la señal reloj_bpsk. Dado que las muestras están dispuestas de manera secuencial en dicha tabla, a cada salto del puntero se irá representando la siguiente muestra en el tiempo, con lo que, tras M saltos, se habrá completado la representación de la señal senoidal a la salida del sistema. Por último, tenemos una serie de líneas de código para el envío de la palabra digital a representar por el DAC. En primer lugar, se ha creado una señal interna denominada valor a la que se le asigna el valor de la tabla negado si el dato suministrado por el generador de datos (datos_serie) es uno o el propio valor de la tabla sin negarlo si el dato es cero. Este es básicamente el proceso de modulación BPSK. A continuación, dicho valor es enviado a la salida de datos del modulador a través del puerto datos. Se han incluido dos posibles líneas de código, cada uno excluyente de la otra, una para simulación, donde se envía directamente el dato, y otra para la síntesis donde se le suma una determinada cantidad a fin de hacer el valor enviado a la interfaz con el DAC positivo. Téngase en cuenta que el DAC sólo trabaja con valores 11/13

12 enteros sin signo (tipo unsigned). Lo que se ha hecho es sumarle un valor constante que se corresponde con la mitad del margen de salida del DAC (VREF/2). De esta forma, la onda de salida representada estará centrada en torno a dicho valor. 3. Haciendo uso del ISE Simulator, comprobar el correcto funcionamiento del modulador BPSK. Obsérvese que se ha incluido la señal clk_bpsk como línea de salida del bloque (asignándole el valor contenido en reloj_bpsk), únicamente a efectos de facilitar el análisis del dispositivo, pues dicha señal realmente trabaja únicamente de manera interna en dicho bloque. 4. A continuación se muestra un posible código en VHDL que integre todos los bloques diseñados anteriormente: use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; use work.constantes.all; entity sistema is Port ( reloj : in STD_LOGIC; reset : in STD_LOGIC; dac_cs : out STD_LOGIC; spi_mosi : out STD_LOGIC; spi_sck : out STD_LOGIC; dac_clr : out STD_LOGIC; datos : out STD_LOGIC); end sistema; architecture Behavioral of sistema is component bpsk is Port ( reloj : in STD_LOGIC; reset : in STD_LOGIC; datos_serie : in STD_LOGIC; clk_datos : out STD_LOGIC; clk_spi : out STD_LOGIC; clk_bpsk : out STD_LOGIC; datos : out STD_LOGIC_VECTOR (11 downto 0)); end component bpsk; component gen_datos is generic (Nreg : positive := N); port (clk,reset : in STD_LOGIC; datos,sinc : out STD_LOGIC); end component gen_datos; component com_dac is Port ( reloj : in STD_LOGIC; reset : in STD_LOGIC; dac_cs : out STD_LOGIC; dac_clr : out STD_LOGIC; spi_mosi : out STD_LOGIC; spi_sck : out STD_LOGIC; datos : in STD_LOGIC_VECTOR(11 downto 0); cuenta_sal : out std_logic_vector(6 downto 0)); end component com_dac; signal clk_datos, clk_spi, datos_serie : std_logic; signal datos_int : std_logic_vector (11 downto 0); Gen_datos0: gen_datos port map (clk_datos,reset,datos_serie); Modulador: bpsk port map 12/13

13 (reloj,reset,datos_serie,clk_datos,clk_spi, datos => datos_int); Interfaz_dac: com_dac port map (clk_spi,reset,dac_cs,dac_clr,spi_mosi,spi_sck,datos_int); datos <= datos_serie; end Behavioral; Obsérvese que existen determinadas señales como clk_bpsk, sinc y cuenta_sal que no son utilizadas por el bloque sistema, ya que en su momento fueron añadidas únicamente a efectos de facilitar el análisis de los distintos dispositivos. 5. Implementar en la FPGA el diseño del modulador BPSK. Observar las señales de salida haciendo uso de un analizador lógico/osciloscopio. A continuación se muestra una posible configuración para los pines de entrada/salida a la FPGA: NET "reset" CLOCK_DEDICATED_ROUTE = FALSE; NET "dac_clr" LOC = AB13; NET "dac_cs" LOC = W7; NET "datos" LOC = A13; NET "reloj" LOC = E12; NET "reset" LOC = T15; NET "spi_mosi" LOC = AB14; NET "spi_sck" LOC = AA20; 13/13