Inhaltsverzeichnis

1 Allgemeines
2 Beispiel
3 Nützliche Skripte

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 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:

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

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

An dieser Stelle muss noch Text rein.

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. 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 http://127.0.0.1/control/zapto -O -)
 
# 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 http://127.0.0.1/control/zapto?$zap -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 http://127.0.0.1/control/zapto?$Zapbackto -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 Soft-Standby geschickt wird ausgeführt und sorgt für einen aktuellen EPG. Um das Script dort einzutragen, reicht es die 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 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 http://$OtherBoxIP/control/rc -O /dev/null
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 http://$MyIP/control/rc?lock -O /dev/null
wget -q http://$OtherBoxIP/control/rc?unlock -O /dev/null
# 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)

 #!/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

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 http://127.0.0.1/control/setmode?status -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 http://127.0.0.1/control/setmode?record=stop -O /dev/null" >> /tmp/S_TMR
           echo "wget -q http://127.0.0.1/control/shutdown -O /dev/null" >> /tmp/S_TMR
           chmod 755 /tmp/S_TMR
                 
           #Sender feststellen
           ACT_CHANNEL=$(wget -q http://127.0.0.1/control/zapto -O -)
           
           #Aktuelles EPG holen in der Hoffnung das es vorhanden ist
           EPG_STRING=$(wget -q http://127.0.0.1/control/epg?ext -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="http://127.0.0.1/control/timer?action=new&alarm=$EPG_END_T&type=8&PluginName=/tmp/S_TMR"
  
           #Timer setzen
           wget -q $TMR_STRING -O /dev/null
  
           echo "Shutdown Timer set to $EPG_END_T"
        fi
        ;;
esac

Grundlagen - Installation - Debug-Mode - Hardware - CDK/Development

LCars - Neutrino - Enigma - Plugins - Spiele - Software - Tools - Howto - FAQ - Images

Hauptseite - News - Alle Artikel - Bewertungen - Gewünschte Seiten - Index - Neue Artikel - Impressum - Team

Hilfeportal - Seite bearbeiten - Bilder - Links - Tabellen - Textgestaltung

Neutrino:Skripte

Inhaltsverzeichnis

Allgemeines

Beispiel

Nützliche Skripte

essus NFS speed test

chickens erweiterter NFS speed test

aluxs Aufnahme check

PetBs und Tommys ChannelZapper

PetBs Easy_FB_Changer

PetBs Multi_FB_Changer

Aufnehmen und danach runterfahren

Navigationsmenü

Meine Werkzeuge

Namensräume

Varianten

Ansichten

Mehr

Suche

Navigation

Neutrino

Kommunikation

Sonstiges

Werkzeuge