Programmieren – Die Grundlagen von C: Hallo Welt

Wer wollte nicht schon einmal ein eigenes Programm schreiben?
Um einen ersten Einblick über die Grundlagen von Programmiersprachen zu geben habe ich beschlossen, angefangen bei der Sprache C, eine neue Kategorie mit Inhalten zu füllen.
Die Programmiersprache C ist eine der am weitest verbreitetsten Programmiersprachen weltweit und auch einer der älteren Sprachen.
Dank des ebenfalls in C geschriebenen Kernels bietet sie unter Linux sogar über die sogenannten Header Dateien eine Schnittstelle an.
Viele andere Programmiersprachen sind von dem Syntax her C ähnlich.

Der Datentyp int

In der Programmiersprache C gibt es wie bei allen Sprachen mehrere Datentypen, der wichtigste ist hierbei die Zahl.
Genauer die ganze Zahl im englischen wie auch im C Syntax wird dies als Integer bezeichnet und im Quellcode das Kürzel int verwendet.
Dies bedeutet dass eine Variable vom Typen int z.b. den Wert 1, 2, 3 etc. aber nicht 1.5 annehmen kann.
In C wird praktischerweise vieles als Integer behandelt was einem eine einfache Methode zum verarbeiten von Daten bietet.
So kann man zum Beispiel einen Buchstaben auch als Zahl verwenden.

Die Main Funktion

Um überhaupt ein Programm zu erschaffen braucht es bei C immer die sogenannte Main Funktion.
Sie wird bei dem ausführen eines Programms als erste aufgerufen und im Idealfall bildet sie auch den Abschluss.
Im deutschen würde man so etwas als Hauptfunktion bezeichnen.

Diese Funktion ist von dem bereits erwähnten Datentypen int und wird folgendermaßen definiert.
Zuerst wird der Typ der Funktion angegeben (int) danach kommt der Name (main) und in den Klammern können noch Parameter angegeben werden die beim aufrufen dieser übergeben werden.
In den geschweiften Klammern steht der Quellcode der beim aufrufen ausgeführt werden soll.
Dabei bedeutet die Zeile return 0; , dass am Ende die Zahl 0 zurückgegeben werden soll.
Hierbei sei gesagt, dass in der Main Funktion bei Rückgabe von 0 dem Betriebssystem mitgeteilt wird, dass das Programm erfolgreich ausgeführt wurde und der Speicher geleert werden kann.

int main()
{
	return 0;
}

Bibliotheken

Die Bibliotheken funktionieren bei Programmiersprachen fast genauso wie bei Büchern.
In Büchereien findet man in den zahlreichen Büchern die Informationen die man gerade braucht sodass man diese nicht selber recherchieren muss.
Um eine häufig gebrauchte Aufgabe in einem Programm nicht jedes mal von vorne zu programmieren benutzt man Bibliotheken in denen einzelne Funktionen für diese Aufgaben bereits enthalten sind.

Jede Bibliothek besteht dabei aus mehreren Headerdateien in denen wiederum die Funktionen und Datentypen deklariert werden.
Nach dem einbinden der einzelnen Headerdateien über den Syntax #include kann man die in ihnen deklarierte Funktionen verwenden.
Bei Standardbibliotheken werden die Dateinamen zwischen den spitzen Klammern < und > geschrieben.
Dies weist den Compiler an die Headerdatei in den ihm bekannten Bibliotheksverzeichnissen zu suchen.
Falls man eigene Headerdateien im jeweiligen Projektverzeichnis verwenden möchte, nutzt man Anführungszeichen.

Die wichtigsten Bibliotheken unter C sind die von C selbst, in ihnen stehen all die Funktionen und Datentypen die den Syntax von C ergeben.
Um sie einzubinden verwendet man folgenden Quelltext welcher ganz oben stehen muss.
Dabei ist stdio.h die Standardbibliothek für Ein- und Ausgabe und muss bei fast jedem Programm eingebunden werden.
In ihr ist zum Beispiel die Funktion printf, mit der man Text ausgeben kann, enthalten.

#include <stdio.h>

Ausgeben von Text

Um Text in die Konsole auszugeben wird die Druckfunktion (printf) aus der Bibliothek stdio.h verwendet.
Mit ihr kann man nicht nur Text ausgeben sondern über sogenannte Platzhalter in dem auszugebenden Textes auch Werte von Variablen jeden Typs einfügen.
Diese Platzhalter werden in dem Text über das Prozentzeichen gefolgt von dem jeweiligen Buchstabens des Datentyps festgelegt.
Nach dem ersten Parameter, welcher den auszugebenden Text darstellt, wird für jeden Platzhalter der reihe nach Parameter mit den entsprechenden Variablen angelegt.
Über bestimmte Zeichenabfolgen, sogenannte Escapesequenzen, können Textformationen wie beispielsweise ein Zeilenumbruch (\n) in dem Text untergebracht werden.

printf(„Dies ist der Text aus Zeile: %i\n“, 0);
Platzhalter Datentyp
%i Integer (Zahl)
%c Char (Zeichen)
%s String (Text)

Das erste Programm: Hallo Welt

Klassisch ist dass Beispielprogramm Hallo Welt, dank des simplen Aufbaus ist jedoch für diesen Zweck ideal geeignet.
Dafür werden die zuvor erwähnten Elemente verwendet welches in dem nachfolgenden Beispielcode aufgeführt wird.
Diesen speichert man in der Datei namens main.c wobei der Dateiname natürlich beliebig gewählt werden kann wobei die Endung .c notwendig ist um dem Compiler später die verwendete Programmiersprache mitzuteilen.

#include <stdio.h>

int main()
{
	printf(„Hallo Welt!\n“);
	return 0;
}

Erstellen des Quellcodes

Um aus C Quelltext ein Programm zu erstellen braucht es 2 Arbeitsschritte (kompilieren und linken), diese jedoch werden meist beide von dem sogenannten Compiler abgearbeitet.
Dabei wird der Code in Menschen lesbarer Textform zu eine vom Betriebssystem ausführbare Binärdatei verwandelt.
Diese besteht aus Einsen und Nullen welche dem Computer im Grunde Anweisungen geben.

Unter Linux verwendet man am besten den GNU-Compiler gcc welcher in den meisten Fällen entweder bereits vorinstalliert oder in den Paketquellen enthalten ist.
Man findet ihn in dem Paket gcc.

Um nun mit dem Compiler den Quellcode zu kompilieren wechselt man mit einem Terminal in das Verzeichnis in dem die zu kompilierende Quelldatei liegt.
Danach führt man den folgenden Befehl aus.

