Category Archives: IT

Projekt: Dimmer für LED-Lichterkette bauen

Für unseren Balkon haben wir eine LED-Lichterkette gekauft, genauer gesagt folgende:

6M LED Lichterkette, 4,5W 125er LEDs, Warmweiß, erhältlich z.B. bei Amazon.

Toll wäre eine Möglichkeit, die Helligkeit nachjustieren zu können, also sollte ein LED-Dimmer her.

Ein Blick in die technischen Daten und auf das Netzteil überraschte, die Lichterkette wird mit nur 3 Volt und 800 mA betrieben:

„Fertige“ Lösungen oder Bausätze beziehen sich oftmals auf wesentlich höhere Spannungen, oft 12-24 V. Also entschied ich mich für einen Selbstbau mit einem Mikrocontrollerboard, genauer einem Arduino UNO R3.

Vorweg – ich sehe den Selbstbau als reines Übungsprojekt – ich bin kein Elektotechniker und übernehme keine Gewähr dafür, sollte sich jemand dazu entschließen, meinen hier geschilderten Aufbau umzusetzen 😉 Aber ich bin sehr an Feedback interessiert, vielleicht hat der ein oder andere noch weitere Ideen oder Optimierungsvorschläge oder verdreht gänzlich die Augen aufgrund meiner Umsetzung 😉

Doch warum ein Mikrokontrollerboard? Zunächst stellte sich heraus, daß das Dimmen von LEDs alles andere als trivial ist. Hierzu wird eine Technik angewendet, welche sich Pulsweitenmodulation (PWM) nennt:

PWM

Vorbereitung:

Nach den ersten Überlegungen stellte sich folgende Konstellation heraus:

Die Spannungsversorgung sollte über ein 9 Volt 1500 mA Netzteil erfolgen, welches den Arduino versorgt. Das gleiche Netzteil versorgt auch die Lichterkette, hier wird über einen Schaltregler die Spannung auf die Versorgungsspannung der Lichterkette reduziert, genauer 3,5 V (direkt am Original-Netzteil ermittelt). Die Ausgangsspannung lässt sich mittels einer kleinen Stellschraube am Schaltregler und einem Multimeter exakt einstellen. Ich habe ein 1500 mA Netzteil gewählt, um 800 mA für die Lichterkette und den Rest für den Arduino bereitzustellen – genug Reserve also.

In den Versorgungsstromkreis der Lichterkette wird ein NPN-Transistor eingebunden, welcher über den Arduino geschaltet wird und somit die Lichterkette ein-/ausschaltet. Die Pulsweitenmodulation wird also durch den Mikrocontroller vorgenommen.

Die Regelung des PWM-Intervalls erfolgt über ein Drehpotentiometer, welches an den Arduino angeschlossen wird.

Mit Hilfe der Fritzing Software habe ich den geplanten Aufbau skizziert und einen groben Schaltplan erstellt – erfahrene Elektrotechniker mögen über diesen bitte wohlwollend hinwegsehen 😉

In diesen Skizzen ist kein Ein-/Ausschalter berücksichtigt, dieser wurde nachträglich implementiert.

Nachtrag 09.08.2017: Als Basiswiderstand B2 habe ich anstelle 220 Ω einen 140 Ω Widerstand gewählt, siehe auch Abschnitt „Anfänger-Stolpersteine – bitte beachten!“

Benötigte Materialien und Kosten:

1x Arduino UNO R3 (ATmega328) – ca. 12,- EUR, z.B. hier, oder hier.
1x Platine ohne Cu-Auflage 100 mm x 50 mm, Rastermaß 2,54 mm – ca. 0,79 EUR
1x LM2596 Schaltreglermodul, DC-DC, verstellbarer Abwärtswandler – ca. 2,- EUR
1x Lüsterklemme – ca. 0,95 EUR
1x 9V-Netzteil oder Universal Netzteil 1500 mA – ca. 13,- EUR
1x Adapterkabel mit Netzgerätebuchse 5,5/2,1 mm – ca. 1,85 EUR
1x rote LED 3mm – ca. 0,10 EUR
1x Metallschicht-Widerstand 220 Ω – (für LED-Versuchsaufbau) ca. 0,08 EUR
1x Metallschicht-Widerstand 140 Ω – (Basiswiderstand für Transistor) ca. 0,08 EUR
1x NPN Transistor BC337/25TA TO-92-3 – ca. 0,20 EUR
1x Leitplastik-Potentiometer Mono 10 kΩ – ca. 1,10 EUR
1x Drehknopf schwarz – ca. 1,80 EUR
1x Kippschalter – ca. 2,70 EUR
1x Gehäuse 150 x 80 x 50 – ca. 3,- EUR
1x Jumper Kabel 20 cm männlich/männlich – ca. 4,- EUR

Gesamtkosten (ohne Kabel): ca. 44,- EUR – wobei die beiden teuersten Komponenten, Arduino und Netzteil insgesamt schon 25,- EUR ausmachen – sollten diese bereits vorhanden sein, sind die Gesamtkosten durchaus im Rahmen dessen, was fertige Lösungen im Verkauf kosten würden. Wer die Komponenten günstiger beschaffen kann, kriegt den gesamten Aufbau vielleicht schon für die Hälfte hin.

Weitere Komponenten:

  • Kabel 0,5/0,75 mm^2 (ca. 0,50 EUR/m)
  • Bohrmaschine + Bohrer
  • Lötkolben incl. Zubehör
  • Heißklebepistole
  • Isolierband
  • Multimeter
  • Schraubendreher
  • Maulschlüssel

Versuchsaufbau

Hier kann man das Grundprinzip nachvollziehen. Die rote LED zeigt den Status (an/aus), die grüne LED dient als Platzhalter für die spätere Lichterkette. Den Aufbau des Arduino Quelltexts für die Pulsweitenmodulation (PWM) sowie die Verwendung des Potentiometers konnte ich dank der vielen sehr guten Tutorials im Web erlernen und nachvollziehen.

Ich habe noch ein paar Optimierungen vorgenommen:

  1. Der analoge Eingang mit dem angeschlossenen Potentiometer wird mehrfach abgefragt und ein Mittelwert berechnet, um evtl. Ausreißer durch Schwankungen zu vermeiden.
  2. Implementierung eines Schwellenwertes für die min/max Aussteuerung
