ubuntuusers.de

Hallo,

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

#!/bin/bash

echo "hallo"
echo "dieses Sript soll warten bis nächster"
echo "Befehl abgewartet wird"
echo "Also bis das Script im Terminal beendet wird oder"
echo "das neue Terminal geschlossen wird"

/usr/bin/gnome-terminal -x /media/sda2/last-news

echo "#!/bin/bash" >> "/media/sda2/last-news"

im zweiten Fenster wird cvlc aufgerufen und dauert so 5 Minuten 😀 😀 😀 Es soll das last-news script erst gelöscht werden, wenn das Sript im neuen Terminal abgeschlossen ist. Dieses Script oben soll also warten bis das 2.te Script (last-news) im neuen Terminal abgeschlossen ist

Wir haben hier eine kl. Inkonsistenz vor uns.

Die Beschreibung spricht von einem Skript, aber Skripte kann man einfach so aufrufen, und das aufrufende Skript läuft eh erst weiter wenn jenes fertig ist.

Aber hier wird ein grafisches Programm aufgerufen, welches sich offenbar selbständig macht - viele grafische Programme machen das, und wenn jmd. weiß wieso, möge er sich jetzt als Guru outen - ich weiß es nicht, und das macht die Sache unberechenbar, wenn man nicht lexikalisch für alle Programme auswendig lernt, welches Programm sich wie verhält - back to topic ...:

Was ist denn jetzt entscheidend - der Ablauf des 2. Skripts oder die Einbettung in gnome-terminal?

Man kann die PID des letzten, gestarteten Programms bestimmen, und prüfen, ob diese noch in Gebrauch ist, und so lange wiederholt warten z.B.

Hi tulpi,

wenn ich in einem gnome-terminal sowas aufrufe:

track@ubuntu:~$ /usr/bin/gnome-terminal -e "sleep 4"

dann öffne ich damit ein neues Terminal, in dem dann (als Modell) mein sleep 4 aufgerufen wird, und das sich dann wieder schließt.
(und dann geht es im 1. Terminal weiter) Das sollte auch gehen, wenn man es per Skript aufruft.

Im schlimmsten Fall muss man es eben als

track@ubuntu:~$ /usr/bin/gnome-terminal -e "bash -c meinskript"

aufrufen.

Geht das bei Dir nicht ? (Infos wegen dem Parameter "-e" siehe man gnome-terminal)

LG,

track

Eigentlich handelt es sich sogar um eine crontab-Anwendung. (die Pfäde müssen angegeben werden z.B /usr/local/bin/ffmpeg)

Aufgabe soll es sein die Radionachrichten jede Stunde nur 5 Minuten lang aufzunehmen. Es handeln sich sogar um 2 Scripte, die von Crontab ausgeführt werden. Das erste Script wird durch ein anderes gestartet und nach 5 Minuten gekillt (funktioniert). Da der Stream nun in einem "not seakable" wma vorliegt nimmt diese Datei ein 2 Script auf und wandelt die Musik so um, dass man z.B im Totem unten den Vorlauf-Balken bedienen kann.

Dies ist das Script, dass das mittler Script (record-kiwi-fm.sh) nach 5 Minuten killt. –→ siehe Crontab-Befehl Der Crontab zur aufnahme sieht so aus

export DISPLAY=:0  && /usr/bin/gnome-terminal -x /home/rumpel/runfor 500 /home/rumpel/record-kiwi-fm.sh news

runfor.sh

1
2
3
4
5
6
7
8

#!/bin/bash
TIME=$1
shift
"$@" &
PID=$!
sleep $TIME
kill $PID
wait

Crontab immer um 59 record-kiwi-fm.sh

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#!/bin/bash
echo "########################"
if [[ ${1} == "news" ]]; then
       echo ${1}
echo "sleep 56"
       sleep 56
fi

date="kiwi-speak-${1}-$(date +'%Y-%m-%d_%H_%M_%S').mp3"
sda5="/media/sda5/home/rumpel/Musik/"
sda2="/media/sda2/"
script="${sda2}last-news"
NOW="${sda2}${date}"
geg="geg"

holla="ja"

if [[ ! ${1} == "news" ]]; then
     if [[ ! ${holla} == "radio-show" ]]; then
           holla="nein"
