Signal in mehrereh Processen ansprechen.

[peter (Gast)]

Danke Michael Fischer (Datum: 20.05.2014 18:37)
----------------------------
D.h. das Signal RamAddr wird an mehreren Stellen beschrieben. So etwas
ist erlaubt wenn das in einem "process" gemacht wird, aber nicht wenn
es von mehreren Prozessen versucht wird.
------------------------------

Ich dachte wenn ich die in "architecture" reinsetze das sie überall 
angesprochen werden können.

Danke.
Gruss

[Duke Scarring (Gast)]

Hallo Lernresistenter!
(lies Bücher, lern zitieren, lern den Unterschied zwischen Programm und 
Beschriebung...)

peter schrieb:
> das sie überall
> angesprochen werden können
Lesen ja, schreiben nein.

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

peter schrieb:
> Ich dachte wenn ich die in "architecture" reinsetze das sie überall
> angesprochen werden können.
Es geht ja nur beim Zuweisen schief. Genauer gesagt dann, wenn aus zwei 
Prozessen das selbe Signal getrieben wird:

    process (b) begin
       if b='1' then 
          c<='0'; 
       else 
          c<='1'; 
       end if;
    end process;

    process (a) begin
       if a='1' then 
          c<='0'; 
       else 
          c<='1'; 
       end if;
    end process;

Wie denkst du denn, dass sowas in realer Hardware innerhalb eines 
FPGAs aussehen sollte? Dass einfach die Ausgänge von ein paar Flipflops 
oder LUTs zusammengeschaltet werden und dann der Stärkere gewinnt?

Nicht mal sowas geht, obwohl hier eigentlich kein Konflikt vorliegt:

    process (a) begin
       if a='1' then 
          c<='1'; 
       end if;
    end process;

    process (a) begin
       if a='0' then 
          c<='0'; 
       end if;
    end process;

Und warum?
Weil der Synthesizer hier mit seiner Mustererkennung zwei Latches 
erzeugt und die dann nicht zusammenschalten kann...

[Fpgakuechle K. (Gast)]

Duke Scarring schrieb:

>  lern den Unterschied zwischen Programm und
> Beschriebung...)
>
> peter schrieb:
>> das sie überall
>> angesprochen werden können
> Lesen ja, schreiben nein.

(1)oben die Beachtung des Unterschieds zwischen Programm und 
Beschreibung eingefordert und unten dann  "Signal schreiben" (Software) 
statt "Signal treiben" (Hardware) verwendet.

(2)Und es ist sehr wohl möglich ein Signal von mehreren processes aus 
zuzuweisen.
Für diesen Fall kennt VHDL die resolution function (Auflösungsfunktion), 
in der Bibliothek an dem Schlüsselwort resolved erkennbar.
Siehe bspw. dort: 
http://www.ida.liu.se/~TDTS01/lectures/14/lect3.frm.pdf

Anders wäre es in VHDL nicht möglich open collector, wired or, PullUp 
etc. zu simulieren. (was man aber immer wieder braucht bspw. für VME-BUS 
IRQ-system oder I2C ACK)


Und genau diese Auflösungsfunktion ist der Unterschied zwischen 
std_logic und std_ulogic (u steht für unresolved).
Siehe: 
http://objectmix.com/vhdl/208460-what-difference-between-types-std_logic-std_ulogic.html
Also ein signal vom typ std_logic kann mehrere Quellen haben, std_ulogic 
nicht (simulator bricht mit error ab).

Ein deutsches Buch das diese Simulatordetails beschreibt ist ISBN 
3-540-59143-5 (auf S.110 ff.) Allerdings ein sehr "akademisches" Buch 
mit überwiegenden Focus auf Simulation und damit IMHO für FPGA-Designer 
nur bedingt hilfreich).

Das dergleichen aber von der Synthese verweigert wird, wenn es die 
Zielhardware nicht zuläßt hat Lothar in seinem Post dargestellt.

