Bit verschieben VHDL

Hallo,

1

signal count_int : STD_LOGIC_VECTOR (7 downto 0) := X"01";

2

....

3

-- bit nach links schieben

4

count_int <= count_int(6 downto 0) & count_int(7);

Zum rechtsschieben:

1

....

2

count_int <= count_int(0) & count_int(7 downto 1);

Falls die 1 beim achten Shift nach links rausfallen soll:

1

count_int <= count_int(6 downto 0) & B"0";

http://www.vhdl-online.de/tutorial/deutsch/t_87.htm

Danke euch!

Es kommen aber jetzt mehr fragen auf:

1

signal count_int : STD_LOGIC_VECTOR (7 downto 0) := X"01";

Was heißt das X"01"; ?

1

count_int <= count_int(6 downto 0) & B"0";

Das nur dann machen wenn das bit schon ganz links ist?


http://www.vhdl-online.de/tutorial/deutsch/t_87.htm

1

count_int <= count_int rol 1;

Wenn ich rol und ror benutzen will kriege ich diese Fehlermeldung:
Line 58. rol can not have such operands in this context.

hi,

also x"01"  ist hexadezimalschreibweise.
und wenn du das bit zu weit nach links oder rechts schiebst, dann 
"fällt" es raus.

verhindern sollte dies der befehl ROR, der das zu weit geschobene bit 
auf der anderen seite wieder anfügt.

ich habe den befehl noch nie benutzt, und kann deshalb auch nix zu 
beisteuern woran es liegen könnte. geht rol evtl. nur mit einem 
bit_vector? du hast da standardlogic verwendet.
an der uni wird uns beigebracht, das man std_logic immer meiden soll 
wenn man es nicht unbedingt benötigt(bin aber auch nich so der vhdl 
crack um das beurteilen zu können)

Richard B. wrote:

>
>

1

> count_int <= count_int(6 downto 0) & B"0";

2

>

> Das nur dann machen wenn das bit schon ganz links ist?
Nein, ständig wenn du willst, dass die 1 nach dem achten Takt nicht mehr 
vorhanden ist.

Ich verstehe mein Problem nicht. Wo ist der Fehler?

1

library IEEE;

2

use IEEE.STD_LOGIC_1164.ALL;

3

use IEEE.STD_LOGIC_ARITH.ALL;

4

use IEEE.STD_LOGIC_UNSIGNED.ALL;

5

6

entity ledShifter is

7

    Port ( CLOCK : in  STD_LOGIC;

8

           DIR : in  STD_LOGIC;

9

           LEDS : out  bit_vector (7 downto 0));

10

end ledShifter;

11

12

architecture Behavioral of ledShifter is

13

14

signal clk_div_counter : STD_LOGIC_VECTOR (24 downto 0);

15

signal ledTMP : bit_vector (7 downto 0) := "00000001";

16

signal clk_149hz: bit := '0';

17

18

begin

19

  clk_div : process(CLOCK)

20

  begin

21

    if CLOCK='1' and CLOCK'event then      

22

      clk_div_counter <= clk_div_counter + 1;

23

      if clk_div_counter = x"10" then

24

        clk_149hz <= '1';    

25

      elsif clk_div_counter /= x"10" then

26

        clk_149hz <= '0';

27

      end if;

28

    end if;

29

  end process clk_div;

30

31

  led_shift : process(clk_149hz)

32

  begin

33

    if clk_149hz='1' then

34

      ledTMP <= ledTMP rol 1;

35

    end if;    

36

  end process led_shift;

37

LEDS <= ledTMP;

38

end Behavioral;

Irgendwie leuchten alle LEDs nach einer kleinen Zeit.

Achja und was ist der unterschied zwischen bit_vector und 
STD_LOGIC_VECTOR?
Mit dem bit_vector kann ich nicht bit_vector <= bit_vector + 1 rechnen 
und mit dem STD_LOGIC_VECTOR kann ich nicht STD_LOGIC_VECTOR <= 
STD_LOGIC_VECTOR rol 1 machen. Wieso?

Welches soll man wann nehmen?

hi,

also mit standard_logic kann man tristate verhalten erlangen. du kannst 
den ausgang damit auf 1, 0 oder hochohmig setzen. bit_vector ist nur 0 
oder 1

