Array-Länge flexibel

[zu Gast (Gast)]

Ich würde gerne mehr Struktur in meine Programme bekommen. Gestern habe 
ich an der Initialisierung von angeschlossener Hardware gesessen. Also 
Sachen die an i2c oder spi hängen und am Anfang erst eingestellt werden 
müssen.
Da hatte ich bis jetzt ewig lange statemachines. Ich versuche das über 
ein record, wo die init-Daten übersichtlich drin sind und was von einer 
viel kleineren statemachine benutzt wird.

Mein Problem ist aber, dass ich keine Ahnung habe, ob und wie ich die 
Länge der init_daten automatisch an die vorgegebenen Konstanten anpassen 
kann.

type t_init_data is
  record
     slv8_adr  : unsigned(7 downto 0);
     slv8_dat   : unsigned(7 downto 0);
     i_delay     : integer range 0 to 100; --in clocks. ms wäre auch ne option?
  end record;

type t_init_datas is array (0 to 2) of t_init_data;

type t_init_states is ( init_idle, init_busy );
-------------------------------------------------------
signal i_init_length   : integer range 0 to t_init_datas'length;
oder so Pause zwischen Werten
signal init_state   : t_init_states := init_idle;
signal init_datas    : t_init_datas := ((slv8_adr=>x"00", slv8_dat=>x"42", i_delay=>3), --0
            (slv8_adr=>x"01", slv8_dat=>x"14", i_delay=>0), --1
            (slv8_adr=>x"42", slv8_dat=>x"23", i_delay=>5) --2
          );

Ich hoffe ihr versteht, was ich für ein Problem habe.

type t_init_datas is array (0 to 2) of t_init_data;

soll nicht fest auf Länge 3 stehen sondern ich möchte das alles nur über 
die Initialisierung des Record machen. Henne und Ei.

Gibt es da eine elegante und übersichtliche Methode?

[Andreas (Gast)]

Erste Frage, Simulation oder Synthese?


zu Gast schrieb:
> Ich würde gerne mehr Struktur in meine Programme bekommen.

Naja mittels VHDL beschreibt man und programmiert nicht. Beim 
Programmieren nutzt du den durch den Prozessorhersteller vorgegeben 
Befehlssatz. Beim FPGA hingegen kannst du z.B. genau solch einen 
Befehlssatz definieren.

zu Gast schrieb:
> Ich hoffe ihr versteht, was ich für ein Problem habe.type t_init_datas
> is array (0 to 2) of t_init_data;

Wer hindert dich daran einen kleinen Spezial Prozessor zu entwerfen. 
Daten bekommt er aus einem ROM (IP Generator deines FPGAs) und dann 
arbeitet die FSM genau diesen ROM ab und initialisiert Device für 
Device.

Wie gut sind deine VHDL Kenntnisse, was waren deine Projekte bis jetzt?

[Pat A. (patamat)]

Unconstraint Array:

type t_init_datas is array (natural range <>) of t_init_data;

[zu Gast (Gast)]

Kenntnisse würde ich sagen über das Anfangsstadium hinaus, aber kein 
Experte. Sonst würde ich ja auch so was nicht fragen müssen ;-)))
Aber auch so weit, dass die reflexartige Erwähnung von HDL und Software 
nicht unbedingt hilfreich ist.
Es geht um die Sythese, denn ich will ja die angeschlossene Hardware 
etwas übersichtlicher initialisieren.
Das ganze auch als unabhängig synthetisierbarer rtl Code.

type t_init_datas is array (natural range <>) of t_init_data;. Kannst du 
das an meinem Beispiel etwas weiter konkretisieren? Denn damit habe ich 
versucht ans Ziel zu kommen und bin gescheitert, denn muss ich nicht 
trotzdem die Gesamtlänge im vorraus wissen?

[Pat A. (patamat)]

zu Gast schrieb:
> denn muss ich nicht
> trotzdem die Gesamtlänge im vorraus wissen?

Nein, das ist ja gerade der Trick an der Sache.

Ändere mal Deinen Code in dieser einen Zeile und Du wirst sehen, er 
funktioniert genauso wie vorher.

Und noch ein Tipp: An die Größe des Arrays kommst Du über das Attribut 
'length', wie z.B.:

constant my_array_length: integer := init_datas'length;

[zu Gast (Gast)]

Hmm. Also nicht dass wir aneinander vorbeireden mal ganz konkret (s.u.): 
:-)
Wenn ich bei

signal init_datas    : t_init_datas(0 to 2) := ((slv8_adr=>x"00", 
slv8_dat=>x"42", i_delay=>3), --0
                (slv8_adr=>x"01", slv8_dat=>x"14", i_delay=>0), --1
                 (slv8_adr=>x"42", slv8_dat=>x"23", i_delay=>5) --2
              );

