katrin – Seite 13 – was ich sah

JTAG als generelle Schnittstelle

JTAG wurde für Built in Tests auf Chips entwickelt. Da durch JTAG direkt auf den Chip zugegriffen werden kann, erweiterten Hersteller die Schnittstelle für diverse Chip-Bedürfnisse:

JTAG-Schnittstelle als Programmer
JTAG kann gebraucht werden zum Laden eines Programms oder von Konfigurationen (FPFA) über einen Speicher (Flash).
Code kann heruntergeladen und ausgeführt werden.

Einblick in CPU und Peripherals
Hersteller bieten JTAG-Schnittstellen an über die auf die Speichersteine, den Bus, die CPU und weitere Blocks zum Debuggen zugegriffen werden kann. Werte können gesetzt wie auch nur analysiert werden.

Schnittstelle für Logic-Analyser
Die JTAG-Schnittstelle kann für den Zugang von Logic-Analyser-Programen gebraucht werden. Im FPGA ist dies Singaltap.

Boundary Scan Test

Ist die am häufigsten verwendete Testmethode in der Digitaltechnik. Das Grundprinzip ist, dass parallel zu den Ein-und Ausgängen FlipFlops zur Abbildung des aktuellen Zustands der Pins, aber auch zur Imitation von Pin-Zuständen eingebaut werden.

Die Flip-Flop Reihe, bilden ein Schieberegister, das die Zustände der IOS abbildet bzw. selbst bildet. Dieses Schieberegister ist SCAN CHAIN genannt.

Um die Daten der Scan Chain zu erhalten, braucht es die JTAG-Schnittstelle.

Die Scan Chain kann den aktuellen Zustand der IOs über die JTAG-Schnittstelle TDO nach aussen geben.

Sie kann auch virtuell Input Werte setzen über die Schnittstelle TDI. Dies dient der Simulation, bei der ein Verhalten von Eingängen simuliert wird.

JTAG: Built in Testing

Von der Prüfspitze zu Testpins
Früher wurde ausschliesslich mit der „Nadelmethode“ Testnadeln an ausgewählte Stellen (Knoten) angelötet, um den Signalverlauf zu testen.
Da die Bauteile immer kleiner werden ist dies physisch fast nicht mehr möglich. An den Teststellen (Knoten) werden Leitungen an die Oberfläche fix geführt. Ist dies in einem Chip (Built in) so enstehen Pins am Chip-Ausgang, die Zugang zu den Knoten bieten.

JTAG-Standard
Der IEEE 1149.1 Standard ist von der Gruppe JTAG verfasst und definiert eine Schnittstelle für Boundary Scan Test in Chips. Detailierter Artikel JTAG

Über die JTAG-Schnittstelle, auch TAP = Test Access Port genannt kann auf die SCAN CHAIN (siehe Boundary Scan) auf die Ein-und Ausgänge des Chips zugegriffen werden.

TAP Schnisstelle
JTAG definiert 4 Signale:
– TCK: Der Clock
– TMS: Der Testmode
– TDI: Die Datenleitung für Input (Simulation)
– TDO: Die Ausgabe des aktuellen Zustands an den Ein-und Ausgängen.

Swift: Vererbung

Alle Swift Objekte sind Subklassen der Klasse NSObjekt oder einer ihrer Subklassen. Die Superklasse wird mit : in der Definition angegeben
class A: Superklasse.
Das Init muss alle Paramter der Superklasse enthalten und weist dieser mit super.init(variable1 = variable1) einen Wert zu
Variablen der Superklasse können (ohne super) im init überschrieben werden. variable2 = 5;
Funktionen werden ausserhalb des init() überschrieben und brauchend das keyword override.Bsp der iOS Developper Site

    class NamedShape {
        var numberOfSides = 0
        var name: String
        
        init(name: String) {
            self.name = name     // self für eigene Klassenvariable
        }
        
        func simpleDescription() -> String {
            return "A shape with \(numberOfSides) sides."
        }
    }


    class Square: NamedShape {
        var sideLength: Double
        
        init(sideLength: Double, name: String) {
            self.sideLength = sideLength   // eigene Klassenvariable
            super.init(name: name)    // Variable der Superklasse
            numberOfSides = 4 // Überschreibt Variable der Superklasse
        }
        
        func area() ->  Double {
            return sideLength * sideLength
        }
        
        override func simpleDescription() -> String {
            return "A square with sides of length \(sideLength)."
        }
    }
    let testSquare = Square(sideLength: 5.2, name: "my test square")
    testSquare.area()
    testSquare.simpleDescription()

..

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.

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()

iOS: Apple Betriebsystem für Mobiles

Apple unterscheidet zwei Plattformen. Für Mobile Geräte heisst das Betriebsystem iOS und das Betriebsystem für Computer heisst OS X.

Apple bietet Entwicklern eine gute Umgebung an: XCode. Diese IDE beinhaltet das Testen von Code, Real Time Debugging und eine visuelle Gestaltung der App und vieles mehr.

Programmiert wird hautpsächlich in Swift (nachfolger von Objective C) und für die Kernel-Functions in C.

Git Basics: drei Dateizustände bei der Verfolgung

Jedes Git-Verzeichnis befindet sich in einem bestimmten Zustand. Dieser Zustand hat eine Commit-Nummer.

Nimmt man Änderungen aktuellen Verzeichnis vor, so können sich die Dateien in einem der nachfolgenden drei Zustände befinden:

Eine Datei, die nachverfolgt wird hat sich geändert: Sie ist im Zustand modified
Mit dem Befehl git add wird die Änderung zum weiteren verfolgen vorgemerkt. Die Datei hat einen Index. Ihr neuer Zustand ist:
Als staged wird eine Datei bezeichnet, die einen Index zum Verfolgen erhalten haben, aber noch nicht einem neuen Zustand zugeordnet wurde. Mit dem Befehl git commit führt man diese Dateien zu einer neuen gespeicherten Versionen.

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

SignalTap

Über den USB-Blaster kann bei altera mit dem Programm SignalTap der Verlauf der internen Signale sichtbar gemacht werden. Der Vorteil zu einem Logic Analyser ist, dass SignalTap intern funktioniert und damit die Signale nicht zuerst nach aussen geführt werden müssen.

Die Screenshots sind von der Präsentation: de.slideshare.net/… quartus tutorial signaltap

Die Signale werden durch Doppelklick bei „node“ ausgewählt. Mit einem * erhält man alle Signale.