Die Wolke in der eigenen Hand

Seit der iTunes-Version 11.2 und iOS 7.0.3 hat nun Apple das vollzogen, wovon ich nie gedacht hätte, dass es passieren würde. Man kann die Kalender- und Kontaktdaten nun nicht mehr lokal über WiFi oder USB zwischen Computer und iPhone/iPad synchronisieren. Stattdessen braucht man dazu seine Apple-ID um das über die iCloud abzugleichen. Aber die iCloud kommt für mich nicht in Frage, da die Daten nichts auf fremden Servern zu suchen haben, die zu allen Überfluss auch noch im Ausland stehen. Ich weis schliesslich nicht, ob sie dort auch verschlüsselt abgelegt werden und muss eventuell davon ausgehen, dass irgendwelche staatlichen Behörden auf diese Server zugriff haben. Deswegen habe ich nun beschlossen, einen meiner Raspberry Pi’s dazu zu nutzen und auf ihn ownClod installieren, der sicher in meiner eigenen Wohnung steht. Mit ihm werde ich meine Kalender- und Kontaktdaten über mein lokales Netz austauschen, währenddessen die Bilder-, Audio- und Applikationen sowieso ich über USB synchronisiere.

Raspberry Pi für ownCloud

Raspberry Pi für ownCloud

Anbei ein kleiner Workaround zur Installation von ownCloud.

Ich entscheide mich hierbei für den Webserver nginx, der wohl etwas Ressourcen schonender als der Apache-Webserver ist und flüssiger läuft.

Auf dem Server werden also folgende Komponenten zur ownCloud mit installiert:

  • nginx Webserver
  • PHP5
  • SQLite (Datenbank auf Dateibasis)
  • sowie diverse Pakete zum Performancegewinn

Nachdem man sich via http://www.raspbian.org/RaspbianInstaller mit den Raspbian-Installer ein Debian Weezy Grundsystem installiert hat, installiert man sich mit raspi-config ein sehr praktisches Konfigurationswerkzeug, um auf dem System ein paar grundlegende Einstellungen für das Gerät vorzunehmen.

sudo apt-get install raspi-config
sudo raspi-config
  1. change_locale zu „en_US.UTF-8“ für das komplette System (Ansonsten meckert ownCloud, dass es zu Fehlern bei Dateinamen mit Sonderzeichen kommen kann)
  2. memory_split auf „16“ MB einstellen. Dies ist die kleinst mögliche Einstellung. Die GPU bekommt somit 16MB.
  3. overclock auf „Medium“ 4. „Finish“ und danach die Frage nach dem Reboot mit „Yes“ beantworten.

Paketlisten aktualisieren

sudo apt-get update
sudo apt-get upgrade

Benutzer erstellen

sudo groupadd www-data
sudo usermod -a -G www-data www-data

Installation der Pakete

 sudo apt-get install nginx openssl ssl-cert php5-cli php5-sqlite php5-gd php5-curl php5-common php5-cgi sqlite php-pear php-apc curl libapr1 libtool curl libcurl4-openssl-dev php-xml-parser php5 php5-dev php5-gd php5-fpm memcached php5-memcache varnish

SSL Zertifikat erstellen (gültig für 1 Jahr)

sudo openssl req $@ -new -x509 -days 365 -nodes -out /etc/nginx/cert.pem -keyout /etc/nginx/cert.key
sudo chmod 600 /etc/nginx/cert.pem
sudo chmod 600 /etc/nginx/cert.key

nginx Webserver konfigurieren

sudo nano /etc/nginx/sites-available/default

Hier löscht man den kompletten Inhalt und fügt stattdessen den unten stehenden ein.
Darauf achten, dass man die IP-Adresse „192.168.XXX.XXX“ mit der des Raspberry Pi ersetzt.

server {
listen 80;
  server_name 192.168.XXX.XXX;
  rewrite ^ https://$server_name$request_uri? permanent;  # enforce https
}

