Januar 2016 – Seite 2

swift Vererbung über Delegierte

Zwei Dateien
Proj_Bauteil_Funktion.swift
Proj_Bauteil_FunktionDelegate.swift

Inhalt DateiDelegate.swift

import Bibliothek

protocol Proj_Bauteil_FunktionDelegate {
.    func name(<var>:<Type>!)
}

Ähnlich zum Header gibt sie das an, was importiert wird.

Bezug auf Vererbung in der Hauptdatei

class xy {
.          // Deklarationen
.         var delegate: Proj_Bauteil_FunktionDelegate?
.
.        // Funktionen
.       func tcpSocket( <argument>) {
.                // Code
.                delegate?.receiveAck(data)
}

Die vererbte Variable wird mit einem ? definiert und immer mit einem ? aufgerufen.
Was bedeutet das ! ?
Vermutung: Die Eltern erhalten dieses Zeichen.

Steuerung Audio Codec

Überblick der Funkionen
Der Audio Codec gibt die Audiodaten aus. Zudem verwaltet er alle Audio-Pfäde auf dem Board. Er definiert, ob der Analoge Input aktiv oder der Digitale Input übergangen wird. Alle Einstellungen stehen in seinen Registern.

Bidirektionale Konfiguration des Audio Codec IO-Bauteilen
Die Einstellungen des Audio Codecs erfolgen über Register. Damit die Register gesetzt werden können, wird mit I2C auf die Codecregister zugegriffen.Insgesamt bestehen 11 Register mit je 16 Bits.

Einerseits werden über den Codec Kontroller die Konfigurationen gesetzt, anderseits setzt der Audio Codec die Pfade aktiv oder nicht. Die Kommunikation ist bidirektional: in beide Richtungen.

Audio Codec mit Audio-Daten speisen
Die konkrete Musikdatei wird über I2S dem Codec übermittelt und dann an den entsprechenden Ausgang geleitet.

Makefile

 # the compiler: gcc for C program, define as g++ for C++
  CC = gcc

  # compiler flags:
  #  -g    adds debugging information to the executable file
  #  -Wall turns on most, but not all, compiler warnings
  CFLAGS  = -g -Wall

  # the build target executable:
  TARGET = myprog

  all: $(TARGET)

  $(TARGET): $(TARGET).c
     $(CC) $(CFLAGS) -o $(TARGET) $(TARGET).c

  clean:
          $(RM) $(TARGET)

Makefiles kann man mit Cmake automatisch generieren lassen.

self in Klassen [aus: swift]

Die Variable self wird nur gebraucht, wenn das Argument einer Funktion denselben Namen hat wie eine Klassenvariable.

Mit self.variable wird die Klassenvariable bezeichnet bzw. unterschieden von dem Argument.

class TipCalculator {
   let total: Double
   let taxPct: Double
   let subtotal: Double

   init(total: Double; taxPct: Double) {
       self.total = total      // Argumente erhalten
       self.taxPct = taxPct
       subtotal = total /(taxPct+1)   // keine Argumente
                                 // nur Klassenvariable
   }


}

aus: Swift 2 Tutorial

PLL Phase Locked Loop

In den FPGAs sind PLLS ein Standard für zwei Gründe:
– Um Pfadverzögerungen zu Kompensieren (Bsp. 2)
– Um andere Taktfrequenzen zu erhalten (Bsp. 1)

Neuer Takt
Viele Protokole besitzen ihre eigene Takt-Frequenz. Daher braucht es einige Takte innerhalb eines FPGAs

f_out = (f_in * m) / n         // m wird multipliziert,  n und g dividiert

Kompensation Verzögerung
Werte im Feedback Pfad v1= 3 ns schieben CLK_IN nach vorne,
Werte beim Ausgang v2 = 8 ns verzögern CLK_IN.

Bsp Kompensation
Ausgangslage: Durch Flip-Flop-Verzögerung oder Pfadverzögerung und IO-Verzögerung kommt data 5ns später als CLK_50 beim SRAM an.
1.) Entweder führt man ein PLL in den data-Pfad ein,
dann muss der PLL den CLK_50 vorverlegen v1 = 5 ns
um die Verspätung zu kompensieren,
oder (siehe Bild)
2.) man verzögert den CLK_50 zum SRAM mit genau der Verzögerung,
die der data-Pfad hat v2 = 5 ns . Dann kommt CLK RAM „gleich verzögert “
wie data beim SRAM an.

PLL Rechenbeispiel mit Takterzeugung und Verzögerung

Dualport Speicher

Singalport
Traditionall wird auf einem Speicher entweder geschrieben oder gelesen werden. Dies geschieht nicht gleichzeitig.Es handelt sich um einen Singel Port Speicher.

