Alten Hometrainer mit einem Interface zum Garmin Connect Portal aufpeppen

Seit längerem nutze ich im Winter sporadisch einen Kettler Ergometer (Golf E). Wäre doch schön wenn ich die Trainings auf diesem Gerät auch in mein Garmin Connect übertragen könnte. 

Der Golf E hat an der Rückseite des Bedienpanels eine serielle Schnittstelle. Das hat mich dann auf die Idee gebracht, mit einem ESP8266 ein kleines Interface zu basteln.

Im Netz fand ich bereits eine Anleitung, wie man dem Kettler Ergometer über die Schnittstelle die aktuellen Daten entlockt: http://technomathematik.blogspot.ch/2013/10/ergometer-kettler-fx1-serial-protocol.html

Leider braucht man für das Garmin Connect API einen kostenpflichtigen Entwickleraccount. Deshalb habe ich mich für Implementation mit einem manuellen Upload entschieden. Hier der logische Aufbau:

Fertig mit einem einfachen Gehäuse und montiert sieht es dann wie unten gezeigt folgt aus. Der Knopf dient zum Starten und am Ende zum Abschliessen. Danach kann man die Trainingsdaten über eine einfache Weboberfläche vom ESP8266 downloaden.

Und so sieht es dann in Betrieb aus. Die Daten hier über die Garmin Connect App dargestellt.

    

 Zum Abschluss noch das Schema zum Interface. Als Ergänzung zum ESP8266 ein SD-Card Interface, zum Speichern der doch recht grossen Datenmengen und ein MAX232 für die Pegelanpassungen an die serielle Schnittstelle.

Balkon erneuern

Alle paar Jahre ist es wieder soweit. Die Lasur ist abgeblättert und muss erneuert werden. Mittlerweilen habe ich ein kleines Hilfsmittel gebastelt, so dass die Demontage und Montage rascher gehen. Wie das dann geht, zeigen die Zeitraffer unten.

Eine Softbox für den Aufsteckblitz selber basteln

Eigentlich ganz einfach. Etwas Wellpappe, ein weisses Papier oder ein Stoffresten und Kleber - und fertig ist die aufsteckbare Softbox

Hier findet sich ein Foto, dass ich mit dieser Softbox geblitzt habe: https://ausmeinerperspektive.blogspot.ch/2017/11/noch-mehr-seifenblasen.html.

Dann wünsche ich nur noch viel Spass beim nachbasteln.

Lightpainting

Inspiriert von einen bereits etwas älteren Kickstarter-Projekt (https://www.kickstarter.com/projects/bitbangerlabs/pixelstick-light-painting-evolved?lang=de), habe ich in den Weihnachtsferien ein cooles kleines Projekt realisiert.

Wegen der kurzen Vorbereitungszeit verwendete ich Bauteile, die ich schon zuhause hatte. Im wesentlichen ein Arduino Uno, ein Ethernetshield mit SD-Kartenslot und eine Neopixel-Strip (RGBW).  Dank dem Neopixel-Painter Programm (https://learn.adafruit.com/neopixel-painter/overview) von Adafruit, konnte ich einen ziemlichen Jumpstart hinlegen. Wie sich herausstellte, ist das Programm aber nur für RGB-Ledstrips geeignet. Die Ansteuerung der Leds (WS2811 Decoder) ist in Assembler realisiert. Nach etwas Recherche konnte ich die Assembler-Routine so modifizieren, dass zusätzlich zu den 3 Farbwerten jeweils ein Farbwert für die weisse Led an den Ledstrip geschickt wird.

Auf instructables.com habe ich eine wirklich gute Erklärung der WS2811 Protokolls und der Implementierung in Assembler gefunden: http://www.instructables.com/id/Bitbanging-step-by-step-Arduino-control-of-WS2811-/?ALLSTEPS#step5

Hier nun die modifizierte Assemblerroutine, in die C-Funktion show() eingepackt. Diese C-Funktion kann nun direkt als Ersatz für die bestehende Neopixel-Painter Funktion eingesetzt werden.

/*------------------------------------------------------------------------
  Acrobotic - 01/10/2013
  Author: x1sc0
  Platforms: Arduino Uno R3
  File: bitbang_105.ino

  Description:
  This code sample accompanies the "How To Control 'Smart' RGB LEDs:
  WS2811, WS2812, and WS2812B (Bitbanging Tutorial)" Instructable
  ()
 
  The code illustrates how to continuously send a single 105 value to the
  WS2811 (driver)/WS2812/WS2812B RGB LEDs over a self-clocked 800KHz, NZR
  signal.  The implementation was done using assembly so that the timing
  of the signal was extremely accurate.

  Usage:
  Connect power (5V), ground (GND), and the Arduino Uno pin defined
  by DIGITAL_PIN to the WS281X ports VCC, GND, and DIN ports, respectively.

  Upload the program to an Arduino Uno, and the Green LED of the first
  WS281X will light up to full brightness.

  ------------------------------------------------------------------------
  For a full-blown Arduino library, check out:
  https://github.com/acrobotic/Ai_Library_WS281X/
  ------------------------------------------------------------------------
  Please consider buying products from Acrobotic to help fund future
  Open-Source projects like this! We’ll always put our best effort in every
  project, and release all our design files and code for you to use.
  http://acrobotic.com/
  ------------------------------------------------------------------------

  License:
  Beerware License; if you find the code useful, and we happen to cross
  paths, you're encouraged to buy us a beer. The code is distributed hoping
  that you in fact find it useful, but  without warranty of any kind.
------------------------------------------------------------------------*/


// NEW SHOW FUNCTION ---------------------------------------------------------
void show()
{
  noInterrupts();

  volatile uint8_t 
   *p    = sdBuf,                  // Copy the start address of our data array
    val  = *p++,                   // Get the current byte value & point to next byte
    high = PORT |  _BV(PORT_PIN),  // Bitmask for sending HIGH to pin
    low  = PORT & ~_BV(PORT_PIN),  // Bitmask for sending LOW to pin
    tmp  = low,                    // Swap variable to adjust duty cycle
    nbits= NUM_BITS,               // Bit counter for inner loop
    white= 3;

  volatile uint16_t nbytes =  N_LEDS*3;  // 4 Bytes per Led

  asm volatile(
    // Instruction        CLK     Description                 Phase
   "nextbit:\n\t"         // -    label                       (T =  0)
    "sbi  %0, %1\n\t"     // 2    signal HIGH                 (T =  2)
    "sbrc %4, 7\n\t"      // 1-2  if MSB set                  (T =  ?)         
    "mov  %6, %3\n\t"     // 0-1   tmp'll set signal high     (T =  4)
    "dec  %5\n\t"         // 1    decrease bitcount           (T =  5)
    "nop\n\t"             // 1    nop (idle 1 clock cycle)    (T =  6)
    "st   %a2, %6\n\t"    // 2    set PORT to tmp             (T =  8)
    "mov  %6, %7\n\t"     // 1    reset tmp to low (default)  (T =  9)
    "breq nextbyte\n\t"   // 1-2  if bitcount ==0 -> nextbyte (T =  ?)               
    "rol  %4\n\t"         // 1    shift MSB leftwards         (T = 11)
    "rjmp .+0\n\t"        // 2    nop nop                     (T = 13)
    "cbi   %0, %1\n\t"    // 2    signal LOW                  (T = 15)
    "rjmp .+0\n\t"        // 2    nop nop                     (T = 17)
    "nop\n\t"             // 1    nop                         (T = 18)
    "rjmp nextbit\n\t"    // 2    bitcount !=0 -> nextbit     (T = 20)

   "nextbyte:\n\t"        // -    label                       -
    "dec %10\n\t"         // 1    decrease colorcount         (T = 11)
    "breq whiteled\n\t"   // 1-2  if byte for whiteled   
    "nop\n\t"             // 1    nop                         (T = 13)
    "cbi  %0, %1\n\t"     // 2    signal LOW                  (T = 15)
    "ld   %4, %a8+\n\t"   // 2    val = *p++                  (T = 17)
    "ldi  %5, 8\n\t"      // 1    reset bitcount              (T = 18)

    "dec %9\n\t"          // 1    decrease bytecount          (T = 19)
    "brne nextbit\n\t"    // 2    if bytecount !=0 -> nextbit (T = 20)
    "rjmp done\n\t"       //      we are done, leave assembler code

   "whiteled:\n\t"        // -    label                       -
    "cbi  %0, %1\n\t"     // 2    signal LOW                  (T = 15)
    "clr  %4\n\t"         // 1    val= 0  (white led off)     (T = 16)
    "ldi  %5, 8\n\t"      // 1    reset bitcount              (T = 17)
    "ldi  %10, 4\n\t"     // 1    reset colorcount            (T = 18)
    "nop\n\t"             // 1    nop                         (T = 19)
    "rjmp nextbit\n\t"    // 2    if bytecount !=0 -> nextbit (T = 20)
   "done:\n\t"        // -    label                       -

    ::
    // Input operands         Operand Id (w/ constraint)
    "I" (_SFR_IO_ADDR(PORT)), // %0
    "I" (PORT_PIN),           // %1
    "e" (&PORT),              // %a2
    "r" (high),               // %3
    "r" (val),                // %4
    "r" (nbits),              // %5
    "r" (tmp),                // %6
    "r" (low),                // %7
    "e" (p),                  // %a8
    "w" (nbytes),             // %9
    "r" (white)               // %10
  );

  interrupts();
  delayMicroseconds(50);
} 


Und so sieht der improvisierte Aufbau aus:

 

Kleiner Hack für ein IKEA-Möbel

In diesem Post gibt es einen kleinen Hardware-Hack ganz ohne Elektronik ;-)

Wir haben seit einiger Zeit ein IKEA Billy-Schrank im Eingang stehen. Darin versorgen wir neben kleinem Krimskrams auf die Ladegeräte für unsere elektronischen Geräte. Aber so richtig praktisch war das nie. Immer wieder ist uns ein Ladegerät rausgefallen.

Deshalb habe ich eine kleine Schublade gebastelt und diese mit zwei Auszugschienen in den Schrank eingebaut. Et voilà das Problem gelöst.

Projekt Electronic Dice

Der Electronic Dice ist fertig!

Und hier ein kleines Video das den Electronic Dice in Action zeigt.

Projekt Electronic Dice: Die Software

Software für ein Mikrocontroller (Embedded System) zu schreiben unterscheidet sich in vielen Teilen stark von der Softwareentwicklung für Desktop, Server oder Mobile Devices.

Wie also schreibt man die Software für den elektronischen Würfel, den Electronic Dice? Was muss man beachten?

Der Arduino ist ein Single-threaded, Single-Process System. Es gibt also kein Betriebssystem, dass einem Parallelität ermöglicht. Der ATMega besitzt zwar Interrupts, diese werden aber bereits von vielen Arduino Bibliotheken verwendet. Deshalb wird der Electronic Dice keine Interrupts verwenden.

Die Software des Electronic Dice basiert auf einer Event-basierten Software-Architektur. Das heisst, der Programmcode reagiert auf auftretende Ereignisse und führt nur die gerade notwendigen Befehle aus. Danach gibt der die Programmkontrolle wieder an den Event-Loop (bei mir heisst dieser Scheduler) ab. Die Dice-Software orientiert sich also an der Idee des kooperativen Multitaskings (siehe Wikipedia: https://de.wikipedia.org/wiki/Multitasking#Kooperatives_Multitasking).

Das tönt alles komplizierter als es ist. Hier die Codesnippets die zeigen, wie der Scheduler funktioniert:

Der Mainloop des Arduino:

void loop() {
  Scheduler::getInstance()->run_once();
  delay(5);
}

Und der entsprechende Code des Schedulers:

void Scheduler::run_once() {
  for(int i = 0; i < MAX_EVENTS; i++) {   
    if (ev_list[i] != 0) {
      ev_list[i]->update();
    }
  }
}

Der Scheduler führt also eine Liste von Eventhandlern (ev_list), die er über die Methode update() aktualisiert. Ist ein Ereignis eingetreten, so führt der Eventhandler die entsprechende Aktion aus. Der Scheduler und die Eventhandler implementieren das bekannte Observer-Pattern (siehe Wikipedia: https://en.wikipedia.org/wiki/Observer_pattern).

Das ganze Eventhandling kann man als grosses Switch-Statement implementieren - oder man verwendet das State-Pattern um eine einfach State-Event-Machine zu implementieren (siehe Wikipedia: https://en.wikipedia.org/wiki/State_pattern). Welche States und Events gibt es beim Electronic Dice? Dazu habe ich ein kleines State-Diagramm entworfen.

  Wie das Ganze zusammengesetzt aussieht, zeigt das nachfolgende Klassendiagramm.

Und das komplette Bild er Dice-Software ist dann wie folgt. die Software besteht aus der Eigenentwicklung Dice sowie den beiden verwendeten Libraries CapSense für den Touch-Sensor und WS2801 zur Ansteuerung der RGB-Leds.

Also eigentlich alles ganz einfach ;-)

Projekt Electronic Dice: Die Hardware Teil 2

Es ist ein Aduino-Projekt. Aber nicht immer ist es notwendig deshalb ein Arduino Uno oder ähnlich einzusetzen. Es reicht oft einfach ein ATMega, ein Quarz und ein Spannungsregler. Wie das Bild unten zeigt, ist der Aufbau wirklich nicht kompliziert. Auf der Arduino Webseite gibt es gute Tutorials, um den Arduino Bootloader zu brennen und nachher das eigene Programm auf den Mikrocontroller zu laden: https://www.arduino.cc/en/Tutorial/ArduinoToBreadboard.

Projekt Electronic Dice: Die Hardware Teil 1

Meine neues kleines Projekt ist ein elektronischer Würfel. 7 RGB-Leds zeigen jeweils den Augenwert des Würfels an. Mit einem Taster kann man ein Würfelwurf auslösen. Auf der Suche nach einem Taster bin ich auf die CapitiveSense Library von Paul Badger gestossen. Cool! 2 Digital-Ports und ein 10MOhm und fertig ist der Touchsensor.

Das Schaltbild des Würfels sieht demnach wie folgt aus:

Wie man im Schema erkennt, verwende ich kein Arduino-Modul, sondern nur den gleichen Mikrocontroller, den ich vorab mit dem Arduino-Bootloader geflasht habe.

Projekt Electronic Dice: Zufall - ist gar nicht so einfach

Mein neues Projekt ist ein elektronischer Würfel. Und dazu braucht es natürlich Zufallszahlen. Wie man in vielen Beträgen lesen kann, ist es gar nicht so einfach gute Zufallszahlen mit dem Arduino zu generieren. Der beste Weg wäre wohl nur mit etwas zusätzlicher Hardware zu erreichen. Das wollte ich mir ersparen. Mit dem Arduino kommt ja bereits eine eingebaute Random Funktion mit. Es gibt auch noch weitere zusätzliche Libraries die man einsetzen kann.  Um mit der Random Funktion etwas zuspielen, habe ich ein kleines Script gemacht. Das Script würfelt 100'000 mal. Nachfolgende Grafiken zeigen, wie oft die einzelnen Würfelwerte vorgekommen sind:

Meine Erwartung war, dass bei einer grossen Zahl von Würfelwürfen, die Anzahl der Würfelwerte ungefähr gleich verteilt sind. Das erfüllt die Arduino Standardfunktion eigentlich ganz gut.

Interessant ist natürlich auch, wie gut die Zufallsfunktion bei nur wenigen Würfelwürfen streut. Hierzu folgende Statisik:

*************************** Arduino standard random funcation **************************
Run:    1 one:      3 two:      0 three:      1 four:      3 five:      0 six:    3
Run:    2 one:      3 two:      3 three:      2 four:      5 five:      1 six:    6
Run:    3 one:      5 two:      6 three:      2 four:      7 five:      3 six:    7
Run:    4 one:      7 two:      9 three:      3 four:     10 five:      3 six:    8
Run:    5 one:      8 two:     10 three:      4 four:     10 five:      5 six:   13
Run:    6 one:      8 two:     12 three:      8 four:     12 five:      5 six:   15
Run:    7 one:      9 two:     14 three:     12 four:     15 five:      5 six:   15
Run:    8 one:      9 two:     15 three:     14 four:     17 five:      7 six:   18
Run:    9 one:     12 two:     15 three:     18 four:     18 five:      7 six:   20
Run:   10 one:     12 two:     18 three:     20 four:     19 five:      9 six:   22
****************************************************************************************

******************************* TrueRandom libary **************************************
Run:    1 one:      3 two:      0 three:      0 four:      1 five:      4 six:    2
Run:    2 one:      6 two:      2 three:      0 four:      1 five:      7 six:    4
Run:    3 one:      9 two:      3 three:      1 four:      1 five:     10 six:    6
Run:    4 one:     11 two:      4 three:      2 four:      2 five:     11 six:   10
Run:    5 one:     12 two:      7 three:      5 four:      3 five:     11 six:   12
Run:    6 one:     14 two:      7 three:      9 four:      3 five:     13 six:   14
Run:    7 one:     15 two:     10 three:     10 four:      5 five:     15 six:   15
Run:    8 one:     17 two:     11 three:     13 four:      5 five:     16 six:   18
Run:    9 one:     19 two:     12 three:     16 four:      5 five:     19 six:   19
Run:   10 one:     22 two:     14 three:     18 four:      6 five:     20 six:   20
****************************************************************************************

Fazit: ich verwende mal die Standard Random Funktion vom Arduino. Für das Spiel sollte eigentlich die Qualität des Randomgenerators ausreichen.

Kleiner Hinweis: Beim Ausführen der Tests ist mir aufgefallen, dass die TrueRandom Funktion wesentlich langsamer ist.

Hinweis: Meine kleinen Tests sind natürlich nicht wissenschaftlich fundiert und nur sehr "hemdsärmlig".

Intervallometer für Nikon DSLR

Noch eine ältere gut funktionierende digitale Spiegelreflexkamera zu Hause? So ist es auch bei mir. Nachdem ich eine Nikon D7100 gekauft habe, bleibt die alte Nikon D80 zuhause im Schrank. Auf EBay oder Ricardo ist mit den alten DSLRs meist kein Geld mehr zu verdienen. Also was tun?

Meine Idee: Die alte DSLR für Zeitraffer (Timelapse) Aufnahmen benutzen. Für solche Zeitraffervideos nimmt man in Zeitabständen ein Foto auf. Die Aufnahmen montiert man am Ende zu einem Video zusammen. Es gibt im Netz wirklich coole Timelapsevideos. Neuere DSLRs haben die Intervallsteuerung bereits eingebaut - so auch meine D7100. Aber bei der D80 fehlt diese Funktion leider. Warum aber für die Zeitraffer-Aufnahmen nicht einfach die neue Kamera verwenden. Hier einige Gründe:

• Verschlussmechanik wird durch die vielen Aufnahmen stark belastet. Für ein Zeitraffervideo braucht es rasch mal 500 Aufnahmen.
• Eine alte Kamera kann man auch mal unbeaufsichtigt irgendwo hinstellen. Im schlimmsten Fall (Diebstahl, schlechtes Wetter) würde man ja nur eine alte "fast wertlose" Kamera verlieren
• Während der Zeitrafferaufnahme steht die neue Kamera für andere Fotos zur Verfügung.

Diese Überlegungen haben mich zum Bau eines Intervallometers geführt. Die benötigten Zutaten dazu: 1 Arduino Uno, 1 Display, 2 Optokoppler, ein paar Tasten, Widerstände und Leuchtdioden sowie ein Gehäuse.

Das Schema zeigt den Aufbau im Detail. Die beiden Optokoppler trennen den Stromkreis der DSLR vom Stromkreis des Mikrokontrollers. Warum braucht es 2 Optokoppler? Der Stecker für die elektrische Kamerauslösung verfügt über 2 Pins. Den einen zum aktiveren der Belichtungsmessung und Autofokus, den anderen Pin zum Auslösen der Kamera. Also Genauso wie der Auslöseknopf an der Kamera funktioniert.

Wie man im Schema erkennt, kann ich mit meinem Intervallometer die Kamera entweder über elektrisch über ein Kabel auslösen oder per Infrarotdiode. Zuerst hatte ich nur die Auslösung über die Infrarotdiode implementiert, dann aber feststellen müssen das die Kamera im Fernbedienungsmodus immer im aktiven Zustand (Belichtung und AF) ist und so sehr viel Strom braucht. Mehr als 6 Stunden Zeitraffer habe ich so nicht geschafft.

Wie bin ich bei der Entwicklung vorgegangen? Zuerst habe ich mich um die Hardware gekümmert.  Wie üblich habe ich einen kleinen Prototypen auf einem Breadboard aufgebaut. Das hat dann wie folgt ausgesehen.

Sobald ich sicher war, dass die Schaltung richtig funktioniert, habe ich die Bauteile auf einem Laborprint aufgelötet und diesen wie ein normales Arduino-Shield auf den Mikrokontroller-Shield aufgebaut.

Nach der Hardware folgt am Schluss die Entwicklung der Software. Die Software für das Intervallometer ist eigentlich recht einfach. Am meisten Aufwand steckt im "Menusystem". Zur Konfiguration des Intervallometers muss man ja über die Tasten Werte (z.B. Zeitdauer zwischen 2 Intervallen, Anzahl Intervalle) eingeben können. Leider habe ich im Internet dazu keine Bibliothek gefunden und musste daher selber etwas entwickeln.

DSL-Geschwindigkeit: Einfluss der Hausinstallation

Vor kurzem haben wir ein neues DSL-Produkt, welches uns schnelleres Internet bringen sollte. Bislang hatten wir 5000/500kBit/s und neu 15000/100kBit/s. Doch noch der Umschaltung waren wir schon etwas entäuscht. Die Internetverbindung war nicht viel schneller geworden.

In Blick auf das Modem zeigte, dass die Leitungskapazität bei gerade 10-12kBit/s lag.

Für die Ursachen der tiefen Leitungskapazität hatte ich zwei Vermutungen: Die Distanz zum DSLAM (Verteiler) und unsere Hausinstallation. Über die Jahre hatten es immer wieder Verlängerungen und Erweiterungen der analogen Telefoninstallation gegeben. Bereits eine erster Rückbau der nicht mehr benötigten Nebenstellen half die Leitungskapazität zu verbessern. Signifikant besser wurde es aber, als ich alle unbenutzen, nachträglich installierten Telefondosen und Leitungen abgehängt und an die Leitung vom Modem zur Dose direkt gezogen haben. Mittlerweilen zeigt mein Modem eine Leitungskapazität von 16900kbit/s. Und mit dem Speedtest erreiche ich nun die Sollwerte.

Der Vergleich der Signalspektren zeigt einen deutlichen Unterschied. Das Signal ist insgesamt stärker und einige Einbrücke im Spektrum sind ganz verschwunden.

Wenn man Schwierigkeiten mit der DSL-Leitung hat, lohnt es sich also, die eigene Hausinstallation zu überprüfen.

Mobiler Power für Arduino-Projekte

Mit der Arduino-Plattform lassen sich viele coole Projekte realisieren. Der Arduino lässt sich aur verschiedene Arten mit Strom versorgen. Aber gerade bei mobilen Projekten stellt sich die Frage nach der Stromquelle. Je nach Projekt braucht es schnell einmal 50mA oder mehr. Natürlich kann man die Speisung über normale AA(A)-Batterien realisieren.

Eine andere und aus meiner Sicht sehr elegante Variante ist die Verwendung einer sog. Powerbank zur Speidung des Arduinos. Powerbanks sind eigentlich hautpsächlich zum Laden von Smartphones, iPods, Tablets etc, unterwegs gedacht. Dank der hohen Akkukapazität, des hohen Outputstroms und des USB-Ausgangs lassen sich die Powerbanks aber auch einfach für die Stromversorgung von Arduino Projekten verwenden.

Für meine Projekte verwende ich eine TP-Link Powerbank. Diese verfügt über eine Kapazität von 10400mAh. Und damit lassen sich viele Arduino-Projekte schon über längere Zeit autonom betreiben.

Die Powerbank kommt auch bei meinem aktuellen Projekt, ein Intervallometer für meine alte Nikon D80, zum Einsatz.Auf dem Foto unten ist mein Prototyp Aufbau mit angeschlossener Powerbank zu sehen.

Und noch ein weiterer Hinweis für autonome Arduino-Projekte. Im Netz gibt es viele gute Anleitungen, Biblotheken, Hardware-Modifikationen, um den Stromverbrauch des Arduinos zu reduzieren.

Notebook RAM-Upgrade

Mein Asus Zenbook ux32vd ist rund 2 jährig und wurde mit 4 GB RAM ausgeliefert. Das Zenbook ist eigentlich ein Ultrabook, lässt sich aber im Gegensatz zu vielen anderen Ultrabook relativ einfach öffnen und erweitern. Das gilt zumindest für das RAM. Welche Werkzeuge braucht es dazu? Da wäre zuerst ein Torx T5 Schraubenzieher zum öffnen des Gehäuses. Da Teile des Gehäusedeckels mit einem doppelseitigen Klebeband verklebt sind ist zudem ein Kunststoff-Spachtel hilfreich. Da ich keinen solchen Spachtel besitze, habe ich Plektrum verwendet. Hilfreich ist auch ein ESD-Armband, welches durch den Potentialausgleich elektronische Bauteile zusätzlich vor Schäden durch statische Aufladung schützt.

Durch Internetrecherche habe ich den richtigen RAM-Typen bestimmt. Aufpassen, der Typ muss wirklich stimmen. Ins Asus ux32vd passen Kingston RAM (SO-DDR3 1600MHz 8GB
8GB, PC12800, 204Pin, CL11, 1.50V, Hersteller-Nr.: KVR16S11/8).

Vor dem Öffnen fährt man den Rechner am besten ganz herunter (Nicht den Standby- oder Hibernate-Modus verwenden). Danach alle Schrauben raus drehen. Die Schrauben am besten in eine kleine Schachtel legen, so dass sie nicht verloren gehen. (Ich könnte mir vorstellen, dass die gar nicht so einfach zu beschaffen sind). Anschliessend mden Deckel vorsichtig abheben und die Klebestellen mit dem Plektrum vorsichtig lösen.

Ist der Deckel weg, findet man den Steckplatz für das RAM eigentlich ganz leicht. ImSteckplatz befindet sich bereits ein 2GB-Riegel. Diesen muss man zuerst entfernen und danach das neue 8 GB-RAM stecken.

Nun den Deckel wieder aufsetzen und danach die Schrauben sorgfältig einsetzen und mit Gefühl anziehen. Damit ist die Operation fertig. Nun kann man den Rechner booten und im Taskmanager prüfen, ob das RAM funktioniert. Bei mir sind es nun 10 GB:

Ein RAM-Upgrade ist also gar nicht so schwierig. Vorausgesetzt, der Rechner lässt sich öffnen!

Eine Frage möchte ich noch klären: Braucht man überhaupt mehr als 4 GB RAM? Unter Windows 7/8 reichen eigentlich für normale Büro-Aufgaben 4 GB locker. Für virtuelle Maschinen (z.B. mit Virtualbox) oder beim Schneiden von Filmen ist zusätzliches RAM aber wirklich hilfreich. Zudem habe ich nun mit 10GB RAM die Auslagerungsdatei unter Windows deaktivieren können. Das ist insbesondere sinnvoll, wenn der Rechner (wie in meinem Fall) nur eine SSD besitzt.

Arduino Yun + Led Pixelstrip = Terrassenlicht

In unseren neuen Wintergarten braucht es auch die richtige Beleuchtung! Natürlich bietet sich Leds auch für den Ausseneinsatz an. An einen Microcontroller angeschlossen, lassen mit mehrfarbigen Leds abwechslungsreiche Lichtstimmungen erzeugen. Hardwareseitig gibt es nicht viel Arbeit. Meine Stückliste:

1 Aduino Yun (Microcontroller mit WLan)
2 Led Pixelstrip (50 Leds), Spritzwasserfest (IP67) pro Led ein WS2801 zu Ansteuerung
1 Netzteil 5V 8A
1 Gehäuse

Aufgebaut sieht das dann ungefähr so aus:

Die Softwareseite ist etwas aufwändiger. Die Programmierung des Arduino ist relativ einfach. Guter Einstiegspunkt ist die offizelle Aduino-Webseite: http://www.arduino.cc/. Zum Glück gibt es zur Ansteuerung der Leds und zur Kommunikation mit dem WLan-Chip gute Bibliotheken. Ich habe von der Arduino Bridge-Library die Mailbox-Funktionen übernommen. Damit lässt sich asynchron zwischen Microcontroller und WLan-Chip kommunizieren.

Der Vorteil am Arduino ist, dass alles gut zusammenpasst. Das Arduinoboard verfügt über einen USB-Anschluss und lässt sich direkt aus der Arduino-Entwicklungsumgebung programmieren. Mit dem Arduino YUN ist das sogar über WLan möglich. Das ist für mich sehr praktisch, weil ich auch nach dem fertigen Einbau meine Software weiterentwickeln und updaten kann. Herausfordernd am Arduino sind die technischen Daten. 2.5k Ram und 32k Flash sind nicht sehr viel. (300 Byte sind schon nur nötig, um die RGB-Werte der 100 Leds im Speicher zu halten.)

Weil jede Led von einem WS-2801 angesteuert ist, kann jede Led individuell angesteuert werden. Pro Led können also separate Rot-, Grün- und Blauwerte setzen. Die Leds sind über einen seriellen Bus miteinander verbunden. Das vereinfacht die Verkabelung natürlich stark. Wegen des seriellen Busses machte ich mir zunächst etwas Sorgen bezüglich der maximalen Übertragungsrate. Bei 100 Leds braucht man sich aber keine Sorgen zu machen.  In einem einfachen Test kam ich auf ca. 40 FPS. D.h. es wäre möglich ca 40 Mal pro Sekunde die RGB-Werte aller Leds neu zusetzen.

Zur Steuerung des Microcontrollers und damit schlussendlich der Leds habe ich einen einfachen Webclient geschrieben. Der Webclient verwendet Twitter Bootstrap und etwas Javascript. Der Client ist damit auf unterschiedlichen Endgräten lauffähig. Getestet habe ich das auf meinem Notbook, einem IPad und einem Samsung S4 Mini.

Und zum Schluss ein Video, dass die Bastelei in Action zeigt:

Stativadapter für Nikkon 70-300mm 4.5-5.6

Ich verwende seit längerem das Nikon 70-300 Telezoom. Eigentlich finde ich das Objektiv ganz passabel. Was mich aber seit längerem stört ist der Einsatz am Stativ. Da das Objektiv keine Stativschelle hat, muss man die Kamera am Stativ befestigen. Da das Objektiv im 300mm-Bereich relativ lang und insgesamt auch recht schwer ist, wird der Kugelkopf von meinem Manfrotto-Stativ stark beansprucht. Wenn man den Kopf nicht richtig stark festschraubt, sinkt das Objektiv langsam nach unten. Leider gibt es bei Nikon keine passende Stativschelle zu kaufen.

Meine erste Idee war, selber eine Stativ-Schelle für das Objektiv herzustellen. Allerdings sind die dazubenötigten Teile relativ aufwändig und wohl nur mit einer Fräse ordentlich herzustellen. Deshalb habe ich mich für eine einfachere, aber durchaus funktionierende Alternative entschieden: Und zwar habe ich aus einem alten Stück Alu und einer gekauften Manfrotto-Wechselplatte folgenden Stativadapter gebaut:

Die Manfrotto Schnellwechselplatte habe ich zerlegt. Die Platte selbst habe ich an das lange Alstück geschraubt, die Stativschraube von der Schnellwechselplatte habe ich zur Besfestigung der Kamera im vorderen Bereich des Alustücks montiert (im Bild rechts).

Damit lässt sich nun der Schwerpunkt von Kamera und Objektiv so versetzen, dass er sich im Bereich des Stativkopfes befindet. Damit ist es nun problemlos möglich, die Kamera stabil auf dem Stativ auszurichten.

Erstes Arduinoprojekt - ein Tresor für Kinder

Zusammen mit meinem Sohn habe ich ein erstes Arduino-Projekt realisiert. Ein einfacher Tresor sollte es werden. Vier Tasten dienen zur Code-Eingabe. Ist der Code richtig, dreht sich im Innern ein Servo um ca 90 Grad. Danach kann die Türe geöffnet werden. Selbstverständlich kann der Code jederzeit geändert werden.
Hier der Schaltplan:

Anstelle eines Arduino Uno Boards, habe ich mich entschieden einen rohen ATMega 328 zu kaufen mit einem Quarz zu beschalten und via bereits vorhandenen Arduino Uno den Bootloader selber zu brennen.Dazu gibt es gute Anleitungen: http://arduino.cc/en/Tutorial/ArduinoISP

Hier der Prototyp, noch mit einem Arduino Uno Board aufgebaut. Den definitiven Aufbau habe ich dann auf eine Laborprintplatte aufgelötet.

Und so sieht der Tresor fertig zusammengebaut aus:

Diascanner selbstgebaut

Vor rund einem Jahr habe ich mit einer D-SLR und einem alten Diaprojektor einen Diascanner selbst gebaut. Für die Interessierten: Das Projekt habe ich hier dokumentiert: http://homemadediascanner.blogspot.ch