Vektorposition im Array auslesen

[Dennis (Gast)]

Moin Moin an die VHDL Gemeinde...

Ich seh den Wald vor lauter Bäumen nicht mehr.

Kann mir mal bitte einer sagen was für ein Wert in der Variable "pixel" 
steckt bei dieser Syntax?

ARCHITECTURE Behavioral of PIC is

type font_type is array (0 to 15) of std_logic_vector (0 to 15);
type font_ROM is array (0 to 1) of font_type; 
              
constant ascii: font_ROM :=            
              (("0000000000000000",  -- 0  #0
                            "0000000000000000", 
                            "0000000000000000",
                            "0000000000000000",
                            "0000000000000000",
                            "0000000000000000",
                            "0000000000000000",
                            "0000000000000000",
                            "0000000000000000",
                            "0000000000000000",
                            "0000000000000000",
                            "0000000000000000",
                            "0000000000000000",
                            "0000000000000000",
                            "0000000000000000",
          "0000000000000000"),
              
         ("0101010101010101",  --#1
                            "0110011000110011",
                            "0111000111000111",
                            "0111100000001111",
                            "0000000000000000",
                            "0000000000000000",
                            "0000000000000000",
                            "0000000000000000",
                            "0000000000000000",
                            "0000000000000000",
                            "0000000000000000",
                            "0000000000000000",
                            "0000000000000000",
                            "0000000000000000",
                            "0000000000000000",
          "1111111111111111")
          );

EGIN
 Process (CLK, Reset, Char)
  variable Char_x    : integer := 0;
  variable Char_y    : integer := 0;
  variable pixel    : std_logic;
Begin
   If (RESET = '1') Then
  Char_x := 0;
  Char_y := 0;
  pixel := '0';
      
   ElsIf (CLK'Event and CLK = '1') Then

  pixel := ascii(conv_integer(char(3 downto 0)))(char_x)(char_y);

    Char_x := Char_x + 1;
    If (Char_x > 15) then
     Char_y := Char_y + 1;
     If (Char_y > 15) then
      Char_y := 0;
     End If;
     Char_x := 0;
    End If;

In der Testbench gebe ich dem Wert Char <= "0001". Char_x und Char_y 
werden mittels Takt hochgezählt und mit 0 intialisiert.

Ich sehe das so, dass am Anfang die variable pixel := ascii(1)(0)(0) mit 
diesen Parametern in die Konstante schaut und den Wert 0 haben müsste.
Bei nächsten CLK würde dann pixel := ascii(1)(1)(0) sein und pixel den 
Wert 1 haben.

Oder verpeile ich hier gerade alles.
PS: Ich weiß mit Variablen zu arbeiten ist in vhdl totaler Mist. Bitte 
habt ein Nachsehn.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Dennis schrieb:
> PS: Ich weiß mit Variablen zu arbeiten ist in vhdl totaler Mist.
Nein, nicht unbedingt. Man muss allerdings wissen, was man da tut...
Und das hier ist schlecht:
> In der Testbench gebe ich dem Wert Char <= "0001". Char_x und Char_y
> werden mittels Takt hochgezählt und mit 0 intialisiert.
Wenn diese Variablen sowieso speichernd sind, dann kannst du auch gleich 
Signale nehmen.

>   pixel := ascii(conv_integer(char(3 downto 0)))(char_x)(char_y);
Irgendwas ist hier faul, denn es dürfen garantiert nicht alle 3 Indexe 
Werte zwischen 0 und 15 annehmen!

> conv_integer()
Ach nee.
Nicht schon wieder die alten Synopsys-Libs...

> std_logic_vector (0 to 15);
Hoffentlich bringst du dann mit to und downto was durcheinander...

>  Process (CLK, Reset, Char)
Da sind m.E. mindestens 2 Signale unnötig in dieser Sensitivliste...

> PS: Ich weiß mit Variablen zu arbeiten ist in vhdl totaler Mist.
Warum tust du es dann und zudem an gänzlich unnötiger Stelle?

[Dennis (Gast)]

über char will ich später mal sagen welches array er nehmen soll, also 
ob 0, 1 etc.

ich hab mal "gelernt bekommen" das in die senstivity list alle signale 
müssen auf der prozess reagieren soll wenn diese sich ändern.

conv_integer...ich weiß müsste eigentlich to_integer(unsigned) heißen 
oder so ähnlich

wenn ich bei 0 anfangen zu zählen dann passt doch 0 to 15.

Welchen wert hat pixel denn bei dir, wenn  pixel := ascii(1)(0)(0) 
ist...0 oder 1

Bei mir wäre er im Array #1 linke obere Ecke und wäre 0.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Dennis schrieb:
> ich hab mal "gelernt bekommen" das in die senstivity list alle signale
> müssen auf der prozess reagieren soll wenn diese sich ändern.
Ja, und wie sieht der Prozess komplett aus?

Dennis schrieb:
> wenn ich bei 0 anfangen zu zählen dann passt doch 0 to 15.
Nehmen wir mal dieses simple Beispiel:

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

entity Feld is
    Port ( clk : in  STD_LOGIC;
           q   : out  STD_LOGIC);
end Feld;

architecture Behavioral of Feld is
-- type FeldDim1 is array (0 to 3) of std_logic_vector(7 downto 0); -- Fall A
type FeldDim1 is array (0 to 3) of std_logic_vector(0 to 7);        -- Fall B
type FeldDim2 is array (0 to 1) of FeldDim1; 
constant Feld : FeldDim2 := ((x"01",x"03",x"07",x"0F"),(x"1F",x"3F",x"7F",x"FF"));

signal cnt0 : integer range 0 to 7 := 0;
signal cnt1 : integer range 0 to 3 := 0;
signal cnt2 : integer range 0 to 1 := 0;

signal cnt  : unsigned (5 downto 0) := (others=>'0');

begin
  cnt  <= cnt+1 when rising_egde(clk); -- Schreibt sich kompakter... ;-)

  cnt0 <= to_integer(cnt(2 downto 0));
  cnt1 <= to_integer(cnt(4 downto 3));
  cnt2 <= to_integer(cnt(5 downto 5));
  q    <= Feld(cnt2)(cnt1)(cnt0);
