Input als Array

[Dirk (Gast)]

Hallo, ich möchte in einer FOR LOOP Schleife per Index die Inputs des
Moduls abfragen, bloss wie lege ich in der Enity die Inputs als Array
an?

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;

entity async_pwm is
 PORT (  CLK    :  in std_logic;
        RST    : in std_logic;
        channel  :  out std_logic_vector(7 downto 0);
        value0    :  in std_logic_vector(7 downto 0);
        value1    :  in std_logic_vector(7 downto 0);
        value2    :  in std_logic_vector(7 downto 0);
        value3    :  in std_logic_vector(7 downto 0);
        value4    :  in std_logic_vector(7 downto 0);
        value5    :  in std_logic_vector(7 downto 0);
        value6    :  in std_logic_vector(7 downto 0);
        value7    :  in std_logic_vector(7 downto 0)
      
      
      );

end async_pwm;

architecture Behavioral of async_pwm is

type arrayfield is array (0 to 7) of  std_logic_vector(7 downto 0);
 
signal value_help : arrayfield;
signal timer_cnt : std_logic_vector(7 downto 0);
signal channel_int : std_logic_vector(7 downto 0);
begin


process(clk)
begin
if rising_edge(clk) then  
  if rst = '1' then
    channel_int <= "00000000";
    FOR index IN 0 TO 7 LOOP
      value_help(index) <= "00000000";
    END LOOP;
  else
    FOR index IN 0 TO 7 LOOP
      value_help(index) <= value_help(index) + 1;
      if value_help(index) = "11111111" then
        channel_int(index) <= '1';
      end if;
      
      if value_help(index) = value0 and value0 > 0 then -- value0 - value7