server {
listen 443 ssl;
server_name 192.168.XXX.XXX;
ssl_certificate /etc/nginx/cert.pem;
ssl_certificate_key /etc/nginx/cert.key;
root /var/www;
index index.php;
client_max_body_size 1000M; # set maximum upload size
fastcgi_buffers 64 4K;


location ~ ^/owncloud/(data|config|\.ht|db_structure\.xml|README) {
  deny all;
}


location / {
  try_files $uri $uri/ index.php;
}

location @webdav {
  fastcgi_split_path_info ^(.+\.php)(/.*)$;
  fastcgi_pass 127.0.0.1:9000;
  fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
  fastcgi_param HTTPS on;
  include fastcgi_params;
}

location ~ ^(?.+?\.php)(?/.*)?$ {
  try_files $script_name = 404;
  include fastcgi_params;
  fastcgi_param PATH_INFO $path_info;
  fastcgi_param HTTPS on;
  fastcgi_pass 127.0.0.1:9000;
}
}

Danach in folgender Datei die Werte „upload_max_filesize“ sowie „post_max_size“ auf 1000M setzen.

sudo nano /etc/php5/fpm/php.ini
upload_max_filesize = 1000M
post_max_size = 1000M

Am Ende der Datei noch folgendes einfügen:

upload_tmp_dir = /srv/http/owncloud/data

Als nächstes muss folgender Ordner mit den dazugehörigen Rechten erstellt werden

sudo mkdir -p /srv/http/owncloud/data
sudo chown www-data:www-data /srv/http/owncloud/data

PHP konfigurieren

sudo nano /etc/php5/fpm/pool.d/www.conf

Hier ändert man folgende Zeile von:

listen = /var/run/php5-fpm.sock

zu

listen = 127.0.0.1:9000

Webserver und PHP neustarten

sudo /etc/init.d/php5-fpm restart
sudo /etc/init.d/nginx restart

ownCloud installieren
Als letztes wird ownCloud installiert. Folgende Befehle müssen abgearbeitet werden.

wget http://download.opensuse.org/repositories/isv:ownCloud:community/Debian_7.0/Release.key
apt-key add - < Release.key echo 'deb http://download.opensuse.org/repositories/isv:ownCloud:community/Debian_7.0/ /' >> /etc/apt/sources.list.d/owncloud.list
apt-get update
apt-get install owncloud

Nun lässt sich der Server im lokalen Netz aufrufen. In meinem Fall ist das https://192.168.1.104/owncloud. Als letztes muss nur noch ein Administratorkennwort und ein Benutzername festgelegt werden. Somit ist die Installation vollends abgeschlossen.

Der schnellste Weg, Adressbücher und Kalender in die eigene Wolke zu laden, führt über die Webanwendung von Owncloud, die Dateien im VCF- und ICS-Format importieren kann.

Bei Adressbüchern (.vcf) klappte der Import im Versuch allerdings nicht immer reibungslos. Bei einem Adressbuch, in dessen Feldern Doppelpunkte vorkamen, brach der Import leider ab. Im Zweifel muss man vor dem Import noch an den Daten feilen. Auch Gruppen ließen sich nicht importieren, da ownCloud sie als regulären Adressbuch-Eintrag interpretierte. Ein Fehler, der hoffentlich bald behoben wird.

Weiterführende Links:
Artikel bei iRights.info
Das Howto im RaspberryPi-Forum

Der Spion vom Pariser Platz

Mit dem Granulat Zyklon B, das hochgiftige Blausäure freisetzt, ermordeten die Nazis unzählige Menschen. Getestet wurde die verheerende Wirkung des vom Frankfurter IG-Farben-Konzern produzierten Zyklon B bereits 1941 an Kriegsgefangenen. Die streng geheimen Informationen über die Giftgasproduktion in Deutschland wurden schon früh an die Amerikaner verraten. Die Dokumentation des amerikanischen Journalisten Scott Christianson und seines deutschen Kollegen Egmont R. Koch untersucht in diesem Zusammenhang die Rolle des deutschen Wirtschaftsberaters Erwin Respondek.