end Behavioral;

Was erwartest du im Fall A, was im Fall B?
Fazit: es ist überhaupt nicht egal, wie herum die Bits im Vektor 
angeordnet sind... :-o

> Bei mir wäre er im Array #1 linke obere Ecke und wäre 0.
Bei mir auch...

[Dennis (Gast)]

...ahhh...totale Verwirrung. :)

Ich will ja das er den Vektor von links nach rechts abarbeitet. Also 
links oben anfängt, dann 15 mal nach rechts rückt in die nächste Zeile 
springt und von vorn beginnt.

Das es nicht egal ist ist mir klar :).

0 to 7 wäre ja 2^0, 2^1, 2^2 etc also 0,1,2...
7 downto 0 ware dann 2^7, 2^6 also 128,64,...

FallA würde den Vektor von rechts beginnend nach links hin auslesen. Bei 
B umgedreht. Würd ich jetz sagen.

Ich glaube ich ge mal ne Runde ums Haus...seh nur noch Nullen und Einsen 
LOL

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Dennis schrieb:
> ..seh nur noch Nullen und Einsen
Aber in einer unerwarteten Reihenfolge?
Ich vermute, du hast die Indexe char_x und char_y vertauscht:
char_y läuft in deinem Zähler schneller als char_x... :-o

[Dennis (Gast)]

ich habe mal aus spass an der freude aus 0 to 15, 15 downto 0 gemacht 
ohne das sich eas verändert hat in der modelsim.

Lothar Miller schrieb:
> Aber in einer unerwarteten Reihenfolge?

aber total. Ich hätte es ja verstanden, wenn er den Vektor verkehrt 
herum ausliest aber der macht totalen Murx, so als er er im Array 
sinnlos umher springt.

