Spartan 3AN RAM schreiben und lesen über RS232

[Hans (Gast)]

Hallo zusammen,

ich habe in VHDL eine RS232 Schnittstelle implementiert und fülle 
darüber in 8bit Datenblöcken ein Array (128x64). Das beschreiben dieses 
Arrays funktioniert, allerdings würde ich gerne aus diesem Array auch 
wieder Informationen lesen wollen. Dieser Schritt funktioniert noch, 
solange ich nur einzelne definierte Einträge aus dem Array abfrage (weil 
er mir dann beim synthetisieren den Rest wegoptimiert). Ich würde 
allerdings gerne abhängig von einem anderen Signal Einträge aus diesem 
Array abfragen. Wenn ich dies mache, dann bekomme ich starkes 
Overmapping. Ist es grundsätzlich in VHDL möglich, ein RAM (Array mit 
insgesamt 32768 bit) über RS232 zu füllen und dann abhängig von einem 
Steuersignal Einträge aus diesem auszulesen.

Dazu kann ich noch sagen, dass es funktioniert, wenn ich das Array als 
Konstante hinterlege. Kann ich eventuell nachdem die Informationen über 
RS232 übertragen worden sind, diese in eine Konstante speichern oder 
geht das nicht?

Ich hoffe mein Problem ist einigermaßen klar geworden. Ich hoffe auf 
Unterstützung.

Grüße

Hans

[Falk B. (falk)]

@ Hans (Gast)

>solange ich nur einzelne definierte Einträge aus dem Array abfrage (weil
>er mir dann beim synthetisieren den Rest wegoptimiert).

Weil konstant.

> Ich würde
>allerdings gerne abhängig von einem anderen Signal Einträge aus diesem
>Array abfragen. Wenn ich dies mache, dann bekomme ich starkes
>Overmapping.

Hehe ;-)

>Ist es grundsätzlich in VHDL möglich, ein RAM (Array mit
>insgesamt 32768 bit) über RS232 zu füllen und dann abhängig von einem
>Steuersignal Einträge aus diesem auszulesen.

Sicher, warum nicht? Rein mit VHDL im Simulator kannst du megabyteweise 
Daten schreiben. In der realen Synthese muss natürlich deine 
Zielarchitektur genügend BRAM haben. CPLDs haben das eher nicht.

>Dazu kann ich noch sagen, dass es funktioniert, wenn ich das Array als
>Konstante hinterlege.

Ein ROM.

> Kann ich eventuell nachdem die Informationen über
>RS232 übertragen worden sind, diese in eine Konstante speichern oder
>geht das nicht?

Kann man in ROM schreiben? Eher nicht.

Du brauchst eine state machine, welche die Daten vom UART in den RAM 
schreibt bzw. diese von dort auch wieder lesen kann. Dazu braucht es ein 
paar Steuereingänge, die sagen, was zu tun ist. Je nach Ansatz kann man 
den RAM allgemein beschreiben und hoffen, dass der VHDL-Compiler diesen 
erkennt und einen BRAM draus macht. Oder man geht gleich auf Nummer 
sicher und generiert den passenden RAM mittels 
Coregenerator/Megawizard/whatever als IP-Block. Ich würde die 2. 
Variante empfehlen.

[Hans (Gast)]

Okay! Hier mal der stark vereinfachte Code. Eventuell ist ja nur ein 
einfacher Fehler vorhanden. Eingänge der Entity sind das RXD Signal für 
die serielle Datenübertragung, der Takt und das Steuersignal, das 
letztendlich eine Position abfragt und aus dem beschriebenen Array den 
dieser Position zugehörigen Wert in den Ausgang DATEN_WERTT der Entity 
schreiben soll. Die Daten werden zunächst in ein Buffer Array 
geschrieben (dieser Teil ist vereinfachend nicht dargestellt und 
funktioniert auch). Wenn alle 8192 Werte in den Buffer geschrieben 
worden sind, sollen das Array in ein anderes Array geschrieben werden. 
Auch dieser Schritt funktioniert noch. Wenn ich aber auf das 
Speicherarray, abhängig von dem Eingangssignal POS zugreifen möchte, 
bekomme ich starkes Overmapping. Beschriebe ich durch den unten 
stehenden Code überhaupt einen Blockram? Es sieht eher so aus, als würde 
er alles durch Logik versuchen zu beschreiben. Wenn ich nur 10 bestimmte 
Positionen abfragen, dann funktioniert das Ganze, allerding optimiert er 
dann ja auch den Rest des Arrays weg, da nicht benutzt. Habt ihr 
vielleicht einen Verbesserungsvorschlag?

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use WORK.TYPE_DEFINITION.ALL;
use IEEE.NUMERIC_STD.ALL;
use IEEE.STD_LOGIC_UNSIGNED.all;

