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:

git_3_stages

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

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.
singaltap_select_signal

Der Tackt muss angegeben werden:

singaltap_set_clock
clock setzen

Nach dem Clk sind die Grundeinstellungen wichtig. Kleine FPGAs haben nicht viel Speicher und zeichnen deshalb nur wenig Signale auf…
singaltap_configurations

Am Schluss wird die Konfiguration ins FPGA geladen. (Zuvor sollte man das Projekt .sof bereits einmal hinuntergealden haben.)
singaltap_download_signaltap

Die Signale erscheinen so:
singaltap_analysis

Will man ein Signal detaillierter anschauen, so geht dies so:
singaltap_analysis_more_details

Simulation Signale exportieren

– Exportier werden kann nur eine Postscript-Datei <datei.ps>
– Diese wird dann per Konsole mit ps2pdf <datei.ps>  in ein pdf gewandelt

Einstellung zur schwarz-weiss Ausgabe
Im Questsim: File/Page_Setup…
– Papter size: A4, Cursor on/off, Grid on/off, Color: B&W, Scaling: Fit to 1 page
File/Write Postscript
– Hacken bei: File name:  Pfad und Name angeben
– Signal Selection: Current view (oder All signals oder Selected)
– Time Range: Current view oder Full Range oder Custom

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.

Cmake introduction

Automatisches Generieren von Makefiles

$ mkdir build
$ cd build
$ cmake ..   // führt die CMakeList.txt aus = generiert Makefiles
             // cmakeList.txt liegt ein Verzeichnis weiter unten
$ make       // führt die Makefiles aus

Mit cmake werden Makefiles generiert. Alle Makefiles liegen im Ordner build. Alle Dateien, die die Programme zur Ausführung brauchen, müssen im build liegen.

Mehrere Executables

CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
PROJECT(HuffmanDecoder)

ADD_DEFINITIONS("-std=c++11 -g")

ADD_EXECUTABLE(decoder
    main.cpp
    FileStreamReader.cpp
    HuffmanDecoder.cpp
    BinaryTree.cpp
    EndoscopeImage.cpp
)

ADD_EXECUTABLE(decoder_fullversion
    decoder.cpp
    FileStreamReader.cpp
    HuffmanDecoder.cpp
    BinaryTree.cpp
    EndoscopeImage.cpp
)

ADD_EXECUTABLE(encoder
    encoder.cpp
    FileStreamReader.cpp
    HuffmanDecoder.cpp
    BinaryTree.cpp
    EndoscopeImage.cpp
)

ADD_EXECUTABLE(testTree
    testTree.cpp
    BinaryTree.cpp
)

Will man nur ein bestimmtes Projekt kompilieren, schreibt man:

$ make testTree && ./testTree

Durch && ./executalbe wird das Programm direkt ausgeführt.

 

Referenzen im Netz

Link1: Anleitung für Programmiererinnen

Link2: Einfache Einführung

Make bedeutet kompilieren (und linken). Will man mehrere Dateien kompilieren und dann auch linken, genügt ein einfacher Shell-Befehl gcc -o main.c test  nicht mehr. Man macht dann ein Makefile, in dem durch Pfad-Variablen und Variablen der Datein, das Kompilieren, Linken vereinfacht wird.

Die Aufgabe von Cmake ist es, Makefiles automatisiert zu erstellen. Der Aufruf cmake funktioniert nur, wenn im Zielordner auch die Datei CMakeLists.txt liegt. In jedem Unterordner liegt eine CMakeLists.txt

cmake pfad/zu/dateien

Alle wichtigen Ergebnisse des Kompilieren, Linkens legt das Programm selbständig in diese Datei ab.

………………………………………………………………………………….

Projektstruktur
project /  CMakeList.txt                          // das main CMake
.                 / source /  CMakeList.txt      // jeder Unterordner braucht sein CMake
.                                     main.cpp
.                                      classb.cpp
.                  /build/                                        // nur hier kein CMakeList.txt
.

