Wir bauen eine Fotobox

feier_0285__hi_7387

Auf vielen Hochzeiten und Veranstaltungen ist eine Fotobox inzwischen nicht mehr wegzudenken. Und weil auch bei mir die Nachfrage immer mehr gestiegen ist dachte Ich mir dass es auf Dauer doch anstrengend, und riskant für die Hardware ist, immer eine (dritte) Kamera auf einem Stativ + Blitzanlage + Laptop mitzunehmen, aufzubauen und irgendwo unbeobachtet abzustellen.
Also kam der Wunsch nach einer Fotobox auf.

Überlegungen

Nur in welcher Form? Selbst gebaut oder gekauft? Klein und Handlich oder doch eher Stabil? Eine kurze (gut.. lange) Suche im Internet ergab keine – für mich im Preis vertretbare – Lösung. Weder im Komplett-System Bereich, noch als reine Softwarelösung in Kombination mit individuellem Kamera-Aufbau.
Wichtig waren mir folgende Dinge:

  1. Gute Bildqualität
  2. Sofortiges Auslösen (kein „3-2-1 … Los!“)
  3. Möglichst alles in einer Kiste (kein Vergessen von einer essentiellen Kiste möglich)
  4. Möglichst wenig Software.

Weniger wichtig, aber nice to have:

  1. Drucker
  2. Upload über WiFi/Mobil/LAN zu FB/Instagram/FTP/WebDAV (Next/Own-Cloud)
  3. Diashow

Also blieb ‚leider‘ nur eine Wahl – erst mal selber bauen und dann noch die Software dazu entwickeln.

Gut, welche grundsätzliche Möglichkeiten gibt es dabei:

  1. Eine Software wartet auf ein Bild von einer extern ausgelösten Kamera.
  2. Die Software löst die Kamera aus und wartet auf ein Bild
  3. Die Kamera wird extern ausgelöst und zeigt das Bild über ihren Monitorausgang an.

Möglichkeit 2 habe ich aussortiert wegen Punkt 2 aus der oberen Liste. Die Kamera soll ohne jegliche Verzögerung direkt auf Knopfdruck auslösen.

Punkt 3 fällt wegen des limitierten Post-Processings weg. Also Bleibt Punkt 1, die Kamera wird ausgelöst und ein Stück Software wartet auf den Empfang der Bilder und verarbeitet diese weiter.

Aber: Ich kann doch wohl nicht der erste sein der so etwas plant. Also wieder intensiv gesucht und ein paar Windows / Linux / Raspberry-Pi / Intel NUC DIY Projekte gefunden. Letztendlich gab es aber defintiv keine Lösung die mir in allen Punkten gefallen hätte.

Es gibt auch (kommerzielle-) Projekte die das ganze mit einer Software auf Windows oder mit einer App auf dem iPad lösen. Extra ein iPad für den Zweck kaufen sah ich aber nicht ein + Display finde ich zu klein.

Ein weiteres kleines Hindernis: ich spreche kein kaum Phython.

Das System

Nun gut, dann ein paar Überlegungen zum System:

Intel NUC mit Windows an Bord… und dann … wo hab ich noch mal die übrigen Windows Lizenzen im Regal liegen?

Realistisch betrachtet ist das für die einfache Anwendung eine große Investition.. gut > 200€ für das Board + 100€ für eine Windows Lizenz.

Okay, weiter.. also doch ein alter PC mit nem Linux drauf? Oder ein Raspberry?

Ich habe mich für die Himbeere entschieden aus folgenden Gründen:

  • Kosten. 30€ und gut ist. 50€ mit bisschen Zubehör und Gehäuse.
  • Rechenleistung: ausreichen (vermutlich)
  • Linux / Opensource / Stabil
  • BASH (später mehr dazu)
  • Stromverbrauch
  • Hardwarenah (=ich kann einfach Tastschalter anschließen..)

Die Softwarelogik

Für Windows gibt es einige kommerzielle Produkte die wirklich lohnenswert sind (Hier Hier und Hier gibts ne ganz gute Linksamlung)

Ich dachte mir aber: wenn schon Raspberry und Linux, dann muss das doch auch gescripted gehen. Und Jap, auch dafür gibts schon Projekte: Hier z.B… Sogar mit Druckfunktion über CUPS.. cool!

Jetzt stand also nicht mehr viel im Weg und der Plan war klar:

Ein Proof of concept musste her, schwupps einen neuen raspberry pi 3 bestellt, installiert und betriebsbereit gesetzt, nach langem hin und her wurde ein grundsätzlicher Aufbau der Software entwickelt:

[Hier Bild vom Aufbau einfügen – der eine Fresszettel den hoffentlich noch keiner weggeworfen hat..]

  • gphoto2 zum aquirieren der Bilder
  • qic zum anzeigen der Bilddaten
  • xscreensaver zum ausschalten der Kennwortabfrage
  • /var/pfad/zum/schalter zum anschalten von LEDs und abfragen von gedrückten Schaltern.

Zum simplen Auslösen und dem einlesen der Bilder kam dann noch eine Druckfunktion hinzu, dafür habe ich mich auch CUPS bedient und einen Canon Selphy 910 damit angesteuert (es gehen überigens auch die aktuellen Versionen mit den alten Treibern… ).
Über drei beleuchtete Knöpfe im Case können dann verschiedene Funktionen ausgelöst werden. Die Beleuchtung der Knöpfe („Vandalismusschalter“) sollte vom Raspi aus gesteuert werden. Also nur die Funktion die in der Software auch aktiviert wurde hat ein leuchten des dementsprechenden Knopfes zur folge. Cool oder? Naja. Später mehr dazu.

Der Anlass

Ein konkretes Datum (=a.k.a Deadline) verleiht dem Bastler und Programmierer bekanntlich Flügel. So auch mir. Eine (private) Hochzeit stand an wo das Ding einfach mit musste. Ich war als Gast eingeladen und sollte nur eine Fotobox mitbrignen – und als Backup war ja immer noch der ursprüngliche Aufbau verfügbar..

Die Hardware

Die Hardware sollte vor allem eines sein:

Robust.

Und dann noch schick aussehen, ich hab mich für einen „Veranstaltungstechnik – Style“ entschieden.

Als Komponenten wurden:

  • Eine alte DSLR (Canon EOS 400D)
  • ein Studioblitz (Elinchrome D1 Rite )
  • Stangen und Halterungen (K&M)
  • Ordentliche Steckverbindungen (Neutrik)
  • 19″ Rack (thomann.de)

ausgewählt. Vieles davon bei eBay, einiges direkt beim Hersteller bzw. über thomann.de bestellt.
Eine detaillierte Komponentenliste stell ich sicher irgenwann mal online..

Und dann gings daran die Hardware zu basteln:

Der „Schaltplan“

Alle Steckverbindungen nach aussen sollen am liebsten über Standardkomponenten laufen, und zwar Verpolungssicher (also zumindest fast), es gibt also an der Kiste viele USB Anschlüsse die durch das Rack nach innen geführt werden zum anschließen von z.B. USB Sticks, oder externen Druckern oder Tastatur & Maus.  Es gibt zusätzlich auch einen RJ45 Anschluss der nach innen weitergeführt wird, und die ganze Stromversorgung wird per Powercon angeschlossen. Die Stecker lassen sich nicht „ausversehen“ ziehen (Raster) und sind quasi farblich markiert (Blau is rein, Grau is raus..). Die Kamera wird oben in einer extra Kiste verbaut und mit 10 Adern angeschlossen (geführt über 2x DMX 5 Pol Kabel), die 10 Adern werden gebraucht für: 4xUSB, 2x Blitzauslöser, 2x Stromversorgung, 2x Remoteauslöser. Der Studioblitz wird über ein 6,3mm Kabel + Powercon, der Monitor über HDMI + Powercon angeschlossen.

Es hätte sicherlich auch noch andere möglichkeiten gegeben die Kabel zu führen (siehe z.B. bei www.fotobuzzer.com) aber ich fand die Idee ganz nett 🙂

Der "Schaltplan"
Der „Schaltplan“ der Box.

 

Der Auslöser

Ausgelöst werden kann die Kamera über zwei Systeme die beide letztendlich nur den Stromkreis am Fernauslöseport der 400D schließen.
Es gibt einen Funk und einen Kabelgebundenen Auslöser, beide Systeme benutzen als Buzzer einen „Grobhandtaster“.

Wie man sowas bastelt findet man z.B. Hier. Ich schalte dann einfach mit einem Kippschalter zwischen beiden Auslösemöglichkeiten um.

 

Die beiden Auslöser. Links mit Kabel, rechts per Funk
Die beiden Auslöser.

 

Die Verkabelung bis auf das fehlende Batteriefach in der Übersicht
Die Verkabelung bis auf das fehlende Batteriefach in der Übersicht

 

Der Funkauslöser in der Seitenansicht
Der Funkauslöser in der Seitenansicht

 

Der fertige Funkauslöser
Der fertige Funkauslöser

 

 

Das Case

Ordentliches Tour-Case, ausgebaut mit 19″ Rack schienen und Blue-Wheels. So mag ich das.

Hier ein paar Bilder vom Enstehungsprozess.

fotoboxbauen_0013_img_4695 fotoboxbauen_0014_img_4699 fotoboxbauen_0004_img_4657 fotoboxbauen_0005_img_4658 fotoboxbauen_0006_img_4665 fotoboxbauen_0002_img_4652 fotoboxbauen_0017_img_4734

Das kleine Case für die Kamera habe ich selbst gebaut – wenn man es ganz genau betrachtet sieht man das auch.. Casebauer werde ich wohl nicht mehr in diesem Leben 😀

Die Halterungen sind Lautsprecherhalterungen von K&M, die Halterung vom Monitor ist eine K&M VESA Halterung adaptiert auf einen Mikrofonständer, adaptiert auf eine ‚Lautsprecher Disstanz stange – mit Mikrofon 3/8″ Aufnahme‘ (von K&M). Dies war die einfachste Lösung ohne etwas basteln zu müssen.

 

Das Kamera Case

Wie bereits geschrieben.. ich werde wohl kein Casebauer mehr. Grundsätzlich ganz okay, man darf es nur nicht von innen betrachten. Die Kamera sitzt übrigens auf einem Manfrotto Kopf und die Schraube geht nach unten durch und wird durch die „Boxenaufnahme“ verschraubt (Bild folgt), sie ist also direkt auf der Distanzstange fixiert und die Multiplexplatte wird dadurch nicht so arg belastet.

fotoboxbauen_0008_img_4672 fotoboxbauen_0007_img_4669 fotoboxbauen_0010_img_4679 fotoboxbauen_0009_img_4677

 

Hier noch ein wenig Kabelwirrwar mit dem ich die Kamera angeschlossen habe:

fotoboxbauen_0012_img_4685

 

Die Programmierung

Die ersten Testläufe des Systems sahen dann so aus:

fotoboxbauen_0015_img_4704 fotoboxbauen_0018_img_4736 fotoboxbauen_0019_img_4737

Programierung/Scripten direkt auf dem Gerät (oder an und an remote über eine SSH Verbindung).

Es ging schnell vorran und war auch recht produktiv, nach kurzer Zeit mehreren Tagen ging dann auch die Druckfunktion endlich zuverlässig:
fotoboxbauen_0020_img_4741

Gut. Den mittlerweile stand auch schon der Abend vor der oben genannter Hochzeit an.. und es gab nur noch eine Sache die mir Probleme bereitete. Aber das war eher eine Kleinigkeit:

Das einzige was noch nicht funktionierte war die Ansteuerung der Schalter, bzw. genauer das Anschalten der einzelnen LEDs im Schalter, da die Vandalismusschalter (von conrad.de) mit integrierten Vorwiderständen kamen und dadurch im gesamten mehr Strom zogen als über die direkt schaltbaren IOs des Raspberries verfügbar waren. Leider bin ich ja Mediziner und kein E-Techniker und somit ist es vollkommen legitim dass ich wohl beim berechnen und/oder verlöten der Transistorschaltung einen klitzekleinen winzigen Fehler gemacht und mir dadurch (vermutlich) die Stromregelung des Raspis zerschossen habe. Zumindest wurde der Raspi extrem Warm (>80°C) und war kaum noch zu bedienen. Sch… also PlanB – da muss doch noch irgendwo ein anderer Raspi (V2) rumliegen.

Geht schon, Rechenleistung passt so grob, WLAN brauch ich nicht zwingend, und wenn geht das ja auch über USB..

Also kurz Speicherkarte tauschen und … nichts geht mehr.

Nicht mehr lesbar, zerstört, kaputt.

Wo genau habe ich nochmal entwickelt? Richtig. Auf dem Raspi. Als Kopie gab es nur eine extrem alte Version deren Ansatz nicht funktioniert hatte.
Das war dann der Zeitpunkt in dem ich eigentlich in’s Auto hätte steigen sollen um loszufahren.

Also dann. Abfahrt um eine Nacht verschieben und aus dem Kopf alles nochmal neu runterschreiben. Hochzeit war ja erst am nächsten Tag. Dann halt ohne den Fancy Stuff, ohne den Daemon der alles automatisch startet, ohne die Jobs die im Hintergrund wieder aufräumen, ohne den Drucker, ohne die sch… Schalter.

Das war vor einem Jahr. Und bekanntlich hält nichts länger als ein Provisorium.
Die Software ist also immer noch in einem Zustand in dem die Schalter nicht aktiviert werden können, die Platine dazu gibts noch nicht und die ganze Kiste ist noch ein wenig Benutzerunfreundlich….

Aber dafür kommt hier demnächst der kommentierte Code der Bash-Scripte 🙂

 

Aufbau der Ordnerstruktur

/bin   <– Beinhaltet alle Scripte
/config   <– Alle config Dateien
/files  <– in Unterordnern werden die Fotos gespeichert

 

// Note: Hier stimmt was nicht mit dem Synatxhighlightning – Schreibt mir eine Email dann gibts den aktuellen Code

// sobald ich dazukomme wird das hier gefixt!

 

Das Konfigurationsscript:

[code lang=“shell“ title=“bin/config_photobox.sh“ collapse=“true“]

#!/bin/bash

#mit diesem Script wird die Box konfiguriert und alle Parameter in die /home/pi/photobox/config/XYZ.cfg dateien geschrieben.
# alternative: eine config datei und als array laden… mal schauen was geschickter ist.
#Alle andere scripte greifen auf die config datei zu.