entity Array_Abfrage is
  port (      RXD      : in  STD_LOGIC;            -- Eingangssignal Serial Port (Serielle Schnittstelle)
        CLK      : in  STD_LOGIC;
        POS      : in  t_int_array;            -- Array mit 2 Einträgen (x,y) zur Bestimmung des Wertes, der aus dem Speichergelesen werden soll
        DATEN_WERT    : out integer range 0 to 15          -- Integerwert des abgefragten Arrayeintrages
      );
end Array_Abfrage;

architecture Behavioral of Array_Abfrage is
----------------------------------------------------------------------------------
---------- Deklarationen
signal s_uebertragenedaten : integer range 0 to 8192 := 0;                -- Zählt die bereits in den Zwischenspeicher übertragenen Werte

type t_array is ARRAY (1 to 64, 1 to 128) of integer range 0 to 15;              -- 4bit Einträge

signal s_eingangsbuffer : t_array := (others => (others => 0));                -- Initialisierung Zwischenspeicher
signal s_speicher : t_array:= (others => (others => 0));                -- Initialisierung Speicher

signal s_read : std_logic :='1'; 
signal s_datenwert : integer range 0 to 15; 

begin

------------------------------------------------SIGNALBEREITSTELLUNG-ÜBER-SERIELLE-SCHNITTSTELLE-----------------------------------------------------------

process begin                              --EINLESEN von 8 bit alle t=10*t_baud
  wait until rising_edge(CLK);
    

--Befüllen von s_eingangsbuffer, hier vereinfachend nicht dargestellt

if (s_uebertragenedaten = 8192) then                --Wenn gesamte Datenmenge angekommen, dann von Buffer in den Speicher schreiben
        s_speicher <= s_eingangsbuffer;
  s_read <= '0';
end if;

    
    
if (s_read = '1') then          
      
s_datenwert <= s_speicher(POS(2),POS(1));  
      
else 

s_datenwert <= 0;
      
end if;                  
    
    
    
end process;

DATEN_WERT <= s_datenwert;


end Behavioral;

[Falk B. (falk)]

@ Hans (Gast)

>Okay! Hier mal der stark vereinfachte Code.

Den kannst du dir schenken. Damit kann keiner was sinnvolles anstellen.
Das ist nix anderes als wirr!

> Eventuell ist ja nur ein
>einfacher Fehler vorhanden.

Was man an deinen Fragmenten sicher erkennen kann .....

> Eingänge der Entity sind das RXD Signal für
>die serielle Datenübertragung, der Takt und das Steuersignal, das
>letztendlich eine Position abfragt und aus dem beschriebenen Array den
>dieser Position zugehörigen Wert in den Ausgang DATEN_WERTT der Entity
>schreiben soll.

Schon mal was von einem Blockschaltbild gehört?


>Speicherarray, abhängig von dem Eingangssignal POS zugreifen möchte,
>bekomme ich starkes Overmapping.

Du wiederholst dich.

> Beschriebe ich durch den unten
>stehenden Code überhaupt einen Blockram?

Willst du uns verarschen?

>dann ja auch den Rest des Arrays weg, da nicht benutzt. Habt ihr
>vielleicht einen Verbesserungsvorschlag?

Bist du leseschwach oder lernresistent?

Beitrag "Re: Spartan 3AN RAM schreiben und lesen über RS232"

[Hans (Gast)]

Danke für die sehr freundliche antwort.

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

Hans schrieb:
> --Wenn gesamte Datenmenge angekommen, dann von Buffer in den Speicher
> schreiben
> s_speicher <= s_eingangsbuffer;
Dir ist schon klar, dass auf ein RAM nicht massiv parallel 
zugegriffen werden kann?
Stattdessen gibt es ein "Schlüsselloch" namens Adress- und Datenbus, 
über das man immer nur ein par einzelne Bits des gesamten RAM ansprechen 
kan...

[Falk B. (falk)]

@ Lothar Miller (lkmiller) (Moderator) Benutzerseite

>Dir ist schon klar, dass auf ein RAM nicht massiv parallel
>zugegriffen werden kann?

In C schon ;-)

Die Script-Kiddies mal wieder. (jaja, ich bin böse, muss manchmal sein)

Früher (tm) hat man Digitaltechnik von Anfang an gelernt.

Gatter, Flip-Flop, Dekoder. Und alles als Schaltplan aufgezeichnet. Da 
war den Leuten klar, dass das Hardwareblöcke sind, die ineinander 
greifen. Auch was eine state machine ist.

Heute meint jeder, der ein paar Buchstaben in den Editor hacken kann, er 
könne modernen FPGA-Entwurf. Naja, meinen kann das jeder.