Erhält man ein Programm aus einer Plattform, wird das Programm oft so gebildet:

$ mkdir build
$ cd build
$ cmake ..   // führt die CMakeList.txt aus = generiert Makefiles
$ make       // führt die Makefiles aus

 

……………………………………………………………………………………….

CMake legt auch eine CMakeCache.txt Datei selbständig an. Darin sind alle Konfigurationen gespeichert. Diese Datei sollte nicht manuell geändert werden.

Das Programm wird oft nicht im Ordner der Quelldateien abgelegt. Man kann einen Ordner build angeben oder /user/bin nehmen.


Hauptdatei: CMakeLists.txt

add_executable(hallowelt main.c)

Hat man mehrere Files, so werden diese in einer Varibale zusammengefasst

SET( SOURCE main.c calculator.c)   Mit set werden Variablen gesetzt

Braucht man später die Variable, so geschieht dies mit ${SOURCE}  .

add_executable(calculator ${SOURCE})

PROJECT( name )
INCLUDE_DIRECTORY( /usr/bin )
TARGET_LINK_LIBRARIES()
ADD_DEFINITIONS()

INSTALL( TARGETS <programm> RUNTIME DESTINATION bin)

 

Variable zu bereits bestehenden Variablen hinzufügen

SET( EXTRALIBS ${EXTRALIBS} /usr/local/bla)
Fett stehen hier alle alten Pfade zu Bibliotheken, danach kommt der neue Pfad.
Ein typisches Beispiel ist die Umgebungsvariable PATH. Dort wird auch zu ${PATH} <neuer Pfad> dazugeführt.

..

yocto: Konzept und Literatur

Yocto ist ein Build-System und hilft, ein embedded Linux-System aufzubauen.

 

Konzept

  • Yocto stellt eine Referenz-System (Poky), durch das viele Tools und Projekte leicht einbaubar sind zur Verfügung.
  • Unter den Cores besteht eine offene Struktur (Metadaten). Dadurch besteht Kompatibilität unter diversen Projekten
  •  Einfaches Buildprogramm (Bitbake), dass mit dieser offenen Struktur umgehen kann und Images buildet.

Wegen dieser Offenheit, können viele BSP (Board Support Packets) der Hersteller eingebunden und weiterentickelt werden. Dadurch muss das Build-System nicht neu erfunden werden.
BSP: Altera stellt über Quartus BSP für FPGAs her. Diese können relativ einfach in Yocto integriert werden. (Device Tree generieren, aus Datei.sof -> Datei.rbf und einen Preloader hinzufügen.)

 

Notwendige Grundlagen-Dateien
Auf dem Speichermedium, vom dem aus gebootet wird, liegen neben dem Yocto-Image weitere Dateien. Yocto ergänzt nur diese Dateien (mit seinem zImage), bzw. hilft, die Grundlagen-Dateiene zu einem funktionstüchtigen Gebilde zusammenzufügen.

  • Bootloader (Image)
  • Bootscript  -> nur so ist das System startfähig
  • Kernel mit Devicetree
  • File System (Image)

 

Struktur Yocto Projekt
-> Ordner build/
conf/                                          layers einstellen,
….

-> ordner pocky/
bitbake/
documentation/
meta/
meta-yocto/
meta-yocto-bsp/                               scripts/                                      um neue Projekte beizufügen
(layers)

Image builden

cd build
bitbake virtual/bootloader
bitbake virtual/kernel
bitbake core-image-minimale     // root file System

 

Vorteile

Die Vorteile von Yocto liegen laut der Linux Foundation darin, dass viele Vorlagen für die Unterstützung spezifischer Hardware (Board Support Packages) vorhanden sind und es einfach ist, das System auf neue Hardware zu portieren. Auch in Lizenzfragen ist man mit Yocto auf der sicheren Seite.

Bücher

  • Embedded Linux Projects Using Yocto Project Cookbook, March 2015
    By Alex González

https://www.packtpub.com/application-development/embedded-linux-development-yocto-project