Schlagwort: Array

binary output C++

Problem mit << (Standard filestream Operator)

Mit Bitset und << in einen Outputfilestream wurde jedes 0 und jedes 1 zu einem Ascii gewandelt.

std::bitset<16> left (161);
std::bitset<8> symbol(98);

std::ofstream ofs;
ofs.open("treebinary.bin", std::ofstream::binary) 

ofs << left << symbol ;

ofs.close()

Dateigrösse (16 + 8) * 1 Char = 24 Byte. (Faktor 8 zu gross).

Lösung write( Pointer to Data, size)
In der Funktion write kann ein Pointer übergeben werden. Dadurch findet keine Umwandlung in String (durch <<) statt. Die 0 und 1er werden direkt binär geschrieben.

char data[3]    // 3 Bytes

// inhalt von 1 Byte und 2 Bytes
std::bitset<16> left (361);
std::bitset<8> symbol(98);

// array füllen
data[0] = left;
data[2] = symbol;

//array in 1mal ausgeben
std::ofstream ofs; ofs.write((char *) data , 3) 

ofs.close()
  • Alle Bits werden auf einmal geschrieben
  • kein << left << symbol notwendig
  • Man gibt den Pointer mit und die Länge der Daten
char* data[3]    // initalisiert als Pointer

std::bitset<16> left (361);
std::bitset<8> symbol(98);

data[0] = left;
data[2] = symbol;