Dualport (z.B. in FPGAs)
Auf denselben Speicher wird über zwei Schnittstellen zugegriffen. Dadurch kann zeitgleich auf denselben Speicher gelesen wie geschrieben werden.
Bei der Dualport-Konfiguration sagt man, welche Aktion Priorität hat, falls lesen und schreiben auf die selbe Adresse getätigt werden soll.

Vorteile des Dualport
– lesen und schreiben können einen anderen Takt haben
– lesen und schreiben können andere Datenbreiten haben

Implementation
Dualport ist nur durch 2 unabhängige Bussysteme möglich. Beide Ports werden an einen Bus manuell angebunden. Ebenso wird beim FPGA in der Konfiguration der Ports in den IP-Einstellungen minutiös eingestellt.

DMA: Direct Memory Access

Normalerweise kooridiniert die CPU den Verkehr auf dem Bus. Angeschlossenen Periphierie-Geräte senden ihren Inhalt in ein CPU-Register und diese sendet diese an das RAM.

DMA: Periphierie-Geräte schreiben direkt in RAM
Die Zwischenspeicherung in das CPU-Regsiter entfällt. Es braucht für die Koordination eine DMA-Leitung zur CPU. Sind mehrere Geräte DMA-fähig, werden sie durch ihren Index voneinander unterschieden.

DMA: Entlastet Bus und CPU
..

DebugNavitator XCode

Fensterübersicht
Das fünfte Fenster im Navigator dient dem Debuggen.
Das Fenster links (1) heisst Stack View. Es zeigt alle Aufrufe (Ablagen auf dem Stack) bis zum aktuellen Programmpunkt. Zu unterst im Stack ist das main(), dann folgen alle aufrufe. Theoretisch kann man die Grösse der Stack-Details durch die Bedienung zu unterst am Fenster einstellen (nur Aufrufe, auch Variablen, …). Bei der hier abgebildeten Funktion war dies nicht möglich.
Das Fenster unten links (2) nennt sich Variable View. Durch Klicken auf das Dreieck vor der Variable, erhält man mehr Details. Man kann über das Menü ganz unten festlegen, ob man nur die lokalen Variabeln (aktuelle Einstellung) oder alle oder AUTO sehen will.
Das Fenster (3) ist die Konsole.

Debugg-Knöpfe

CONTINUE: Verlässt die aktuelle Debugging-Stelle. Das Programm läuft weiter bis zum nächsten Breakpoint.
STEP OVER: Aktuelle Zeile wird ausgeführt. Cursor geht zur nächsten Zeile.
STEP INTO: Sprung von der aktuellen Stelle in die Funktion. Man sieht wohin das Programm geht und wie die Variablen gesetzt werden
STEP OUT: Verlassen der aufgerufenen Funktion. Man kehrt an die Debugging-Stelle zurück.

Variablen währende dem Debuggen temporär setzen
Im zweiten Fenster (Variable View) können während dem das Debuggen läuft, also der Code ausgeführt wird, Variablen-Werte manuell gesetzt werden. Man sieht dann, wie sich das auf den Code auswirkt.

ASCII-File to Binary-File

edid.txt
Eine Binärdatei, die in hex eingelesen wurde:

00 FF FF FF FF FF FF 00 4D D9 01 08 01 01 01 01 
01 11 01 03 80 A0 5A 78 0A 0D C9 A0 57 47 98 27 
12 48 4C 21 08 00 01 01 01 01 01 01 01 01 01 01

Konvertieren zu edid.bin

cat edid.txt | xxd -r -p > edid.bin

xxd ist ein Programm. Das andere ist hexdump

Binary File to Ascii File

edid.bin

Will man den Inhalt überprüfen, braucht man die Konversion in Ascii.

Programms hexdump (Alternative ist xxd)

Pro Ziffer werden 4 Bit dargestellt. 1 Byte hat zwei Ziffern. Bzw. aus 8 Bit entstehen 2 Ziffern.

hexdump binaryTree.bin

0000000 0008 0001 0000 0002 000a 0000 0007 0003
0000010 0000 000f 0004 0000 0005 0010 0000 0011
0000020 0006 0000 0000 0000 0100 0000 0000 0101

Jedes Zeichen entspricht einem Byte. 0008 sind somit 4 Bytes bzw. 0x00 und 0x08.
Vorne Anzahl Hexzahlen: Zeile hat 16 hex-Zeichen (pro Block zwei Hexzahlen)
Ausgabe ist Big Endian (wie Zahl geschrieben wird). Zurst die höherwertigen Bytes.
binär: 00000000 00001000 => 0x 00 08

Ohne Hexzahlen

hexdump  -e '16/1 "%02x " "\n"'   binaryTree.bin

08 00 01 00 00 00 02 00 0a 00 00 00 07 00 03 00
00 00 0f 00 04 00 00 00 05 00 10 00 00 00 11 00

Ausgabe ist LittelEndian
Höherwertige Zahlen kommen an zweiter Stelle.
Zuerst die tiefen Bytes. (zuerst 08)
binär: 00000000 00001000 => 0x 08 00