Wichtig – was ich sah

Swift: Constructor

Implizite Variablendeklaration gilt beim Konstruktor nicht

Swift kennt die implizite Variablendeklatration: let a = 5. So ist die Variable a implizit ein Integer.

class Shape {
  var numberOfSides = 0

  init(numberOfSides:Int){
     self.numberOfSides = numberOfSides
}

Instanzierung bedingt Wertzuweisung
Bei der Instanzierung muss dem Argument ein Wert zugewiesen werden.

var s1 = Shape(numberOfSides: 4);  // numberOfSides = 4

Konstruktor einer vererbten Klasse

Der Konstruktor muss mindestens die Argumente der Superklasse enthalten. Kann auch eigene Klassenvariablen zusätzlich auflisten

init(numberOfSides:Int, name:String){
    super.init(numberOfSides = numberOfSides)  // Zuweisung Superklasse
    self.name = name     // Zuweisung zu eigener Klassenvariable
}

Mehr Details zur Vererbung in anderem Beitrag.

Klasse aufbauen

Die Klasse dient zum spezifischen Verarbeiten eines Objektes.

Das Objekt wird mit em Konstruktor gebildet Klasse::Klasse()

Um auf das Objekt zuzugreifen, es zu verändern oder den Zustand seiner Variablen zu kennen braucht man Klassen-Funktionen Klasse::funktion() .

Auf alle Klassenvariablen kann man nur über das Objekt zugreifen objekt.variable .

Bsp Huffman Map
– Konstruktor bildet die Map- hm.readToken(„stream.txt“) Daten werden von aussen eingegeben und lokal im Objekt gespeichert
– hm.getBitValue() Lokale Varibale wird verarbeitet und ausgegeben
– hm.getZeros() Andere Variable wird verabeitet und ausgegeben

per Reference C++, per Pointer C, C++

Grund
Will man mehrere externe Variable in einer Funktion bearbeiten, hat aber nur einen return Wert, so gibt man die Adressen dieser Variablen als Paramter mit. Dadurch wird die Variable direkt durch die Funktion bearbeitet. (Die Alternative wäre, globale Variablen zu definieren und diese zu übergeben. Da globale Varibalen vermieden werden sollen, entfällt diese Alternative.)

Pointer übergeben (C und C++)

function(int *x){do someting}    // Deklaration: Parameter ist ein Pointer

int a ;
function(&a);                    // Argument: Adresse der Variable

Bei der Übergabe per Pointer, wird keine lokale Kopie des Arguments erstellt, sondern die Änderungen werden direkt in den Speicher geschrieben.

Per Reference übergeben (C++)

function(int &x);           // Deklaration: Parameter einer Variable per Ref.
int a;
function(a);                // Die Adresse des Arguments wird genommen

Bei per Reference geschieht das selbe wie beim Pointer. Nur sieht man es beim Argument nicht direkt. Die Variable wird „normal“ übergeben.
Trotzdem ist die Wirkung die selbe wie bei der Pointerübergabe: Wie bei einer gobalen Varibale wird durch die Funktion die externe Variable verändert (LINK)

ASCII to binary

Wird einem char eine Zahl zugewiesen, so entspricht dies nicht der binären Darstellung !

int a = 16         0001 0000
char b = ‚16′     0011 0001 0011 0110     sind zwei Ascii-Zeichen
char c = ‚1‘        0011 0001
char d = ‚6‘         0011 0110
int d = 6        0000 0110

Lösung
char c = ‚1‘ – ‚0‘ 0000 0001
Will man einen Char, der die Zahl binär darstellt, so muss man den char-Wert ‚0‘ abziehen. Die Hochkommas sind zwingend, da sonst ein Typcast (zu int) vollzogen wird.

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

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.

…

VHDL: natural, unsigned, integer

Operiert man mit Indexes, Adressen, etc. so ist dies am einfachsten mit dez. Zahlen:12 + 100 = 112;
Das selbe gilt auch für die Zähler.
VHDL hat dafür 3 Types: integer, unsigned, natural .

Integer

signal addr:        integer range 0 to 15;
addr <= to_integer(value_a);

Adresse kann Werte von 0, 1, 2, … 15 annehmen.

cnt: integer range 0 to 3;

Der Zähler zählt 0, 1, 2, 3 und beginnt wieder bei 0.
.

2. Unsigned

-- 5 Werte
signal count:       unsigned(4 downto 0); 
signal value_a:     unsigned(15 downto 0);
signal  value_b:     unsigned(15 downto 0);

Der Zähler kann die Werte 4, 3, 2, 1, und 0 annahmen. Er besitzt 5 Zustände.

value_b <= to_unsigned(max_value,  4); ????? not shure

3. Natural

CONSTANT    max_value:        natural := 200;
signal      s_reg_index:      natural;
signal      s_next_reg_indes: natural;

s_next_reg_index := s_reg_index + 1;

Zuweisung braucht ein : vor dem = line_cnt := line_cnt + 1; reset := 1;

…

Pointer C++: Wert auslesen

struct ImageInt16 {
.        short data[100]
};

Objekt bilden
2 Bilder werden abgelegt. Inhaltstruktur ist identisch. Der Typ der Speichervariable nicht.

ImageInt16     bild_1;          // enthält Wert
ImageInt16*    bild_2;          // enthält Speicherort, an dem Wert liegt

Variable auslesen

int result_1, result_2;

result_1 = bild_1.data[0];    
result_2 = bild_2->data[1];       // Objektreferenz
  //oder
result_2 = (*bild_2).data[1];    // Dereferenziert
.                                // Wert des Objekts

Der ersten zwei Wert aus dem Array wurden übergeben.
..

VHDL signal operationen

Operatoren Beschreibung

not
kann für boolean und signale gebraucht werden

std_logic_signal_1 <= not std_logic_signal_2;

if (not enable_data_1) then
    //

and, & , +

std_logic_signal <= signal_a and signal_b;

natural, unsigned, integer
Typkonversionen zwischen den logischen Signalen und den natürlichen.

Bit Operationen
Signale zusammensetzen
Bist aus Vektor extrahieren
Signal Bits setzen (LSB, MSB)