Am 3. September 1941 führte die SS im Konzentrationslager Auschwitz ein streng geheimes Experiment durch, das den Beginn der Shoah markierte. Mehrere Hundert Kriegsgefangene wurden mit Zyklon B ermordet, einem Granulat, das hochgiftige Blausäure freisetzt. Wenige Wochen später übergab der Repräsentant des deutschen IG-Farben-Konzerns in der Schweiz in seiner Villa am Vierwaldstätter See amerikanischen Kurieren streng geheime Dokumente über Hitlers Giftgasproduktion, auch über das von den IG Farben produzierte Zyklon B. Gelangten auf diesem Wege schon früh Informationen über die geplante sogenannte „Endlösung der Judenfrage“ in die USA?
In den USA war Blausäure schon 1924 zur Exekution von Menschen eingesetzt worden. Damals starb im Staatsgefängnis von Nevada erstmals ein Straftäter durch das Giftgas. In den 30er Jahren forschte das amerikanische Chemieunternehmen Du Pont über Blausäure als Insektenkiller, aber auch als Mittel der Wahl für Hinrichtungen in der Gaskammer. Du Pont stand dabei in engem Informationsaustausch mit den Experten des IG-Farben-Konzerns in Frankfurt. Diese Beziehungen blieben sogar bestehen, nachdem Amerika im Dezember 1941 in den Krieg gegen Hitler-Deutschland eingetreten war.
Die Dokumentation erzählt in diesem Zusammenhang auch die einzigartige Geschichte des deutschen Wirtschaftsberaters Erwin Respondek, der erst an den Kartellvereinbarungen zwischen IG Farben und Du Pont beteiligt war, dann zum Spion wurde und die Amerikaner mit Geheimnissen über Hitlers Giftgasproduktion versorgte. Respondek residierte in einem Büro am Pariser Platz in Berlin, direkt neben der US-Botschaft. Mit den meist handschriftlichen Dossiers in der Aktentasche ging er die paar Schritte hinüber, in vollem Bewusstsein, dass dies ein tödliches Risiko bedeutete. Die Amerikaner jedoch, so stellte sich später heraus, misstrauten seinen Angaben. Nach dem Krieg geriet Respondek schnell in Vergessenheit – auch in Washington.

Direktlink

4x4x4 LED-Cube Teil 2

Den LED-Cube werde ich über einen ArduinoMega mit den unten aufgeführten C-Code ansteuern.

ArduinoMega mit ATmega2560 Prozessor

ArduinoMega mit ATmega2560 Prozessor

Der ArduinoMega hat folgende Eigenschaften

Microcontroller: ATmega2560
Operating Voltage: 5V
Input Voltage (recommended): 7-12V
Input Voltage (limits): 6-20V
Digital I/O Pins: 54 (of which 15 provide PWM output)
Analog Input Pins: 16
DC Current per I/O Pin: 40 mA
DC Current for 3.3V Pin: 50 mA
Flash Memory: 256 KB of which 8 KB used by bootloader
SRAM: 8 KB
EEPROM: 4 KB
Clock Speed: 16 MHz

Davon nutzen werde ich folgenden Teil:

Ebenen (von unten nach oben, z = 0..3) an Pins A0, A1, A2, A3
LEDs erste Reihe (y = 0) an Pins 22, 23, 24, 25
LEDs zweite Reihe (y = 1) an Pins 26, 27, 28, 29
LEDs dritte Reihe (y = 2) an Pins 30, 31, 32, 33
LEDs letzte Reihe (y = 3) an Pins 34, 35, 36, 37

/*
 cube 
 */
 
#define LAYERs 4
#define COLs 4
#define ROWs 4
 
/* global variable definitions */
unsigned char LEDs[LAYERs][COLs * ROWs];
unsigned char pwmpos = 0; // actual step of the PWM
unsigned char layer = 1; // actual controlled layer
 
/*
 * cmp_carry_shift_left compares the two parameters
 * which results in the carry bit to be set/unset
 * that carry bit is rotated into para_io
 * the complete function consumes only 2 cycles
 */
static inline unsigned char cmp_carry_shift_left ( 
	unsigned char para_io,
	unsigned char cmp_para_1,
	unsigned char cmp_para_2 )
{
	asm volatile (
		// compare the parameters
		// (get the carry flag set/unset)
		"cp %r[cmp2], %r[cmp1]"	"\n\t"
 
		// rotate carry bit into paramter
		"rol %r[out]"		"\n\t"
 
		// output operand
		: [out] "+r" (para_io)		
		// input operands
		: [in] "r" (para_io),
		  [cmp1] "r" (cmp_para_1),
		  [cmp2] "r" (cmp_para_2)
	);
	return para_io;
}
 