zum programmieren von solchen countern braucht vhdl aus irgendeinem 
grund auch std_logic. wieso das so ist, das kann ich dir jedoch nicht 
erklären.

hier mal dein program ein wenig verändert...
du musst den counter z.b. auch wieder auf null setzen.
wenn du einen vergleich auf die x"10" machst, dann muss die vektorlänge 
auch übereinstimmen...du hattest da ja vorher eine länge von 24 oder 
sowas

1

library IEEE;

2

use IEEE.STD_LOGIC_1164.ALL;

3

use IEEE.STD_LOGIC_ARITH.ALL;

4

use IEEE.STD_LOGIC_UNSIGNED.ALL;

5

6

entity ledShifter is

7

    Port ( RESET:in bit;

8

           CLOCK : in  bit;

9

           DIR : in  bit;

10

           LEDS : out  bit_vector (7 downto 0));

11

end ledShifter;

12

13

architecture Behavioral of ledShifter is

14

15

signal clk_div_counter : STD_LOGIC_VECTOR (4 downto 0);

16

signal ledTMP : bit_vector (7 downto 0) := "00000001";

17

signal clk_149hz: bit := '0';

18

19

begin

20

  clk_div : process(RESET,CLOCK)

21

  begin

22

    if RESET = '1' then

23

       clk_div_counter <= (others => '0'); 

24

       clk_149hz <= '0';

25

    elsif CLOCK='1' and CLOCK'event then      

26

      if clk_div_counter = x"10" then

27

        clk_149hz <= '1'; 

28

        clk_div_counter <= (others => '0');   

29

      else 

30

         clk_div_counter <= clk_div_counter + 1;

31

         clk_149hz <= '0';

32

      end if;

33

    end if;

34

  end process clk_div;

35

36

  led_shift : process(clk_149hz)

37

  begin

38

    if clk_149hz='1' and clk_149hz'event then 

39

      ledTMP <= ledTMP rol 1;

40

    end if;    

41

  end process led_shift;

42

43

LEDS <= ledTMP;

44

end Behavioral;

hattest du das ganze mal simuliert? ich kann dir da nur modelsim 
empfehlen(kenne nur das)
dann sieht man schon eher wo es hakt.

achso:

Clock z.b. muss eigentlich nie std_logic sein, sondern immer bit!


Desweiteren ist es wichtig ein ResetBit zu haben. Zu Anfang gibt es ja 
keinen definierten Zustand, sondern alles hängt irgendwie in der Luft 
rum

moin,

wenn ich std_logic benutze ohne das es einen Grund dafür gibt, dann 
kriege ich das von meinem Prof. um die Ohren geknallt. :)

Wie ich schon sagte, ich bin nicht so der VHDL Crack um das beurteilen 
zu können, aber evtl. ist bit_vector ne Ecke resourcenschonender??

Auf nem Mikrocontroler verwende ich ja auch nur Variablen mit dem 
kleinst möglichen Wertebereich und benutze nicht für alles long oder 
float, obwohl das natürlich genauso gehen würde.

Aber vielleicht sagt da auch jemand was zu der mehr Ahnung von VHDL hat, 
was da sinnvoll ist.

Eigentlich verwendet niemand im FPGA-Design bit oder bit_vector, nicht 
zuletzt weil die U und X-Zustände in der Simulation sehr nützlich sind.

Direkt mit std_logic_vector zu rechnen (mit Hilfe von 
std_logic_(un)signed) ist kein guter Stil, dafür gibt es die Typen 
signed und unsigned (siehe Rechnen in VHDL).

Auf die Ressourcen kann es nicht ankommen, am Schluss landet ein 
Clock-Signal typischerweise eh im Clock-Netzwerk.

Ich schaue mir grad den Draft für die Konventionen für synthetisierbares 
VHDL durch, da steht:

"The allowed types for clock signals shall be: BIT, STD_ULOGIC and their 
subtypes (e.g. STD_LOGIC) with a
minimum subset of '0' and '1'. Only the values ‘0’ and ‘1’ from these 
types shall be used in expressions representing
clock levels and clock edges (See 6.1.2)."


Insofern kann man argumentieren, dass man es bei std_logic leichter 
falsch machen kann, als bei zb bit, weil man da auch ein 'H' in der 
Clock haben könnte.