"Serialisieren" VHDL-Rekord

Angenommen ich habe die folgende definition basiert auf Konstanten, die angeben, Vektor Länge des Datensatzes Mitglieder:

type point_t is record
    x: std_logic_vector(X_WIDTH-1 downto 0);
    y: std_logic_vector(Y_WIDTH-1 downto 0); 
end record;

Ich würde gerne konvertieren diese Art von Aufzeichnungen in std_logic_vectors, um in, sagen wir, ein FIFO. Momentan benutze ich den folgenden code:

PROCEDURE encodepoint(signal pnt: in point_t;
                      signal d: out std_logic_vector(POINT_ENC_WIDTH-1 downto 0)) is
    variable top: integer := 0;
begin
    top := X_WIDTH-1;
    d(top downto 0) <= pnt.x;

    top := top + Y_WIDTH;
    d(top downto top-X_WIDTH+1) <= sl.y;

    d(d'left downto top+1) <= (others => '0');
end;

Dieser code ist suboptimal in vielerlei Hinsicht. Zum Beispiel verlangt von mir immer richtig eingestellt POINT_ENC_WIDTH auf einen Wert, der groß genug ist, um zu ermöglichen d zu halten die ganze serialisierten Datensatz. Es stützt sich auf die Programmierer zu tun, sehr mechanische Arbeit. Zum Beispiel für jedes Mitglied der Datensatz, sagen x, X_WIDTH erscheint zweimal in den code, einmal in direktem Zusammenhang mit x und einmal in Verbindung mit dem nächsten Mitglied y. Dies schnell langweilig. Wenn ich die definition ändern des Datensatzes durch das hinzufügen zusätzlicher Felder, ich habe zu aktualisieren, sowohl die Serialisierung und die (sehr ähnliche) Deserialisieren von code, und ich kann nur vergessen diese. Wenn ich die Felder entfernen, zumindest der compiler meckert.

So das führt mich zu meiner Frage: gibt es eine einfache, automatisierte oder zumindest quasi-automatisierten Weg, um zu konvertieren VHDL-records in std_logic_vectors ohne Rückgriff auf manuell geschrieben serialisieren/Deserialisieren von code? Es ist nicht wichtig für mich zu wissen, die spezifische Codierung, wie ich bin über die Datensätze intern und die endgültige Ausgabe-format ist spezifiziert und implementiert werden manuell.

InformationsquelleAutor distributed | 2010-10-21

5

Können Sie nicht einfach dies schreiben:
```
d <= pnt.x & pnt.y;
```
- Oh, guter Punkt, danke! Manchmal Frage ich mich, wie viel ich in der Lage bin, zu übersehen! Ist die inverse operation auch beschreibbar in eine ähnlich prägnante Weise?
- Ich denke, Sie müssen zwei Zuordnungen und Attribute zu "entpacken" den Rekord. Probieren Sie etwas wie: pnt.x <= d(pnt).x'length-1 downto 0);
InformationsquelleAutor Philippe

Entnommen Diskussion hier

Einem vernünftigen Weg, dies zu tun, mit großen Datensätzen zu definieren, die Bereiche vor der Zeit, wie diese:

type t_SPI_DATA_PORT is record
  Data_Size_Minus1: std_ulogic_vector(31 downto 28);
  Done: std_ulogic_vector(27 downto 27);
  Rx_Wait_Timeout: std_ulogic_vector(26 downto 26);
  Rx_Wait_On_Miso: std_ulogic_vector(25 downto 25);
  Sclk_Select: std_ulogic_vector(24 downto 24);
  Reserved: std_ulogic_vector(23 downto 20);
  Hold_Cs: std_ulogic_vector(19 downto 19);
  Cpha: std_ulogic_vector(18 downto 17);
  Cpol: std_ulogic_vector(16 downto 16);
  Data: std_ulogic_vector(15 downto 0);
end record;

Dann die Funktionen für die Konvertierung wie folgt Aussehen:

function To_Std_ULogic_Vector(L : t_SPI_DATA_PORT) return
  std_ulogic_vector is
    variable RetVal: std_ulogic_vector(31 downto 0);
  begin

    RetVal := (others => '0');
    RetVal(L.Data_Size_Minus1'range) := L.Data_Size_Minus1;
    RetVal(L.Done'range) := L.Done;
    RetVal(L.Rx_Wait_Timeout'range) := L.Rx_Wait_Timeout;
    RetVal(L.Sclk_Select'range) := L.Sclk_Select;
    RetVal(L.Reserved'range) := L.Reserved;
    RetVal(L.Rx_Wait_On_Miso'range) := L.Rx_Wait_On_Miso;
    RetVal(L.Hold_Cs'range) := L.Hold_Cs;
    RetVal(L.Cpha'range) := L.Cpha;
    RetVal(L.Cpol'range) := L.Cpol;
    RetVal(L.Data'range) := L.Data;

    return(RetVal);
end To_Std_ULogic_Vector;

function From_Std_ULogic_Vector(L : std_ulogic_vector) return
  t_SPI_DATA_PORT is
    variable RetVal: t_SPI_DATA_PORT;
    variable Lx: std_ulogic_vector(L'length - 1 downto 0);
  begin
    Lx := L;    
    RetVal.Data_Size_Minus1 := Lx(RetVal.Data_Size_Minus1'range);
    RetVal.Done := Lx(RetVal.Done'range);
    RetVal.Rx_Wait_Timeout := Lx(RetVal.Rx_Wait_Timeout'range);
    RetVal.Sclk_Select := Lx(RetVal.Sclk_Select'range);
    RetVal.Reserved := Lx(RetVal.Reserved'range);
    RetVal.Rx_Wait_On_Miso := Lx(RetVal.Rx_Wait_On_Miso'range);
    RetVal.Hold_Cs := Lx(RetVal.Hold_Cs'range);
    RetVal.Cpha := Lx(RetVal.Cpha'range);
    RetVal.Cpol := Lx(RetVal.Cpol'range);
    RetVal.Data := Lx(RetVal.Data'range);

    return(RetVal);
end From_Std_ULogic_Vector;

InformationsquelleAutor Lincoln

1

Ich in der Regel zu definieren, die conversion-Funktionen in einem Paket zusammen mit dem Datensatz.

In deinem Fall, so etwas wie:
```
function point2slv (pnt : point_t) return std_logic_vector is
    variable slv : std_logic_vector(X_WIDTH + Y_WIDTH - 1 downto 0);
begin
    slv :=  pnt.x & pnt.y;
    return slv;
end;

function slv2point (slv : std_logic_vector) return point_t is
    variable pnt : point_t;
begin
    pnt.x     := slv(X_WIDTH + Y_WIDTH - 1 downto Y_WIDTH);
    pnt.y     := slv(Y_WIDTH - 1 downto  0);
    return pnt;
end;
```
HINWEIS:
Je nachdem, was Sie versuchen zu tun, möchten Sie vielleicht verwenden Sie vordefinierte Größen auf der einen Seite oder der anderen, und Konvertierungsfunktionen, um pad/Clips zu den natürlichen Längen (dh: vielleicht passen die X-und Y-Werte in 16-oder 32-bit-Werte). Das unsigned-Typ und die resize-Funktion funktioniert gut für diese:
```
slv(31 downto 16):=  std_logic_vector(resize(unsigned(pnt.x,16)));
slv(15 downto  0):=  std_logic_vector(resize(unsigned(pnt.7,16)));
```
- Hum, das ist genau die situation, die ich jetzt habe. Ich versuche das encoding/decoding-Funktionen sehr nahe an der Typ-Definitionen. Ihre Codierung/Decodierung-code geschrieben wird, ein wenig anders, mit expliziten Indizes, aber die Auswirkungen sind die gleichen. Je mehr Mitglieder Sie haben in Ihrem Datensatz, je länger Ihre Linien zu bekommen. Für Einträge, die mit, sagen wir, 10 Mitglieder, dies schwerfällig. Wenn Sie Mitglieder hinzufügen oder löschen, müssen Sie den code zu aktualisieren und seien Sie sehr vorsichtig, dass Sie dies tun richtig.
- Für große Datensätze mit mehr Mitglieder, ich in der Regel explizit definieren, die bit-Regionen anstelle von verketten die SLVs, dh: slv(31 downto 16) := pnt.x; slv(15 downto 0) := pnt.y; Dies ist, wo die Verwendung der resize-Funktionen können sehr nützlich sein, wenn die Länge von X und Y sind nicht behoben: slv(31 downto 16) := std_logic_vector(resize(unsigned(pnt).x,16));
InformationsquelleAutor Charles Steinkuehler
1

Obwohl es derzeit keine offizielle automatisierte Möglichkeit der Umwandlung von Datensätzen auf Vektoren (und Umgekehrt), ist es eine sehr häufige Anforderung. Sie haben 2 Optionen:
- Definieren Sie Ihre eigenen to_vector und from_vector Funktionen für jeden Datensatz-Typ (mühsam)
- Autogenerate-Pakete mit den oben genannten Typ-Konvertierungen (schwierig /fehleranfällig)
Langwierigen und sich wiederholenden Aufgaben, die Sie motivieren, um ein Skript zu schreiben um code zu generieren, sind ein Indiz für einen Mangel in der Sprache selbst. Sie können dies ändern, indem Sie einen aktive Rolle in der IEEE-working-group und Einfluss die nächste version des VHDL-standard.

InformationsquelleAutor Chiggs
1

Vorbereitet habe ich ein Skript generiert automatisch den VHDL - Paket für Konvertierungen zwischen den benutzerdefinierten Datensatz-Typ und den std_logic_vector geben.

Den Quellen dieses Skript veröffentlicht PUBLIC DOMAIN im alt.sources Gruppe.
Sie können sehen, http://groups.google.com/group/alt.sources/browse_frm/thread/53ea61208013e9d1 oder suchen Thema "Skript zum generieren VHDL - Paket für die Konvertierung zwischen den record-Typ und std_logic_vector"
Wenn Sie wollen, packen Sie das Archiv aus dem Google-Archiv, denken Sie daran, wählen Sie " show original " - option. Ansonsten ist die indendation der Python Quelle beschädigt wird.

InformationsquelleAutor WZab

Habe ich, die anderen versuchen, bei record-Serialisierung. Ich glaube, meine Methode ist ein wenig mehr robust. Sie müssen noch zu erstellen-Funktion für jeden Datensatz-Typ, aber Sie brauchen nicht zu erwähnen, Bereiche.

Können sagen, Sie brauchen, um zu serialisieren type_a mit meinem Paket:

type type_a is record
  a : std_logic_vector(15 downto 0);
  b : std_logic_vector(31 downto 0);
  c : std_logic_vector(7 downto 0);
  d : std_logic_vector(7 downto 0);
end record type_a;

constant type_a_width : integer := 64;

Definieren die beiden Funktionen so:

use work.SERIALIZE_PKG.all;

function serialize (
     input : type_a)
  return std_logic_vector is
  variable ser : serializer_t(type_a_width-1 downto 0);
  variable r   : std_logic_vector(type_a_width-1 downto 0);
begin  -- function serialize_detectorCacheLine_t
  serialize_init(ser);
  serialize(ser, input.a);
  serialize(ser, input.b);
  serialize(ser, input.c);
  serialize(ser, input.d);
  r := serialize_get(ser);
  return r;
end function serialize;


function deserialize (
     input : std_logic_vector)
  return type_a is
  variable ser : serializer_t(type_a_width-1 downto 0);
  variable r   : type_a;
begin  -- function serialize_detectorCacheLine_t
  ser := serialize_set(input);
  deserialize(ser, r.a);
  deserialize(ser, r.b);
  deserialize(ser, r.c);
  deserialize(ser, r.d);
  return r;
end function deserialize;

Und dann kannst du es im code wie folgt:

signal type_a_ser       : std_logic_vector(type_a_width-1 downto 0)       := (others => '0');
signal type_a_in        : type_a;
signal type_a_out       : type_a;
....
type_a_ser       <= serialize(type_a_in);
type_a_out       <= deserialize(type_a_ser);

Ich habe meine code und ein Beispiel von komplexer Typen (geschachtelte Datensätze etc.) finden Sie unter: https://github.com/gitmodimo/vhdl-serialize

InformationsquelleAutor modimo

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.