Neutrino:Skripte - Versionsgeschichte

WikiBot: Bot: Fixing redirects

2011-08-22T08:57:43Z

Bot: Fixing redirects

← Nächstältere Version		Version vom 22. August 2011, 10:57 Uhr
Zeile 9:		Zeile 9:


	'''''Hinweis:''' Der Menüpunkt Skripte (im [[Neutrino:~~Hauptmenu~~\|Neutrino Hauptmenü]] - dbox Taste) ist nur vorhanden, wenn mindestens ein Skript existiert.''		'''''Hinweis:''' Der Menüpunkt Skripte (im [[Neutrino:Hauptmenü\|Neutrino Hauptmenü]] - dbox Taste) ist nur vorhanden, wenn mindestens ein Skript existiert.''


Zeile 37:		Zeile 37:


	Nach einem Neustart der [[DBox2]] sollte der Menüpunkt "Skripte" im Hauptmenü (dbox Taste) vorhanden sein. Hier kann jetzt das angelegte Script ausgewählt und damit ausgeführt werden:		Nach einem Neustart der [[Hardware:dbox2\|DBox2]] sollte der Menüpunkt "Skripte" im Hauptmenü (dbox Taste) vorhanden sein. Hier kann jetzt das angelegte Script ausgewählt und damit ausgeführt werden:


Zeile 51:		Zeile 51:
	=Nützliche Skripte=		=Nützliche Skripte=
	==essus NFS speed test==		==essus NFS speed test==
	Der Test dient der Ermittlung der Netzwerkgeschwindigkeit. Diese ist abhängig von der Netzwerkkonfiguration. ([[Dbox2]]->[[Crossover-Kabel]]->[[NIC]], [[DBox2]]->[[Switch]]/[[HUB]]->[[NIC]])		Der Test dient der Ermittlung der Netzwerkgeschwindigkeit. Diese ist abhängig von der Netzwerkkonfiguration. ([[Hardware:dbox2\|Dbox2]]->[[Crossover-Kabel]]->[[Netzwerkkarte\|NIC]], [[Hardware:dbox2\|DBox2]]->[[Switch]]/[[Hub\|HUB]]->[[Netzwerkkarte\|NIC]])

	#!/bin/sh		#!/bin/sh
Zeile 79:		Zeile 79:


	Aufruf auf der [[DBox2]] mit./<dateiname> share-ohne-slash-am-anfang		Aufruf auf der [[Hardware:dbox2\|DBox2]] mit./<dateiname> share-ohne-slash-am-anfang
	Beispiel:		Beispiel:

Zeile 120:		Zeile 120:


	Der Test dient zur Ermittlung der Netzwerkgeschwindigkeit. Diese ist abhängig von der Netzwerkkonfiguration. ([[Dbox2]]->[[Crossover-Kabel]]->[[NIC]], [[DBox2]]->[[Switch]]/[[HUB]]->[[NIC]])		Der Test dient zur Ermittlung der Netzwerkgeschwindigkeit. Diese ist abhängig von der Netzwerkkonfiguration. ([[Hardware:dbox2\|Dbox2]]->[[Crossover-Kabel]]->[[Netzwerkkarte\|NIC]], [[Hardware:dbox2\|DBox2]]->[[Switch]]/[[Hub\|HUB]]->[[Netzwerkkarte\|NIC]])


Zeile 130:		Zeile 130:
	:'''exportdir:''' Hier kommt das exportierte Verzeichnis des [[NFS]]-Servers rein (mit führendem Slash).		:'''exportdir:''' Hier kommt das exportierte Verzeichnis des [[NFS]]-Servers rein (mit führendem Slash).

	:'''dboxmountpoint:''' Das Verzeichnis auf der [[DBox2]], in das gemountet werden soll.		:'''dboxmountpoint:''' Das Verzeichnis auf der [[Hardware:dbox2\|DBox2]], in das gemountet werden soll.

	:'''filesize:''' Die Größe der zu testenden Datei. Sie sollte 8MByte oder mehr sein, damit die Ergebnisse brauchbar werden. 32 oder 64 MByte sind ein guter Ansatz. Wenn man dann noch genauer werden will, kann man das ganze ja noch mal mit 128 MByte starten.		:'''filesize:''' Die Größe der zu testenden Datei. Sie sollte 8MByte oder mehr sein, damit die Ergebnisse brauchbar werden. 32 oder 64 MByte sind ein guter Ansatz. Wenn man dann noch genauer werden will, kann man das ganze ja noch mal mit 128 MByte starten.