// LED dimmen via PWM und Poti

const int numReadings = 10;
const int analogInPin = A1; // Input-Pin fuer Potentiometer (0-1023)
const int analogOutPin = 3; // Pin fuer LED (0-255)

int readings[numReadings]; // the readings from the analog input
int readIndex = 0;         // the index of the current reading
int total = 0;             // the running total
int average = 0;           // the average

int inputPin = analogInPin;

int sensorValue = 0; // Berechneter Mittelwert von Poti
int outputValue = 0; // Wert fuer PWM-Output

void setup() {
//  Serial.begin(9600); // For Bugfixing
  // initialize all the readings to 0:
  for (int thisReading = 0; thisReading < numReadings; thisReading++) {
    readings[thisReading] = 0;
  }
  pinMode(inputPin, INPUT);
  digitalWrite(inputPin, HIGH);
}

void loop() {
  // subtract the last reading:
  total = total - readings[readIndex];
  // read from the sensor:
  readings[readIndex] = analogRead(inputPin);
  // add the reading to the total:
  total = total + readings[readIndex];
  // advance to the next position in the array:
  readIndex = readIndex + 1;

  // if we're at the end of the array...
  if (readIndex >= numReadings) {
    // ...wrap around to the beginning:
    readIndex = 0;
  }

  // calculate the average:
  average = total / numReadings;
  // send it to the computer as ASCII digits

  sensorValue = average;

  // Werte in Bereich des Analog-Out mappen:
  outputValue = map(sensorValue, 0, 1023, 0, 255);

  if (outputValue < 6) {
    outputValue = 0;
  }
  else if (outputValue > 250) {
    outputValue = 255;
  }


  // Wert ausgeben
  analogWrite(analogOutPin, outputValue);

  // For Bugfixing
/*  
  Serial.print("sensor = ");
  Serial.print(sensorValue);
  Serial.print("\t output = ");
  Serial.println(outputValue);
*/ 
  delay(2);        // delay in between reads for stability
}

Aufbau der Platine

Anschließend habe ich die Komponenten auf eine Platine gesetzt und miteinander verbunden. Spannungsregler und Lüsterklemmen wurden mittels Heißkleber fixiert. Beim Einbau das Transistors bitte die Pinbelegung gemäß Datenblatt heranziehen (Emitter, Basis und Kollektor).

Anfänger-Stolpersteine – bitte beachten!

Wie man ersehen kann, habe ich die ersten Versuchsaufbauten mit kleinen LEDs vorgenommen und für die Verkabelung Jumperkabel verwendet. Zudem hatte ich zunächst einen zu kleinen Transistor (2N3904TA) und die Basis mit einen 10 kOhm Widerstand verbunden. Für den Versuchsaufbau stellte dies alles kein Problem dar, doch bei der finalen Umsetzung zeigten sich hierbei mehrere Probleme – die Lichterkette leuchtete nur noch mit 50% Leuchtstärke.

Meine Idee, Jumperkabel an ein Potentiometer zu löten, war in vielerlei Hinsicht eine schlechte Idee: Der Drahtquerschnitt war so gering, das die Verbindung alles andere als stabil war und zu stark schwankenden Eingangswerten führte. Ich habe diese durch Drähte mit 0.5 mm^2 Querschnitt ersetzt und diese an Stiftbrücken gelötet, um die Verbindung mit dem Arduino herzustellen.

Anschließend war der gewählte Transistor zwar für LEDs ausreichend, doch mit 200 mA Kollektorstrom bewirkte dieser nur ein schwaches Leuchten der Lichterkette. Nach der Umrüstung auf einen BC337/25TA Transistor mit 800 mA Kollektorstrom war dann auch dieses Problem gelöst.

Danach stellte sich heraus, das ein 10 kOhm Widerstand an der Basis des Transistors viel zu hoch bemessen war – ich habe diesen durch einen 140 Ohm Widerstand ersetzt.

Berechnung Basiswiderstand

Als Nachtrag vom 09.08.2017 füge ich die Berechnung des Basiswiderstandes für den Transistor bei. Ich habe mich dabei nach dem Artikel Basiswiderstand auf mikrocontroller.net orientiert.

Folgende Werte habe ich hierbei berücksichtigt:

\(U_{E}=5V\) Steuerspannung
\(I_{C}=800 mA\) für den Verbraucher, also die Lichterkette
\(h_{FE}= 100\) DC Current Gain des Transistors laut Datenblatt bei \(V_{CE}=1V, I_{C}=100mA\)

Zunächst die Abschätzung der Stromverstärkung in Sättigung für die weitere Berechnung:\(h_{FE}=\frac{h_{FE}}{3,7}=\frac{100}{3,7}\approx 27\)

Berechnung des Basisstroms: \(I_{b}=\frac{I_{C}}{h_{FE}}=\frac{800mA}{27}\approx 30mA\)

Berechnung des Basiswiderstands: \(R_{b}=\frac{U_{E}-0,7V}{I_{B}}=\frac{5V-0,7V}{0,030 A}\approx 143 \Omega\)
Anmerkung: 0,7 V werden von der Steuerspannung abgezogen, da diese an der Basis-Emitter Strecke des Transistors abfallen.

Nach dieser Auslegung habe ich einen 140 Ohm Basiswiderstand gewählt.

Einbau in das Gehäuse


Das Gehäuse habe ich nach den Gegebenheiten meines Aufbaus ausgewählt, es geht sicherlich auch deutlich kompakter 🙂

Wie man ersehen kann, habe ich den Arduino mittels M3 Schrauben und Muttern mit dem Gehäuse verschraubt und in den Deckel des Gehäuses die Bohrungen für Schalter, Potentiometer und Status LED eingebracht.

Die Buchse für die Stromversorgung wird seitlich herausgeführt und wurde im Gehäuse mit Heißkleber fixiert.

Die Zugentlastung des nach außen geführten Kabels für die Lichterkette erfolgt mittels eines Kabelbinders. Die offenen Kabelenden an Schalter, Potentiometer und Status LED wurden mit Isolierband versehen.