/*
 * The timer3 overflow interrupt routine builds the pin states
 * to be output. the actual output is done in the beginning
 * (of the next execution) of the routine to achieve a more
 * constant time behaviour
 */
ISR ( SIG_OVERFLOW3 )
{
	static unsigned char porta, portc, portf;
	PORTB = 0x80; // turn on pin B7 for measuring the time consumption
 
	PORTA = porta; // turn on the pins of PORTA and B in resull of
	PORTC = portc; // the previous cycles outcome
	PORTF = portf;
 
	pwmpos++;
	if ( pwmpos >= 128 ) pwmpos = 0;
	if ( pwmpos == 0 )
	{
		layer++;
		if (layer == LAYERs)
		{
			layer = 0;
			PORTB |= 0x10;	// get an impulse on Pin B4 as debug output
			PORTB &= ~0x10;	// -"-
			PORTA = 0;
			PORTC = 0;
		}
		portf = 1 <= LAYERs * COLs * ROWs ) ? 0 : RX_pos + 1;
	}
	PORTB &= ~0x08;	 // turn off B3 as debug output
}
 
void setup()  { 
	unsigned char i;
 
	// Initialize port directions and output values
	DDRA = 0xFF; PORTA = 0xFF; // first 8 LEDs
	DDRC = 0xFF; PORTC = 0xFF; // second 8 LEDs
	DDRF = 0x0F; PORTF = 0x01; // 4 layers
	DDRB = 0xFF; PORTB = 0x00; // debug output LEDs
 
	// Initialize timer
	TCCR3A = (1 << WGM31) | (1 << WGM30) | (0x00 << COM3B0);
	TCCR3B = (0x01 << CS30) | (1 << WGM32) | (1 << WGM33);
	TIMSK3 |= 1 << TOIE3;
	OCR3A = 0xFF; // */
 
	// init LEDs array
	for ( i = 0; i < LAYERs * COLs * ROWs; i++ )
		( (unsigned char *) LEDs )[i] = 1;
 
	// Enable interrupts
	sei();
 
	// listen on RS232 for new data
	Serial.begin(115200);
}
 
void loop()  { 
	PORTB ^= 0x02; // debug output (toggles pin B1 if nothing else is done)
}

Der Programmcode wird ganz simple mit der eigenen Arduino-Applikation via USB auf den Microkontroller in einem Rutsch kompiliert und hochgeladen. Code in das Fenster einfügen und Upload-Button klicken. Fertig!

Programm zum bespielen von Arduino's

Programm zum bespielen von Arduino’s

Von Datenträgern und mit Lochkarten betriebenen Waschmaschine

Nicht all zu selten kommt es in meiner Peer-Group zu einer Diskussion über alte Speichermedien. Dann kommt es auch schnell zu den Aussagen, wer mit welchen Medium seine Computerkarriere begonnen hat. Es fallen dann Sätze wie: „Mein erster PC besaß nur eine zwei Gigabyte große Festplatte.“ oder „Ich habe meine Daten auf eine Datasette einst speichern müssen.“ Je nach Alter und vielleicht dem Einstiegsalter hat also jeder etwas andere Erfahrungen.

Der erste PC, der bei uns zu Hause stand, hatte anno 1991 auch nur eine 50 Megabyte große Festplatte und besaß sowohl ein 3,5 als auch ein Diskettenlaufwerk für die etwas wabbeligeren 5,25 Zoll großen Disketten. Aber meine eigene Computerkarriere begann schliesslich schon vorher mit dem DDR-Heimcomputer KC 85/4 von Robotron. Da wir mit beginnenden Besitz des Gerätes allerdings keinen Radiorekorder hatten, mit dem die Programme auf eine Kompaktaudiokasette als Datasette gespeichert werden können, mussten als Dauerspeicher die netten alten 7 Zoll Tonbänder herhalten. Da die zugehörigen Tonbandgeräte üblicherweise im Hausgebrauch für den senkrechten Betrieb gebaut wurden, hatte dies ein bisschen den Charme von Rechenzentren der 1960er und ’70er Jahre, wo große Magnetbänder im professionellen EDV-Betrieb üblich waren.