#Config Files einlesen
. &lt;(cat /home/pi/photobox/config/*) clear # Den Namen der Session definieren, wird für Verzeichnis und Dateinamen benötigt
echo „Titel dieser Fotosession?“
echo „Bitte ohne Leerzeichen, wird für den Dateinamen benutzt“ read -p „[ENTER]:${jobname} ODER [Sessionname eingeben]:“ jobnameNeu case „$jobnameNeu“ in ENTER|““)
echo „Titel auf ${jobname} festlegen…“
sleep 1
echo „#!/bin/bash“ &gt; $configdir/jobname.cfg
echo „jobname=${jobname}“ &gt;&gt; $configdir/jobname.cfg
;;
*)
echo „Titel auf ${jobnameNeu} festlegen…“
sleep 1
echo „#!/bin/bash“ &gt; $configdir/jobname.cfg
echo „jobname=${jobnameNeu}“ &gt;&gt; $configdir/jobname.cfg
;;
esac

echo „“
echo „“
echo „“

# Drucker aktivieren?

echo „Druckfunktionen aktivieren?“
echo „Enter = alte Konfiguration“
read -p „[J]a | [N]ein | [Enter]: “ printerNeu
case „$printerNeu“ in
ENTER|““)
echo „#!/bin/bash“ &gt; $configdir/printer.cfg
echo „printer=${printer}“ &gt;&gt; $configdir/printer.cfg
if [[ „${printer}“==“true“ ]]
then
echo „Druckfunktionen bleiben aktiviert“
else
echo „Druckfunktionen bleiben deaktiviert“
fi
;;
J|j)
echo „#!/bin/bash“ &gt; $configdir/printer.cfg
echo „printer=true“ &gt;&gt; $configdir/printer.cfg
echo „Drucker wird aktiviert“
;;
n|N|*)
echo „#!/bin/bash“ &gt; $configdir/printer.cfg
echo „printer=false“ &gt; $configdir/printer.cfg
echo „Drucker wird deaktiviert“
;;
esac
echo „“
echo „“
echo „“

# Hashtag abfragen
sleep 0
echo „#-Tag für Twitter/Facebook/Instagram festlegen“
echo „bitte kein # Zeichen eingeben“
read -p „[ENTER]:#${hashtag} ODER [Hashtag eingeben] “ hashtagNeu
case „$hashtagNeu“ in
ENTER|““)
echo „Hashtag #${hashtag} speichern…“
sleep 1
echo „#!/bin/bash“ &gt; $configdir/hashtag.cfg
echo „hashtag=${hashtag}“ &gt;&gt; $configdir/hashtag.cfg
;;
*)
echo „#!/bin/bash“ &gt; $configdir/hashtag.cfg
echo „hashtag=${hashtagNeu}“ &gt;&gt; $configdir/hashtag.cfg
echo „Hashtag #${hashtagNeu} speichern…“
sleep 1
;;
esac

echo „“
echo „“
echo „“

#
# Facebook aktivieren
#

sleep 0
echo „Sollen Bilder zu Facebook gepostet werden wenn der FB-Knopf gedrückt wird?“
echo „INFO: Der Facebook Knopf leuchtet gerade“
if [[ ${facebook} == „true“ ]]
then
echo „[ENTER] drücken um weiterhin zu Facebook posten zu können“
else
echo „[ENTER] drücken um weiterhin nichts zu Facebook posten zu können“
fi
echo „TODO: Button leuchten lassen….“
echo „“
read -p „Facebook aktivieren?: [J]a | [N]nein | [ENTER] für alte Einstellungen: “ facebookNeu
case „$facebookNeu“ in
J|j)
echo „Facebook wird aktiviert“
echo „#!/bin/bash“ &gt; $configdir/facebook.cfg
echo „facebook=true“ &gt;&gt; $configdir/facebook.cfg
;;
n|N)
echo „Facebook wird deaktiviert“
echo „#!/bin/bash“ &gt; $configdir/facebook.cfg
echo „facebook=false“ &gt;&gt; $configdir/facebook.cfg
;;
„“)
if [[ „${facebook}“ = „true“ ]]
then
echo „Facebook bleibt aktiviert“
echo „#!/bin/bash“ &gt; $configdir/facebook.cfg
echo „facebook=true“ &gt;&gt; $configdir/facebook.cfg
else
echo „Facebook bleibt deaktiviert“
echo „#!/bin/bash“ &gt; $configdir/facebook.cfg
echo „facebook=false“ &gt;&gt; $configdir/facebook.cfg
fi
;;
*)
echo „Facebook wird deaktiviert“
echo „#!/bin/bash“ &gt; $configdir/facebook.cfg
echo „facebook=false}“ &gt;&gt; $configdir/facebook.cfg
;;
esac

echo „“
echo „“
echo „“

#
# Twitter aktivieren
#
sleep 0
echo „Sollen Bilder zu Twitter gepostet werden wenn der Twitter-Knopf gedrückt wird?“
echo „INFO: Der Twitter Knopf leuchtet gerade“
if [[ „${twitter}“ = „true“ ]]
then
echo „[ENTER] drücken um weiterhin zu Twitter posten zu können“
else
echo „[ENTER] drücken um weiterhin nichts zu Twitter posten zu können“
fi
echo „TODO: Button leuchten lassen….“
echo „“
read -p „Twitter aktivieren?: [J]a | [N]nein | [ENTER] für alte Einstellungen: “ twitterNeu
case „$twitterNeu“ in
J|j)
echo „Twitter wird aktiviert“
echo „#!/bin/bash“ &gt; $configdir/twitter.cfg
echo „twitter=true“ &gt;&gt; $configdir/twitter.cfg
;;
n|N)
echo „Twitter wird deaktiviert“
echo „#!/bin/bash“ &gt; $configdir/twitter.cfg
echo „twitter=false“ &gt;&gt; $configdir/twitter.cfg
;;
„“)
if [[ „${twitter}“ == „true“ ]]
then
echo „Twitter bleibt aktiviert“
echo „#!/bin/bash“ &gt; $configdir/twitter.cfg
echo „twitter=true“ &gt;&gt; $configdir/twitter.cfg
else
echo „Twitter bleibt deaktiviert“
echo „#!/bin/bash“ &gt; $configdir/twitter.cfg
echo „twitter=false“ &gt;&gt; $configdir/twitter.cfg
fi
;;
*)
echo „Twitter wird deaktiviert“
echo „#!/bin/bash“ &gt; $configdir/twitter.cfg
echo „twitter=false}“ &gt;&gt; $configdir/twitter.cfg
;;
esac
echo „“
echo „“
echo „“

#
# Instagram aktivieren
#

sleep 0
echo „Sollen Bilder zu Instagram gepostet werden wenn der Instagram-Knopf gedrückt wird?“
echo „INFO: Der Instagram Knopf leuchtet gerade“
if [[ „${instagram}“ == „true“ ]]
then
echo „[ENTER] drücken um weiterhin zu Instagram posten zu können“
else
echo „[ENTER] drücken um weiterhin nichts zu Instagram posten zu können“
fi
echo „TODO: Button leuchten lassen….“
echo „“
read -p „Instagram aktivieren?: [J]a | [N]nein | [ENTER] für alte Einstellungen: “ instagramNeu
case „$instagramNeu“ in
J|j)
echo „Instagram wird aktiviert“
echo „#!/bin/bash“ &gt; $configdir/instagram.cfg
echo „instagram=true“ &gt;&gt; $configdir/instagram.cfg
;;
n|N)
echo „Instagram wird deaktiviert“
echo „#!/bin/bash“ &gt; $configdir/instagram.cfg
echo „instagram=false“ &gt;&gt; $configdir/instagram.cfg
;;
„“)
if [[ „${instagram}“ == „true“ ]]
then
echo „Instagram bleibt aktiviert“
echo „#!/bin/bash“ &gt; $configdir/instagram.cfg
echo „instagram=true“ &gt;&gt; $configdir/instagram.cfg
else
echo „Instagram bleibt deaktiviert“
echo „#!/bin/bash“ &gt; $configdir/instagram.cfg
echo „instagram=false“ &gt;&gt; $configdir/instagram.cfg
fi
;;
*)
echo „Instagram wird deaktiviert“
echo „#!/bin/bash“ &gt; $configdir/instagram.cfg
echo „instagram=false}“ &gt;&gt; $configdir/instagram.cfg
;;
esac
echo „“
echo „“
echo „“

# USB Stick löschen?
sleep 3
echo „Den PHOTO-STICK komplett löschen?“
read -p „Um ALLE Bilder zu löschen ‚DELETE‘ tippen und [ENTER] drücken“ loeschen
case „$loeschen“ in
DELETE)
echo „alles löschen…“
sleep 1
if sudo rm $usbstick/* -R -f
then
echo „alles gelöscht.“
else
echo „Fehler beim löschen“
fi
;;
*)
echo „“
echo „Es wird NICHTS gelöscht…“
sleep 1
;;
esac

sleep 2
clear
echo „Fotobox wird gestartet…“
sleep 1
sh ${bindir}/start_photobox.sh

[/code]

Das Script zum anzeigen der Bilder

[code lang=“shell“ collapse=“true“ title=“bin/display_fotos.sh“]

#!/bin/bash

# Config Files einlesen
. &lt;(cat /home/pi/photobox/config/*)

# Ablauf:

# 1. mit inotify den folder überwachen
# 2. mit FEH fullscreen das Bild anzeigen
# 3. wenn neues inotify kommt neues FEH starten und das alte FEH killen und gleich weiter gehts…
# 4. Wenn XX sekunden nichts neues gekommen ist wird aufgehört mit warten
# 5. Eine Slideshow wird gestartet (immer eins groß oder vier kleien oder sowas…)
# 6. Sobald eine neue Datei ankommt wird die slideshow unterbrochen und es wird wieder das aktuelle bild angezeigt.
# Erst mal aufräumen…
killall -9 feh 2&gt; /dev/null
rm -f /tmp/slideshow*.pid

inotifywait –event MOVED_TO –format %w%f –quiet $fotodir/$jobname/ | while read STARTFILE
do
#Das erste mal ein Bild anzeigen und aktuelle PID files anlegen.
echo Mögen die Spiele beginnen!
feh $STARTFILE –fullscreen –hide-pointer –auto-zoom &amp;
echo $! &gt; /tmp/slideshow.pid
done
#timenow=$(date +%s)
#limit=$(($starttime+$waiting))
while true
do

timenow=$(date +%s)
limit=$(($timenow + $waiting))

echo „Zeit: $timenow $waiting $limit“
while [ „$timenow“ -le „$limit“ ]
do

echo Huiiiiiii….. nochmal!

inotifywait –event MOVED_TO –format %w%f –quiet –timeout 10 $fotodir/$jobname/ | while read FILE

do
echo Warten auf mehr Bilder….

# Reset des timeouts… wird am anfang gemacht dass wenigstens einmal sicher durchlaufen werden kann
timenow=$(date +%s)
limit=$(($timenow+$waiting))
echo „Zeit: $timenow $waiting $limit“
feh $FILE –fullscreen –hide-pointer –auto-zoom &amp;
echo $! &gt; /tmp/slideshow.pid

if [ -a /tmp/slideshow_bg.pid ]
then
kill -TERM $(cat /tmp/slideshow_bg.pid)
sleep 1
rm -f /tmp/slideshow_bg.pid
fi

if [ -a /tmp/slideshow_2.pid ]
then
sleep 1
kill -TERM $(cat /tmp/slideshow_2.pid) &amp;
fi
echo $(cat /tmp/slideshow.pid) &gt; /tmp/slideshow_2.pid
done
timenow=$(date +%s)
done

# Aufräumen
#rm -f /tmp/slideshow.pid

# 5. Slideshow starten
# danach den aktuellen Bildbetrachter killen
# alternativer parameter -&gt; „–sort mtime“ damit wird von neu -&gt; alt sortiert und angezeigt. Auch ganz lustig 🙂

echo Mir ist langweilig… ich zeig mal irgendwas an…
feh –fullscreen –hide-pointer –auto-zoom –slideshow-delay 5 –randomize $fotodir/$jobname &amp;
echo $! &gt; /tmp/slideshow_bg.pid

if [ -a /tmp/slideshow_2.pid ]
then
sleep 2
kill -TERM $(cat /tmp/slideshow_2.pid) &amp;
fi

# Wenn eine neue Datei erstellt wird diese anzeigen und die BG Slideshow killen

inotifywait –event MOVED_TO –format %w%f –quiet $fotodir/$jobname/ | while read BREAKFILE
do
echo Oha! Es geht weiter….
feh $BREAKFILE –fullscreen –hide-pointer –auto-zoom &amp;
echo $! &gt; /tmp/slideshow_2.pid
sleep 2
kill -TERM $(cat /tmp/slideshow_bg.pid) &amp;
done

done # arbeiten und arbeiten und arbeiten und arbeiten …. schleife….
[/code]

Kritische Überlegungen

  • Einfacher wäre eine fertige Lösung gewesen – aber nicht so interessant
  • Die Kiste wiegt sehr viel – Vor und Nachteil – Stabilität vs. Flexibilität
  • Bugs in den Scripten… es darf gerne geholfen werden 😉
  • Backup Backup Backup! – Hab ich hiermit getan..