Wir haben das Gehäuse mittels eines Nagels an der Wand befestigt.

Der Praxistest:

Auch wenn das Gerät sehr „Retro“-lastig erscheint, erfüllt es seinen Zweck und ist – hey – immerhin selbstgebaut.

Nach dem Einschalten lässt sich die Leuchtstärke der LED-Lichterkette stufenlos mit dem Drehregler einstellen und sorgt so stets für die gewünschte Beleuchtung. Ich habe ein paar Fotos in den Einstellungen maximal, mittel und gering beigefügt. Man möge die schlechte Aufnahmequalität in der Nacht verzeihen, doch erkennt man gut den Effekt.

macOS: dd-Status überprüfen

Das vielseitig nutzbare Tool „dd“ (DiskDump) gibt während des Programmlaufs normalerweise keinerlei Statusmeldungen aus. Um zu überprüfen, wieviele Bytes bereits verarbeitet wurden, kann unter Linux der folgende Befehl genutzt werden: kill -USR1 prozessnummer. Unter macOS führte dieser Befehl (zumindest bei mir) zum Abbruch des gesamten Vorganges, was gerade beim Schreiben eines Images auf einen Datenträger fatal ist.

Nach ein wenig Recherche fand ich folgende Möglichkeit: killall -INFO dd oder alternativ die Tastenkombination [Strg] + [T]. Hierbei handelt es sich um ein BSD-Feature, welches ein SIGINFO an den Prozess sendet und zur gewünschten Ausgabe führt.

ssh als SOCKS-Proxy unter OS X nutzen

TUX-Avatar-350In dieser Anleitung möchte ich vorstellen, wie sich ssh als SOCKS-Proxy unter OS X nutzen lässt. Kurz vorweg, diese Anleitung lässt sich selbstverständlich auch auf andere Systeme wie z.B. BSD oder Linux übertragen, auf welchen eine Installation des ssh-Clients vorliegt.

Voraussetzung hierzu ist das Vorhandensein eines Root- oder V-Servers mit Zugriff auf einen installierten und konfigurierten SSH-Server, zu dem man eine Verbindung aufbauen kann.

Ziel ist, mittels SSH einen Tunnel einzurichten, der sich wie ein SOCKS-Proxy verhält, welcher zwischen dem anfragendem Webbrowser und dem Webserver steht. Anfragen werden nun über den verbundenen Root- bzw. V-Server geleitet. Der angefragte Webserver „sieht“ hier nur die IP-Adresse des Root- bzw. V-Servers, nicht die tatsächliche IP-Adresse des Clienten. Die tatsächliche IP-Adresse bleibt somit dem Kommunikationspartner verborgen.

Warum nutze ich diese Möglichkeit?

Kurz vorweg: Nicht aus Anonymisierungsgründen 😉 – da der verwendete Root-Server ohnehin von mir betrieben wird. Mir ging es um einen anderen Fall: Die gängige Praxis der Bandbreitenbeschränkung über ganze IP-Adressbereiche, vorzugsweise für private IP-Adressen. utilities-system-monitorIch habe Verständnis für Load-Balancing in einem vernünftigen (!) Rahmen, aber keinerlei Verständnis dafür, das Software-Updates in Größenordnungen von mehreren hundert Megabyte mit z.B. 60 KB/s durch die Leitung tröpfeln und ein Download somit mehrere Stunden dauern soll. Ein Login auf dem Root mit anschließendem manuellem Download via curl oder wget ergab dann oft Gewissheit: In diesem IP-Adressbereich sind Datenraten mit voller Bandbreite kein Thema.

Anfänglich fiel mir das nur bei wenigen Diensten auf, doch scheint es mittlerweile in Mode gekommen zu sein – und es nervt, ich bezeichne das als technischen Rückschritt und Gängelei der Endbenutzer. Ich erwarte nicht, das Serverbetreiber für tausende Nutzer zugleich pro Download-Slot 100 MB/s anbieten – aber Datenraten in Bereichen von ISDN und weniger sind ein definitives NoGo und eine Zumutung in der heutigen Zeit.

quasselWie schon beschrieben, umgehe ich diese Beschränkungen mittles manuellen Downloads via Server-Konsole, dies ist allerdings recht unkomfortabel. Die Alternative ist die Einrichtung eines „richtigen“ Proxy-Servers wie z.B. Squid. Diese ist allerdings nicht ganz trivial und entsprechend gegen missbräuchliche Nutzung abzusichern – was man als Serverbetreiber durchaus ernst nehmen sollte.

Mir ging es allerdings nicht um eine dauerhafte Proxy-Nutzung, weshalb ich mich für die Realisierung mittels eines ssh-Tunnels entschlossen habe.

Einrichtung

1) Start des ssh-Clients

Im OS X – Terminal hierzu folgenden Befehl absetzen:

ssh -D 8080 -C -N user@server.tld

user@server.tld ist natürlich durch eigene Angaben zu ersetzen. Das Terminal-Fenster bitte geöffnet lassen! Die Verbindung kann mittels der Tastenkombination Strg + C beendet werden.

2) Konfiguration des SOCKS-Proxys unter OS X

Hierzu wird im Bereich Systemeinstellung/Netzwerk eine separate Umgebung eingrichtet, um bequem zwischen normalem Netzwerkprofil und SSH-Lösung umschalten zu können.

Im Apfel-Menü den Punkt „Systemeinstellungen“ öffnen und das Icon „Netzwerk“ anklicken:

Bildschirmfoto 2016-04-10 um 17.09.51

„Umgebungen bearbeiten“ selektieren. Nun das Zahnrad-Symbol wählen und „Umgebung duplizieren“ wählen:

Bildschirmfoto 2016-04-10 um 17.11.04

Bildschirmfoto 2016-04-10 um 17.11.58

Einen Namen für die neue Umgebung wählen, z.B. SSH-Proxy und mit „Fertig“ abschließen:

Bildschirmfoto 2016-04-10 um 17.14.56

Anschließend auf „Weitere Optionen“ klicken und den Reiter „Proxies“ wählen:

Bildschirmfoto 2016-04-10 um 17.17.59