#     fi
fi
echo "$holla"
echo "########################"
if [[ ${holla} == "ja" ]]; then
     echo "/usr/local/bin/ffmpeg -i \"${NOW}\" \"${sda2}${geg}${date}\"" >> "${script}"
     echo "mv \"${sda2}${geg}${date}\" \"${sda2}kiwi/\"" >> "${script}"
     echo "cp \"${NOW}\" \"${sda5}\"" >> "${script}"
     echo "rm \"${NOW}\"" >> "${script}"
     #damit last-new-auswertung es abspielen kann :-)
     echo "/usr/bin/cvlc --play-and-exit \"${sda2}kiwi/${geg}${date}\"" >> "${script}"
     echo "wait" >> "${script}"
fi

mplayer mms://wms-trn-all.streaming.net.nz/trn-newstalk-zb-chc -dumpstream -dumpfile $NOW

Diese record-kiwi-fm.sh erzeugt ein Script zum Umwandeln und abspielen.der Datei und wird 6 Minuten nach der Aufnahme von Crontab aufgerufen.

Der Crontab zur aufnahme sieht so aus

export DISPLAY=:0  && /usr/bin/gnome-terminal -x /home/rumpel/runfor 500 /home/rumpel/record-kiwi-fm.sh news

Der Crontab zum Umwandeln und abspielen sieht so aus

export DISPLAY=:0  && /usr/bin/gnome-terminal -x /home/rumpel/last-new-aufruf.sh

last-new-aufruf.sh

1
2
3
4
5

#/bin/sh

export DISPLAY=:0  && /usr/bin/gnome-terminal -x /media/sda2/last-news
sleep 50
echo "#!/bin/bash" > "/media/sda2/last-news"

So geht es mit dem Sleep 50 bleibt das alte Terminal offen bis zum Abspielen. Lieber wäre es mir wenn das unterste Script last-new-aufruf.sh wartet anstatt dem sleep 50. Es geht so wie gewünscht mich würde es aber interessieren ob man was machen kann. Aber es funktioniert so halbwegs 😬 😊

Das von user unknown angesprochene Problem ist halt … ein Problem. 😉

Sprich, deine vielen Aufrufe eines Terminal-Emulators machen die Sache schon kompliziert. Aber wenn ich mir so deine eigentliche Anforderung anschaue …

Aufgabe soll es sein die Radionachrichten jede Stunde nur 5 Minuten lang aufzunehmen. Es handeln sich sogar um 2 Scripte, die von Crontab ausgeführt werden. Das erste Script wird durch ein anderes gestartet und nach 5 Minuten gekillt (funktioniert). Da der Stream nun in einem "not seakable" wma vorliegt nimmt diese Datei ein 2 Script auf und wandelt die Musik so um, dass man z.B im Totem unten den Vorlauf-Balken bedienen kann.

… dann sehe ich keinen Bedarf für zwei oder gar noch mehr Skripte. Oder ich habe dich von grundauf überhaupt nicht verstanden, was natürlich auch sein kann. ☺

Ich war mir eigentlich sicher, dass der mplayer oder mencoder eine Option haben, um die Dauer anzugeben, aber das finde ich gerade nicht mehr. Es geht aber trotzdem in einem Skript, indem du den mplayer-Aufruf, welcher mitschneiden soll, im Hintergrund laufen lässt. Dann wartest du eine gewisse Zeit und beendest dann den Hintergrundjob. Danach kann deine Konversion laufen. Eine grobe Skizze:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

#!/bin/bash

# Mitschnitt im Hintergrund:
mplayer -dumpstream -dumpfile blabla mms://dein/stream &

# Auf das Ende des Jobs warten:
waitpid=$!
sleep 10
kill $waitpid

# Jetzt kann die Konversion passieren:
ffmpeg ...

Also ein Skript und ein Eintrag in deiner Crontab. Wenn es denn sein muss, kannst du das dann auch in einem Terminal laufen lassen.

Es sind mittlerweile 2 Sender, deren Nachrichten angezapft werden. Und es können noch mehr werden. Die Idee, warum es vielleicht so kompliziert aussieht ist der damit ffmpeg nicht mehrmals gleichzeitig läuft. Da nur last-new-aufruf.sh dieses erzeugte Script von z.B record-kiwi-fm.sh löschen kann. Bei 4 gleichzeitig laufenden ffmpeg fängt das Laptop an zu glühen 😀