gcc -o helloworld main.c
Parameter Bedeutung
gcc Aufruf des GNU-Compilers.
-o helloworld Der Buchstabe o steht für output.
Nach einem Leerzeichen folgt der Dateiname welcher für die kompilierte Datei benutzt werden soll.
Im Beispiel wird die Datei helloworld erstellt.
main.c Name der zu kompilierenden Datei.
Im Beispiel wird die Binärdatei aus der Quelldatei main.c erstellt.

Legende von den Fachwörtern

Da man beim Programmieren eine sehr fachbezogene Thematik hat, gibt es für alles immer ein Fachwort.
Um Neulinge nicht gleich ins kalte Wasser zu stoßen findet man in diesem Abschnitt eine kurze Erklärung von Wörtern die man zum Verständnis des Artikels braucht.

Funktionen sind im Grunde Aufgaben, beispielsweise kann eine Funktion zum addieren oder drucken existieren.
Diese können beliebig oft aufgerufen werden ohne immer wieder ihren Quelltext aufschreiben zum müssen.

Parameter sind Angaben welche dynamisch, also nicht immer gleich, sind.
Funktionen enthalten Parameter wie beispielsweise die Funktion addiere den Parameter A und B hat.
Die beiden Parameter A und B werden addiert und dann zurückgeben.

Ausblick

Nächstes mal geht es um den zweiten wichtigen Datentypen Char und dass einlesen von Text mit einem weiteren Beispiel.

Fazit

Durch wenig Aufwand ist man schnell zu einem ersten Programm gekommen und hat dabei erste Grundlagen von C gelernt.
Da dies längst noch nicht alles an den Grundlagen darstellt, möchte ich diese in späteren Artikeln behandeln.

Nachtrag:
Dank eines aufmerksamen Lesers habe ich die, natürlich, falsche Bezeichnung zu Datentyp korrigiert.

Skript – Bildschirmfoto automatisch benennen

Mit Skripten lässt sich nicht nur Zeit sparen sondern sie erleichtern einem auch dass Leben, ein Thema bei dem so manch Autor Zeit aufwendet sind Bildschirmfotos.
So wird beispielsweise nicht nur der Artikel zu einem Spiel geschrieben sondern auch während des Spielens eine menge Bildschirmfotos gemacht um ein paar in dem besagten Artikel zu verwenden.
In diesem Artikel möchte ich zeigen wie man mit einem einfachen Skript diese Arbeit per Tastendruck zu erledigen.
Dabei werden Tools benutzt die bei vielen Distributionen bereits vorinstalliert sind und die mit wenig Aufwand weitere Anpassungen zulassen.

Was brauche ich?

Für die Bildschirmaufnahme wird die weit verbreitete Software gnome-screenshot und für die Tastenkonfiguration dass Systemeinstellungswerkzeug, ebenfalls von dem Gnome Projekt, verwendet.

Falls dass Werkzeug zur Bildschirmfotoerstellung nicht bereits installiert ist kann dies über die
Installation von folgendem Paket getan werden.
Dafür benutzt man den jeweiligen Paketmanager, bei apt würde beispielsweise dieser Befehl genügen.

apt-get install gnome-screenshot 

Das Skript

Als erstes erstellt man eine Datei mit dem späteren Namen des Kommandos welcher auf die Dateiendung .sh enden sollte.
Die erste Zeile gibt an mit welchem Programm diese Datei später ausgeführt werden soll.
Darauf folgend kann man sich über ein Kommentar wichtige Informationen wie dass spätere Tastenkürzel aufschreiben.
Dabei fängt jede Kommentar Zeile mit einer Raute an, diese teilt dem Programm mit dass der folgende Inhalt ignoriert werden soll.

#!/bin/bash
# Tastenkombination: ALT F5

Darauf folgend definiert man zwei Variablen in denen später Informationen gespeichert oder gelesen werden.
Die erste Variable trägt den Name appname und beinhaltet den Titel der Applikation die man derzeit aufnehmen möchte.
Dabei wird sie später benutzt um den ersten Teil des Dateinamen des aufgenommenen Bildschirmfotos zu bilden und muss manuell gesetzt werden.

Die nächste Variable wurde als number benannt und deren Wert wird von dem Skript automatisch gesetzt.
Sie bildet den abschließenden Teil des Dateinamens und wird im nächsten Schritt hochgezählt.

appname="Firefox"
number="0"

In diesem Teil legt man eine sogenannte Zählschleife (for) an welche nach jedem Durchlauf den Wert der Zähl Variable (hier z) solange um einen erhöht bis dieser eine vorher festgelegte Höhe überschreitet.
Mit done signalisiert man das Ende der Schleife und nach dem Durchlauf wird an dieser Stelle zurück zum Anfang der Zählschleife gesprungen.

for ((z=0;z<=100;z++))
do
…
done

Innerhalb der Schleife wird eine sogenannte Bedinge Anweisung (im engl. if statement) ausgeführt.
Bedingte Anweisungen führen den inneren Quellcode nur dann aus wenn ihre Bedingung erfüllt ist.
In diesem Beispiel wird geprüft ob die Datei mit dem Namen schon existiert.
Wem hier der Pfad mit den beiden Dollarzeichen komisch vorkommt dem sei noch gesagt dass diese die beiden Variablen von oben widerspiegeln.
Quellcode der nach then kommt wird immer dann ausgeführt wenn die Bedingung erfüllt ist, in diesem Fall wird die Variable number um einen erhöht.

Um etwas für den Fall dass die Bedingung nicht erfüllt ist zu definieren verwendet man else.
In diesem Beispiel wird der Befehl zum aufnehmen des Screenshots ausgeführt und über break die Anweisung zum vorzeitigen unterbrechen der Zählschleife gegeben.
Ähnlich wie zuvor wird nur der eingerückte (einmal Tabulatortaste drücken) Quelltext ausgeführt.
Um die bedingte Anweisung wieder zu schließen nutzt man einfach dass Wort fi.

if [ -f "/home/username/Bilder/$appname-Screenshot$number.png" ]
	then
		((number++))
	else
		gnome-screenshot --window --remove-border –file="/home/username/Bilder/$appname-Screenshot$number.png"
		break
fi

Dass fertige Shell Skript:

#!/bin/bash
# Tastenkombination: ALT F5
appname="Firefox"
number="0"
for ((z=0;z<=100;z++))
do
	if [ -f "/home/username/Bilder/$appname-Screenshot$number.png" ]
		then
			((number++))
		else
			gnome-screenshot --window --remove-border --file="/home/username/Bilder/$appname-Screenshot$number.png"
			break
	fi