Dort allerdings: 
http://web02.gonzaga.edu/faculty/talarico/cpen430/documents/vhdl-for-synthesis.pdf 
lässt man die Frage ob resolved signals zufriedend stellend 
synthetisierbar sind offen und empfiehlt um Probleme von vornherein 
auszuschliessen keine zwei Quellen ein Signal treiben zu lassen (S.13).

MfG,

[peter (Gast)]

Jup danke.
Eure Beschreibungen gefallen mir.

So ausführlich mit den Konflikten steht es nicht im Buch bei mir.

Gruss

[peter (Gast)]

Jup dann kann das mit dem speicher_ram nicht funktionieren, weil es 2x 
zugewiesen wird :

Type ram_vec is ARRAY (0 to 127) OF unsigned(7 downto 0);
signal speicher_ram : ram_vec;

type Rom128x8 is array (0 to 127) of unsigned (7 downto 0); 
  constant Speicher_rom : Rom128x8 := (
    x"ff",  x"ff",  x"81",  x"82",  x"83",  x"11",  x"14",  x"17",
    x"ff",  x"ff",  x"ff",  x"23",  x"26",  x"29",  x"2c",  x"2f",
..................................

Danke.
Gruss

[peter (Gast)]

Habe ich hier so einen Typischen Fall?
Wenn ich die Daten vom PC sende sw(2) kommt in den Ramzellen nur der 
Wert "128".
Wenn ich aber mit Sw(0) dem ROM ins RAM schreibe, kann ich die Daten vom 
RAM zum PC  übertragen mit sw(1).

Gruss

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

entity ram_array is
  Generic ( Quarz_Taktfrequenz : integer := 50000000;  
              Baudrate        : integer  := 9600 
          );      
  port(
    clk    : in  std_logic;
    sw     : in  std_logic_vector(3 downto 0);
    TXD    : out  STD_LOGIC; 
    RXD    : in   STD_LOGIC;
    led_g  : out  STD_LOGIC_VECTOR (7 downto 0)     
    );
end ram_array;

architecture Behavioral of ram_array is

signal rxd_sr  : std_logic_vector (3 downto 0) := "1111";        
signal rxsr    : std_logic_vector (7 downto 0) := "00000000";     
signal rxbitcnt : integer range 0 to 9 := 9;
signal rxcnt   : integer range 0 to (Quarz_Taktfrequenz/Baudrate)-1; 
signal RX_Data : STD_LOGIC_VECTOR (7 downto 0);  

signal txstart : std_logic := '0';
signal txsr    : std_logic_vector  (9 downto 0) := "1111111111";  
signal txbitcnt : integer range 0 to 10 := 10;
signal txcnt    : integer range 0 to (Quarz_Taktfrequenz/Baudrate)-1;

signal TX_Start : STD_LOGIC :='0';
signal TX_Data  : STD_LOGIC_VECTOR (7 downto 0);
signal TX_Wert  : STD_LOGIC_VECTOR (7 downto 0);

signal c : integer range 0 to 10000000 := 0; 

signal RomAddr: integer range 0 to 128 := 0; 
signal RamAddr: integer range 0 to 128 := 0; 

Type ram_vec is ARRAY (0 to 127) OF unsigned(7 downto 0);
signal speicher_ram : ram_vec;

type Rom128x8 is array (0 to 127) of unsigned (7 downto 0); 
  constant Speicher_rom : Rom128x8 := (
    x"ff",  x"ff",  x"81",  x"82",  x"83",  x"11",  x"14",  x"17",
    x"ff",  x"ff",  x"ff",  x"23",  x"26",  x"29",  x"2c",  x"2f",
    x"32",  x"36",  x"39",  x"3c",  x"3e",  x"40",  x"43",  x"46",
    x"48",  x"4b",  x"4d",  x"50",  x"52",  x"54",  x"57",  x"59",
    x"5b",  x"5d",  x"5f",  x"62",  x"64",  x"65",  x"67",  x"69",
    x"6b",  x"6d",  x"6e",  x"70",  x"71",  x"73",  x"74",  x"75",
    x"76",  x"77",  x"79",  x"79",  x"7a",  x"7b",  x"7c",  x"7d",
    x"7d",  x"7e",  x"7e",  x"7f",  x"7f",  x"7f",  x"7f",  x"7f",
    x"01",  x"02",  x"04",  x"08",  x"0e",  x"11",  x"14",  x"17",
    x"1a",  x"1d",  x"20",  x"23",  x"26",  x"29",  x"2c",  x"2f",
    x"32",  x"36",  x"39",  x"3c",  x"3e",  x"40",  x"43",  x"46",
    x"48",  x"4b",  x"4d",  x"50",  x"52",  x"54",  x"57",  x"59",
    x"5b",  x"5d",  x"5f",  x"62",  x"64",  x"65",  x"67",  x"69",
    x"6b",  x"6d",  x"6e",  x"70",  x"71",  x"73",  x"74",  x"75",
    x"76",  x"77",  x"79",  x"79",  x"7a",  x"7b",  x"7c",  x"7d",
    x"7d",  x"7e",  x"7e",  x"7f",  x"7f",  x"7f",  x"7f",  x"7f");

begin

process(clk)
begin
  if rising_edge(clk)  then
    c <= c+1; 
    tx_start <= '0';
    
    if (RomAddr < 128) and  (sw(0) = '1') then    -- rom ins ram kopieren wenn sw(0)='1' (funktioniert)
    speicher_ram(RomAddr) <= Speicher_rom(RomAddr); 
      RomAddr <= RomAddr + 1;     
  
    elsif (c=5000000 ) and (sw(1)='1') then -- ram senden mit rs232 wenn sw(1)='1' (funktioniert)                    
      c <= 0;   
      RamAddr <= RamAddr +1;      
      if (RamAddr < 128) then             
        TX_Data <= std_logic_vector(Speicher_ram(RamAddr)); 
        tx_start <= '1';
      end if;
      
    elsif (sw(2) = '1') and (RamAddr < 128) and (rx_data > "00000000") then  -- 128 Byte vom PC ins RAM lesen (es wird nur "128" in alle Zellen geschrieben)  
      speicher_ram(RamAddr) <= unsigned(rx_data); 
      RamAddr <= RamAddr + 1;   
      led_g <= rx_data;
      
    elsif   (sw(3)='1') then  -- adressen mit sw(3)='1' auf "0" setzen funktioniert 
      RamAddr <= 0;  
      RomAddr <= 0;        
    end if;
  end if;  
end process;

process(clk) ---rs232 empfangen
begin
  if rising_edge(clk) then 
    rxd_sr <= rxd_sr(rxd_sr'left-1 downto 0) & RXD;
    if (rxbitcnt<9) then   
       if(rxcnt<(Quarz_Taktfrequenz/Baudrate)-1) then 
          rxcnt    <= rxcnt+1;
       else
          rxcnt    <= 0; 
          rxbitcnt <= rxbitcnt+1;
          rxsr     <= rxd_sr(rxd_sr'left-1) & rxsr(rxsr'left downto 1); 
       end if;
    else 
       if (rxd_sr(3 downto 2) = "10") then                 
          rxcnt    <= ((Quarz_Taktfrequenz/Baudrate)-1)/2; 
          rxbitcnt <= 0;
       end if;
    end if;
  end if;      
end process;
RX_Data <= rxsr;   
  
process(clk) --- rs232 senden
begin
if rising_edge(clk) then 
  txstart <= TX_Start;
  if (TX_Start='1' and txstart='0') then 
     txcnt    <= 0;                      
     txbitcnt <= 0;                      
     txsr     <= '1' & TX_Data & '0';    
  else
     if(txcnt<(Quarz_Taktfrequenz/Baudrate)-1) then
        txcnt <= txcnt+1;
     else  
        if (txbitcnt<10) then
          txcnt    <= 0;
          txbitcnt <= txbitcnt+1;
          txsr     <= '1' & txsr(txsr'left downto 1);
        end if;
     end if;
  end if;
end if;    
end process;
TXD  <= txsr(0); 
      
end Behavioral;

[Duke Scarring (Gast)]

peter schrieb:
> Habe ich hier so einen Typischen Fall?
> Wenn ich die Daten vom PC sende sw(2) kommt in den Ramzellen nur der
> Wert "128".
> Wenn ich aber mit Sw(0) dem ROM ins RAM schreibe, kann ich die Daten vom
> RAM zum PC  übertragen mit sw(1).
Was sagt die Simulation?

Duke

[peter (Gast)]

Jup, die Simulation stürzt vom QuartusII ab auf meinem Window8 gleich 
nach dem starten. Habe jetzt schon veschiedene Quartusversionen geladen.

Danke.
Gruss

[peter (Gast)]

Wenn ich jetzt das ROM/RAM Füllen zusammenfasse in einer IF , dann 
werden gemäß led_grün die Daten "rx_data"  vom Pc richig angenommen.

Wenn ich aber mit SW(1) die Daten zum PC schicke aus dem RAM , steht da 
nur "68" drin in allen Zellen.

GRuss

process(clk)
begin
  if rising_edge(clk)  then
    if (RomAddr < 128) and  (sw(0) = '1') then    
      speicher_ram(RomAddr) <= Speicher_rom(RomAddr); 
      RomAddr <= RomAddr + 1;     
    elsif (sw(2) = '1') and (RamAddr < 128) and (rx_data > "00000000") then    
      speicher_ram(RamAddr) <= unsigned(rx_data); 
      RamAddr <= RamAddr + 1;   
      led_g <= rx_data;
    end if;
    
    if (c<5000000 ) and (sw(1)='1') then        
      c <= c+1; 
      tx_start <= '0';
    else             
      c <= 0;   
      RamAddr <= RamAddr +1;      
      if (RamAddr < 128) then             
        TX_Data <= std_logic_vector(Speicher_ram(RamAddr)); 
        tx_start <= '1';
      end if;
    end if;
      
    if   (sw(3)='1') then   
      RamAddr <= 0;  
      RomAddr <= 0;        
    end if;
  end if;  
end process;

[peter (Gast)]

Hmm...habe ich hier ein Denkfehler im Ablauf?

if (c<5000000 ) and (sw(1)='1') then        
      c <= c+1; 
      tx_start <= '0';
    else             
      c <= 0;   
      RamAddr <= RamAddr +1;      
      if (RamAddr < 128) then             
        TX_Data <= std_logic_vector(Speicher_ram(RamAddr)); 
        tx_start <= '1';
      end if;
    end if;

Danke.
Gruss

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

peter schrieb:
> Hmm...habe ich hier ein Denkfehler im Ablauf?
Was ist noch mal das zugehörige Problem?

> RamAddr <= RamAddr +1;
Wie weit darf die denn laufen? Es ist dir schon klar, dass der Zähler in 
der realen Hardware einfach wieder bei 0 anfängt? Wir hatten das doch 
schon durchgekaut...

peter schrieb:
> die Simulation stürzt vom QuartusII ab auf meinem Window8 gleich nach
> dem starten.
Ändere das. du wirst ohne Simulator nicht weit kommen mit FPGAs. Schon 
der kleinste Fehler wird dich (und uns) tagelang beschäftigen.

> ----------------------------
> ...
> ----------------------------
Nimm bitte die VHDL Tags zum Formatieren des Quelltextes.

[peter (Gast)]

Jup danke.
Das ist mir klar.

WEnn zum PC gesendet wird fängt er wieder bei "0" an, das ist so gewollt 
das es im vorgegebenen Raster abläuft.

Gruss