Eine etwas andere Begegnung hatte ich dann während meiner Ausbildung. Im zweiten Lehrjahr absolvierte ich in einem Betrieb mein Praktikum, wo ich gelegentlich große Filtersäcke mit einer auch ziemlich großen Industriewaschmachine waschen musste. Aber in Gegensatz zu den üblichen Waschmaschinen, bei denen man das Waschprogramm mit Druckknöpfen und Drehwählern einstellte, musste man das bei dieser mit Lochkarten machen. Die Karten bestanden allerdings nicht wie aus der EDV bekannt, aus Karton oder Pappe, da diese natürlich in einer feuchten Umgebung relativ schnell durchgeweicht gewesen wären. Sondern bestanden aus einem etwas weichen und flexiblen Kunststoff, damit sie auch nicht so schnell durchbrechen konnten. Das ganze war circa im Jahre 2001/2002.

Update 04. April 2021, 22:44 Uhr:

In der WRINT-Folge WR1014 war der Historiker Ilko-Sascha Kowalczuk zu Gast und sprach mit Holger Klein über seine Jugend in der DDR anlässlich seines im August 2019 erschienen Buch „Die Übernahme: Wie Ostdeutschland Teil der Bundesrepublik wurden“ (ISBN 978-3-406-74020-6). Dabei erzählt er etwas beiläufig, dass in der DDR die Tonbänder nur unwesentliche teurer waren als die Audiokassetten, aber eine bessere Tonqualität besaßen.

4x4x4 LED-Cube Teil 1

Ich habe mir mal vorgenommen, einen roten 4x4x4 LED-Würfel zu bauen. Also mit insgesamt 64 einzelnen LED’s. Ganz gut eignen sich für dieses Vorhaben 5 Millimeter große LED’s.

Schablone mit 8x8 Löchern

Schablone mit 8×8 Löchern

Als erstes dachte ich mir, ich erfinde das Rad neu und erstelle eine eigene Schablone mit Acht mal Acht Löschern, die ich mit einer Lötkolbenspitze vor- und danach mit einer 5 Millimeter LED nachgestochen habe. Für meinen Würfel reicht im Grunde eine Matrix mit vier mal vier Löchern. Ich dachte mir nur, wenn ich diesen zur Übung erst einmal fertig gestellt habe, kann man diese Schablone später für einen größeren Würfel mit insgesamt 512 LED’s benutzen. Nur leider habe ich feststellen müssen, dass meine Löscher zwar akkurater sind, aber in der Tiefe mehr Kratern als zylindrischen Vertiefungen gleichen. Dadurch stehen die einzelnen LED’s während des zusammen löten nicht stabil auf den Kopf. Ich habe dann doch die schon vorhandene benutzt, auch wenn die einzelnen gestochenen Löcher nicht immer die 20 Millimeter Abstand zu den jeweiligen benachbarten aufweisen.

Gebogene LED

Gebogene LED

Als nächstes ging es an das Biegen der Beinchen der einzelnen LED’s und dem zusammen Löten dieser zu den vier Ebenen. Es ist ganz ratsam, die Anode um wenige Millimeter circa 45 Grad abzuwinkeln, so dass sie später an der darunter liegenden Eben nicht auf den LED-Kopf stösst. Die Katode wird um 90 Grad abgewinkelt und mit jeweils nächsten verlötet. Am Ende der Viererkette wird die Katode zusätzlich mit etwas Abstand auf der Horizontalen ein weiteres Mal um 90 Grad gebogen, damit sie mit seinem Gleichen der nächsten Viererkette verlötet wird. Die Vier Stränge bekommen auch an ihren Anfängen zum Halt einen Querdraht angelötet.

Fertiger 4x4x4 LED-Würfel ohne Elektronik

Fertiger 4x4x4 LED-Würfel ohne Elektronik

Dadurch dass ich mit den Schablonen etwas Pech hatte, sieht das Endergebnis des Würfel nicht so sauber und gerade aus. Entscheidend ist nur, dass die Lötpunkte richtig fest sind, dass das Konstrukt auch hält.

Fotoalbum des LED-Cube auf Flickr