done

Bitte beachten:
In den Codebeispielen wird der Pfad /home/username/…. verwendet, diesen bitte an dass eigene Benutzerverzeichnis anpassen.

Die Tastenkombination

Damit man am ende nur eine Tastenkombination für ein Screenshot betätigt werden muss sollte man diese in den Systemeinstellungen festlegen.
Meist findet man die in den Konfigurationsmöglichkeiten der Tastatur wieder.
In dem Beispiel wird eine eigene Tastenkombination hinzugefügt und als Befehl der Pfad zu dem eben erstellten Skript festgelegt.
Nach einer Bestätigung des Dialoges kann nun jederzeit ein Bildschirmfoto mit den in der vorhin erstellten Datei gesetzten Parametern aufgenommen werden.

Das Tastenkürzel anlegen - Quelle – Bildschirmfoto von Gnome Einstellungsmanager
Das Tastenkürzel anlegen – Quelle – Bildschirmfoto von Gnome Einstellungsmanager

Fazit

Mit so einem Skript lässt sich nicht nur Stück für Stück eine menge Zeit sparen sondern es macht meiner Meinung nach auch eine menge Spaß sie zu erstellen.
Man schafft sich Skript für Skript seine eigene Bibliothek an kleinen Helfern für den Alltag.
Dieses Skript erlässt einem dass lästige aufnehmen und benennen der Bildschirmfotos während man beispielsweise ein Spiel spielt um später einen Artikel darüber zu schreiben.
Darüber hinaus hat man mithilfe diesen kleinen Projektes ein paar Grundlagen aus der Programmierung gelernt.

GIMPThings – Cartoon Hintergrund

In diesem Artikel geht es darum zu zeigen wie man ein Bild mit Cartoon ähnlichem Aussehen mithilfe des freien Bildbearbeitungsprogramms GIMP erstellen kann.
GIMP ist eine vielseitig einsetzbare Software in der man recht schnell zu ersten Erfolgen kommt.
Dabei gibt es zahlreiche Anleitungen im Internet und viele Foreneinträge sodass man fast immer die Lösung zu seinen Problemen findet.
In dem unterem Bild kann man sehen wie das Resultat aus dieser Anleitung aussehen kann.

Quelle - Eigene Grafik
Quelle – Eigene Grafik

Schritt 1

Als erstes öffnet man GIMP und erstellt über den Menüpunkt Neu in dem Reiter Datei eine neue Grafik angelegt.
In dem sich nun öffnen Dialog kann man Breite und Höhe der Grafik in Pixel angeben und anschließend über einen klick mit der linken Maustaste auf Neu bestätigen.
In dem Beispiel werden für die Bildbreite 1920 und für die Bildhöhe 1080 Pixel als Werte verwendet.
Die Auflösung ist beliebig jedoch schlage ich die Auflösung des jeweiligen Monitors für die bestmögliche Qualität vor.

Schritt 2

Nun legt man den eigentlichen Hintergrund an indem man in mehreren kleinen Schritten 3 Balken erstellt.
Dabei Wird zunächst mit dem Auswahlwerkzeug gearbeitet welches man über dass Icon, was wie ein Rechteck mit gestricheltem Rand aussieht, auswählen kann.
Nun müssen noch einige Parameter eingestellt werden um die Arbeit zu erleichtern, daher sollte man bei der Option Fest einen hacken setzten und die Auflösung mit der Breite der Grafik und als Höhe ein drittel von dem Bild angeben.
Bei dem Beispiel wurde eine Auflösung von 1920×360 eingesetzt.
Danach klickt man auf eine stelle oben im Bild und zieht kante oben links bis an den Bildrand.
Dabei kann ein zoomen über STRG + Mausrad hilfreich sein.

Quelle - Bildschirmfoto von GIMP
Quelle – Bildschirmfoto von GIMP

Schritt 3

Folgend wählt man die erste Farbe aus indem man auf die farbige Schaltfläche unter den Icons mit der linken Maustaste klickt.
In dem anschließendem Dialog wählt man eine beliebige Farbe aus, in dem Beispiel wird Blau verwendet.
Um den gleichen Farbton zu bekommen kann man den Farbcode 225d8a in dass Feld HTML-Notation eingeben und auf die Eingabetaste drücken.

Quelle - Bildschirmfoto von GIMP
Quelle – Bildschirmfoto von GIMP

Schritt 4

Nun wählt man dass Füllwerkzeug über dass Icon, welches wie ein Farbeimer aussieht und in der linken Seitenleiste platziert ist, aus.
Danach klickt man auf die in Schritt 3 ausgewählte Fläche mit der linken Maustaste um diese mit der Farbe zu füllen.
Anschließend wiederholt man Schritt 2 bis 4 mit dem Unterschied dass diesmal die Auswahl nach unten verschoben wird.

Schritt 5

Im Anschluss wählt man über die Farbauswahl (Siehe Schritt 3) eine andere Farbe aus, in dem Beispiel wird Rot verwendet.
Um den genauen Farbton zu bekommen gibt man den Farbcode cb4242 in das Feld HTML-Notation ein und bestätigt mit einem druck auf die Eingabetaste.
Danach schließt man den Dialog über die Schaltfläche mit der Aufschrift OK.

Danach füllt man wie in Schritt 4 die mittlere Fläche mit der eben ausgewählten Farbe.
Dabei sollte man sichergehen dass man die Auswahl beendet indem man die Escapetaste betätigt.

Quelle - Bildschirmfoto von GIMP
Quelle – Bildschirmfoto von GIMP

Schritt 6

Jetzt legt man ein Textelement an und wählt seine bevorzugte Schriftart über der Auswahlmöglichkeit, welche im Normalfall mit der Aufschrift Sans unten in der linken Seitenleiste vorzufinden ist, aus.
Anschließend stellt man die Schriftgröße auf 100 und klickt man möglichst in die Mitte des Bildes damit ein Textelement erzeugt wird.
Nun gibt man seinen Wunschtext, zum Beispiel seinen Namen, ein und stellt in der linken Seitenleiste den Wert von der Auswahlmöglichkeit Box von Fest auf Dynamisch.

In dem Beispiel wurden übrigens als Schriftart Ubuntu Bold und der Text DevDiary benutzt.