als index (value(index)
        channel_int(index) <= '0';
      end if;
    END LOOP;
    
  end if;
end if;
end process;

channel <= channel_int;

end Behavioral;

Oder funktioniert das in VHDL nicht?

Gruß,
Dirk

[tobias (Gast)]

Du legst einfach deine Typedefinition in ein Package ab:
type arrayfield is array (0 to 7) of  std_logic_vector(7 downto 0);
Includierst das Package.

Danach kannst du ein Signal dieses Typs einfach als Ein- oder Ausgang
in
deine Entity Mappen.

[Dirk (Gast)]

Hattest du ein Beispiel? Ich kann Dir leider nicht ganz folgen.

[tobias (Gast)]

Schau dir einfach die beiden Dateien an. Eine Datei enthält eine Reihe
von Datentypen, in der anderen Datei werden diese Datentypen als In und
Out in der Entity benutzt.
Du kannst jeden Datentyp den du dir selbst definiert hast als In und
Out- Port benutzen. Es spielt keine Rolle um was für einen Datentyp es
sich handelt ! Wenn du nicht weiter weisst, dann präzisiere doch deine
Fragestellung. Vielleicht habe ich nicht richtig verstanden was du
meinst.

[Dirk (Gast)]

Hallo, ich hab mir jetzt das Package definiert.

library IEEE;
use IEEE.STD_LOGIC_1164.all;

package value is 
  type arrayfield2 is array (0 to 7) of  std_logic_vector(7 downto 0);
end value;

In meiner Behav. Beschreibung habe ich das Package in der Entity als
Input deklariert. Die Synthese generiert mir auch meine
Logikbeschreibung, aber Modelsim bringt mir beim Compelieren Fehler.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
use work.value.ALL;

entity async_pwm is
 PORT (  CLK    :  in std_logic;
        RST    : in std_logic;
        EN    : in std_logic;
        channel  :  out std_logic_vector(7 downto 0);
        value : in arrayfield2
      );

end async_pwm;

architecture Behavioral of async_pwm is

type arrayfield is array (0 to 7) of  std_logic_vector(7 downto 0);
 
signal value_help : arrayfield;
signal channel_int : std_logic_vector(7 downto 0);
begin

process(clk)
begin
if rising_edge(clk) then  
  if rst = '1' then
    channel_int <= "00000000";
    FOR index IN 0 TO 7 LOOP
      value_help(index) <= "00000000";
    END LOOP;
  else
    if EN = '1' then
    FOR index IN 0 TO 7 LOOP
      value_help(index) <= value_help(index) + 1;
      if value_help(index) = "11111111" then
        channel_int(index) <= '0';
      end if;
      
      if value_help(index) = value(index) and value(index) > 0 then
        channel_int(index) <= '1';
      end if;
    END LOOP;
    end if;
  end if;
end if;
end process;

channel <= channel_int;

end Behavioral;

Die Fehlermedlungen von Modelsim:

# ** Error: tb_a2.vhw(41): (vcom-1136) Unknown identifier
"arrayfield2base".
# ** Error: tb_a2.vhw(49): (vcom-1136) Unknown identifier
"arrayfield2base".
# ** Error: tb_a2.vhw(49): String literal found where non-array type
(error) was expected.
# ** Error: tb_a2.vhw(109): String literal found where non-array type
(error) was expected.
# ** Error: tb_a2.vhw(113): String literal found where non-array type
(error) was expected.
# ** Error: tb_a2.vhw(133): VHDL Compiler exiting
# ** Error: F:/Mikrocontroller/modelsim6.1/win32xoem/vcom failed.

Kann mir jemand weiterhelfen?

Gruß,

Dirk

[Dirk (Gast)]

Mir kommt es so vor als wenn das Package bzw. das Array falsch
deklariert ist und zwar nicht als 8 * 8 Bit Array.

Hier mein Testbenchfile, vielleicht hilft es weiter.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
library work;
use work.value.ALL;
USE IEEE.STD_LOGIC_TEXTIO.ALL;
USE STD.TEXTIO.ALL;

ENTITY tb3_tb_0 IS
END tb3_tb_0;

ARCHITECTURE testbench_arch OF tb3_tb_0 IS
    FILE RESULTS: TEXT OPEN WRITE_MODE IS "results.txt";

    COMPONENT async_pwm
        PORT (
            CLK : In std_logic;
            RST : In std_logic;
            EN : In std_logic;
            channel : Out std_logic_vector (7 DownTo 0);
            value : In arrayfield2Base (0 To 7)
        );
    END COMPONENT;

    SIGNAL CLK : std_logic := '0';
    SIGNAL RST : std_logic := '0';
    SIGNAL EN : std_logic := '0';
    SIGNAL channel : std_logic_vector (7 DownTo 0) := "00000000";
    SIGNAL value : arrayfield2Base (0 To 7) := "00000000";

    SHARED VARIABLE TX_ERROR : INTEGER := 0;
    SHARED VARIABLE TX_OUT : LINE;

    constant PERIOD : time := 40 ns;
    constant DUTY_CYCLE : real := 0.5;
    constant OFFSET : time := 0 ns;

    BEGIN
        UUT : async_pwm
        PORT MAP (
            CLK => CLK,
            RST => RST,
            EN => EN,
            channel => channel,
            value => value
        );

        PROCESS    -- clock process for CLK
        BEGIN
            WAIT for OFFSET;
            CLOCK_LOOP : LOOP
                CLK <= '0';
                WAIT FOR (PERIOD - (PERIOD * DUTY_CYCLE));
                CLK <= '1';
                WAIT FOR (PERIOD * DUTY_CYCLE);
            END LOOP CLOCK_LOOP;
        END PROCESS;

        PROCESS
            PROCEDURE CHECK_channel(
                next_channel : std_logic_vector (7 DownTo 0);
                TX_TIME : INTEGER
            ) IS
                VARIABLE TX_STR : String(1 to 4096);
                VARIABLE TX_LOC : LINE;
                BEGIN
                IF (channel /= next_channel) THEN
                    STD.TEXTIO.write(TX_LOC, string'("Error at
time="));
                    STD.TEXTIO.write(TX_LOC, TX_TIME);
                    STD.TEXTIO.write(TX_LOC, string'("ns
channel="));
                    IEEE.STD_LOGIC_TEXTIO.write(TX_LOC, channel);
                    STD.TEXTIO.write(TX_LOC, string'(", Expected =
"));
                    IEEE.STD_LOGIC_TEXTIO.write(TX_LOC, next_channel);
                    STD.TEXTIO.write(TX_LOC, string'(" "));
                    TX_STR(TX_LOC.all'range) := TX_LOC.all;
                    STD.TEXTIO.writeline(RESULTS, TX_LOC);
                    STD.TEXTIO.Deallocate(TX_LOC);
                    ASSERT (FALSE) REPORT TX_STR SEVERITY ERROR;
                    TX_ERROR := TX_ERROR + 1;
                END IF;
            END;
            BEGIN
                -- -------------  Current Time:  3045ns
                WAIT FOR 3045 ns;
                value <= "10000000";
                -- -------------------------------------
                -- -------------  Current Time:  3405ns
                WAIT FOR 360 ns;
                value <= "11000000";
                -- -------------------------------------
                -- -------------  Current Time:  8965ns
                WAIT FOR 5560 ns;
                value <= "01000000";
                -- -------------------------------------
                -- -------------  Current Time:  9005ns
                WAIT FOR 40 ns;
                value <= "00000000";
                -- -------------------------------------
                WAIT FOR 91035 ns;

                IF (TX_ERROR = 0) THEN
                    STD.TEXTIO.write(TX_OUT, string'("No errors or
warnings"));
                    STD.TEXTIO.writeline(RESULTS, TX_OUT);
                    ASSERT (FALSE) REPORT
                      "Simulation successful (not a failure).  No
problems detected."
                      SEVERITY FAILURE;
                ELSE
                    STD.TEXTIO.write(TX_OUT, TX_ERROR);
                    STD.TEXTIO.write(TX_OUT,
                        string'(" errors found in simulation"));
                    STD.TEXTIO.writeline(RESULTS, TX_OUT);
                    ASSERT (FALSE) REPORT "Errors found during
simulation"
                         SEVERITY FAILURE;
                END IF;
            END PROCESS;

    END testbench_arch;

Dirk

[T.M. (Gast)]

Deine Component Declaration in der Testbench stimmt doch gar nicht mit
der Entity des Designs überein. Oder was ist arrayfield2Base für ein
Typ?

[Dirk (Gast)]

Hallo, das arrayfield2Base sollte eigentlich das 8 * 8 Bit Array
darstellen. Das Testbench ist mit dem ISE Testbench Waveform View
erstellt.

library IEEE;
use IEEE.STD_LOGIC_1164.all; 
package value is   type arrayfield2 is array (0 to 7) of 
std_logic_vector(7 downto 0);
end value;

Ist es ein Programmfehler vom testbench waveform viever?

Wie muesste es den richtig sein?

[T.M. (Gast)]

Das die Fehler zuerst bei der Component Instanziierung auftreten, deutet
zumindestens darauf hin, dass an den Ports was nicht stimmt. Das
Design-file hat er wohl anstandslos kompiliert, also stimmt auch das
Package. Da haut meiner Meinung was mit der Component Declaration nicht
hin.

Mach in der Testbench mal:

COMPONENT async_pwm
  PORT (
    CLK : In std_logic;
    RST : In std_logic;
    EN : In std_logic;
    channel : Out std_logic_vector (7 DownTo 0);
    value : In arrayfield2
  );
END COMPONENT;

T.M.

[tobias (Gast)]

Hmm, ich habe deinen Sourcecode mit der Ise erfolgreich synthetisiert.
Modelsim hatte auch keine Probleme beim kompilieren der Dateien. Was
ist den "tb_a2.vhw" für eine Datei. Ich denke, dass das
Problem eher an deiner Testbench liegt. Ich vermute, dass du diese
automatisch oder grafisch erzeugt hast, und dort Datentypen verwendet
werden die nicht bekanntgegeben wurden. Aus der Ferne lässt sich dieses
aber schlecht beurteilen. Evtl. schreibst du die Testbench neu nach der
klassischen Methode als VHDL-Datei.

Gruß tobias

[tobias (Gast)]

ups, da war jemand schneller

[Dirk (Gast)]

Hallo, @tobias du hast recht das Testbench ist grafisch erzeugt. Hm, bis
jetzt hab ich eigentlich alles immer nur über die Grafikoberfläche
erstellt, deshalb wird es sehr schwierig fuer mich das Testbench
zuschreiben.

Das grafische Testbenchfile zum Project Adden klappt leider auch nicht
dann bekomme ich immer noch die Fehlermeldungen.

Gruß,
Dirk

[Dirk (Gast)]

Vielleicht ist jemand von euch beiden so nett und kann mir nochmal beim
Testbench unter die Arme greifen.

LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.ALL;

ENTITY tb4_vhd IS
END tb4_vhd;

ARCHITECTURE behavior OF tb4_vhd IS 

  -- Component Declaration for the Unit Under Test (UUT)
  COMPONENT async_pwm
  PORT(
    CLK : IN std_logic;
    RST : IN std_logic;
    EN : IN std_logic;
    value : IN std_logic_vector(0 to 7);          
    channel : OUT std_logic_vector(7 downto 0)
    );
  END COMPONENT;

  --Inputs
  SIGNAL CLK :  std_logic := '0';
  SIGNAL RST :  std_logic := '0';
  SIGNAL EN :  std_logic := '0';
  SIGNAL value :  std_logic_vector(0 to 7) := (others=>'0');

  --Outputs
  SIGNAL channel :  std_logic_vector(7 downto 0);

  
  constant PERIOD : time := 40 ns;
  constant DUTY_CYCLE : real := 0.5;
  constant OFFSET : time := 0 ns;


BEGIN

  -- Instantiate the Unit Under Test (UUT)
  uut: async_pwm PORT MAP(
    CLK => CLK,
    RST => RST,
    EN => EN,
    channel => channel,
    value => value
  );

  PROCESS    -- clock process for CLK
        BEGIN
            WAIT for OFFSET;
            CLOCK_LOOP : LOOP
                CLK <= '0';
                WAIT FOR (PERIOD - (PERIOD * DUTY_CYCLE));
                CLK <= '1';
                WAIT FOR (PERIOD * DUTY_CYCLE);
            END LOOP CLOCK_LOOP;
        END PROCESS;


  tb : PROCESS
  BEGIN

    -- Wait 100 ns for global reset to finish
    wait for 100 ns;
    rst <= '1';
    wait for 100 ns;
    rst <= '0';
    value(0) <= "00001111";
    wait for 10 ms; -- will wait forever
  END PROCESS;

END;

Ich bekomme beim starten des Testbench in Modelsim immer noch
Fehlermeldungen. Ich haette lieber bei der alten Methode bleiben sollen
und ohne For Schleifen arbeiten sollen.

Fehlermeldungen:
# ** Error: tb4.vhd(96): Incompatible types for signal assignment.
# ** Error: tb4.vhd(100): VHDL Compiler exiting

[Dirk (Gast)]

Ich hab es geschafft. Vielen Dank und damit es anderen auch weiterhilft
hier das TB.

LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.ALL;
use work.value.ALL;

ENTITY tb4_vhd IS
END tb4_vhd;

ARCHITECTURE behavior OF tb4_vhd IS 

  -- Component Declaration for the Unit Under Test (UUT)
  COMPONENT async_pwm
  PORT(
    CLK : IN std_logic;
    RST : IN std_logic;
    EN : IN std_logic;
    value : IN arrayfield2;          
    channel : OUT std_logic_vector(7 downto 0)
    );
  END COMPONENT;

  --Inputs
  SIGNAL CLK :  std_logic := '0';
  SIGNAL RST :  std_logic := '0';
  SIGNAL EN :  std_logic := '0';
  SIGNAL value :  arrayfield2;

  --Outputs
  SIGNAL channel :  std_logic_vector(7 downto 0);

  
  constant PERIOD : time := 40 ns;
  constant DUTY_CYCLE : real := 0.5;
  constant OFFSET : time := 0 ns;


BEGIN

  -- Instantiate the Unit Under Test (UUT)
  uut: async_pwm PORT MAP(
    CLK => CLK,
    RST => RST,
    EN => EN,
    channel => channel,
    value => value
  );

  PROCESS    -- clock process for CLK
        BEGIN
            WAIT for OFFSET;
            CLOCK_LOOP : LOOP
                CLK <= '0';
                WAIT FOR (PERIOD - (PERIOD * DUTY_CYCLE));
                CLK <= '1';
                WAIT FOR (PERIOD * DUTY_CYCLE);
            END LOOP CLOCK_LOOP;
        END PROCESS;


  tb : PROCESS
  BEGIN

    -- Wait 100 ns for global reset to finish
    wait for 100 ns;
    rst <= '1';
    wait for 100 ns;
    rst <= '0';
    value(0) <= "00001111";
    wait for 10 ms; -- will wait forever
  END PROCESS;

END;

[Josef K. (netroman-)]

@Dirk

Vielen Dank, dass Du die Lösung auch für andere weitergibst - das wird
nämlich oft vergessen. Nebenbei habe ich nach so einer Lösung schon ein
wenig gesucht!

Gruß Josef

[Dirk (Gast)]

Hallo, das freut mich das jemand anderen auch geholfen ist / wird.

Die Beschreibung ist ein 8 Kanal 8Bit PWM mit 24 Makrozellen. Ich hab
das Design zur Übung erstellt, aber nun wuerde ich gerne noch alle 8
Kanaele asynbchron zueinander laufen lassen um den Gesamtstrom
zuminieren.


Meine Ueberlegungen waeren die folgenden:

Bei einer Pwmgrundfrequenz von 100Hz ergibt sich folgende Interruptzeit
1/100Hz = 10ms, 10ms / 256 = 39µs. Jeder der 8 Kanaele soll ansychron
zueinander arbeiten, deshalb muesste die PWM Grundfreq. um das 8 fache
erhoeht werden. 1/800Hz = 1,25ms , 1,25ms / 256 = 4,88µs.

Sind diese Überlegungen soweit richtig? Ich werde heute abend meinen
VHDL Code posten und hoffe mir kann jemand weiterhelfen, weil die
Simulation der Beschreibung ein anderes Verhalten hat als ich mir
vorgestellt habe.

Gruß,
Dirk

[Dirk (Gast)]

Hallo, endlich Feierabend und ich kann meinen Code posten.

Ich hoffe jemand ist so nett und hat ein Tipp fuer mich.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
use work.value.ALL;

entity async_pwm2 is
 PORT (  CLK    :  in std_logic;
        RST    : in std_logic;
        EN    : in std_logic;
        channel  :  out std_logic_vector(7 downto 0);
        value : in arrayfield2 
      );

end async_pwm2;

architecture Behavioral of async_pwm2 is

type arrayfield is array (0 to 7) of  std_logic_vector(7 downto 0);
TYPE state IS (STATE0, STATE1, STATE2, STATE3, STATE4, STATE5, STATE6,
STATE7); 
 
signal value_help : arrayfield;
signal channel_int : std_logic_vector(7 downto 0);
signal cnt : std_logic_vector(3 downto 0);
signal nstate : state;

begin

process(clk)
begin
if rising_edge(clk) then  
  if rst = '1' then
    channel_int <= "00000000";
    cnt <= "0000";
    FOR index IN 0 TO 7 LOOP
      value_help(index) <= "00000000";
    END LOOP;
  else
    if EN = '1' then
      case nstate is
        
        when STATE0 =>
          channel_int <= "00000000";
          value_help(0) <= value_help(0) + 1;
          if value_help(0) = "11111111" then
            channel_int(0) <= '0';
          end if;
          if value_help(0) = value(0) and value(0) > 0 then
            channel_int(0) <= '1';
          end if;
          nstate <= STATE1;
      
        when STATE1 =>
          channel_int <= "00000000";
          value_help(1) <= value_help(1) + 1;
          if value_help(1) = "11111111" then
            channel_int(1) <= '0';
          end if;
          if value_help(1) = value(1) and value(1) > 0 then
            channel_int(1) <= '1';
          end if;
        nstate <= STATE2;
      
        when STATE2 =>
          channel_int <= "00000000";
          value_help(2) <= value_help(2) + 1;
          if value_help(2) = "11111111" then
            channel_int(2) <= '0';
          end if;
          if value_help(2) = value(2) and value(2) > 0 then
            channel_int(2) <= '1';
          end if;
          nstate <= STATE3;
          
        when STATE3 =>
          channel_int <= "00000000";
          value_help(3) <= value_help(3) + 1;
          if value_help(3) = "11111111" then
            channel_int(3) <= '0';
          end if;
          if value_help(3) = value(3) and value(3) > 0 then
            channel_int(3) <= '1';
          end if;
          nstate <= STATE4;
      
        when STATE4 =>
          channel_int <= "00000000";
          value_help(4) <= value_help(4) + 1;
          if value_help(4) = "11111111" then
            channel_int(4) <= '0';
          end if;
          if value_help(4) = value(4) and value(4) > 0 then
            channel_int(4) <= '1';
          end if;
          nstate <= STATE5;
      
        when STATE5 =>
        channel_int <= "00000000";
          value_help(5) <= value_help(5) + 1;
          if value_help(5) = "11111111" then
            channel_int(5) <= '0';
          end if;
          if value_help(5) = value(5) and value(5) > 0 then
            channel_int(5) <= '1';
          end if;
          nstate <= STATE6;
      
      
        when STATE6 =>
          channel_int <= "00000000";
          value_help(6) <= value_help(6) + 1;
          if value_help(6) = "11111111" then
            channel_int(6) <= '0';
          end if;
          if value_help(6) = value(6) and value(6) > 0 then
            channel_int(6) <= '1';
          end if;
        nstate <= STATE7;
      
        when STATE7 =>
          channel_int <= "00000000";
          value_help(7) <= value_help(7) + 1;
          if value_help(7) = "11111111" then
            channel_int(7) <= '0';
          end if;
          if value_help(7) = value(7) and value(7) > 0 then
            channel_int(7) <= '1';
          end if;
          nstate <= STATE0;      
      end case;
    end if;
  end if;
end if;
end process;

channel <= channel_int;

end Behavioral;

Normalerweise sollten jetzt alle 8 Kanaele asynchron zueinander
arbeiten. Alle 8 Kanaele laufen somit ohne Überlappungen, aber laut der
Simulation sind die einzelnen Kanaele nur einmal kurz eingeschaltet. Ich
hoffe jemand ist so nett und kann kurz meinen Knoten im Kopf lösen.