Nun den Eintrag „SOCKS-Proxy“ auswählen und als Server localhost und Port 8080 eintragen:

Bildschirmfoto 2016-04-10 um 17.24.42

Mit „Ok“ abschließen und mit „Anwenden“ aktivieren.

Fertig! Ob alles funktioniert, lässt sich z.B. in Safari / Firefox / Chrome über https://www.whatismyip.com testen. Hier sollte nun die IP-Adresse des Servers aufgelistet werden.

3) Wechsel zur regulären Konfiguration

Um wieder mit den normalen Einstellungen ohne SSH-Proxy zu surfen, einfach im Bereich Systemeinstellungen / Netzwerk auf die Umgebung „Automatisch“ schalten und mit „Anwenden“ bestätigen. Der ssh-Tunnel im Terminal kann nun via Strg + C beendet werden.

Programmierprojekt: WoW-Addon-Updater

WoW-Addon-Updater-Logo

Sorry für die lange „Durststrecke“ im Blog, ich komme leider nur recht sporadisch zum Schreiben. Heute möchte ich für die Interessierten mein kleines Programmierprojekt vorstellen.

Vorweg: Wer mich kennt, sei es nun von meinem Blog oder persönlich, weiß das ich seit jeher Spaß am Programmieren habe. Meine ersten Gehversuche erfolgten bereits in den 90er-Jahren mit QBASIC unter DOS und VisualBasic unter Windows; ich hatte viel Spaß daran, die ersten eigenen kleinen Programme zu schreiben. Über die Jahre habe ich in diverse Programmiersprachen und deren Dialekte hinein geschnuppert, neben C/C++ sagt mir (Free-) Pascal am meisten zu, insbesondere in Verbindung mit der IDE Lazarus, dessen Plattformunabhängigkeit mir sehr gefällt und die ich zu schätzen gelernt habe.

Als erstes „größeres Projekt“ ist daraus mein „WoW-Addon-Updater“ entstanden, welchen ich an dieser Stelle gerne vorstellen möchte. Das Projekt ist auf GitHub zu finden, dort existiert auch eine Seite mit Screenshots und Binarys zum Download:

http://arndtb.github.io/WoW-Addon-Updater

Bevor es in die Details geht: Warum ausgerechnet „nur“ ein Addon-Updater für ein Spiel und keine Bildbearbeitung, Tabellenkalkulation oder Berechnungsprogramm für elliptische Satellitenbahnen? 😀

Nun, nachdem ich viele Tutorials und Übungen aus Delphi-Büchern durch hatte, musste etwas praktisches mit überschaubarer Komplexität her. Wer Über mich gelesen hat, weiß das ich zwischendurch gerne mit meiner Frau das MMORPG World of Warcraft spiele.

Die Entwickler erlauben die Anpassung des Spiele-Interfaces mittels einer LUA-API an eigene Bedürfnisse – mittlerweile gibt es kaum überschaubare Anzahl praktischer Interface-Anpassungen und Erweiterungen, hauptsächlich zu finden auf Curse.com. Die Entwickler dieser Erweiterungen sind sehr aktiv und arbeiten fleißig an Ihren Erweiterungen, was ein regelmäßiges Aktualisieren notwendig macht. Dies kann man entweder manuell über Websites oder auch via einer Software von Curse erledigen – welche leider ausschließlich für Windows zur Verfügung steht. Wer nicht unter Windows spielt, sondern wie ich unter OS X oder unter GNU/Linux hat leider Pech – hier gibt es keinen praktischen Updater. 🙁

Die Idee war also geboren – es sollte ein plattformunabhängiger Addon-Updater werden, der unter OS X, Linux und Windows läuft. Für dieses Vorhaben boten sich, wie Eingangs schon beschrieben, meine favorisierte Programmiersprache FreePascal und die Entwicklungsumgebung Lazarus an.

Nach einigen Wochen Entwicklungszeit, in welcher ich eine Menge dazugelernt habe und mich auch in Dinge wie Versionsverwaltung mittels Git ein wenig einarbeiten konnte, freue ich mich nun, Euch die Version 1.0.0 zu präsentieren. Ich stelle das Programm und dessen Sourcecode als Freie Software unter den Bedingungen der GNU General Public License (GPL) Version 3 zur Verfügung.

WAU_1.0.0_OSX-2

WoW-Addon-Updater 1.0 (Vivienna)
Copyright (C) 2016 Arndt Braier – dev@braier.net

Der WoW-Addon-Updater dient zur Installation und Aktualisierung von Interface-Erweiterungen (= Addons) des MMORPGs World of Warcraft. Dieses Programm dient als Alternative zur Applikation „Curse Client“, welche derzeit nur unter Microsoft Windows zur Verfügung steht.

Die Idee entstand als Hobby aus dem Wunsch heraus, eine plattformunabhängige grafische Lösung zur Aktualisierung eines Addon-Bestandes zu entwickeln, welche unter Microsoft Windows, GNU/Linux und Mac OS X lauffähig ist. Das Resultat wurde unter den 64 Bit-Versionen von Windows 7, Ubuntu 14.04 (LTS) „Trusty Tahr“, Kubuntu 15.10 „Wily Werewolf“, Arch Linux und Mac OS X El Capitan 10.11 erfolgreich getestet.

Das Programm unterstützt derzeit zwei Sprachen: Deutsch und Englisch.

Der Addon-Bestand wird in einer tabellarischen Übersicht verwaltet und in einer XML-basierten Textdatei neben den individuellen Einstellungen des Programms gespeichert. Von der Addon-Datenbank werden automatisch Backups erzeugt, um im Fehlerfall eine spätere Wiederherstellung zu ermöglichen.

Addon-Einträge können komfortabel hinzugefügt und entfernt werden. Bei der Überprüfung auf neue Versionen werden die neuen oder geänderten Versionen farblich hervorgehoben. Diese können im Anschluß installiert bzw. aktualisiert werden, einzelne Addons können zuvor per Selektion aus- oder abgewählt werden. Der Fortschritt einzelner Programmoperationen wird mittels einer Statuszeile angezeigt.