Darauf folgend wählt man Funktion zum ausrichten von Elementen über dass Icon, welches wie ein Rechteck mit 4 Pfeilen aussieht, aus.
Danach klickt man auf dass eben erstellte Textelement und richtet es in der Mitte aus.
Dies geschieht in dem man jeweils die Buttons, welche 2 Pfeile enthalten, betätigt.

Quelle - Bildschirmfoto von GIMP
Quelle – Bildschirmfoto von GIMP

Schritt 7

Nun wählt man die Ebene mit dem Namen Hintergrund in der rechten Seitenleiste aus und öffnet die Filtereinstellungen von dem Filter Weave welchen man über den Pfad Filter → Künstlerisch → Weave findet.
Den sich nun öffnenden Dialog bestätigt man mit einem klick auf die Schaltfläche OK.

Schritt 8

Zunächst wählt man die Ebene mit der Bezeichnung Eingefügte Ebene in der rechten Seitenleiste aus.
Nun kommt der eigentliche Cartoon Look zustande indem man den Filter Bump-Map benutzt.
Diesen findet man über den Pfad Filter → Abbilden → Bump-Map wobei man dort den Wert Tiefe auf 16 erhöhen muss.
Danach bestätigt man mit OK und hat die fertige Grafik vor sich und kann über den Reiter Datei unter dem Menüpunkt Exportieren seinen Hintergrund als Bilddatei abspeichern.

Quelle - Bildschirmfoto von GIMP
Quelle – Bildschirmfoto von GIMP

Fazit

In 8 mehr oder weniger einfachen Schritten kommt man leicht zu einem schön anzusehenden Hintergrund und hat dabei vielleicht den einen oder anderen Kniff bei GIMP gelernt.
Der Hintergrund kann natürlich ganz leicht ausgetauscht werden in dem man die Ebene Hintergrund noch weiter bearbeitet.
Eine dieser weiteren Möglichkeiten wäre natürlich ein Foto als Hintergrund zu verwenden oder man probiert verschieden Werte an den Tiefen Einstellungen in dem Bump-Map Filter aus.

KurzeTipps – GDB

Wenn man Programmiert kommt es immer mal wieder vor dass dass Programm welches man gerade entwickelt abstürzt und man aufwendig Fehler im Quelltext suchen darf.
Dies ist nicht wirklich beliebt und um dies zu vereinfachen gibt es sogenannte Debugger, sie führen die Software im Grunde aus und beim Absturz zeigen sie auf die jeweilige stelle im Code und geben ein paar Informationen zu der Ursache.
Dies verkürzt häufig extrem die Zeit und den Aufwand um ein Problem zu lösen.
Dass Open Source Programm GDB ist so ein Debugger und entstammt dem Gnu Projekt und ist über die Jahre bei vielen zum Standard-Werkzeug geworden.

Installation

GDB ist in der Distribution Ubuntu bereits enthalten, falls nicht kann mit dem jeweiligen Paketmanager dass Paket GDB nachträglich installiert werden.
Für den Paketmanager APT kann beispielsweise folgender Befehl genutzt werden.

sudo apt-get install gdb

Um bei anderen Programmen noch hinweise zu bekommen gibt es inzwischen für viele Programme Pakete die solche Informationen für GDB bereitstellen.
In der Regel werden diese Paket nach dem Schema <Paketname>-dbg benannt wobei die Abkürzung dbg für Debug steht.
Für die Informationen von der Sprache Python installiert man zum Beispiel dass Paket python-dbg.

Quelle - Eigene Grafik
Quelle – Eigene Grafik

Programm Debuggen

Um ein Programm zu Debuggen ruft man als erstes dieses Kommando in dem Ordner in dem dass bereits fertig kompilierte Programm sich befindet.
Dabei ist nach dem Aufruf von gdb der Name der kompilierten Datei anzuhängen.

gdb Programm

Danach startet GDB und man kommt in eine Art Befehlszeile über die man den Debugger steuert.
Um dass Programm jetzt zu starten genügt der Befehl run und ein druck auf die Eingabetaste.
Dass Programm startet nun ganz normal und ist benutzbar bis es Abstürzt, ab da wird es quasi eingefroren und man kann über dass Kommando c in dem Programm jeweils Aktion für Aktion weiterspringen bis es völlig abstürzt.
Bei jedem Sprung werden Informationen zu der jeweiligen Zeile und dem Fehler ausgegeben.

Um dem Programm noch Argumente zu übergeben kann auch dieser Weg benutzt werden.
Dazu fügt man dem Befehl run noch die Argumente für das jeweilige Programm an.

(gdb) run „arg1“

Steuerung

Es gibt natürlich noch weitere hilfreiche Befehle innerhalb von GDB.
Um die Ausführung eines Programms zum Beispiel abzubrechen genügt die Eingabe von kill innerhalb der Befehlszeile von dem Debugger.

(gdb) kill

Damit man die Befehlszeile von GDB verlässt und den Debugger beendet nutzt man dass Kommando quit.

(gdb) quit
Quelle - Eigene Grafik
Quelle – Eigene Grafik

Mach mal Pause

Um während der Laufzeit eines Programms eine Pause einzulegen gibt es die Möglichkeit mit dem Kommando break in GDB.
Ebenfalls funktioniert auch die Tastenkombination STRG + C sodass man keinen bestimmten Haltepunkt angeben muss.

Befehl Beispiel Beschreibung
break [<Datei>:]<Zeile> (gdb) break main.c:5 Stoppt dass Programm bei der angegebenen Zeile (5). Für den Fall dass das Projekt nur aus einer Quelldatei besteht kann der Dateiname (main.c) weggelassen werden.
break <Funktion> (gdb) break main Beim Aufruf der angegebenen Funktion (main) wird der Programmablauf unterbrochen. (Nur bei Verwendung von der Programmiersprache C)
break <member/Funktion>(<Argumenttypen>) (gdb) break widget::init(int, int) Bei C++ muss immer die volle Signatur angegeben werden, selbst wenn die Funktion nicht überladen ist.

Programmablauf beeinflussen

Normalerweise brauchen Menschen Anhaltspunkte welches meiner Meinung nach auch einer der Gründe für die weite Verbreitung von Zeilenangaben bei Entwicklern ist.
In den meisten Fällen kann man dadurch vielleicht Indirekte Fehler, solche die zu dem eigentlichen Fehler führen, finden wobei dort die von GDB ausgegebene Zeile aus dem Quelltext wenig hilft.
Mithilfe von list gibt GDB 10 Zeilen des aktuellen halt von dem Quellcode aus, so lassen sich Problemquellen schneller identifizieren.

(gdb) list

Um dass Programm bis zum nächsten Unterbruch weiterlaufen zu lassen kann der Befehl continue verwendet werden.

(gdb) continue

Damit nur eine Zeile weiter gesprungen wird benutzt man dass Kommando next, dabei bleibt man auch in der aktuellen Ebene.
Dass bedeutet dass nicht zwischen im Quellcode aufgerufene Funktionen hin und her gesprungen wird.
Um diese Regel zu ignorieren und damit Funktionen nutzbar machen kann wird der Befehl step verwendet.
Jetzt kann der Befehl finish hilfreich sein, er beendet die derzeitige Funktion und kehrt zu der Funktion zurück aus der diese aufgerufen wurde.

Zeit sparen durch Manipulation

Um nicht jedes mal eine Variable im Quelltext zu ändern, zu kompilieren um dann wieder einen Fehler festzustellen gibt es die Möglichkeit Variablen während der Ausführung eines Programms über den Debugger zu verändern.
Dies ist besonders hilfreich bei Funktionen die auf den Berechnungen vorheriger aufbauen und so schnell Fehleranfällig werden.

Werte von Variablen können über den print-Befehl ausgegeben und mithilfe von set verändert werden.

(gdb) print i
$1 = 10
(gdb) set var i = 1
(gdb) print i
$4 = 1

Abschließend sei noch anzumerken dass ich hier selbstverständlich nicht alle Funktionen des freien Debuggers GDB zeigen konnte.
Wer mehr darüber erfahren möchte kann sich den Eintrag zu GDB im Ubuntuusers Wiki mal anschauen und die man-page von GDB durchstöbern.

GIMPThings – Hintergrund einer Blaupause

Mit diesem Artikel möchte ich gleich eine neue Kategorie, die den Namen GIMPThings trägt, in meinem Blog einführen.
Unter ihr werde ich zukünftige Artikel zu dem Thema Dinge mit GIMP erstellen sammeln.
In diesem Artikel geht es darum zu zeigen wie man den Hintergrund einer sogenannten Blaupause (Blueprint) mit dem freien Bildbearbeitungsprogramm erstellen kann.
Blueprints werden im übrigen oft für Konstruktionszeichnungen, wie zum Beispiel Baupläne für eine Maschine oder ein Haus, verwendet.

Schritt 1

Als erstes öffnet man dass Programm GIMP welches falls nicht bereits installiert, über den Paketmanager installiert werden kann.
Dort wird über den Menüpunkt Neu im Reiter Datei der Dialog zum erstellen einer neuen Grafik geöffnet.
Dort passt man die Werte Breite und Höhe an die jeweils gewünschte Auflösung des späteren Hintergrundes an, in meinem Fall habe ich für die Breite 1920 und für die Höhe 1080 Pixel gewählt.
Schließlich klickt man auf OK um die neue Grafik zu erstellen worauf dass Programm automatisch die Grafik zum bearbeiten öffnet.

Quelle - Bildschirmfoto von GIMP
Quelle – Bildschirmfoto von GIMP

Schritt 2

Rechts befindet sich eine Leiste in der eine Vielzahl von Icons zu sehen ist, darunter eine farbige Schaltfläche mithilfe der man die derzeitige Farbe wechseln kann.
Diese klickt man nun mit der rechten Maustaste an und wählt in dem sich öffnen Dialog die gewünschte Farbe aus.
Für diese Anleitung empfehle ich ein bestimmtes Blau welches man über die Eingabe des Farbcodes 1f557e in dem Feld HTML-Notation und ein druck auf die Eingabetaste auswählen kann.
Nach der Auswahl der Farbe bestätigt man mit OK und der Dialog schließt sich wieder.

Quelle - Bildschirmfoto von GIMP
Quelle – Bildschirmfoto von GIMP

Schritt 3

Nachdem man die erste Farbe für den Hintergrund ausgewählt hat (Schritt 2) wählt man dass Füllwerkzeug aus.
Dazu klickt man mit der rechten Maustaste auf dass Icon welches wie ein Eimer aussieht und sich Links in der Werkzeugleiste befindet.
Danach klickt man mit rechts auf die weiße Fläche in der Mitte des Programms.
Die weiße Fläche sollte nun blau sein, falls nicht hat man hier einen Fehler gemacht und sollte die vorherigen Schritte noch einmal überprüfen.

Quelle - Bildschirmfoto von GIMP
Quelle – Bildschirmfoto von GIMP

Schritt 4

Nun muss man eine andere Farbe auswählen dazu wiederholt man den Schritt 2 mit der Ausnahme dass man nun den Farbcode 225d8a verwendet.
Dabei habe ich den Schwarzwert (S) von der Farbe aus Schritt 2 um 4 Stufen erhöht was die Farbe heller als die vorherige macht.
Dieser Effekt ist meiner Meinung nach typisch für eine Blaupause.

Quelle - Bildschirmfoto von GIMP
Quelle – Bildschirmfoto von GIMP

Schritt 5

In diesem Schritt wird dass Muster durch die Verwendung eines sogenannten Filters erzeugt.
Filter sind im Grunde kleine Programme die vorgeben wie ein Bild verändert wird und dabei meist mehre Parameter besitzen mit denen man dass Resultat anpassen kann.
Für diese Anleitung verwendet man den Filter mit dem Namen Raster welchen man über den Pfad Filter → Render → Muster → Raster aufrufen kann.
Dabei ist es wichtig dass bevor dieser dass Erste mal seit Programmstart aufgerufen wird die Farbe feststeht da sonst die Farbe über die drei unteren Buttons im nachfolgenden Dialog nachträglich geändert werden muss.
Nach einem Rechtsklick auf den Filternamen (Raster …) öffnet sich ein Dialog den ihr nur über einen weiteren Rechtsklick auf OK bestätigt.
Ist alles Ordnung so ist in der mittigen Fläche des Programms nun ein Muster erkennbar, dies ist nun unsere Blaupause (Blueprint).

Quelle - Bildschirmfoto von GIMP
Quelle – Bildschirmfoto von GIMP

Schritt 6

Als letztes Exportiert man den Hintergrund als eine Bilddatei, ich empfehle hierbei dass Format PNG zu verwenden da es weit verbreitet ist und fast überall unterstützt wird.
Dazu ruft man über den Menüpunkt Exportieren unter dem Reiter Datei mit einem Linksklick auf danach wählt man in dem Dialog Dateiname und Speicherort aus und bestätigen mit OK.
Nun hat man die Bilddatei von dem eben erstellen Hintergrund und kann diese gleich in den Einstellungen dem Arbeitsplatz als Hintergrundbild zuweisen.

Quelle - Bildschirmfoto von GIMP
Quelle – Bildschirmfoto von GIMP

Fazit

Mit 6 einfachen Schritten kann man ganz leicht seinen eigenen Blaupausenhintergrund erstellen, dabei kann dieses Tutorial natürlich auch als Basis für fortgeschrittener Projekte dienen.
Falls man mag können auch verschiedene Farben ausprobiert und mit den Parametern für den Filter experimentiert werden.
Weitere infos zu der freien Bildbearbeitungsmöglichkeit gibts unter anderem in dem Wikieintrag von GIMP bei Ubuntuusers.

KurzeTipps – Make

Ein bei mir recht häufig zum Einsatz kommendes Werkzeug ist Make.
Es ermöglicht über einen Befehl (make) ein Programm vollkommen automatisch zu kompilieren ohne Ellen lange Parameter und Dateinamen eingeben zu müssen.

Make kann bereits auf eine lange Geschichte zurückblicken und ist bei vielen Entwicklern beliebt.
Unter den vielen Implementierungen sind wohl die bekanntesten die Gnu und die BSD Varianten.
Jedoch sind die Implementierungen untereinander nicht immer Kompatibel zu einander.
In diesem Artikel gehe ich auf das in den Standard Quellen von Ubuntu bereits enthaltene Gnu make ein.

Installation:

Um make auf dem eigenem Rechner zu installieren kann beispielsweise dass Paketverwaltungssystem apt verwendet werden.

sudo apt-get install make

Das Regelwerk: Makefiles

Gesteuert wird dass Programm über sogenannte Makefiles die in dem jeweiligen Verzeichnis gespeichert sind.
Diese sind im Grunde einfache Textdateien in denen Konfigurationen angeben und Regeln aufgestellt werden.

CC = gcc

In der ersten Zeile definiert man meist den Compiler den man verwenden möchte, in diesem Beispiel wird gcc verwendet.
Dabei funktioniert die Zeile in etwa so wie eine Definition (define) in der Programmiersprache C.
Von nun an kann CC überall da eingesetzt werden wo der Compiler angeben werden soll.

OBJECTS = cbg.o

In dieser Zeile werden die zu Kompilierenden Quelldateien angegeben.
Bei diesem Beispiel wird der Dateiname und anschließend .o statt .c angeben, genauer soll der Quellcode aus der Datei cbg.c kompiliert werden.

%.o: %.c
        $(CC) -c $(CFLAGS) $<

Später kommen solche Regeln zum Einsatz, sie geben an wie etwas geschehen soll.
In diesem Fall beschreibt die Regel wie aus einer .c Quelldatei eine .o Objektdatei erstellt wird.
$< wird als alias für den jeweiligen Dateinamen verwendet, vergleichbar ist dieses Konstrukt mit einer for Schleife wobei $< dann z.B. die Variable i darstellt.

Hier ein Beispiel wie ein komplettes Makefile aussehen kann:

CC = gcc
OBJECTS = cbg.o
LIBS = -lglib-2.0
CFLAGS = -Wall -O2
BINDIR = $(DESTDIR)/usr/bin
NAME = cbg

cbg: $(OBJECTS)
        $(CC) -o $(NAME) $(OBJECTS) $(LIBS)

%.o: %.c
        $(CC) -c $(CFLAGS) $<

install:
        install --mode=755 $(NAME) $(BINDIR)/

clean:
        rm *.o $(NAME)

uninstall:
        rm $(BINDIR)/$(NAME)

Auf mein Kommando : make

Um den Vorgang zu starten genügt der Befehl make welcher, in dem selben Verzeichnis in dem auch dass Makefile liegt, ausgeführt wird.

Wird nur der Befehl make ohne weitere Argumente verwendet wird dass Programm einfach nur erstellt.

In dem oben stehenden Beispiel gibt es noch weitere Möglichkeiten, so kann etwa mit make clean automatisch Aufgeräumt werden.
Beim Aufräumen werden dann alle Objektdateien und die Binärdatei gelöscht, dies ist beispielsweise bei der Verwendung eines Versionsverwaltungssystem, wie Git, recht nützlich.

Abschließend sei noch anzumerken dass make noch vieles mehr kann als ich in diesem Artikel beschrieben habe.
Wer interessiert ist kann sich einmal die manpage zu make anschauen.

KurzeTipps – arecord

Manchmal braucht man nur ein kleines Tool dass eine einzige Aufgabe zu erledigen hat, dieses Werkzeug sollte aber immer zur Verfügung stehen sodass man nicht viel Aufwand betreiben muss um es zu benutzen.
Ein solches Tool habe ich letztens benötigt als es darum ging Audioaufnahmen für mein derzeit in Entwicklung befindliches Spiel zu machen.

Dabei bin ich im Ubuntuusers Wiki auf „arecord“ gestoßen welches zu ALSA gehört und daher auf allen Ubuntu-Installationen bereits vorinstalliert ist.

Aufnehmen

Um mit „arecord“ aufzunehmen genügt dieser kleine Befehl:

arecord -D default -f cd foo.wav 

Damit wird aus dem in den Audioeinstellungen ausgewählten Mikrofon in eine WAV Datei mit 44.1 KHz und 16-Bit-Auflösung (das Format einer Audio-CD) aufgenommen.
Es lassen sich noch weitere Anpassungen vornehmen, mehr dazu in der jeweiligen manpage.

KurzeTipps – Die Befehle diff und patch

Wer sich mit Programmieren beschäftigt stößt garantiert irgendwann auf dass Thema Versionskontrolle.
Die nützliche Methode ermöglicht eine leichte Verwaltung von Quellcode und wird über kurz oder lang zu eines der Standard Werkzeuge eines jeden Programmierers.
Neben der Möglichkeit sich Systeme wie Git, Bzr und weite zu installieren ist aber jeder Linux-Standardinstallation schon die Basis für die Quellcodeverwaltung schon enthalten.

Die Befehle diff und patch ermöglichen die Änderungen von einer modifizierten Version der Originaldatei in dass Original zu übernehmen.
Dabei können bei jedem Vorgang auch Backups angelegt werden und Änderungen auch wieder rückgängig gemacht werden.

Schritt 1

Als erstes muss eine diff Datei über den Befehl diff angelegt werden.
Dazu benutzt man den folgenden Befehl und ändert die Namen in diesem auf die eigenen.

diff -uNr „main.c“ „main_patch.c“ > „main_patch.diff“

Argumente

Argument Beschreibung
-u (unified) Es werden NUM (Standard 3) von unveränderten Zeilen ausgeben.
-N (New) Die fehlenden Dateien werden erstellt.
-r (rekursiv) falls vorhanden werden die Unterverzeichnisse verglichen.

Der Befehl bewirkt dass die Änderungen von der Datei „main_patch.c“ gegenüber der Ursprungsdatei „main.c“ in „main_patch.diff“ geschrieben werden.

Schritt 2

Nun wird die Originaldatei mithilfe der diff Datei gepatcht.
Dazu wird der Befehl patch verwendet wobei auch hier die Dateinamen auf die eigenen abgeändert werden müssen.

patch -p1 „main.c“ < „main_patch.diff“

Argumente

Argument Beschreibung
-pNUM Zieht von dem Dateinahmen NUM führende Komponenten ab.
-R Macht ein zuvor angewendeten Patch wieder rückgängig.

Nun werden die Änderungen welche in der Datei „main_patch.diff“ protokolliert wurden in die Ursprungsdatei „main.c“ übernommen.

Schritt 3

Um dass ganze wieder rückgängig zu machen braucht man nur die Ursprungsdatei und die jeweilige diff Datei.
Die Befehlsstruktur ist ähnlich der von Schritt 2 und hat vor der Angabe der Anzahl von Striplevel (-p1) noch dass Argument „-R“.

patch -R -p1 „main.c“ < „main_patch.diff“

Nun wird genau dass Gegenteil von Schritt 2 gemacht und z.b. alle Änderungen die in der diff Datei stehen und etwas hinzufügen sollen gelöscht.

SideAway – Erste Alpha Version veröffentlicht

SideAway ist ein neues Projekt von mir welches ein kleines Jump and Run Spiel ist.
Dabei habe ich die Programmiersprache C und die Bibliotheken SDL und GLib verwendet und versucht den Quelltext für Simple zu halten damit Leute die sich mal an einem eigenem kleinem Spiel mit SDL versuchen wollen dies als Basis nutzen können.
Dass Spiel hat auch ein eigenes Levelsystem mit dem auch ohne ändern des Quelltextes eigene Level relativ einfach erstellt werden.
Wer interessiert ist kann sich gerne einmal die Projektseite dazu anschauen.
Dass Projekt ist OpenSource und auf der Projektseite findet sich auch der Link zu dem Launchpad-Projekt.

Hier ein Bildschirmfoto wie es aktuell aussieht:

Quelle - Bildschirmfoto von SideAway
Quelle – Bildschirmfoto von SideAway

Viel Spaß beim ändern des Quelltextes.

Hardware – Raspberry Pi gekauft und nun?

Der Raspberry PI ist ein 30 Euro Mini Computer auf dem Linux läuft und der über Ein und Ausgänge ähnlich dem Arduino verfügt.
Zusätzlich ist die Hardware Open Source und somit kann jeder sich einen Raspberry Pi selber Zusammenlöten falls Interesse besteht.
Mit 30 Euro eignet er sich also Ideal für Projekte bei denen der Einsatz eines großen PCs entweder vom Stromverbrauch oder der Verlust durch einen Fehler zu teuer werden.
Damit man sofort Loslegen kann möchte ich hier alles über den ersten Start damit zusammenfassen.

20140206-114039.jpg
Quelle – Foto von Marc Volker Dickmann

Vorbereitung

Damit nach der Lieferung der Spaß sofort beginnen kann sollten einige Dinge zuvor geprüft werden.
Ein Beispiel ist die Notwendigkeit eines HDMI Monitors oder einen Monitor mit Chinch Eingang (Gelb) der zumindest für die Installation notwendig sein wird.
Der Monitor muss danach aber nicht weiter an den Pi angeschlossen sein da nach der Installation des Betriebssystems alles weitere über dass Netzwerk erledigt werden kann.

Daneben ist eine USB Tastatur für die Installation ebenfalls erforderlich welche genau wie der Monitor nur für die Installation des Betriebssystems erforderlich ist und danach wieder dem Ursprünglichen Zweck zurückgeführt werden kann.

Der PC und der Kartenleser wird für dass Kopieren der Betriebssystemdaten auf die SD Karte gebraucht.
Nach der Installation wird der PC für die weitere Konfiguration und Steuerung des Raspberry Pi’s verwendet.

Voraussetzungen

– Einen Monitor mit HDMI oder Video Chinch (Gelb)
– Ein HDMI oder Video Chinch (Gelb) Kabel
– Eine USB Tastatur
– Einen SD Kartenleser für den PC
– Einen PC

Quelle - Foto von Marc Volker Dickmann
Quelle – Foto von Marc Volker Dickmann

Einkauf

Wer noch Raspberry Pi gekauft hat kann sich beispielsweise einen bei Reichelt bestellen.
Damit dass einfacher geht habe ich hier eine Liste mit Erklärung sowie einen Link über den alle nötigen Teile in den Warenkorb von Reichelt gelegt werden können.

Bei dem Raspberry Pi handelt es sich um einen Einplatinencomputer was bedeutet dass auf der Mainboardplatine bereits alles Komponenten wie CPU und GPU fest installiert sind.
Einplatinencomputer sind meist klein und für einen erschwinglichen Preis im Fachhandel oder über dass Internet beziehbar.
Besonders für Leute die Elektronik mit dem Computer steuern wollen sind Einplatinen Computer Ideal und im Internet findet man eine breite Auswahl an Projekten wie beispielsweise eine Kaffeemaschine die über dass Internet gesteuert werden kann.

Für den Raspberry Pi gibt es aktuell 3 Versionen die ihre eigenen Vorteile haben allerdings ist die 3. Version (B+) noch ganz neu und daher nicht überall erhältlich und somit empfehle ich erst mal die Version B.
Die dritte Version gleicht der B was die Systemleistung angeht und bringt nur einige Verbesserungen wie mehr GPIO Pins, 2 USB Buchsen mehr usw. mit.
Die Version B bietet immerhin 512 MB Arbeitsspeicher, 10/100 MB Ethernet sowie einen 700 MHZ schnellen Prozessor.
Die GPU ist dabei in dem Prozessor eingebaut jedoch leistungsfähiger als die CPU und somit ideal für komplizierte Berechnungen.

Vorsicht ist bei dem Kauf über Amazon und dergleichen da es einen Qualitativ minderwertigen Nachbau aus China gibt der dort oft vertrieben wird.

Um den Raspberry Pi mit Strom zu versorgen ist ein Netzteil mit Micro USB Ausgang und 5V Spannung sowie etwa 1000mA erforderlich.
Wer viele USB Geräte an dem Raspberry Pi betreiben möchte sollte je nach Anzahl einen USB-Hub mit eigener Stromversorgung oder ein Stärkeres Netzteil (1500mA usw.) kaufen.

Was im Computer eine Festplatte ausmacht wird beim Raspberry Pi auf ein SD Karte verlagert und daher sollte man bei dem Kauf auf eine Schnelle SD Karte von einem Markenhersteller wie beispielsweise ScanDisk zurückgreifen.
Da fast alle Daten auf der SD Karte lagern sollte eine der Datenmenge entsprechende Speicherkapazität gewählt werden.
Für die meisten Fälle reicht eine 8GB große SD Karte vollkommen aus.
Damit der Raspberry Pi schnell genug läuft habe ich mir eine SDHC Karte von ScanDisk mit bis zu 30MB Lesegeschwindigkeit und 8GB Speicherkapazität ausgesucht.

Um den Pi vor Elektrostatischer Aufladung (zb. Haustieren) zu schützen empfehle ich ein Gehäuse gleich mit zu bestellen.
Wer plant seinen Pi offen an Wänden oder der gleichen aufzuhängen sollte vielleicht auch auf ein Gehäuse welches zu seinem Geschmack passt zurückgreifen.
Ich habe hierbei ein Gehäuse auf dem ein Taschenrechner aufgedruckt ist ausgewählt.

Den Link zu dem Warenkorb bei Reichelt findet ihr hier ansonsten sind die Produkte sicher auch über den Namen bei eurem Lieblingsshop auffindbar.

Materialliste

– Raspberry Pi Rev. B – 29.95 Euro
– TEK-BERRY CALC – 5.95 Euro
– ANS DUAL MICRO – 6.50 Euro
– SanDisk Ultra – Class 10 (8GB, SDHC, 30MBs) – 7.40 Euro

Gesamt – 49.80 Euro (+ 5.60 Euro Versand = 55.40 Euro)

Quelle - Foto von Marc Volker Dickmann
Quelle – Foto von Marc Volker Dickmann

Installation

Der Aufbau des Raspberry Pi ist einfach und schnell vollbracht die SD Karte kommt oben rein und der HDMI, Strom etc in die jeweiligen Ports.
Um dass Betriebsysten später von der SD Karte installieren zu können müssen nun die dafür erforderlichen Daten auf diese Kopiert werden.
Als Beispiel für diesen Artikel habe ich dass auf Debian basierende Raspbian genommen welche über die Raspberry Pi Webseite hier heruntergeladen werden kann.

Unter Linux kann dass Kopieren der Dateien aus der img Datei über den Praktischen Befehl

dd bs=4M if=wheezy-raspbian.img of=/dev/sdd

Bitte /dev/sdd an den Ort eurer SD Karte und wheezy-raspbian.img an die img Datei anpassen.
geschehen.

Danach müssen Monitor und USB Tastatur mit dem Raspberry Pi verbunden und die SD Karte eingelegt werden.
Ab jetzt kann der erste Start des Pi’s losgehen.

Nachdem der Pi hochgefahren ist wird bei dem ersten mal automatisch ein Dialog zur Konfiguration gestartet mit dem wir wichtige Dinge einfacher erledigen können.
Als erstes klicken wir auf Expand Filesystem um auch wirklich den gesamten Speicherplatz auf der SD Karte benutzen zu können.

Nun können wir noch unter Advanced SettingsHostname einen Namen für den künftigen Pi festlegen und über Finsh ihn Neustarten.
Danach kann man sofort Loslegen und beispielsweise ein Projekt starten.

Quelle - Foto des Raspberry Pi Model B+ von Marc Volker Dickmann
Quelle – Foto des Raspberry Pi Model B+ von Marc Volker Dickmann

Erstes Projekt

Als erstes Projekt habe ich mir die Bereitstellung von einer Speichermöglichkeit in dem lokalen Netzwerk, also einer NAS, ausgedacht welches ziemlich nützlich sein kann.

Materialliste

– 1x USB Stick (Größe ist unwichtig)
– 1x Raspberry Pi Aufbau (von eben)
– 1x PC

Als erstes wird der USB Stick mit dem Raspberry Pi verbunden und der Pi gestartet.
Von nun an kann schon über dass Protokoll SFTP auf den USB Stick über dass Netzwerk zugegriffen werden und dort Daten abgelegt sowie abgerufen werden.

Auf einem Linux System kann über die meisten Dateimanager über die folgende Adresse auf den Pi zugegriffen werden.

sftp://[nutzername]@[ip des pi's]

Danach kann man die Dateien über den Dateimanager auf den Pi hoch und herunterladen.

Tipp:
Den USB Stick solltest du unter dem folgendem Pfad finden.

/media/[nutzername]/[gerät]

Fragen und Antworten

F: Wofür kann der Raspberry Pi ideal verwendet werden?
A: Er eignet sich bedingt durch seinen geringen Preis und dem niedrigen Stromverbrauch ideal um Elektronische Geräte beispielsweise über dass Internet zu steuern.
Weiter kann durch ihn auch der erste Einstieg im sogenannten Cluster Rechnen (Supercomputer) gewonnen werden.

F: Wie niedrig ist der Stromverbrauch des Raspberry Pi’s wirklich?
A: Der Raspberry Pi verbraucht etwa soviel wie ein Handyladegerät was im Vergleich zu den Möglichkeiten ziemlich niedrig ist.

F: Wie Groß ist der Raspberry Pi?
A: Der Raspberry Pi ist etwa so groß wie eine Kreditkarte.

F: Welches Betriebssystem läuft auf dem Pi?
A: Es läuft ein Linux System wie beispielsweise Raspbian die speziell für arm Geräte entwickelt worden sind.

Fazit

Der Raspberry Pi’s ist ein wirklich nützlicher Begleiter vor allem für Bastler, Entwickler und co die hier einen vollwertigen Computer mit extrem wenigem Stromverbrauch für kleines Geld gestellt bekommen.
Durch die winzige Größe und GPIO Pins eröffnen sich nahezu unendliche Möglichkeiten und dank des Internet gibt es laufend neue Projekte sowie die passenden Anleitungen dazu.
Ich finde die Investition lohnt sich auch für Leute die noch neu in dem Bereich Technik sind und schnell etwas lernen wollen.