Lothar Miller schrieb:
> char_y läuft in deinem Zähler schneller als char_x... :-o

Char_y wird doch erst erhöht wenn Char_x 16 mal erhöht wurde. Also 
sollte er doch erst in Zeile 0, 16 mal nach rechts rücken ehe er in die 
nächste Zeile des Array springt.

nochmal zum Grundverständnis...wie das Array aufgerufen wird. Vielleicht 
bin ich auch total verpeilt gerade.

pixel := ascii(Nummer font_ROM)(x-Position im font_Type Array)(y-Postion 
im font_Type Array)

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Dennis schrieb:
> Char_y wird doch erst erhöht wenn Char_x 16 mal erhöht wurde.
Richtig...

>> Aber in einer unerwarteten Reihenfolge?
> aber total.
Würdest du sowas wie im Anhang erwarten?

[Dennis (Gast)]

ja sowas soll mir mein modelsim auch zeigen!!!, nur das die char_x und 
char_y Werte sich gemaß dem Zähler ändern.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Dennis schrieb:
> ja sowas soll mir mein modelsim auch zeigen!!!
Aber du bekommst sowas wie hier?
Dann tausche doch mal die beiden Indexe aus und schreib:
      pixel := ascii(to_integer(unsigned(char)))(char_y)(char_x);


> nur das die char_x und char_y Werte sich gemaß dem Zähler ändern.
Dass die hier 0 bleiben hat andere Gründe (ISIM kann Variablen leider 
nicht darstellen)...

[Dennis (Gast)]

...ja sowas komisches kommt bei mir auch. Absolut kein zusammenhang zum 
Array zu finden.

ES GEHT. DANKE...*handkuss* und niederknie

Kannst Du mir das auch mal erklären. Ich dachte er ruft erst die array 
Nummer auf dann den x-Wert im Array und dann den zugehörigen y-Wert.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Dennis schrieb:
> Ich dachte er ruft erst die array
> Nummer auf dann den x-Wert im Array und dann den zugehörigen y-Wert.
Er löst das Array von links nach rechts in der Reihenfolge deiner 
Klammern auf:

                        1.                     2.        3.
pixel := ascii (to_integer(unsigned(char))) (char_y)  (char_x);

                  1. char
                 (("0000000000000000",  <-- 2. char_y
                   "0000000000000000",  <-- 2.   |
                   "0000000000000000",      :    v
                   "0000000000000000",      :
                   "0000000000000000",
                   "0000000000000000"),
                  1. char
                  ("0101010101010101",  
                   "0110011000110011",
                   "0111000111000111",
                   "0111100000001111",
                   "0000000000000000",
                   "1111111111111111")
                    ^^^^^^^^^^^^^^^^
                    |    3. char_x | "Bitnummer"
                    0123456789ABCDEF

[Dennis (Gast)]

...also macht er es immer so oder liegt es an meiner Syntax?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Dennis schrieb:
> ...also macht er es immer so
Ja.
Es gibt noch die "andere Art, (d)ein Array zu beschreiben, aber auch da 
wird von links nach rechts und von aussen nach innen ausgewertet:

--                                       3.
subtype font_type is std_logic_vector (0 to 15);       --- Fall Y
--                        1.      2.        
type font_ROM is array (0 to 1, 0 to 15) of font_type; --- Fall Y
                              1. 2.   3.             2.    3.                 1. ...
constant ascii: font_ROM := ( (  "0000000000000000", "0000000000000000",..) , (..) );
:
:
      q  <= ascii(to_integer(unsigned(char)), char_y)(char_x);

> oder liegt es an meiner Syntax?
Na, du greifst eben falsch auf dein Array zu. Es ist anders 
organisiert...

[Dennis (Gast)]

...ich galube in C hatte ich auch ähnliche Probleme mit dem Zugriff auf 
Array's

Noch mal Danke Lothar, jetzt kann ich mal ohne ständiges Grübeln in der 
Feierabend.