Ich hoffe, das Ihnen das Programm gefällt und Sie dieses nützlich finden. Für Ihre Vorschläge, Lob und Kritik sowie jeglicher Art von Feedback bin ich stets offen, bitte schreiben Sie mir einfach eine Email unter

Dieses Programm wurde in FreePascal 2.6.4 (http://www.freepascal.org) mit Unterstützung der Entwicklungsumgebung Lazarus 1.4.4 (http://www.lazarus-ide.org/) geschrieben und verwendet das Package „Internet Tools“ (http://www.benibela.de/sources_en.html#internettools) von Benito van der Zander.

Das Programm WoW-Addon-Updater ist freie Software. Sie können es unter den Bedingungen der GNU General Public License, wie von der Free Software Foundation veröffentlicht, weitergeben und/oder modifizieren, entweder gemäß Version 3 der Lizenz oder (nach Ihrer Option) jeder späteren Version.

Die Veröffentlichung dieses Programms erfolgt in der Hoffnung, daß es Ihnen von Nutzen sein wird, aber OHNE IRGENDEINE GARANTIE, sogar ohne die implizite Garantie der MARKTREIFE oder der VERWENDBARKEIT FÜR EINEN BESTIMMTEN ZWECK. Details finden Sie in der GNU General Public License.

Sie sollten ein Exemplar der GNU General Public License zusammen mit diesem Programm erhalten haben. Falls nicht, siehe .

Curse Client und curse.com sind Warenzeichen von Curse Inc.

World of Warcraft, Warcraft und Blizzard Entertainment sind Marken oder eingetragene Marken von Blizzard Entertainment, Inc. in den USA und/oder in anderen Ländern.

Vielleicht habt Ihr Lust, Euch das Ganze mal anzuschauen – über Feedback würde ich mich freuen 🙂

OS X 10.10: ownCloud Client 2.0 – Finder-Plugin entfernen

FinderIcon

Wie in meinem früheren Blogeintrag „OS X Finder: ownCloud-Plugin entfernen“ beschrieben, kennzeichnet auch die aktuelle Version des ownCloud Desktop Clients (derzeit 2.0.1) unter OS X den Status der Synchronisation von Ordnern und Dateien mit zusätzlichen (Overlay-) Symbolen mittels eines Finder-Plugins:

Bildschirmfoto 2015-05-20 um 19.38.27

Während die ownCloud-Entwickler dies für OS X 10.9 (und älter) mittels eines „Legacy Finder Plugins“ realisiert haben, wurde für OS X 10.10 Yosemite eine native Lösung integriert, hier ein Auszug aus dem Changelog der Version 2.0.0:

OS X: Support native finder integration for 10.10 Yosemite (#2340)

Dieses Plugin lässt sich innerhalb der Systemeinstellungen – Erweiterungen bequem deaktivieren (und auch wieder aktivieren):

Bildschirmfoto 2015-09-18 um 15.02.12

Bildschirmfoto 2015-09-18 um 15.00.52

Diese Einstellung lässt sich auch über das Terminal vornehmen:

Plugin deaktivieren:
pluginkit -e ignore -i com.owncloud.desktopclient.FinderSyncExt

Plugin aktivieren:
pluginkit -e use -i com.owncloud.desktopclient.FinderSyncExt

OS X Finder: ownCloud-Plugin entfernen

FinderIcon

Die aktuelle Version des ownCloud Desktop Clients (aktuell 1.8.1) kennzeichnet unter OS X den Status der Synchronisation von Ordnern und Dateien mit zusätzlichen (Overlay-) Symbolen mittels eines Finder-Plugins:

Bildschirmfoto 2015-05-20 um 19.38.27

Das Plugin „SyncStateFinder.osax“ ist unter /Library/ScriptingAdditions zu finden. In Fällen, wo die neue Funktionalität störend ist oder gar zu Performanceproblemen führt (insbesondere bei der Synchronisation von großen Datenbeständen), kann das Plugin (mit Admin-Rechten) einfach wieder entfernt werden, z.B. via Terminal:

sudo su
cd /Library/ScriptingAdditions
rm -Rf SyncStateFinder.osax

Linux/OS X: Zugriffsdatum von Digitalbildern an Aufnahmedatum anpassen

apps-digikam
Ergänzend zu meinem früheren Blogeintrag zum Thema iPhone-Fotos nach dem Aufnahmedatum benennen mittels dem ExifTool gibt es heute wieder einen praktischen (Bash-) Einzeiler für Linux respektive OS X, welcher sich besonders für die Sortierung von Bilddaten eignet, wenn ein physikalisches Umbenennen nicht erwünscht ist:

for i in *.jpg; do touch -t $(exiftool -p '$DateTimeOriginal' $i | sed 's/[: ]//g' | sed 's/\(..$\)/\.\1/') $i; done

Mittels einer for-Schleife wird das jeweilige „Date/Time Original“ aus den Exif-Daten ausgelesen, mittels sed formatiert und an den touch-Befehl übergeben, welcher den Zugriffs- und Änderungs-Zeitstempel der Datei anpasst. Die Schleife wird so lange ausgeführt, bis alle Dateien im Verzeichnis bearbeitet wurden.

CDE – Common Desktop Environment

Wer wie ich in den 1990ern auf diversen Unix-Workstations (HP-UX, AIX, usw.) gearbeitet hat, kennt sicherlich noch das Common Desktop Environment (CDE), welches 1993 von der Open Group (HP, IBM und Sun Microsystems) als proprietäre Software entwickelt wurde. Bei vielen kommerziellen Unix-Workstations war CDE bis ins Jahr 2000 der Standard-Desktop schlechthin, bis es u.a. durch Gnome oder KDE abgelöst wurde.

Am 6. August 2012 wurden die Quelltexte von CDE unter der LGPL veröffentlicht und stehen nun als OpenSource auf Sourceforge zum Download zur Verfügung.

Die Einrichtung ist ein wenig tricky, das Wiki auf Sourceforge leistet hierbei eine gute Hilfestellung. Ich habe CDE auf meinem älteren Laptop unter Linux (Ubuntu 12.04) eingerichtet und ein paar Screenshots beigefügt.

Auch wenn CDE nicht mehr ganz zeitgemäß erscheint, kann eine Einrichtung zur Nutzung auf gerade älteren Systemen aus Performancegründen durchaus sinnvoll sein – ist aber durchaus Geschmackssache 😉

CDE - The Common Desktop Environment, the classic UNIX desktop

CDE - The Common Desktop Environment, the classic UNIX desktop

CDE - The Common Desktop Environment, the classic UNIX desktop

CDE - The Common Desktop Environment, the classic UNIX desktop

Projekt: Raspberry Pi – Gameboy

RaspiGB-Intro

Original und Raspberry Pi-Gameboy

Heute stelle ich Euch mein neues Projekt vor: den Umbau eines klassischen Gameboys zu einer ultimativen Retro-Game-Konsole mithilfe der Raspberry Pi.

01-Intro

Vorwort

Raspberry Pi Modell B

Raspberry Pi Modell B

Die Raspberry Pi eignet sich als Einplatinen-Minicomputer für eine Vielzahl Anwendungszwecke, sei es als Mediacenter, Web- oder Cloudserver, für die Hausautomatisierung oder dank seiner freiprogrammierbaren GPIO-Schnittstelle für eine Vielzahl weiterer Projekte. Auch ich zähle mich zu den begeisterten Raspberry Pi-Fans und setze meine Raspberry zuhause primär als Mediencenter (Raspbmc) ein. Mehr zur Raspberry Pi auch unter http://raspberrypiguide.de.

Vor einiger Zeit entdeckte ich einen interessanten Artikel über eine auf Raspbian basierenden Distribution namens Retropie, welche eine Vielzahl Emulatoren unter einem grafischen Frontend zusammenfasst. Die Umsetzung ist sehr gut, die Zahl der emulierbaren Systeme beachtlich, hier eine Auswahl (Version 1.9):

Amiga, Apple (II/Mactintosh), Armstrad CPC, Arcade, Atari (800/2600/ST/STE/TT/Falcon), C64, Game Boy (Classic/Advance/Color), Game Gear, MAME, NeoGeo, Sega (Master System/Megadrive/Genesis/Mega-CD/Sega 32X), Nintendo Entertainment System (NES), N64, PC Engine, Playstation 1, ScummVM, Super Nintendo Entertainment System (SNES), Sinclair ZX Spectrum, PC/x86, Z Machine.

Später, genauer im Juli 2014 entdeckte ich ein Posting auf Facebook, was mich auf Anhieb begeisterte: Jemand hatte einen alten Gameboy mittels einer Raspberry Pi und einem 3,5″ LCD-Display umgebaut und mittels Retropie in einen „Super Pi Boy“ verwandelt.

Dieses Projekt inspirierte mich, das wollte ich auch! Die Idee zu meinem Vorhaben war also geboren, an dieser Stelle vielen Dank an „microbyter“ und seinen tollen Umbau, welchen er unter http://superpiboy.wordpress.com dokumentiert hat.

 I. Vorarbeiten

Zunächst ging es an die Planung: Welche Features sollte mein Umbau haben, was sollte gegenüber dem „Super Pi Boy“ verbessert werden? Ich entschied mich für nachfolgende Optimierungen:

  • 4 Buttons auf der Rückseite (statt 2), um mehr Bedienelemente nutzen zu können
  • Seitlicher Knopf zum Beenden der Emulation und Rückkehr zum Hauptmenü
  • Verschraubung des Gehäuses, Verbindung möglichst ohne Klebeband
  • Frontabdeckung für Display (Schutz des LCDs vor Verschmutzung)

Was wird benötigt?

Anschließend ging es an die Beschaffung der Einzelteile, die Liste hat sich im Verlauf des Umbaus mehrfach geändert, deshalb hier die finale Zusammenstellung. Bezugsquellen habe ich beigefügt, wo es möglich war:

Optionale Komponenten:

II. Versuchsaufbau & Ansteuerung GPIO

Eines der ersten Probleme, die zu lösen waren, war die Steuerung. Retropie mittels Tastatur zu bedienen, war ja kein Problem – doch wie lassen sich Steuerkreuz und Drucktaster des Gameboys für die Steuerung verwenden?

Hierzu bietet sich die GPIO-Schnittstelle an, eine gute Anleitung fand ich unter https://learn.adafruit.com/retro-gaming-with-raspberry-pi. Ein kleines C-Programm (Adafruit-Retrogame) setzt die Informationen der abgefragten GPIO-Pins (Taste gedrückt?) in entsprechend konfigurierte Tastaturbefehle um. Die entsprechenden Tastaturbefehle lassen sich im Retropie-Frontend konfigurieren.

Als die ersten Teile eingetroffen waren und ich noch auf Post von Übersee warten musste, ging es an einen ersten Versuchsaufbau, um genau dieses zu testen und die Softwareumsetzung zu realisieren.

Ein altes USB-Gamepad (Logitech Wingman) sollte als Versuchs-Gamepad herhalten, im Prinzip benötigte ich nur die Platine (PCB, printed circuit board) und das Gehäuse mit den Tasten. Also fix den IC ausgelötet

01-Versuchsaufbau Ansteuerung GPIO mit Logitech Wingman

und einzelne Drähte mit den Kontaktpunkten verlötet.

02-Versuchsaufbau Ansteuerung GPIO mit Logitech Wingman

03-Versuchsaufbau Ansteuerung GPIO mit Logitech Wingman

Die Drähte müssen vor dem Zusammenbau entsprechend beschriftet werden, um sie später korrekt anzuschließen. Anschließend erfolgte der Zusammenbau, die einzelnen Drähte habe ich mit einer Experimentierplatine verbunden und jede Taste auf Funktion überprüft. Hierzu kann z.B. eine Widerstandsmessung mittels einem Multimeter vorgenommen werden (unbetätigt = ∞ unendlich großer Widerstand, z.B. Anzeige einer „1“ auf der linken Seite des Displays / betätigt = < ∞ kleiner unendlich).

04-Versuchsaufbau Ansteuerung GPIO mit Logitech Wingman

Hierzu muss man verstehen, was ein Tastendruck eigentlich auf der Platine bewirkt. Die druckempfindlichen Bereiche sind nichts anderes als Schalter, die bei Betätigung geschlossen werden. Jeder Schalter hat seinen eigenen Verbindungsdraht (+), aber alle Schalter eine gemeinsame Masse (common ground, -). Nimmt man nun eine Widerstandsmessung zwischen Masse und z.B. Schalter „A“ vor, ist der Messwert zunächst unendlich groß. Betätigt man nun den A-Knopf, verringert sich der Messwert (kleiner unendlich) – der Schalter ist geschlossen.

Die Verbindung der Experimentierplatine mit den GPIO-Pins der Raspberry PI habe ich mittels Jumperkabeln (männlich/weiblich) vorgenommen, diese lassen sich bequem ohne Löten umstecken.

Zur Planung der Belegung der einzelnen GPIO-Pins habe ich mich an nachfolgender Pinbelegung (gültig für Raspberry Pi Modell B) orientiert:

raspberry-pi-rev2-gpio-pinout

Nun mussten die GPIO-Pins mit den einzelnen Schaltern verbunden werden, dies habe ich zunächst auf dem Papier geplant und anschließend mittels der Jumperkabel umgesetzt.

05-Versuchsaufbau Ansteuerung GPIO mit Logitech Wingman

Wie man sieht, reichten die Tasten das Gamepads nicht ganz – hier musste ich mir mit zwei Drucktastern (für Select + Start) sowie zwei weiteren Tastern aus einem Experimentierset (für die Schultertasten LI/RE) behelfen.

Nun konnte ich die Software und dessen Konfiguration entsprechend anpassen, auf den Einbau des Kitsch Bent PCB sowie der Drucktaster vorbereiten und einen finalen Anschlussplan erstellen, auf diesen komme ich später noch einmal zurück.

2014-08-03-Belegungsmatrix Planung fuer PCB

Finaler Anschlussplan / Belegungsmatrix für Kitsch Bent PCB + Taster

III. Demontage Gameboy

Zur Demontage des Gehäuses wird ein spezieller „Triwing“-Schraubendreher verwendet, welchen ich oben in der Materialliste aufgeführt habe. Nach dem Öffnen des Gehäuses ist zu beachten, das Ober- und Unterseite mit einem Flachbandkabel verbunden sind, welches vorsichtig herausgezogen werden kann.

Da von dem Gameboy selbst „nur“ das Gehäuse, Batteriefachabdeckung sowie Bedienelemente benötigt werden, können die elektrischen Komponenten, sofern noch funktionsfähig, einfach ausgebaut und als Ersatzteile für die Reparatur eines ggf. weiteren Gameboy aufbewahrt werden.

IV. Bearbeitung des Gehäuses

Nach einer Grundreinigung der Gehäuseteile und Bedienelemente ging es an die Bearbeitung. Hierzu eignet sich ein Dremel sehr gut, ich empfehle ein Sägewerkzeug sowie zwei Fräser, insbesondere zur stirnseitigen Bearbeitung. Wer noch nie mit dem Dremel gearbeitet hat, sollte zuvor ein wenig üben – gerade bei Kunststoffen ist schnell etwas zuviel Material entfernt.

Ich habe zuvor die Teile vermessen und Handskizzen erstellt, um so wenig Material wie möglich zu entfernen – dennoch muss gerade an der Unterseite der gesamte Batteriekasten einschließlich der Verrippung entfernt werden, stirnseitig habe ich eine kleine Bohrung für den Anschluss des Netzteils vorgesehen. An der Oberseite ist ein vergrößerter Ausschnitt für das Display erforderlich, sowie eine kleine Aussparung für den Lautsprecher.

Beim Batteriefach-Deckel sind 4 Bohrungen ø12,7 mm erforderlich sowie minimale Materialabtragung um die Bohrungen herum, um die Verschraubung der Taster zu ermöglichen. Hier sieht man das finale Ergebnis (oder was davon übrig geblieben ist):

01-Bearbeitung GehaeuseDie verbliebenen Öffnungen habe ich mittels kleiner Kunststoffzuschnitte und Sekundenkleber verschlossen.

Zur Befestigung habe ich zwei kleine Laschen mit kleinen Muttern M3 angeklebt, um beide Gehäusehälften miteinander verschrauben zu können, da sämtliche der früheren Befestigungspunkte bedingt durch die beengten Platzverhältnisse weichen mussten.

 V. Lötarbeiten und Verkabelung – Steuerung + GPIO

Nach dem Eintreffen des Kitsch Bent Common Ground DMG Control Panels ging es nun daran, die geplante Verkabelung der Steuerung in die Realität umzusetzen. Hierzu greife ich noch einmal meine Belegungsmatrix auf:

Finaler Anschlussplan / Belegungsmatrix für Kitsch Bent PCB + Taster

Finaler Anschlussplan / Belegungsmatrix für Kitsch Bent PCB + Taster

Zunächst führte ich die Lötarbeiten an den Drucktastern durch:

01-Steuerung Anschließend die Anbindung des Kitsch Bent PCBs:

02-Steuerung

03-Steuerung

 

Als zusätzlichen Schalter für die ESCAPE-Sequenz (Abbruch der Emulation und Rückkehr ins Frontpanel) band ich noch einen kleinen Drucktaster an den noch freien Pin 26 / GPIO 7 an und setzte dessen Masse auf Pin 14. Mit ein wenig Sekundenkleber und Heisskleber fixiert passt dieser ideal in die Öffnung des früheren Gameboy-Netzteilanschlusses:

04-Steuerung

VI. Lötarbeiten und Verkabelung – Stromversorgung + Sound

Die Stromversorgung gestaltete sich ein wenig schwieriger als zunächst gedacht. Ich wollte diese zunächst wie beim „Super Pi Boy“ mittels einer 5V-Micro-USB-Schnittstelle lösen, musste dieses Vorhaben aber letztendlich aufgeben (siehe Abschnitt LCD-Display) und mich primär auf die 12V-Schiene beschränken. Um die 5V-Komponenten wie Raspberry Pi und Audio-Verstärker zu versorgen, entschied ich mich für den Einbau eines LM2596 Schaltreglermoduls.

a) LCD-Display

Nachdem ich das Taotronics LCD-Display aus seinem Gehäuse ausgebaut hatte, stellte ich erfreut fest, das die Platine bedeutend kleiner war, als beim verwendeten Modell des „Super Pi Boy“. Doch stellte sich bei der Recherche heraus, das ein Umbau der Stromversorgung von 12V auf 5V bei diesem Modell nicht so ohne weiteres zu realisieren war – mangels tiefergehender Kenntnisse entschied ich mich, keine Lötarbeiten an der Platine durchzuführen und die Stromversorgung auf 12V zu belassen.

01-Kabelverlegung

Rückseite des 3,5″ LCD Displays

Die Anschlussbelegung ist wie folgt:

  • rot: +12V
  • schwarz: GND
  • gelb: AV2
  • weiss: AV1

Da mein Clinch-Stecker für den Videoausgang zu groß für den Einbau ins Gehäuse war, baute ich ihn auf ein Minimum um, die gelbe Ader habe ich an AV2 (gelb) und die schwarze Ader an GND angeschlossen. AV1 (weiss) blieb ungenutzt und wurde abgebunden.

02-Kabelverlegung

 

b) Spannungswandler LM2596 Schaltreglermodul