nicht angebe wie groß das Array denn nun ist, gibt es "init_datas" does 
not have an index constraint"

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity initialize is
  port(   isl_clk    : in std_logic;
    isl_rst    : in std_logic;
    oslv8_data   : out std_logic_vector(7 downto 0); --hier nur auf leds nachher spi
    isl_init_start  : in std_logic; --initialisierung starten
    osl_init_busy  : out std_logic := '0' );
  
end initialize;


architecture rtl of initialize is
-------------------------------------------------------
--package?
-------------------------------------------------------
type t_init_data is
  record
     slv8_adr  : unsigned(7 downto 0);
     slv8_dat   : unsigned(7 downto 0);
     i_delay     : integer range 0 to 100; --in clocks. ms wäre auch ne option?
  end record;

type t_init_datas is array (natural range <>) of t_init_data;


type t_init_states is ( init_idle, init_busy );
-------------------------------------------------------

signal i_delay_counter   : integer range 0 to 1000; --maximal 1000 Takte/ms oder so Pause zwischen Werten
signal init_state   : t_init_states := init_idle;
signal init_datas    : t_init_datas(0 to 2) := ((slv8_adr=>x"00", slv8_dat=>x"42", i_delay=>3), --0
                (slv8_adr=>x"01", slv8_dat=>x"14", i_delay=>0), --1
                 (slv8_adr=>x"42", slv8_dat=>x"23", i_delay=>5) --2
              );
signal i_init_length   : integer range 0 to init_datas'length;
begin

init_hardware : process (isl_rst,isl_clk) 
begin
  if( isl_rst = '1' ) then
    init_state   <= init_idle;
    osl_init_busy <= '0';  --oder lieber '1'????
  elsif( isl_clk'event and isl_clk = '1' ) then
    case init_state is
      when init_idle =>
        i_init_length <= 0;
        i_delay_counter <= 0;
        if( isl_init_start = '1') then
          init_state <= init_busy;
          osl_init_busy <= '1';  --hm doppelt?
        end if;

      when init_busy =>        
        if( i_delay_counter = 0) then
          oslv8_data <= std_logic_vector(init_datas(i_init_length).slv8_adr); --ist ja nur zum ausprobieren. Hier auf spi schicken
          i_delay_counter <= init_datas(i_init_length).i_delay;
          if( i_init_length < init_datas'length ) then
            i_init_length <= i_init_length + 1;
          else
            init_state <= init_idle;   
            osl_init_busy <= '0';  --initialisierung ist durch  
          end if;
        else
          i_delay_counter <= i_delay_counter - 1;
        end if;
    end case;
  end if;
end process init_hardware;

end rtl;

[Pat A. (patamat)]

Tatsächlich, funktioniert mit Signalen nicht. Aber mit dem Umweg über 
eine Konstante geht's:

constant c_init_datas: t_init_datas := (
    (slv8_adr=>x"00", slv8_dat=>x"42", i_delay=>3), --0
    (slv8_adr=>x"01", slv8_dat=>x"14", i_delay=>0), --1
    (slv8_adr=>x"42", slv8_dat=>x"23", i_delay=>5)  --2
);

signal init_datas : t_init_datas(c_init_datas'range) := c_init_datas;

[zu Gast (Gast)]

Sehr schön!
Allerbesten Dank! Hatte auch mit einem constanten Block rum probiert, 
war aber wohl etwas zu doof - offensichtlich.

[Pat A. (patamat)]

Dass es mit Signalen so direkt nicht funktioniert, hatte ich auch noch 
nicht gewusst ;-)

Aber da Du auf das Signal 'init_datas' sowieso nur lesend zugreifst, 
kannst Du auch gleich die Konstante 'c_init_datas' anstatt verwenden.

Und noch eine Falle lauert: das Attribut 'length' gibt die Länge an; in 
diesem Fall 3. Dein Indexsignal 'i_init_length' sollte also nur von 0 
bis 'length' -1 laufen:

signal i_init_length   : integer range 0 to c_init_datas'length -1;

Sonst kann es passieren, dass Du auf das 4. Arrayelement zugreifst, was 
jedoch nicht existiert. Die Synthese geht darüber in der Regel großzügig 
hinweg, obwohl es ein undefiniertes Verhalten bedeutet. Die Simulation 
ist da strenger; die haut Dir das, so wie es sich gehört, um die Ohren 
;-)

[zu Gast (Gast)]

Logischer, doch hier weiser Einwand von dir. :-)
Werde heute abend mal mit dem Wissensschub weiter werkeln.

[Weltbester FPGA-Pongo (Gast)]

Pat A. schrieb:
> Dass es mit Signalen so direkt nicht funktioniert, hatte ich auch noch
> nicht gewusst ;-)
Die können ja beliebige Breiten annehmen und Ich glaube, dass die 
Synthese so viel Variable Information nicht handhaben kann. Das gibt es 
ja auch noch an anderer Stelle, wo sie aussteigt und Deklarationen nicht 
auflösen kann.