Spartan 3AN RAM schreiben und lesen über RS232

Hans Gast #4151233
Lesenswert?
• ▲
▼ 
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
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Falk B. #4151452
Lesenswert?
• ▲
▼ 
@ 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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Hans Gast #4152455
Lesenswert?
• ▲
▼ 
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?

1
library IEEE;

2
use IEEE.STD_LOGIC_1164.ALL;

3
use WORK.TYPE_DEFINITION.ALL;

4
use IEEE.NUMERIC_STD.ALL;

5
use IEEE.STD_LOGIC_UNSIGNED.all;

6


7
entity Array_Abfrage is

8
  port (      RXD      : in  STD_LOGIC;            -- Eingangssignal Serial Port (Serielle Schnittstelle)

9
        CLK      : in  STD_LOGIC;

10
        POS      : in  t_int_array;            -- Array mit 2 Einträgen (x,y) zur Bestimmung des Wertes, der aus dem Speichergelesen werden soll

11
        DATEN_WERT    : out integer range 0 to 15          -- Integerwert des abgefragten Arrayeintrages

12
      );

13
end Array_Abfrage;

14


15
architecture Behavioral of Array_Abfrage is

16
----------------------------------------------------------------------------------

17
---------- Deklarationen

18
signal s_uebertragenedaten : integer range 0 to 8192 := 0;                -- Zählt die bereits in den Zwischenspeicher übertragenen Werte

19


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

21


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

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

24


25
signal s_read : std_logic :='1'; 

26
signal s_datenwert : integer range 0 to 15; 

27


28
begin

29


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

31


32
process begin                              --EINLESEN von 8 bit alle t=10*t_baud

33
  wait until rising_edge(CLK);

34
    

35


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

37


38
if (s_uebertragenedaten = 8192) then                --Wenn gesamte Datenmenge angekommen, dann von Buffer in den Speicher schreiben

39
        s_speicher <= s_eingangsbuffer;

40
  s_read <= '0';

41
end if;

42


43
    

44
    

45
if (s_read = '1') then          

46
      

47
s_datenwert <= s_speicher(POS(2),POS(1));  

48
      

49
else 

50


51
s_datenwert <= 0;

52
      

53
end if;                  

54
    

55
    

56
    

57
end process;

58


59
DATEN_WERT <= s_datenwert;

60


61


62
end Behavioral;
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Falk B. #4152858
Lesenswert?
• ▲
▼ 
@ 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"
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Lothar M. Moderator (Firma: Titel) Persönliche Seite #4152938
Lesenswert?
• ▲
▼ 
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...
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Falk B. #4152988
Lesenswert?
• ▲
▼ 
@ 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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren