Die Projektübersicht von OpenCores

Gegründet im Oktober 1999 von Damjan Lampret, gibt es auf den Webseiten des Projektes eine Reihe von offenen Rechenwerken bis hin zu ganzen Prozessoren. Geschrieben ist das ganze meist in einer Hardwarebeschreibungssprache wie VHDL, Verilog oder SystemVerilog. Die Lizenzen variieren je nach Projekt meist zwischen der LGPL oder einer BSD Lizenz.

Aus diesem Grund habe ich für das Extrahieren eines Subprojektes aus einem Git Repository ein Skript geschrieben:

#!/bin/sh
# extractSubproject <orignal repopath> <new repopath> <subfolder> <new remote (optional)>

# clone repository
git clone --no-hardlinks $1 $2

# extract subproject
cd $2
git filter-branch --subdirectory-filter $3 HEAD
git reset --hard
git remote rm origin
rm -r .git/refs/original/
git reflog expire --expire=now --all
git gc --aggressive
git prune

# Add optional remote and push
if [ "$4" != "" ]; then
git remote add origin $4
  git push origin master
fi

Heruntergeladen werden kann sich das Skript auch unter https://github.com/seeseekey/archive/blob/master/Bash/Git/extractSubproject.sh.

sn –k keypair.snk

Das Tool befindet sich dabei im Windows SDK Ordner (z.B. C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A) wobei sich die Version des SDKs durchaus unterscheiden kann. Die erzeugte Snk-Datei wird dabei dem Projekt hinzugefügt. Anschließend stellt man in den Projekteinstellungen unter „Signing“ die entsprechende Datei ein. In diesem Tab ist es auch möglich eine neue Schlüsseldatei zu generieren, so das man für den Schritt der Erzeugung nicht auf das „Strong Name Utility“ angewiesen ist.

Die Projektoptionen im Visual Studio

Bei der Signierung ist es wichtig darauf zu achten, das alle Bibliotheken ebenfalls mit einem Strong Name versehen sind, sonst verweigert das Studio die Signierung der Anwendung. Möchte man aus dem signierten Assembly den öffentlichen Schlüssel extrahieren, so kommt wieder das „Strong Name Utility“ zur Anwendung:

sn -e Assembly.exe public.pk

Das Schlüsselpaar welches man erzeugt hat, kann man dabei für alle eigenen Anwendungen benutzen. Es ist nicht nötig, für jede Anwendung ein eigenes Schlüsselpaar zu erzeugen, da sich der „SimpleName“ bei jedem Assembly unterscheidet.

Weitere Informationen gibt es unter:
http://msdn.microsoft.com/en-us/magazine/cc163583.aspx
http://msdn.microsoft.com/en-us/library/h4fa028b%28v=vs.80%29.aspx

Der Realtek HD Audio-Manager

Das liegt allerdings nicht daran, das es nicht gehen würde, aber meist fehlt der „Realtek HD Audio-Manager“ welcher dafür sorgt das man die Anschlüsse konfigurieren kann. Wenn man diesen herunterlädt (in den Treibern enthalten) und anschließend etwas an die Eingänge steckt, so wird man gefragt wie der Anschluss (Eingang, Ausgang) konfiguriert werden soll.

Als Lösung für das Problem wird Gitolite für die Nutzer und Rechteverwaltung genutzt. Im ersten Schritt werden auf dem Server die notwendigen Pakete installiert:

sudo apt-get install git openssh-server perl

Als nächster Schritt wird der Nutzer angelegt, in welchem Gitolite läuft und in diesen gewechselt:

sudo useradd -m git
sudo su git

Danach geht es auch schon an die Installation von Gitolite:

cd ~
git clone git://github.com/sitaramc/gitolite
mkdir bin
cd gitolite
./install -ln

Anschließend muss der öffentliche SSH Schlüssel von dem Rechner mit welchem auf das System zugriffen werden soll in den Home Ordner des „git“ Nutzers kopiert werden. Anschließend kann das Setup abgeschlossen werden:

cd ~/bin
./gitolite setup -pk $HOME/seeseekey.pub

Damit ist das Setup abgeschlossen und es kann an die Konfiguration gehen. Dazu wird vom Rechner dessen Public Key beim Setup benutzt wurde das entsprechende administrative Repository geklont:

git clone git@192.168.1.128:gitolite-admin

Die Dateistruktur des Repositories sieht dabei wie folgt aus:

conf
  gitolite.conf
keydir
  seeseekey.pub

In dem Verzeichnis „keydir“ sind die SSH Schlüssel enthalten. Um einen Nutzer hinzuzufügen reicht es einfach einen neuen öffentlichen Schlüssel in das Verzeichnis zu legen und das ganze ins Git Repository einzubringen. Die eigentliche Konfiguration der Repositories erfolgt in der „gitolite.conf“ Datei. Diese sieht nach der Erzeugung so aus:

repo gitolite-admin
    RW+     =   seeseekey

repo testing
    RW+     =        @all

Das bedeutet das es zwei Repositores gibt, eines trägt den Namen „gitolite-admin“ und dient der Verwaltung. Das zweite Repository ist „testing“ auf das alle Nutzer zugreifen dürfen. Benötigt man nun ein neues Repository, so fügt man einen neuen „repo“ Abschnitt mit dem Namen und den entsprechenden Rechten hinzu. Sobald das ganze commitet und gepusht wurde, legt Gitolite das neue Repository an. Wenn man bei den Schlüsseln mehrere SSH Schlüssel pro Nutzer wünscht, so legt man dafür am besten eine Verzeichnisstruktur an:

keydir
  seeseekey
    rechner1
      seeseekey.pub
    rechner2
      seeseekey.pub

Möchte man ein Repository löschen so entfernt man es aus der „gitolite.conf“ und löscht es anschließend auch vom Server. Damit hat man eine Lösung für Git Server mit mehren Nutzern und und entsprechender Verwaltung.

sudo apt-get install avahi-daemon cups cups-pdf

Nach der Installation geht es an die Konfiguration. Dazu wird die „cupsd.conf“ bearbeitet:

sudo nano /etc/cups/cupsd.conf

Den Sektionen „<Location />“, „<Location /admin>“ und „<Location /admin/conf>“ wird dabei die Zeile:

Allow @Local

hinzugefügt. Daneben sollte noch die Zeile:

Listen <IP Adresse>:631

hinzugefügt werden. Das sorgt dafür das auf dem passenden Interface gehorcht wird. Danach geben wir in der Konsole folgendes ein:

sudo adduser pi lpadmin
sudo service cups restart

Damit wird der Nutzer „pi“ der Gruppe der Nutzer hinzugefügt welche Einstellungen vornehmen dürfen. Außerdem wird der CUPS Service neugestartet, so das die Änderungen in der Konfigurationsdatei wirksam werden. Nun kann sich über die URL:

https://<IP Adresse>:631

mit dem Webinterface von CUPS verbunden werden.

Das CUPS Webinterface

Im Webinterface wird nun unter dem Tab „Verwaltung“ der Punkt „Freigeben von Druckern welche mit diesem System verbunden sind“ aktiviert. Bestätigt wird das ganze mit den Zugangsdaten des Nutzers „pi“. Abschließend klickt man auf den Button „Verfügbare Drucker auflisten“ und fügt die angeschlossenen Drucker hinzu und gibt ihn frei. Dazu muss das passende Modell ausgesucht und bestätigt werden.

Anschließend kann man den Drucker in seinem Betriebssystem hinzufügen und über den Raspberry Pi drucken. Sollte wieder erwarten kein Druck stattfinden, so liegt das meist am falsch gewählten Druckertyp. Mit der beschriebenen Konfiguration lässt sich auch von iOS Geräten mittels AirPrint druchen.

manage-bde -status

ein. Die Ausgabe zeigt dann wie es um die Verschlüsslung steht:

Volume "C:" [System]
[Betriebssystemvolume]

    Größe:                    4492,21 GB
    BitLocker-Version:        Windows 7
    Konvertierungsstatus:     Verschlüsselung wird durchgeführt
    Verschlüsselt (Prozent):  44 %
    Verschlüsselungsmethode:  AES 128 mit Diffuser
    Schutzstatus:             Der Schutz ist deaktiviert.
    Sperrungsstatus:          Entsperrt
    ID-Feld: Kein

Wichtig ist dabei, das die entsprechende Konsole als Administrator gestartet wurde, sonst schlägt das Kommando fehl.

Für einen Raspberry Pi, Airplay Server benötigt man:

• einen Rapsberry Pi
• ein Gehäuse für den Pi
• einen WLAN Stick
• ein paar Boxen

Im ersten Schritt sollte man sich eine Raspberry Pi Distribution herunterladen, in diesem Fall wird Raspian benutzt. Dazu wird das Image heruntergeladen und entpackt. Anschließend hat man auf dem Rechner eine .img Datei. Diese muss nun auf die SD Karte geflasht werden. Um herauszufinden, welches Volume nun geflasht werden muss, kann man sich auf dem Terminal unter Mac OS X mittels „df -h“ anschauen welches Gerät dazukommt. Eine andere Möglichkeit ist es die Karte über den Namen zu identifizieren, welcher bei neuen Karten meist „NO NAME“ oder „Untitled“ sein sollte.

Wenn das passende Gerät identifiziert wurde, sollte die gemountete Partion mittels:

diskutil unmount /dev/disk2s1

wieder freigegeben werden. Nun wechselt man im Terminal in den Ordner in welchem die Imagedatei liegt und gibt dabei folgendes ein:

sudo dd bs=1m if=raspbian.img of=/dev/rdisk2

Zu beachten ist dabei das aus „disk2s1“ -> „rdisk2“ wird, womit das Gerät direkt angesprochen wird. Theoretisch würde auch „disk2“ funktionieren, allerdings geht die Übertragungsgeschwindikeit hierbei drastisch in den Keller. Nach dem flashen der Karte wird das Gerät mittels:

diskutil eject /dev/rdisk2

ausgeworfen. Die Karte kann nun in den ausgeschalteten Pi gelegt werden und dieser mit Strom versorgt werden. Beim ersten Start wird man vom Konfigurationsmenü „raspi-config“ begrüßt. Hier kann man das Tastaturlayout, den SSH Server und andere Dinge einstellen. Wir stellen ein deutsches Tastaturlayout ein und aktivieren den SSH Server. Desweiteren sollte man das Passwort für den Nutzer Pi ändern und die root Partion auf den gesamten Bereich der SD Karte ausdehnen. Anschließend kann man den Pi neustarten.

Für das drahtlose Netz wird der WLAN Stick an den Raspberry Pi angeschlossen. Wenn man dies im laufenden Betrieb macht kann es passieren das der Pi anschließend neustartet. Das ganze sieht etwas nach einer Brownout Detection aus, sprich der Raspberry hat für einen Moment zu wenig Strom und startet neu.

In der Konsole kann man nun mittels „ifconfig“ feststellen ob ein weiteres Netzwerkgerät hinzugekommen ist. Dort sollten die Geräte „eth0“, „lo“ und „wlan0“ auftauchen. Nun geht es an die Konfiguration des WLANs. Dazu wird die „/etc/network/interfaces“ mittels „nano“ aufgerufen:

sudo nano /etc/network/interfaces

Dabei werden einige Änderungen in der Datei vorgenommen. Anschließend sollte die „interfaces“ Datei wie folgt aussehen:

auto lo

iface lo inet loopback
iface eth0 inet dhcp

allow-hotplug wlan0
auto wlan0
iface wlan0 inet dhcp
pre-up wpa_supplicant -B w -D wext -i wlan0 -c /etc/wpa_supplicant/wpa_supplicant.conf
iface default inet dhcp

Nun geht es an die Konfiguration der „/etc/wpa_supplicant/wpa_supplicant.conf“ Datei. Diese sollte nach der Konfiguration in etwa so aussehen:

ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1

network={
  ssid="WLAN"
  scan_ssid=1
  proto=RSN
  key_mgmt=WPA-PSK
  pairwise=CCMP
  group=CCMP
  psk="geheim"
}

Im vorliegenden Beispiel wurde ein WPA 2 verschlüsseltes WLAN eingerichtet. Bei einem Neustart sollte das WLAN anschließend verfügbar sein. Ist dies nicht der Fall, so kann der Prozess mittels:

sudo wpa_supplicant -i wlan0 -D wext -c /etc/wpa_supplicant/wpa_supplicant.conf -d

manuell aktiviert werden. Dabei sieht man dann auch entsprechende Fehlermeldungen, welche auf Probleme hinweisen können. Wenn die WLAN Schnittstelle aktiv ist, kann man auf einem anderen Terminal mittels „iwconfig“ sehen ob die Schnittstelle funktioniert. Dies ist dann gegeben wenn die Schnittstelle nicht mehr als „unassociated“ markiert ist.

Der letzte Punkt der jetzt noch fehlt ist die Unterstützung für Airplay. Hierfür wird Shairport installiert. Dazu werden im ersten Schritt die notwendigen Bibliotheken installiert, sowie der Quellcode von Shairport und dem SDP Modul auf den Pi geholt:

sudo apt-get install git libao-dev libssl-dev libcrypt-openssl-rsa-perl libio-socket-inet6-perl libwww-perl avahi-utils libmodule-build-perl
git clone git clone https://github.com/njh/perl-net-sdp.git
git clone git://github.com/abrasive/shairport.git

Bevor Shairport kompiliert wird, muss das SDP Modul installiert werden. Dazu wechseln wie in den Ordner und geben dort folgendes ein:

perl Build.PL
sudo ./Build
sudo ./Build test
sudo ./Build install

Danach wechseln wir in den Shairport Ordner und geben dort „make“ ein. Anschließend können wir ganze mittels „perl shairport.pl“ starten und einen ersten Test vornehmen. Nun müssen wir noch dafür sorgen das Shairport beim Start des Pi auch gestartet wird. Außerdem soll der Empfänger noch einen ordentlichen Namen bekommen. Dazu geben wir im Shairport Ordner folgendes ein:

sudo make install
sudo cp shairport.init.sample /etc/init.d/shairport
cd /etc/init.d
sudo chmod a+x shairport
sudo update-rc.d shairport defaults
sudo nano shairport

Nachdem wir die Datei „shairport“ in „nano“ geöffnet haben, ändert wir dort den Namen z.B. in Schlafzimmer oder Wohnzimmer. Damit bekommt der Empfänger einen eindeutigen Namen. Nach einem Neustart oder einem manuellen:

./shairport start

ist der eigene AirPlay Empfänger fertig.

Weitere Informationen gibt es unter:
http://wiki.ubuntuusers.de/WLAN
http://wiki.ubuntuusers.de/WLAN/wpa_supplicant
http://netz10.de/2010/02/13/wlan-wpa2-mit-psk-manuell-konfigurieren/

0xED mit geöffneter Datei

0xED ist dabei in unter anderem ins Deutsche lokalisiert worden. Bezogen werden kann der Editor unter http://www.suavetech.com/0xed/.

sudo apt-get install git

Damit das Update der Firmware nicht in Arbeit ausartet, sollte man „rpi-update“ nutzen, welches unter https://github.com/Hexxeh/rpi-update/ zu finden ist. Mittels:

sudo wget http://goo.gl/1BOfJ -O /usr/bin/rpi-update && sudo chmod +x /usr/bin/rpi-update

wird das ganze auf dem Raspberry Pi installiert. Nun kann das Firmware Update mit:

sudo rpi-update

angestoßen werden. Die Dauer eines Updates beträgt etwa fünf Minuten. Nach dem erfolgreichen Update muss der Raspberry Pi neugetstartet werden.