Monat: September 2015

Änderungen rückgängig machen (Git)

Nachlesen von Änderungen rückgängig machen
https://www.atlassian.com/git/tutorials/undoing-changes

File aus Ordner löschen
Die Datei bleibt physisch da, wird aber aus der Versionierung (aus git) genommen. Git sieht das File nicht mehr.

git rm <file>


Lokale Änderung nicht comitten
– <untracked files> können mit gitignore vom committen ausgeschlossen werden
– wurde eine Datei bereits <add> so kann man git reset HEAD <file> das File aus der commit-Liste nehmen. (es wird dann wieder rot)

File auf alte Version zurücksetzen

git checkout --  <file>          // falscherweise commited
git checkout <commit-nr> <file>  // altes File holen
git reset <file>                 // falscherweise <add>

Der erste Befehl bezieht sich auf den letzten commit. Der zweite auf einen füheren. Achtung: in beiden Fällen wird das lokale File überschrieben!

 

VHDL Types

Int
– Zuweisung erfolgt ohne Hochkomma

variable   cnt: integer range 0 to 255 := 0;

Standard_Logic
– Zuweisung erfolgt über Hochkommas

signal s_reset:     std_logic := '0';

Variable <-> Signale in VHDL

Variable
– Leben nur innerhalb eines Prozesses.
– Ihr Zustand kann nicht gespeichert werden.
– Sie müssen im Prozess, vor dem begin definiert werden
– Zuweisung erfolgt sofort (asynchron)
– Wird die Variable auch ausserhalb des Prozesses gebraucht, wird sie einem Signal zugewiesen.

read_file: process(all)	
	
variable token_note: std_logic_vector(7 downto 0) :=(OTHERS => '0');
variable token_velocity: std_logic_vector(7 downto 0) :=(OTHERS => '0');
	
begin
       // token einlesen (muss variable sein)
      read(line_in, token_type_n, good);

      // variable signal übergeben
      s_token_type <= token_type;


Signale
– Verbinden Blöcke miteinander und/oder werden innerhalb Block gebraucht
– Sie werden ausserhalb von Prozessen definiert
– Ihr Wert kann in einem FF gespeichert werden (muss aber nicht)

architecture rtl of counter is

signal s_token_typ std_logic_vector(7 downto 0) := (others => '0'); 

begin 

execute_file: process (all) 
begin

end

..

Top Level

– Das Top-Level ist die äusserste Hülle eines VHDL-Blocks.
– Im Top-Level müssen die Blockeingänge mit den FPGA-Pins verbunden werden.
.  Dies geschieht über die Pinplanung.

Der Name der Top-Level-Entitiy muss der Name der Datei sein!

CLK und Reset muss nicht mit einem Signal intern angebunden werden, sondern alle alle Komponenten können mit dem Top-Level Port verbunden werden.

Pinzuweisung VHDL

Pinnamen laden
Zum Board besteht ein board.tcl-Datei, mit den Pinnamen. Diese wird als erstes geladen (Tools/script tcl).
Um die Namen anzusehen geht man auf Assignments/Pin Planer

Die Pins werden in der Top Level-Entity zugewiesen.

ENTITY top_counter_verification IS
      PORT(    CLK_50: 			IN std_logic;
	       KEY_0: 			IN std_logic;
	       EX_IO[0]:		OUT std_logic  
		);
END top_counter_verification;

Die Zuweisung erfolgt, in dem der Portname, genau dem Namen in der Pinzuweisungsliste (*.tcl) entspricht. Vgl. EX_IO[0]

Pinplaner

Die Namen in der Pinliste, kann man über Assignment/Assignment Editor setzen.

Node Name:   selber setzen;    Name, der in Projekt verwendet wird
Direction:        Pinrichtung
Location:         Ort auf FPGA (wichtigste Angabe)
diverse:            Spezifikationen zum IO  (Einstellbar über Assignment Editor)

pinplaner_zugewiesen

Soft Core OS

Nachdem ein Soft-Core-Prozessor in ein FPGA geladen wurde, folgt das Aufsetzen des OS. Bei Altera ist dies Nios2, bei Xilinx MicroBlaze.

Remote Zugriff auf OS
Per SSH (bzw. Nios Shell) wird auf den Softcore zugegriffen.

Ordner und Programme
Baut man einen Softprozessor ein, bildet dieser im Synthese Ordner ein Unterordner Software

synthese/software/

In diesen Ordner kann man notwendige Scripts und Settings ablegen.

Board Support Packet erzeugen
Das Script create bildet die Support Packete (und Ordner dazu)

./create

Kompilieren

./compile

Programm auf FPGA laufen lassen

./run

Logikblocks einbauen und ändern

QSys (früher SOPC):
– Ist ein System Integration Tool
– QSys ermöglicht den Import von Logik-Blöcken.
– Die Logikblöcke werden nachher als Files in das Projekt gealden

Qsys: Designen von eigenen Blöcken
quartus: Tools/qsys         eigenes Fenster geht auf
– Als erstes muss neue qsys-Datei erstellt werden (*.qsys)
– Dies Datei liegt in synthese/outputfiles/<name>
– Über Library holt man mit add einen Block
– Block benennen (wird zu Titel im Blockschema)
– Unter Export sagen, Blockvariable setzen
– Speicherplatz dem Block zuweisen
– add: man fügt neue Elemente hinzu
– neues Element verdrahten
– generate: beendet das Design
– die Datei (*.qip) liegt in outputfiles/<name>/synthese
– das Blockbild in outputfiles/<name> (*.bsf)

Quartus: Blöcke einbauen
– Neues, leeres *.bdf öffnen
– Über Block-Import den Block holen (*.bsf)
– Pin zuweisen
– Verdrahtungen benennen gemäss Export
– Kompilieren

 

low cost FPGA

Latice stellte einfachere FPGA her.

  • Der Clk ist weniger schnell, als bei High End FPGAs
  • Memory ist kleiner
  • Viele IP kostenlos

FPGA debuggen

Implementierte Logik
Tools/ Netlist Viewer/RTL Viewer:  zeigt die Logikbausteine

Blöcke und Verdrahtung
Tools/ Netlist Viewer/ Technology Map Viewer (Post-Mapping)

Pinzuweisung
– Um die Pin-Datei zu aktivieren, muss sie einmal gelaufen sein:
.  Tools/ Tcl Scripts/Run
– Pin Überprüfung:
.  Assignments/Pin Planer/
– Die Pin-Namen auf Schaltplan muss dem Name in der tcl-Datei entsprechen
– Abgespeichert wird die Pinzuweisung in der Datei boardname.tcl

Files in Projekt einbinden
Assignments/Settings/Files  auf add

Top-Level definieren
Links, im Projektnavigator, auf den Reiter Files.
Dort per rechte Maustaste eine Datei als Top-Level setezn