std::ofstream ofs; ofs.write(data , sizeof() 

ofs.close()
// array of struct
std::struct Node
{  
    uint16_t left = 0;
    uint16_t right = 0;
    uint8_t symbol = 0;
    bool filled = false;
};

Node tree[100];

// füllen des arrays per tree-funktion


// array per Pointer mitgeben, länge = Node-länge * Anzahl
std::ofstream ofs; ofs.write((char*) tree , sizeof( (struct Node) * 100);

ofs.close()

vhdl: array aus struct

Array aus struct

  • token structure:
    cmd | 4 x midi_data (note + velocity) |  numb_notes
  • aus den Token wird ein Array gebildet
token_array()
.    token_line_1
.           command
.           midi_data
.                  note
.                  velocity
.            token_number
.     token_line_2
  1. Midi-Data Struktur bilden
-- define midi_data
type t_midi_data is record
            note : std_logic_vector(7 downto 0);
            velocity : std_logic_vector(7 downto 0);
        end record;

-- initialise (if needed)
variable data_1: t_midi_data;

2. Array für Midi-Data (weil es 4 x vorkommt)

-- define
type t_midi_data_array is array (3 downto 0) of t_midi_data;

-- initalise (if needed)
signal data_array: t_midi_data_array;

3. Ganze Token Struktur zusammensetzen

-- define
type t_token is record
      token_cmd : string(1 to 5);
      token_midi_data : t_midi_data_array;
       token_number : std_logic_vector(3 downto 0);
end record;

-- initialize (if needed)
signal token_linie: t_token;

4. Mehrere Token zu einem Array zusammenfassen

CONSTANT NUMBR_INPUTLINES: natural := 8;

-- define
type t_token_array is array( NUMBR_INPUTLINES-1 downto 0)  of t_token;

-- initialise
signal token_array_input: t_token_array;

 

Grundsätzlich braucht es keine Signale, da die Inputs direkt in input-array eingelesen werden und Zuweisungen direkt vom Array an das entsprechende Signal gegeben wird.
Einziges Signal das es braucht ist über das Gesamt-Array, damit es angesprochen werden kann.

————————————————————————————-

Werte zuweisen

t_token_array()
.    token_line_1
.           command
.           midi_data
.                  note
.                  velocity
.            token_number
.     token_line_2

-- initialisation
signal s_input_array: t_token_array;
s_token_line_1 <= s_input_array(0);

s_token_command <= s_input_array(0).command;

s_token_note_1 <= s_input_array(0).midi_data(1).note;
s_tk_velocity_1 <= s_input_array(0).m_data(1).vlcty;
s_token_note_2 <= s_input_array(0).midi_data(2).note;
s_tk_velocity_2 <= s_input_array(0).m_data(2).vlcty;

s_token_number <= s_input_array(0);

 

Die einzelnen Variablen werden mit dem Namen angesprochen.

 

 

…

Signale zusammensetzen

In VHDL ist es üblich, vor dem Senden von Daten mehrere Informationen (Signale) in einen grossen Vektor zusammenzubauen.
Beim Empfangen wird dann der grosse Vektor wieder in seine Einzelteile zerlegt.

1. Einzelne Signalgrössen

signal s_tone_on:  std_logic;
signal s_note_value: std_logic_vector(7 downto 0);
signal s_velocity: std_logic_vector(7 downto 0);

signal s_midi: std_logic_vector(16 dowonto 0);


2. Addition  zu Vektor
// Vektor für innerhalb Entity bilden

s_midi <= s_tone_on & s_note_value & s_velocity;

// oder direkt beim Port

GPIO_0 <= s_tone_on & s_note_value & s_velocity;

Man kann auch nur Teile des Vektors addieren.

VHDL Bits aus Vektor extrahieren

Oft ist ein Vektor aus mehreren Informationen zusammengesetzt (vgl midi_in).

entity a is
port( midi_in: in std_logic_vector(16 downto 0);
      data:    out std_logic_vector(7 downto 0)
    );

Braucht man nun nur einen Bit-Abschnitt so geschieht dies so:

1. Signal von der gewünschten Bit-Breite definieren

signal s_tone_on:  std_logic;
signal s_note_value: std_logic_vector(7 downto 0);
signal s_velocity: std_logic_vector(7 downto 0);

2. Vektor bitweise zuweisten

s_tone_on <= midi_in(16);
s_note_value <= midi_in(15 downto 8);
s_velocity <= midi_in(7 downto 0);

….

VHDL speicher, buffer, register

Inputdaten müssen teilweise abgelegt werden. Wie wird dies in VHDL umgesetzt?

  • man kann per IP RAM anschliessen und dort per Adresse die Daten hineinschreiben.
  • Das VHDL-eigene Speicherprinzip sind jedoch die Flip- Flops. Alle Daten die gespeichert werden sollen, werden in (Vektoren) von Flip-Flops abgelegtff_speicher
    Signale führen Wert in und aus dem Flip-Flop

    -- input
signal s_next_value: std_logic_vector(7 downto 0);
-- gespeichert
signal s_current_value: std_logic_vector(7downto0);
-- input in ff-signal ablegen
s_next_value <= input;

-- input speichern
input_register: process (all)
begin
.    if (reset = '1') then
.        s_current_value <= (others => '0');
.    elsif (clk'event) and (clk = '1') then
.        -- ausgang ff  erhält  eingang ff
.        s_current_value <= s_next_value; 
.  end if; 
end process;

 

speicher_mit_enable

Normalerweise wird das Inputsignal nicht asynchron an den Eingang des Flip-Flops gelegt. Oft entscheidet ein enable_signal, wann die Daten vor den Eingang gelegt werden sollen. (Dies geschieht mit einem Multiplexer.)

-- input speichern
input_register: process (all)
begin
.    if (reset = '1') then
.        s_current_value <= (others => '0');
.    elsif (clk'event) and (clk = '1') then
.        -- ausgang ff  erhält  eingang ff
.        s_current_value <= s_next_value; 

.        if (s_enable = '1') then
           s_next_value <= input;
        else
           s_nex_value <= s_current_value;
        end if;
.  end if; 
end process;

c++: vector as new type in -std=c++11

Eine sichere Alternative zum Array!

#include <vector>
std::vector <int> messungen = { 12, 10, 11, 12, 10 };
std::vector <string> klasse_1b = { "eva", "tim", "lin", "noe" };
std::vecrot <Class> token_table = { "n", 5, "+", 2, "*", 4 };


Wertzuweisung

messungen[1] = 11;
token_table[2] = { "*", 3 }

 

Vektor per Referenz übergeben
Damit nicht alle Werte des Vektors übergeben werden müssen, wird nur die Adresse übergeben (siehe Pointer).

void print( const vektor <int>& messungen){
.   // code
}

Zur Referenzübergabe gehört sowohl das & (Adresse mitgeben).

Mit 0 oder leeren Strings initialisieren

std::vector <int> messungen( 5 );
std::vector <string> klasse_1b( 4 );

Achtung: geht nur, wenn man mit -std=c++11 kompiliert.

for eines Vektors

for (int i : messungen){
.    (if i = 5 ) {
.        //
.     }
}

Das verkürzte For für einen Vektor gibt zu Beginn den Datentyp an und nach dem Doppelpunkt die Länge des Vekorts. Dann geht das For durch jedes Elements des Vektors.

for eines Vektors aus einem Klassen-Datentyp

for (Token t: token_table){
.    (if t.nummer == 5) {
.        //
.     }
}

Wieder zuerst der Datentyp (Token) und dann den Vektor.
Bei der interenen Auswertung, muss gesagt werden, auf welchen Variabelntyp der Klasse sich die Auswertung bezieht. (Bei der Klasse Token hat jeder Index zwei Variablen: string operation und int nummer.)

 

Funktionen für Vektorbearbeitung

int anzahl = messungen.size();
messungen.sort();


Daten in Vector einlesen

vector <int> data;
int current_element;

while ( cin ){
    cin >> current_element
     data.push_back ( current_element );
}

– Die Funktion push_back() hängt neue Daten hinten an.
– Sie vergrössert die Vektorgrösse damit immer um 1

 

2-dimensionales Array

Ziel
3 x 3 Array mit 0 initialisieren

Struktur: List of list
Liste mit 3 Elementen, die selbst Listen sind
array = [ [0, 0, 0],  [0, 0, 0], [0, 0, 0] ]

Umsetzung simple
element = [ „0“] * 3
array = element * 3

Umsetzung variabel
for i in range(3):
.              array.append( [„0“ * 3 ]