OpenCores
URL https://opencores.org/ocsvn/raytrac/raytrac/trunk

Subversion Repositories raytrac

[/] [raytrac/] [trunk/] [opcoder.vhd] - Diff between revs 25 and 26

Go to most recent revision | Show entire file | Details | Blame | View Log

Rev 25 Rev 26
Line 34... Line 34...
--! Las entradas a esta descripción son: los vectores A,B,C,D, las entradas opcode y addcode. Las salidas del decodificador, estarán conectadas a las entradas de los 6 multiplicadores de una entidad uf. Los operandos de los multiplicadores, también conocidos como factores, son las salida m0f0, m0f1 para el multiplicador 1 y así hasta el multiplicador 5. Básicamente lo que opera aquí en esta descripción es un multiplexor, el cual selecciona a través de opcode y addcode qué componentes de los vectores se conectaran a los operandos de los multiplicadores.  
--! Las entradas a esta descripción son: los vectores A,B,C,D, las entradas opcode y addcode. Las salidas del decodificador, estarán conectadas a las entradas de los 6 multiplicadores de una entidad uf. Los operandos de los multiplicadores, también conocidos como factores, son las salida m0f0, m0f1 para el multiplicador 1 y así hasta el multiplicador 5. Básicamente lo que opera aquí en esta descripción es un multiplexor, el cual selecciona a través de opcode y addcode qué componentes de los vectores se conectaran a los operandos de los multiplicadores.  
entity opcoder is
entity opcoder is
        generic (
        generic (
                width : integer := 18;
                width : integer := 18;
                structuralDescription : string:= "NO"
                structuralDescription : string:= "NO"
        )
        );
        port (
        port (
                Ax,Bx,Cx,Dx,Ay,By,Cy,Dy,Az,Bz,Cz,Dz : in std_logic_vector (width-1 downto 0);
                Ax,Bx,Cx,Dx,Ay,By,Cy,Dy,Az,Bz,Cz,Dz : in std_logic_vector (width-1 downto 0);
                m0f0,m0f1,m1f0,m1f1,m2f0,m2f1,m3f0,m3f1,m4f0,m4f1,m5f0,m5f1 : out std_logic_vector (width-1 downto 0);
                m0f0,m0f1,m1f0,m1f1,m2f0,m2f1,m3f0,m3f1,m4f0,m4f1,m5f0,m5f1 : out std_logic_vector (width-1 downto 0);
 
 
                opcode,addcode : in std_logic
                opcode,addcode : in std_logic
Line 56... Line 56...
--! \n\n
--! \n\n
--! Por ejemplo para ver la tabla de verdad del m0f0, consultar el registro (línea) m0 y el atributo (columna) f0.\n
--! Por ejemplo para ver la tabla de verdad del m0f0, consultar el registro (línea) m0 y el atributo (columna) f0.\n
 
 
architecture opcoder_arch of opcoder is
architecture opcoder_arch of opcoder is
 
 
        signal aycy,bzdz,azcz,bydy,bxdx,axcx: std_logic_vector(width-1 downto 0);
        variable aycy,bzdz,azcz,bydy,bxdx,axcx: std_logic_vector(width-1 downto 0);
 
 
begin
begin
        --! Proceso que describe las 2 etapas de multiplexores. 
        --! Proceso que describe las 2 etapas de multiplexores. 
        --! Proceso que describe las 2 etapas de multiplexores. Una corresponde al selector addcode, que selecciona con que operadores realizará la operación producto cruz, es decir, seleccionará si realiza la operación AxB ó CxD. En el caso del producto punto, esta etapa de multiplexación no tendrá repercusión en el resultado de la deocdificación de la operación. La otra etapa utiliza el selector opcode, el cual decide si usa los operandos decodificados en la primera etapa de multiplexores, en el caso de que opcode sea 1, seleccionando la operación producto cruz, o por el contrario seleccionando una decodificación de operadores que lleven a cabo la operación producto punto. 
        --! Proceso que describe las 2 etapas de multiplexores. Una corresponde al selector addcode, que selecciona con que operadores realizará la operación producto cruz, es decir, seleccionará si realiza la operación AxB ó CxD. En el caso del producto punto, esta etapa de multiplexación no tendrá repercusión en el resultado de la deocdificación de la operación. La otra etapa utiliza el selector opcode, el cual decide si usa los operandos decodificados en la primera etapa de multiplexores, en el caso de que opcode sea 1, seleccionando la operación producto cruz, o por el contrario seleccionando una decodificación de operadores que lleven a cabo la operación producto punto. 
 
 
        originalMuxGen:
        originalMuxGen:
        if behavioralDescription="NO" generate
        if structuralDescription="NO" generate
 
 
                procOpcoder:
                procOpcoder:
                process (Ax,Bx,Cx,Dx,Ay,By,Cy,Dy,Az,Bz,Cz,Dz,opcode,addcode)
                process (Ax,Bx,Cx,Dx,Ay,By,Cy,Dy,Az,Bz,Cz,Dz,aycy,bzdz,azcz,bydy,bxdx,axcx,opcode,addcode)
                        variable scoder : std_logic_vector (1 downto 0);
 
                begin
                begin
                        case (addcode) is
                        case (addcode) is
                                when "1" =>
                                -- Estamos ejecutando CxD
 
                                when '1'=>
                                        aycy <= Cy;
                                        aycy <= Cy;
                                        bzdz <= Dz;
                                        bzdz <= Dz;
                                        azcz <= Cz;
                                        azcz <= Cz;
                                        bydy <= Dy;
                                        bydy <= Dy;
                                        axcx <= Cx;
                                        axcx <= Cx;
                                        bxdx <= Dx;
                                        bxdx <= Dx;
                                when others =>
                                when others =>
 
                                -- Estamos ejecutando AxB
                                        aycy <= Ay;
                                        aycy <= Ay;
                                        bzdz <= Bz;
                                        bzdz <= Bz;
                                        azcz <= Az;
                                        azcz <= Az;
                                        bydy <= By;
                                        bydy <= By;
                                        axcx <= Ax;
                                        axcx <= Ax;
                                        bxdx <= Bx;
                                        bxdx <= Bx;
                        end case;
                        end case;
                        case (opcode) is
                        case (opcode) is
                                when "1" =>
                                -- Estamos ejecutando Producto Cruz
 
                                when '1' =>
                                        m0f0 <= aycy;
                                        m0f0 <= aycy;
                                        m0f1 <= bzdz;
                                        m0f1 <= bzdz;
                                        m1f0 <= azcz;
                                        m1f0 <= azcz;
                                        m1f1 <= bydy;
                                        m1f1 <= bydy;
                                        m2f0 <= axcx;
                                        m2f0 <= axcx;
Line 100... Line 102...
                                        m4f0 <= axcx;
                                        m4f0 <= axcx;
                                        m4f1 <= bydy;
                                        m4f1 <= bydy;
                                        m5f0 <= aycy;
                                        m5f0 <= aycy;
                                        m5f1 <= bxdx;
                                        m5f1 <= bxdx;
                                when others =>
                                when others =>
 
                                -- Estamos ejecutando Producto Punto
                                        m0f0 <= Ax;
                                        m0f0 <= Ax;
                                        m0f1 <= Bx;
                                        m0f1 <= Bx;
                                        m1f0 <= Ay;
                                        m1f0 <= Ay;
                                        m1f1 <= By;
                                        m1f1 <= By;
                                        m2f0 <= Az;
                                        m2f0 <= Az;
Line 117... Line 120...
                        end case;
                        end case;
                end process procOpcoder;
                end process procOpcoder;
        end generate originalMuxGen;
        end generate originalMuxGen;
        fastMuxGen:
        fastMuxGen:
        if structuralDescription="YES" generate
        if structuralDescription="YES" generate
                mux0 : fastmux (ay,cy,addcode,aycy);
                mux0 : fastmux port map (ay,cy,addcode,aycy);
                mux1 : fastmux (bz,dz,addcode,bzdz);
                mux1 : fastmux port map (bz,dz,addcode,bzdz);
                mux2 : fastmux (az,cz,addcode,azcz);
                mux2 : fastmux port map (az,cz,addcode,azcz);
                mux3 : fastmux (by,dy,addcode,bydy);
                mux3 : fastmux port map (by,dy,addcode,bydy);
                mux4 : fastmux (bx,dx,addcode,bxdx);
                mux4 : fastmux port map (bx,dx,addcode,bxdx);
                mux5 : fastmux (ax,cx,addcode,axcx);
                mux5 : fastmux port map (ax,cx,addcode,axcx);
 
 
                -- Segunda etapa de multiplexores 
                -- Segunda etapa de multiplexores 
                muxa : fastmux (ax,aycy,opcode,m0f0);
                muxa : fastmux port map (ax,aycy,opcode,m0f0);
                muxb : fastmux (bx,bzdz,opcode,m0f1);
                muxb : fastmux port map (bx,bzdz,opcode,m0f1);
                muxc : fastmux (ay,azcz,opcode,m1f0);
                muxc : fastmux port map (ay,azcz,opcode,m1f0);
                muxd : fastmux (by,bydy,opcode,m1f1);
                muxd : fastmux port map (by,bydy,opcode,m1f1);
                muxe : fastmux (az,azcz,opcode,m2f0);
                muxe : fastmux port map (az,azcz,opcode,m2f0);
                muxf : fastmux (bz,bxdx,opcode,m2f1);
                muxf : fastmux port map (bz,bxdx,opcode,m2f1);
                muxg : fastmux (cx,axcx,opcode,m3f0);
                muxg : fastmux port map (cx,axcx,opcode,m3f0);
                muxh : fastmux (dx,bzdz,opcode,m3f1);
                muxh : fastmux port map (dx,bzdz,opcode,m3f1);
                muxi : fastmux (cy,axcx,opcode,m4f0);
                muxi : fastmux port map (cy,axcx,opcode,m4f0);
                muxj : fastmux (dy,bydy,opcode,m4f1);
                muxj : fastmux port map (dy,bydy,opcode,m4f1);
                muxk : fastmux (cz,aycy,opcode,m5f0);
                muxk : fastmux port map (cz,aycy,opcode,m5f0);
                muxl : fastmux (dz,bxdx,opcode,m5f1);
                muxl : fastmux port map (dz,bxdx,opcode,m5f1);
        end generate
 
 
        end generate fastMuxGen;
 
 
 
 
end opcoder_arch;
end opcoder_arch;
 
 
 No newline at end of file
 No newline at end of file

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.