03-Kabelverlegung

Die Ausgangsspannung des Schaltreglermoduls lässt sich mittels einer Verstellschraube sehr fein regeln; dieser Schritt ist zuerst mittels eines Multimeters vorzunehmen. Ich habe eine Leerlaufspannung von 5,1V eingestellt. An den 12V-Eingang habe ich die Anschlüsse der Netzteilbuchse sowie das LCD-Display angebunden; am 5V-Ausgang das Micro-USB-Kabel für die Stromversorgung des Raspberry Pi sowie die Stromversorgung des Audio-Verstärkerboards.

Wie auf nachfolgendem Bild zu sehen, musste der Stecker für die Stromversorgung des Raspberry Pi mangels Bauraum ebenfalls massiv gekürzt werden.

04-Kabelverlegung

c) Audio + Lautsprecher

Bei der Planung entschied ich mich für Ersatzlautsprecher für den Nintendo DS, da diese zum einen vom Bauraum in das Gehäuse passten und zum anderen laut verschiedener Meinungen einen relativ gute Klangqualität aufweisen.

06-Kabelverlegung

Am Audioausgang der Raspberry Pi nutzte ich einen klassischen, abgewinkelten 3,5 mm Klinkenstecker und schaltete zwischen Ausgang und Lautsprecher einen PAM8403 Audio-Verstärker.

05-Kabelverlegung

Interessanterweise trat bei mir auf dem rechten Kanal ein sehr lautes Rauschen auf, weshalb ich mich dazu entschied, nur den linken Kanal anzubinden. Dieses Problem schien bei mir am Audioausgang der Raspberry Pi zu liegen, welche auch mit normalen Kopfhörern ein Grundrauschen auf dem rechten Kanal aufwies – nach dem Studium diverser Foren scheinen Soundprobleme am Audioausgang der Raspberry Pi keine Seltenheit zu sein. Wie auch immer – für Retrogames benötigt man im Regelfall aber keinen HiFi-Sound.

Ich habe meine elektrische Verkabelung in Form eines Schemas zusammengefasst:

Kabelverlegung

 

VII. Zusammenbau der Komponenten

Viel Platz bietet das Gameboy-Gehäuse nicht – dementsprechend benötigt man beim Zusammenbau Geduld und teilweise starke Nerven. Ich habe mit dem Oberteil des Gehäuses begonnen und zunächst den Lautsprecher mit zwei Klebepunkten Heisskleber fixiert. Anschließend erfolgte der Einbau des Displays, welches ich mittels doppelseitigem Klebeband fixierte. Zuletzt erfolgte der Einbau des Common Ground DMG Control Panel. Sämtliche offenliegende Elektronik habe ich anschließend mittels Isolierband abgedeckt.

01-ZusammenbauDie Unterseite gestaltete sich als Herausforderung – der zur Verfügung stehende Bauraum ist mehr als beengt und knapp, gerade die Kabelverlegung erfordert ein wenig „Ideenreichtum“. Gerade das ursprünglich nicht eingeplante Schaltreglermodul erforderte viel Überlegung – das Modul ist nicht gerade klein. Auf dem nachfolgenden Bild sieht man den finalen Aufbau, kurz vorm endgültigen Zusammenbau.

02-Zusammenbau

Beim Verschrauben stellte ich allerdings heraus, das die beiden Schrauben nicht ausreichend waren und gerade in der Mitte eine Befestigung fehlte – hier zeigte sich ein Spalt zwischen beiden Gehäusehälften. Ohne Klebeband liess sich dort leider nichts machen 🙁

Zum Schluss habe ich noch eine Acrylglas-Abdeckung (1 mm Dicke) zum Schutz des Displays aufgebracht (Fixierung mittels ein paar Punkten Sekundenkleber).

Anbei der finale Aufbau, im Vergleich zum Original von 1989:

04-Zusammenbau

05-Zusammenbau

06-Zusammenbau

 VIII. Schlusswort

Nach dem Zusammenbau und einem ersten Test muss ich sagen: Ich bin begeistert! 😀 Der Umbau selbst hat eine Menge Spaß gemacht und ich habe sehr viel dabei gelernt. Wenn man bedenkt, das ich kein Elektrotechniker bin und zum ersten Mal (wirklich) mit einem Lötkolben gearbeitet habe, war die Lernkurve sicherlich hoch 😀 Im Verlauf des ganzen Projekts habe ich mir einige Kenntnisse und Fähigkeiten aneignen können, das es mich umso mehr freut, das alles so reibungslos geklappt hat und am Ende sogar funktioniert. Und es macht einfach Spaß, mit dieser ultimativen Retro-Game-Konsole zu spielen 😀

An dieser Stelle noch einmal meinen herzlichen Dank für die Anregung, welche mir der Umbau von „microbyter“ unter http://superpiboy.wordpress.com gegeben hat.

So, nun seit Ihr gefragt! Ich freue mich auf Eure Zuschriften, Lob, Kritik, Ideen, Vorschläge und natürlich: Eure eigene Umsetzung Eurer ultimativen Retrogame-Konsole!