Zeile 236:		Zeile 236:
	Das Script dient hauptsächlich dazu, die [[EPG]]-Daten aktuell zu halten.		Das Script dient hauptsächlich dazu, die [[EPG]]-Daten aktuell zu halten.

	Ihr solltet euch vorher mit eurem Browser über das [[Webinterface]] der [[DBox2]] versichern, dass die ChannelId-Werte mit euren übereinstimmen.		Ihr solltet euch vorher mit eurem Browser über das [[Webinterface]] der [[Hardware:dbox2\|DBox2]] versichern, dass die ChannelId-Werte mit euren übereinstimmen.
	Gebt dazu einfach in eurem Browser folgendes ein:		Gebt dazu einfach in eurem Browser folgendes ein:
	http://ip-eurer-box/control/channellist		http://ip-eurer-box/control/channellist
	Als Ausgabe erhaltet ihr die Liste eurer auf der [[DBox2]] gespeicherten Channels. [[Neutrino:Customizing#Die_Kanalliste\|Beispiel]]		Als Ausgabe erhaltet ihr die Liste eurer auf der [[Hardware:dbox2\|DBox2]] gespeicherten Channels. [[Neutrino:Customizing#Die_Kanalliste\|Beispiel]]

	Dort sucht ihr euch eure Lieblinge aus (Für einen aktuellen [[EPG]] reicht es nur einen Sender eines Transponders zu nehmen.)		Dort sucht ihr euch eure Lieblinge aus (Für einen aktuellen [[EPG]] reicht es nur einen Sender eines Transponders zu nehmen.)
Zeile 282:		Zeile 282:

	Es macht z.B. auch Sinn das Script in die standby.on einzutragen.		Es macht z.B. auch Sinn das Script in die standby.on einzutragen.
	Damit wird es immer wenn die [[DBox2]] in den [[Neutrino:Ausschalten#Soft-Standby\|Soft-Standby]] geschickt wird ausgeführt und sorgt für einen aktuellen [[EPG]].		Damit wird es immer wenn die [[Hardware:dbox2\|DBox2]] in den [[Neutrino:Ausschalten#Soft-Standby\|Soft-Standby]] geschickt wird ausgeführt und sorgt für einen aktuellen [[EPG]].
	Um das Script dort einzutragen, reicht es die [[Neutrino:Customizing#Standby_ON\|standby.on]] um den folgenden Eintrag zu erweitern.		Um das Script dort einzutragen, reicht es die [[Neutrino:Customizing#Standby_ON\|standby.on]] um den folgenden Eintrag zu erweitern.
	Vorausgesetzt ihr hab den Vorschlag oben befolgt und die ChannelZapper.sh unter /var/tuxbox/plugins gespeichert.		Vorausgesetzt ihr hab den Vorschlag oben befolgt und die ChannelZapper.sh unter /var/tuxbox/plugins gespeichert.
Zeile 288:		Zeile 288:
	./ChannelZapper.sh &		./ChannelZapper.sh &

	Nutzt ihr immer nur den normalen Standby Modus (in dem ihr keinen oder kaum Strom spart) und habt ihr immer ein wenig Zeit wenn ihr die [[DBox2]] anschaltet?		Nutzt ihr immer nur den normalen Standby Modus (in dem ihr keinen oder kaum Strom spart) und habt ihr immer ein wenig Zeit wenn ihr die [[Hardware:dbox2\|DBox2]] anschaltet?
	Dann könnt ihr es ebenfalls auf die gleiche Art in die [[Neutrino:Customizing#Standby_OFF\|standby.off]] eintragen.		Dann könnt ihr es ebenfalls auf die gleiche Art in die [[Neutrino:Customizing#Standby_OFF\|standby.off]] eintragen.
	Je nach eingestellter Channel-Haltedauer dauert der Start dann dementsprechend lange, dafür ist aber der [[EPG]] schön aktuell.		Je nach eingestellter Channel-Haltedauer dauert der Start dann dementsprechend lange, dafür ist aber der [[EPG]] schön aktuell.

Tommy am 21. August 2008 um 22:00 Uhr

2008-08-21T22:00:51Z

Neue Seite

[[Category:Register]]
[[Category:Neutrino]]
{{Neutrino_sidebar}}
__TOC__

=Allgemeines=
[[Neutrino]] bietet die Möglichkeit Shell-Scripte über die [[GUI]] aufzurufen. Die Ausgabe des Scriptes wird, wenn das Script ausgeführt wurde, auf dem Bildschirm ausgegeben.

'''''Hinweis:''' Der Menüpunkt Skripte (im [[Neutrino:Hauptmenu|Neutrino Hauptmenü]] - dbox Taste) ist nur vorhanden, wenn mindestens ein Skript existiert.''

=Beispiel=
Es muss ein Shellscript (*.sh) im Pluginverzeichnis erzeugt werden:

''vi /var/tuxbox/plugins/test.sh''
#!/bin/sh
ls -la /

Jetzt muss noch das Script ausführbar gemacht werden:

chmod 755 /var/tuxbox/plugins/test.sh

Des Weiteren muss eine *.cfg Datei erzeugt werden. Wichtig ist hier der Eintrag '''type=3'''. Dieser gibt an, dass dies ein Shell-Script ist.

''vi /var/tuxbox/plugins/test.cfg''
type=3
name=test
desc=test
needfb=0
needrc=0
needvtxtpid=0
needoffsets=0

Nach einem Neustart der [[DBox2]] sollte der Menüpunkt "Skripte" im Hauptmenü (dbox Taste) vorhanden sein. Hier kann jetzt das angelegte Script ausgewählt und damit ausgeführt werden:

[[Bild:Neutrino_Scripte.png|300px]]

Die Ausgabe des Scriptes wird, wenn das Script ausgeführt wurde, am Bildschirm angezeigt:

[[Bild:Neutrino_Scripte_Ausgabe.png|350px]]

=Nützliche Skripte=
==essus NFS speed test==
Der Test dient der Ermittlung der Netzwerkgeschwindigkeit. Diese ist abhängig von der Netzwerkkonfiguration. ([[Dbox2]]->[[Crossover-Kabel]]->[[NIC]], [[DBox2]]->[[Switch]]/[[HUB]]->[[NIC]])

#!/bin/sh
V=$1
R=`expr 32 \* 1024`
for P in udp tcp
do
for S in sync async
do
echo
echo $P", "$S
umount /mnt/filme
mount -t nfs -o rw,soft,$P,nolock,$S,rsize=$R,wsize=$R '''192.168.0.1''':/$V /mnt/filme
a=`date +%s`
time dd if=/dev/zero of=/mnt/filme/test bs=8k count=8192
z=`date +%s`
n=`expr $z - $a`
expr 512000 / $n
a=`date +%s`
time dd of=/dev/null if=/mnt/filme/test bs=8k count=8192
z=`date +%s`
n=`expr $z - $a`
expr 512000 / $n
mount | grep /mnt/filme
done
done

Aufruf auf der [[DBox2]] mit./<dateiname> share-ohne-slash-am-anfang
Beispiel:

./nfs_test home/dbox >linux_v3.log

Wenn dein [[PC]] eine andere [[IP-Adresse]] als 192.168.0.1 hat, musst du das natürlich anpassen.
Die Ergebniswerte /1000 sind die Geschwindigkeiten in MBit/s.

Das Ergebnis sollte so aussehen:
udp, sync
5505
46545
192.168.0.1:/home/dbox on /mnt/filme type nfs (rw,sync,v3,rsize=32768,wsize=32768,soft,udp,nolock,addr=192.168.0.1)

udp, async
8827
46545
192.168.0.1:/home/dbox on /mnt/filme type nfs (rw,v3,rsize=32768,wsize=32768,soft,udp,nolock,addr=192.168.0.1)

tcp, sync
5333
8126
192.168.0.1:/home/dbox on /mnt/filme type nfs (rw,sync,v3,rsize=32768,wsize=32768,soft,tcp,nolock,addr=192.168.0.1)

tcp, async
7757
8126
192.168.0.1:/home/dbox on /mnt/filme type nfs (rw,v3,rsize=32768,wsize=32768,soft,tcp,nolock,addr=192.168.0.1)

==chickens erweiterter NFS speed test==
Chicken hat das Script von essu ein wenig überarbeitet. Folgene Punkte wurden verbessert:
* Die Ausgaben sind übersichtlicher gestaltet
* Die Bedienung ist einfacher
* Die Ergebnisse sollten genauer sein

Quelle: http://forum.tuxbox.org/forum/viewtopic.php?p=282953#282953

Der Test dient zur Ermittlung der Netzwerkgeschwindigkeit. Diese ist abhängig von der Netzwerkkonfiguration. ([[Dbox2]]->[[Crossover-Kabel]]->[[NIC]], [[DBox2]]->[[Switch]]/[[HUB]]->[[NIC]])

Das Programm erwartet keine Parameter.

In den ersten Zeilen werden die persönlichen Einstellungen eingetragen:
:'''serverip:''' Hier kommt die [[IP-Adresse]] des [[NFS]]-Servers rein.

:'''exportdir:''' Hier kommt das exportierte Verzeichnis des [[NFS]]-Servers rein (mit führendem Slash).

:'''dboxmountpoint:''' Das Verzeichnis auf der [[DBox2]], in das gemountet werden soll.

:'''filesize:''' Die Größe der zu testenden Datei. Sie sollte 8MByte oder mehr sein, damit die Ergebnisse brauchbar werden. 32 oder 64 MByte sind ein guter Ansatz. Wenn man dann noch genauer werden will, kann man das ganze ja noch mal mit 128 MByte starten.

:'''blocksizelist:''' Hier können die zu testenden Blockgrößen durch Leerzeichen getrennt eingegeben werden. Mögliche Werte sind 1, 2, 4, 8, 16 und 32. Wenn man beispielsweise weiß, dass die Werte 1, 2 und 4 keine verwertbare Performance bringen, so kann man sich eine Menge Zeit sparen, wenn man diese Tests auslässt.

:'''enablesynctests:''' Im Normalfall sollten die Übertragungsraten mit der Mountoption "sync" immer langsamer sein als die mit "async". Darum besteht hier die Möglichkeit, Tests mit der sync-Option abzuschalten. Mögliche Werte sind "yes" (Tests ausführen) oder "no" (Tests nicht ausführen).

#!/bin/sh
# IP of your NFS server
serverip=192.168.0.1
# exported directory on your NFS server
exportdir=/var/exports/dbox2
# mount point on dbox
dboxmountpoint="/mnt"
# filesize to transfer in MBytes.
# At least 8 MByte. Good values are 32 or 64 MByte.
# Try 128 to be more accurate (takes much longer!)
filesize=32
# block sizes to test in KBytes, possible values are 1 2 4 8 16 32.
# values have to be separated with spaces. See examples below.
# blocksizelist="4 8 32"
# blocksizelist="16"
blocksizelist="4 8 16 32"
# wether to enable synchronous reading, writing. Possible values are "yes"
# or no. Normally synchronous reading or writing should be slower than
# asynchronous, so to save some time most people would say "no" here.
enablesynctests="no"

##################################################################
######## don't edit below this line ########
##################################################################

bs=8192
count=`expr $filesize \* 1048576 / $bs`
wlist=""
rlist=""
synctests="async"
if [ $enablesynctests = "yes" ]; then
synctests="sync "$synctests
fi

echo
echo "Measuring NFS throughput..."
for factor in $blocksizelist
do
for protocol in udp tcp
do
for synchronized in $synctests
do
size=`expr $factor \* 1024`
bitcount=`expr $bs \* $count \* 8`
umount $dboxmountpoint 2>/dev/null
mount -t nfs -o rw,soft,$protocol,nolock,$synchronized,rsize=$size,wsize=$size $serverip:$exportdir $dboxmountpoint
echo "Mount options: "$protocol", "$synchronized", wsize="$size
echo "writing "$filesize" MBytes..."
a=`date +%s`
dd if=/dev/zero of=$dboxmountpoint/test bs=$bs count=$count 2>/dev/null;
if [ $? = "0" ]
then
z=`date +%s`
duration=`expr $z - $a`
throughput=`expr $bitcount / $duration`
echo "Success after "$duration" seconds"
else
throughput="Failure"
echo "Failure"
fi
wlist=$wlist$throughput" with "$protocol","$synchronized",wsize="$size"\n"

echo "Mount options: "$protocol", "$synchronized", rsize="$size
echo "reading "$filesize" MBytes..."
a=`date +%s`
dd of=/dev/null if=$dboxmountpoint/test bs=$bs count=$count 2>/dev/null;
if [ $? = "0" ]
then
z=`date +%s`
duration=`expr $z - $a`
throughput=`expr $bitcount / $duration`
echo "Success after "$duration" seconds"
else
throughput="Failure"
echo "Failure"
fi
rlist=$rlist$throughput" with "$protocol","$synchronized",rsize="$size"\n"
echo
done
done
done

echo "Results for write throughput:"
echo -e $wlist | sort -nr | sed 's/^$[0-9]*$$[0-9]\{3\}$$[0-9]\{3\}\(.*$\)/\1.\2 Mbit\/s\4/g'

echo "Results for read throughput:"
echo -e $rlist | sort -nr | sed 's/^$[0-9]*$$[0-9]\{3\}$$[0-9]\{3\}\(.*$\)/\1.\2 Mbit\/s\4/g'

==aluxs Aufnahme check==
{{MissingText}}

==PetBs und Tommys ChannelZapper==
Das Script dient hauptsächlich dazu, die [[EPG]]-Daten aktuell zu halten.

Ihr solltet euch vorher mit eurem Browser über das [[Webinterface]] der [[DBox2]] versichern, dass die ChannelId-Werte mit euren übereinstimmen.
Gebt dazu einfach in eurem Browser folgendes ein:
http://ip-eurer-box/control/channellist
Als Ausgabe erhaltet ihr die Liste eurer auf der [[DBox2]] gespeicherten Channels. [[Neutrino:Customizing#Die_Kanalliste|Beispiel]]

Dort sucht ihr euch eure Lieblinge aus (Für einen aktuellen [[EPG]] reicht es nur einen Sender eines Transponders zu nehmen.)
Für die meisten sollte z.B.: Sat1, RTL, ARD schon ein tolles Ergebnis liefern.
Im Beispielscript habe ich für Astra (Stand Nov/05) Sat1, Rtl, ARD und ZDF bereits eingefügt
#!/bin/sh

#Hier die ChannelIDs der Kanäle eintragen getrennt mit Leerzeichen
Kanaele='210085002e 44100012ee3 43700016d66 44d00016dca'
#Haltedauer auf Channel in Sekunden
Dauer=20

#aktuellen Sender merken
Zapbackto=$(wget -q <nowiki>http://127.0.0.1/control/zapto -O</nowiki> -)

# Hier werden die Kanaele mittels der Control Funktionen des Webinterface gezappt.
for zap in $Kanaele
do
echo "Sender mit ID $zap wird angezappt und fuer $Dauer Sekunden gehalten"
wget -q <nowiki>http://127.0.0.1/control/zapto?$zap</nowiki> -O /dev/null && sleep $Dauer
echo "Sender mit ID $zap wurde angezappt und fuer $Dauer Sekunden gehalten"
done

# zurück zu gemerktem Sender
wget -q <nowiki>http://127.0.0.1/control/zapto?$Zapbackto</nowiki> -O /dev/null
echo "Durchlauf beendet - aktueller Channel ist wieder der Alte"

exit

An welcher Stelle ihr das Script speichert ist euch freigestellt.
Sinnvoll allerdings wäre es wie folgt:
/var/tuxbox/plugins/ChannelZapper.sh
Dort kann es dann auch mittels der oben genannten Vorgehensweise in das Neutrino Menü eingebunden werden und ermöglicht so das automatische Durchzappen, eine Art Intro-Scan, der Kanäle und vervollständigt nebenbei den [[EPG]]. Das Menü bleibt leider dabei sichtbar, daher sollte die Transparenz der Menüs entsprechend eingestellt sein.

'''ACHTUNG: Zurzeit können maximal 3 Sender gezappt werden, sofern das Script über das Menü aufgerufen wird. Werden mehr Sender eingetragen, fährt die Box runter.
Über Telnet gibt es diese Beschränkung nicht!
An der Beseitigung des Problems wird gearbeitet.'''

'''''Nicht vergessen das Script ausführbar zu machen'''''
chmod 755 /var/tuxbox/plugins/ChannelZapper.sh

Es macht z.B. auch Sinn das Script in die standby.on einzutragen.
Damit wird es immer wenn die [[DBox2]] in den [[Neutrino:Ausschalten#Soft-Standby|Soft-Standby]] geschickt wird ausgeführt und sorgt für einen aktuellen [[EPG]].
Um das Script dort einzutragen, reicht es die [[Neutrino:Customizing#Standby_ON|standby.on]] um den folgenden Eintrag zu erweitern.
Vorausgesetzt ihr hab den Vorschlag oben befolgt und die ChannelZapper.sh unter /var/tuxbox/plugins gespeichert.
cd /var/tuxbox/plugins/
./ChannelZapper.sh &

Nutzt ihr immer nur den normalen Standby Modus (in dem ihr keinen oder kaum Strom spart) und habt ihr immer ein wenig Zeit wenn ihr die [[DBox2]] anschaltet?
Dann könnt ihr es ebenfalls auf die gleiche Art in die [[Neutrino:Customizing#Standby_OFF|standby.off]] eintragen.
Je nach eingestellter Channel-Haltedauer dauert der Start dann dementsprechend lange, dafür ist aber der [[EPG]] schön aktuell.

==PetBs Easy_FB_Changer==
Das Script dient dazu, die FB zwischen 2 Boxen, die nebeneinander stehen, hin und her zu schalten.

Dazu muss nur auf der jeweiligen Box die eigene BoxIP bei "MyIP" und die IP der anderen Box in "OtherBoxIP" eingetragen werden.
Am besten startet ihr das Script auch in der start_neutrino hinter dem Aufruf vom nhttpd.

Damit wird sicher gestellt, dass die gerade gestartete Box nicht mit aktiver FB startet.
Das hat aber gleichzeitig den Nachteil, dass solange keine Box an ist, auf der zuerst eingeschalteten Box die FB einmalig mit der roten und dann der dbox-Taste entsperrt werden muss.
(Leider lässt sich der Status, ob gesperrt oder frei, nicht abfragen.)

Das folgende kleine Script kopiert ihr am besten wie in den obigen Beispielen gezeigt auf eure Box und bindet es wie oben gezeigt in euer Scriptmenü ein.

Auch hier nicht vergessen, das Script ausführbar zu machen, siehe oben.
#!/bin/sh
MyIP=x.x.x.x
OtherBoxIP=y.y.y.y
# Check if OtherBoxIp is a DBOX2 and Webapi is operational, If not then exit Script
wget -q <nowiki>http://$OtherBoxIP/control/rc -O /dev/null</nowiki>
if [ $? -eq 1 ]; then
echo "Fehler mit OtherBoxIP $OtherBoxIP"
echo "Box aus oder Webapi Problem (keine DBox2 ?)"
echo "FB wird daher nicht gesperrt"
exit 1
fi;
# Block FB on MyIP and Free FB on OtherBoxIP
wget -q <nowiki>http://$MyIP/control/rc?lock -O /dev/null</nowiki>
wget -q <nowiki>http://$OtherBoxIP/control/rc?unlock -O /dev/null</nowiki>
# Output Explanation
echo "FB per Script fuer $MyIP gesperrt und"
echo "fuer $OtherBoxIP freigegeben"
exit 0

Achtung, die Box merkt sich anscheinend, wie oft hintereinander man die FB gesperrt hat. Sofern man das z.B. 3 mal gemacht hat, will sie dann dementsprechend auch 3 mal entsperrt werden :-(
Daher beim Testen in der Konsole aufpassen und das Script nicht mehrmals hintereinander aufrufen.
In der Praxis sollte das kein Problem sein, da nach dem Aufruf die FB ja gesperrt ist und es somit nur auf der anderen (freien) Box aufgerufen werden kann.

'''Das Script funktioniert grundsätzlich.'''
'''Ob der Aufruf in der start_neutrino auch funktioniert, muss noch getestet werden.'''
'''Auch das Ausgabefenster, das auf dem Bildschirm lange stehen bleibt, stört den ein oder anderen vielleicht.''' '''Dann lasst einfach die Ausgabe weg.'''

==PetBs Multi_FB_Changer==
Mit diesem Script ist es möglich, viele Boxen mit einer FB zu verwalten.

Man kann die FB nicht auf eine inaktive Box übertragen.
Es wird vorher geprüft, ob die Box an ist, falls nicht, wird die FB nicht gesperrt.
Auch ist das Script für Newbies zu benutzen, da es anhand der Box IP das komplette Subnetz nach anderen Boxen scannt.
Das dauert aber sehr lange. Wer mag kann die fb_change.conf auch direkt mit seinen IP Adressen der Dboxen füttern.
Dann werden nur die FB Umschaltscripte erzeugt.
Grundsätzlich muss das Script init_fb-change.sh auf die Box ins Verzeichnis '''/var/tuxbox/plugins''' gebracht werden.
Dort muss es ausführbar gesetzt werden.
Das war's auch schon.

Nach dem Starten schaut das Script, ob bereits eine config Datei vorhanden ist.
Falls ja, wird gefragt, ob diese benutzt werden soll, dafür "n" oder "N" drücken oder ob eine neue Datei erstellt werden soll.
Antwortet man mit "J/j/y/Y" will das Script wissen, ob das komplette Subnetz von 1 bis 254 gescannt werden soll oder nur ein Teilbereich.
Dieser Teilbereich sollte vorher im Script angepasst werden, da er defaultmäßig nur von 100 - 102 reicht.

'''Das Script geht davon aus, dass die Box eine feste IP in /var/etc/network/interfaces eingetragen hat.'''
Falls dies nicht der Fall ist, muss das im Moment noch von Hand im Script geändert werden. (Eintrag MyIP=x.x.x.x)
Dabei muss auch die IP-Range angegeben werden, da diese normalerweise aus der BoxIP abgeleitet wird.

Wie auch oben schon mehrfach erläutert, müssen nach dem Durchlauf die Plugins neu geladen werden, sofern man das Sciptmenü bereits aktiv hatte.
Sonst muss die Box neu gestartet werden.
Und vergesst nicht das Init-Script auf jeder Box im Netz auszuführen, damit die Scripte auch überall erstellt werden.

Jetzt hier das Script (Hoffentlich wurde nichts verhauen beim Einpflegen hier ins Wiki)

<nowiki>
#!/bin/sh

# Soll das Script eine Vollzugsmeldung auf der gesperrten Box anzeigen ? Dann tragen sie für Showaction ein 1 ein
# Die FB wird nicht gesperrt, wenn auf der anderen Box die Webapi nicht reagiert. Diese Meldung erscheint dann immer.
ShowAction=1

# Look for local Dbox IP
#IFS=" " #Delimiter
while read PName PRest
do
if [ "$PName" = "address" ]; then
MyIP=$PRest
fi;
done < /var/etc/network/interfaces

# IPRange = IP Adressbereich der durchsucht wird
#Entweder hier anhand der BoxIp ermittelt
MyIP1=$(echo $MyIP | cut -f1 -d.)
MyIP2=$(echo $MyIP | cut -f2 -d.)
MyIP3=$(echo $MyIP | cut -f3 -d.)
MyIP4=$(echo $MyIP | cut -f4 -d.)
IPRange=$MyIP1"."$MyIP2"."$MyIP3"."

# oder hier von Hand angegebene Werte nutzen (Bsp: 192.168.100. Punkt am Schluss nicht vergessen) einfach das Doppelkreuz entfernen
#IPRange=192.168.100.
#BoxIP
#MyIP=192.168.100.x

#Vorgabe des Suchbereichs
#Beginne bei Erste IP Bsp: 192.168.100.95 = 95 Erste IP nach der gesucht wird.
CheckIPStart=100
#Und ende bei Letzte Ip +1 Bsp: 192.168.100.103 wenn 102 die letzte Ip sein soll nach der gesucht wird.
CheckIPEnd=103

if [ -e fb_change.conf ]; then
echo "Configfile vorhanden, Loeschen und neues anlegen ? y/n"
while [ "$createnewconf" -eq "0" ];
do
read Userinput
case $Userinput in
y|Y|j|J )
createnewconf=1
echo "Configfile wird geloescht und neues angelegt"
rm fb_change.conf
;;
n|N )
createnewconf=2
;;
* )
echo "ich kann leider keine Gedanken lesen, bitte nur y/n/j/n eingeben"
;;
esac
done
else
createnewconf=1
fi;

if [ "$MyIP" -a "$createnewconf" = "1" ]; then
echo "\nBoxIP gefunden, soll das komplette Subnetz gescannt werden ? y/n"
echo "\nWenn hier nein angegeben wird sollten in der Datei fb_change.conf"
echo "schon die IP Adressen der Dboxen eingetragen sein oder zumindest"
echo "der IP Bereich der durchsucht werden soll hier im Script angegeben sein."
echo "Sonst werden vieleicht keine DBoxen gefunden."
echo "Da das Script ohne Aenderungen sonst nur den Bereich von"
echo "$IPRange$CheckIPStart bis $IPRange$CheckIPEnd durchsucht."
echo "\nMoechten sie das komplette Subnetz scannen lassen ? y/n"
echo "Dies kann sehr lange dauern !"
while [ "$subnetzscan" -eq "0" ];
do
read Userinput
case $Userinput in
y|Y|j|J )
subnetzscan=1
CheckIPStart=1
CheckIPEnd=255
echo "Komplettes Subnetz wird gescannt"
echo "Scanbereich von IP $IPRange$CheckIPStart bis $IPRange$CheckIPEnd"
;;
n|N )
subnetzscan=2
echo "Teilbereich im Subnetz wird gescannt"
echo "Scanbereich von IP $IPRange$CheckIPStart bis $IPRange$CheckIPEnd"
;;
* )
echo "ich kann leider keine Gedanken lesen, bitte nur y/n/j/n eingeben"
;;
esac
done
fi;

if [ "$createnewconf" = "1" ]; then
#Look for other Dbox IPs in IPRange
while [ "$CheckIPStart" -lt "$CheckIPEnd" ]
do
echo "\nPruefe "$IPRange$CheckIPStart
ping -q -c 1 $IPRange$CheckIPStart > /dev/null
if [ $? -eq 0 ]; then
wget -q http://$IPRange$CheckIPStart/control/rc -O /dev/null
if [ $? -eq 0 ]; then
echo "Found Box at $IPRange$CheckIPStart"
if [ "$IPRange$CheckIPStart" != "$MyIP" ]; then
echo "$IPRange$CheckIPStart" >> fb_change.conf
else
echo "Eigene Box gefunden, wird nicht eingetragen."
fi;
else
echo "IP $IPRange$CheckIPStart reagiert, aber vermutlich keine Box"
fi;
else
echo "IP $IPRange$CheckIPStart reagiert nicht"
fi;
CheckIPStart=`expr $CheckIPStart + 1`
done
fi;

if [ -e fb_change.conf ]; then
while read OtherBoxIP
do
echo "\nBearbeite cfg File fuer "$OtherBoxIP
cfg_file="multi_fb_"$OtherBoxIP".cfg"
echo "type=3" > $cfg_file
echo "name=Aktiviere FB auf Box $OtherBoxIP" >> $cfg_file
echo "desc=Sperrt die FB und gibt sie auf Box $OtherBoxIP frei." >> $cfg_file
echo "needfb=0" >> $cfg_file
echo "needrc=0" >> $cfg_file
echo "needvtxtpid=0" >> $cfg_file
echo "needoffsets=0" >> $cfg_file

echo "Bearbeite Scriptfile fuer "$OtherBoxIP
script_file="multi_fb_"$OtherBoxIP".sh"
echo "#!/bin/sh" >$script_file
echo "#" >> $script_file
echo "#" >> $script_file
echo "# Check if OtherBoxIp is a DBOX2 and Webapi is operational, If not then exit Script" >> $script_file
echo "wget -q http://$OtherBoxIP/control/rc -O /dev/null" >> $script_file
echo "if [ \$? -eq 1 ]; then " >> $script_file
echo " echo \"Fehler mit OtherBoxIP $OtherBoxIP\"" >> $script_file
echo " echo \"Box aus oder Webapi Problem (keine DBox2 ?)\"" >> $script_file
echo " echo \"FB wird daher nicht gesperrt\"" >> $script_file
echo " exit 1" >> $script_file
echo "fi;" >> $script_file
echo "# Block FB on MyIP and Free FB on OtherBoxIP" >> $script_file
echo "wget -q http://$MyIP/control/rc?lock -O /dev/null" >> $script_file
echo "wget -q http://$OtherBoxIP/control/rc?unlock -O /dev/null" >> $script_file
if [ "$ShowAction" = "1" ]; then
echo "# Output Explanation" >> $script_file
echo "echo \"FB per Script fuer $MyIP gesperrt und\" " >> $script_file
echo "echo \"fuer $OtherBoxIP freigegeben\"" >> $script_file
fi;
echo "exit 0" >> $script_file

chmod 755 $script_file
done < fb_change.conf
else
echo "Es wurden keine IP Adressen in der Datei fb_change.conf gefunden."
echo "Haben sie dem Script erlaubt die fb_change.conf neu zu erstellen ?"
echo "Dann wurden vermutlich keine aktiven Boxen im Scanbereich entdeckt."
echo "Daher wurde auch kein FB Script erstellt."
fi;

echo "\nScriptbearbeitung Fertig"
exit 0
</nowiki>

==Aufnehmen und danach runterfahren==
Bei einer Sofortaufnahme wird normalerweise ein 4h Timer gesetzt. Hier eine Lösung bei der es möglich ist dieses auf das Sendungsende zu verkürzen und die Box dann runterzufahren.
Szenario:
Ich schaue einen Film und merke in der Mitte das ich eigentlich ins Bett müßte.
Mit diesem script in /var/tuxbox/config/standby.on brauche ich nur eine Sofortaufname starten und beim "ins Bett gehen" den Softstandby zu aktivieren.

#!/bin/sh

#läuft Aufnahme?
REC_Mode=$(wget -q <nowiki>http://127.0.0.1/control/setmode?status</nowiki> -O -)

case $REC_Mode in
off*)
echo "Shutdown Timer not set no record detected"
;;
on*)

if [ ! -e /tmp/S_TMR ]; then
#Shutdown Script schreiben
echo "#!/bin/sh" > /tmp/S_TMR
echo "wget -q <nowiki>http://127.0.0.1/control/setmode?record=stop</nowiki> -O /dev/null" >> /tmp/S_TMR
echo "wget -q <nowiki>http://127.0.0.1/control/shutdown</nowiki> -O /dev/null" >> /tmp/S_TMR
chmod 755 /tmp/S_TMR

#Sender feststellen
ACT_CHANNEL=$(wget -q <nowiki>http://127.0.0.1/control/zapto</nowiki> -O -)

#Aktuelles EPG holen in der Hoffnung das es vorhanden ist
EPG_STRING=$(wget -q <nowiki>http://127.0.0.1/control/epg?ext</nowiki> -O - | grep $ACT_CHANNEL)

#Startzeit aus dem EPG String lesen
EPG_START_T=$(echo $EPG_STRING | cut -d\ -f2)

#Dauer aus dem EPG String lesen
EPG_DURATION_T=$(echo $EPG_STRING | cut -d\ -f3)

#Dauer auf Startzeit aufrechnen um Endzeit zu erhalten + 2 Minuten
EPG_END_T=`expr $EPG_START_T + $EPG_DURATION_T + 120`
echo "coumputed shutdown $EPG_END_T"

#String für Timer basteln
TMR_STRING="<nowiki>http://127.0.0.1/control/timer?action=new&alarm=$EPG_END_T&type=8&PluginName=/tmp/S_TMR</nowiki>"

#Timer setzen
wget -q $TMR_STRING -O /dev/null

echo "Shutdown Timer set to $EPG_END_T"
fi
;;
esac

{{body}}