Aufruf eines nächsten Programms ...

Heute ist Stammtischzeit:
Jeden Donnerstag 20:30 Uhr hier im Chat.
Wer Lust hat, kann sich gerne beteiligen. ;)
  • Hallo,
    vermutlich habe ich nur die falschen Suchworte genommen, denn was ich suche ist sicher öfters notwendig.

    Für meine Rollladensteuerung habe ich mir zwei Skripte geschrieben. Das eine soll die Rollläden runterfahren und das andere soll danach in regelmäßigen Abständen kontrollieren, ob sie noch unten sind. Das ist der Plan.

    Jedes für sich funktioniert schon. Da die Rollläden aber sonnenstand- und temperaturabhängig runterfahren sollen, kann ich das Kontrollprogramm nicht zu einer festen Zeit starten.

    Nun dachte ich, das Kontrollprogramm starte ich (nachdem alle Rollos unten sind) innerhalb des ersten Programms mittels

    Code
    $(sudo /home/pi/./kontrolle.sh)

    Das hat aber den Nachteil, dass mein erstes Programm so lange nicht weiter abgearbeitet wird, bis das Kontrollprogramm beendet wird. Ich möchte aber sofort nach dem Programmaufruf mit dem ersten Programm weiter machen.
    Gibt es da eine Möglichkeit, möglichst mit Bash?

    Viele Grüße
    DocAdams

    1x RaspberryPi 2, 1x RaspberryPi 3, 1x OpenELEC, 1x RaspberryPi 4 mit ioBroker ,

  • Hallo DocAdams,

    so?

    Code
    $(sudo /home/pi/./kontrolle.sh &)

    Dann laufen beide Skripts parallel nebenher.


    Beste Grüße

    Andreas

    Ich bin wirklich nicht darauf aus, Microsoft zu zerstören. Das wird nur ein völlig unbeabsichtigter Nebeneffekt sein.
    Linus Torvalds - "Vater" von Linux

    Linux is like a wigwam, no windows, no gates, but with an apache inside dancing samba, very hungry eating a yacc, a gnu and a bison.

  • ähm, wieso wollt ihr es in $( ) ausführen? Soll die Rückgabe genutzt werden :s Wenn nicht dann lasst doch einfach $( ) weg? :D

    Also " & " ist hier denk ich die Lösung, damit das 1.Programm nicht wartet bis das 2. beendet ist. Damit wird der Befehl halt in den Hintergrund geschickt..

    Bash
    #!/bin/bash
    echo bla
    bash kontrolle.sh &
    echo blub


    Wird das 1.Script bereits mit 'sudo' ausgeführt brauch man im 1.Script kein weiteres sudo, da das ganze Script und auch die darin enthaltenen befehle bereits als root ausgeführt werden.
    Das is btw das selbe als wenn du das einfach in der Konsole eingibst, da die Konsole i.d.R. ebenfalls bash ist

  • Danke.
    Jetzt ärgere ich mich über mich, denn ich hatte es schon mit "/&" probiert, das war aber falsch.
    Danke auch für den Tipp mit "$(..)" weglassen.

    Viele Grüße
    DocAdams

    1x RaspberryPi 2, 1x RaspberryPi 3, 1x OpenELEC, 1x RaspberryPi 4 mit ioBroker ,

  • Für eine Ablaufgesteuerte Abarbeitung von Programmen in der Shell wäre auch so ein Konstrukt möglich.

    Code
    script1 && script2

    Damit wiird script2 erst nach einer erfolgreichen Abarbeitung (exitcode 0) von script1 gestartet.

  • Naja, genau so möchte ich es ja nicht.

    Aber irgendwie mache ich es doch noch falsch.
    Ich habe 2 Skripte geschrieben, Skript 1 ruft nur Skript 2 auf und beendet sich, Skript 2 wartet 5 Sekunden und beendet sich auch.
    Das Ergebnis soll so sein:
    1. Start Skript 1
    2. Start Skript 2
    3. Ende Skript 1
    4. nach 5 Sekunden Ende Skript 2
    5. im Terminal möchte ich den Cursor wieder haben.

    Klappt fast, aber Punkt 5 kommt nicht, ich muss mit <Srtg>+<c> bzw. mit <ENTER> mir die Eingabemarke holen. Ist das OK so? Nicht dass ich dann jeden Tag ein neues Programm starte, das nie ganz aufhört und so irgendwann mal Probleme bereiten wird.

    Skript 1:

    Bash
    #!/bin/bash
    #
    zeit1=$( date +%H-%M-%S )
    echo $zeit1 Start SKRIPT 1 
    /home/pi/skripte/test/kontrolle/./skript2.sh &
    sleep 2
    zeit2=$( date +%H-%M-%S )
    echo $zeit2 stop SKRIPT 1
    exit 0

    Skript 2:

    Bash
    #!/bin/bash
    #
    zeit1=$( date +%H-%M-%S )
    echo $zeit1 Start SKRIPT 2
    sleep 5
    zeit2=$( date +%H-%M-%S )
    echo $zeit2 stop SKRIPT 2
    exit 0

    Terminalausgabe:

    Code
    pi@fhem2 ~/skripte/test/kontrolle $ ./skript1.sh
    14-20-43 Start SKRIPT 1
    14-20-43 Start SKRIPT 2
    14-20-45 stop SKRIPT 1
    pi@fhem2 ~/skripte/test/kontrolle $ 14-20-49 stop SKRIPT 2

    Als letzten Eintrag hätte ich das erwartet:

    Code
    ...
    14-20-45 stop SKRIPT 1
    pi@fhem2 ~/skripte/test/kontrolle $ 14-20-49 stop SKRIPT 2
    pi@fhem2 ~/skripte/test/kontrolle $

    Viele Grüße
    DocAdams

    1x RaspberryPi 2, 1x RaspberryPi 3, 1x OpenELEC, 1x RaspberryPi 4 mit ioBroker ,

    Einmal editiert, zuletzt von docadams (18. März 2015 um 14:25)

  • Also zunächst mal ist " ./ " im absoluten Pfad überflüssig. "./" brauch man nur wenn man ein Script im aktuellen Pfad ausführen möchte...

    Nun ist halt erst mal die grundlegende Frage wieso du das überhaupt derart machen möchtest - den Sinn dahinter versteh ich nicht, wieso 2 bash Scripte? :s Die Funktion ist gegeben, aber wieso willst du unbedingt den Promt?

    Das 1.Script ist das Hauptscript. Wenn sich das beendet kriegst du den Promt. Das 2.Script beendet sich aber erst danach und dessen Ausgabe kommt dann halt in die Zeile wo der Promt is.

    Würdest du die sleep's umdrehen, also das 1.Script länger laufen lassen als das 2., würdest du den Effekt merken:

    Bash
    #!/bin/bash
    echo $(date +%H:%M:%S) Start 1
    /tmp/s2.sh &
    sleep 5
    echo $(date +%H:%M:%S) Stop 1
    exit 0
    Bash
    #!/bin/bash
    echo $(date +%H:%M:%S) Start 2
    sleep 2
    echo $(date +%H:%M:%S) Stop 2
    exit 0

    Ausgabe:

    Code
    root@raspberrypi:/tmp# ./s.sh    
    19:13:26 Start 1
    19:13:26 Start 2
    19:13:28 Stop 2
    19:13:31 Stop 1
    root@raspberrypi:/tmp#
  • Tjaaa, der tiefere Sinn...
    Zunächst einmal, die Kontrollaufgabe (symbolisch Script 2) kommt noch mal in einer anderen Konstellation vor, nämlich beim Start des RasPi. Sollte, warum auch immer, der RasPi nachts gestartet werden, würde sonst die Kontrollaufgabe nicht erfolgen. Darum möchte ich diese Aufgabe ausgliedern und bei Bedarf aufrufen.

    Meine Grundidee ist die: Das Hauptprogramm (symbolisch Script 1) fährt die Rollos abhängig von Wochentag, Sonnenstand und Außentemperatur runter. Dann prüft es, ob alle Rollos unten angekommen sind, wenn nicht gibt es eine Meldung. Danach startet es die Kontrollroutine (Script 2), die in regelmäßigen Abständen prüft, ob die Rollos auch unten bleiben.
    Dieser Startzeitpunkt schwankt ja sehr, deshalb kann ich ihn nicht fest in der crontab hinterlegen.
    Nach dem Starten der Kontrollroutine soll das Hauptprogramm noch andere Dinge tun, darum kann ich nicht warten, bis das Script 2 fertig ist.

    Diese Problematik, also dass es nach Aufruf eines Unterprogramms sofort im Hauptprogramm weiter geht, ohne abzuwarten, bis das Unterprogramm fertig ist, habe ich auch noch an einer ganz anderen Stelle:

    Ich kann meine Rollos via Webserver steuern. Klappt schon ganz gut, hat aber einen Schwachpunkt. Bei Bedarf wird auch wieder eine kleine Routine gestartet, die ein bestimmtes Rollo runter fährt. Danach kommt der Focus zurück zum Programm, und _dann_ könnte das nächste Rollo runter fahren. Wenn es aber nun _während_ des Runterfahrens eine Notwendigkeit gäbe, den Vorgang zu stoppen, habe ich keine Möglichkeit, einzugreifen.

    Deshalb habe ich eine Routine geschrieben, die alle Relais deaktiviert, eine Art Notaus. Nutzt aber nichts, weil sie erst aufgerufen wird, wenn das Runterfahrprogramm beendet ist. OK, Spielerei, aber dafür machen wir das ja hier...

    Danke für den Tipp mit "./", das wusste ich noch nicht.

    Viele Grüße
    DocAdams

    1x RaspberryPi 2, 1x RaspberryPi 3, 1x OpenELEC, 1x RaspberryPi 4 mit ioBroker ,

    Einmal editiert, zuletzt von docadams (19. März 2015 um 11:45)

    • Offizieller Beitrag

    Vielleicht bist du auch einfach an dem Punkt angekommen wo Bash nicht mehr ausreicht. Wenn dir Jetzt noch ein Sonderfall einfällt, fängst du dann mit Script3 an...welches dann auch noch im Hintergund läuft?
    In Programmiersprachen kann man Sachen parallel ausführen, pausieren, stoppen und sich ggf. lustige Katzenbilder anzeigen lassen, Alles was das Herz begehrt.

  • Du hast sicher recht,
    aber meine letzten Programmiererfahrungen stammen aus den 80ern mit BASIC und so linear ist meine Denke. Ich bin offen für Neues, doch aus mir wird kein Programmierer mehr. Also muss ich mit meinen bescheidenen Mitteln auskommen und _die_ erweitern.

    Falls dein Beitrag in Richtung "so geht's nicht" gemeint ist, ist das ne klare Ansage, dass ich in einer Sackgasse bin.
    Und ich muss mir was einfallen lassen, wie ich da raus komme und es anders löse, aber immer mit meinen begrenzten Möglichkeiten, oder es sein lasse. Aber davon bin ich noch entfernt...
    Also, mit Bash ist meine Aufgabe nicht lösbar ??

    Viele Grüße
    DocAdams

    1x RaspberryPi 2, 1x RaspberryPi 3, 1x OpenELEC, 1x RaspberryPi 4 mit ioBroker ,

  • Hallo DocAdams,

    ich würde die ganze Sache in einem einzigen Programm machen.

    Mit den Bash-Skripten hast Du immer das Problem der Interprozess-Kommunikation. Du musst prüfen, welches Bash-Skript ist gerade aktiv, welches Bash-Skript muss welches andere Bash-Skript aufrufen, um mit diesem zu kommunizieren. Was passiert, wenn ein Bash-Skript beendet werden muss, das andere Bash-Skripte aufgerufen hat, die aber noch laufen - und ein anderes Bash-Skript festgestellt hat, dass die Aktion des ersten Bash-Skriptes umzukehren sind?

    Allein aus dieser simplen Denke heraus wird deutlich, dass Dein Vorhaben nur schwer nachvollziehbar oder überschaubar bleibt.

    Die Stärke von Bsh-Skripten besteht darin, irgendwelche "sturen" Aktionen durchzuführen, wie bestimmten Dateien mit festgelegten Eigenschaften / Inhalten aufzuspüren und mit diesen Dateien / Inhalten irgendwas zu machen.

    Bei komplexeren Dingen wird's ganz schnell unübersichtlich.


    Denkansatz:
    Endlosschleife:
    - Statusabfrage (wo befindet sich welches Rollo)
    - Ermittlung, welches Rollo seine Position ändern soll
    - Prüfen, ob der aktuelle Status dem Zielstatus entspricht:
    Ja ==> Relais aus
    Nein => Entweder Relais auf hochfahren oder auf herunterfahren setzen (abhängig von Status und Zielstatus)

    Für den Fall, dass ein Rollo herunterfahren soll:
    - Du setzt einen Impuls (Relais etc.)
    - Du musst nicht warten, bis das Rollo unten angekommen bist - der Impuls reicht als Aktion.
    - In der Zwischenzeit macht das Programm sonstwas (inkl. andere Rollos herunterfahren - also Impulse setzen)

    Im Prinzip reicht es, wenn regelmäßig geprüft wird, ob der aktuelle Status dem Zielstatus entspricht. Wenn nein, werden Relais geschaltet. Wenn ja, Relais aus.

    Und den Zielstatus kannst Du abhängig machen, z.B.
    - von Anwendereingabe
    - von Uhrzeiten / Tageszeiten
    - Außenhelligkeit
    - Bewegungen im Zimmer am Morgen oder was auch immer ...


    Beste Grüße

    Andreas

    Ich bin wirklich nicht darauf aus, Microsoft zu zerstören. Das wird nur ein völlig unbeabsichtigter Nebeneffekt sein.
    Linus Torvalds - "Vater" von Linux

    Linux is like a wigwam, no windows, no gates, but with an apache inside dancing samba, very hungry eating a yacc, a gnu and a bison.

    Einmal editiert, zuletzt von Andreas (19. März 2015 um 13:38)

  • Hm, ich habe bisher immer modular gedacht, auch, damit die Programme nicht zu groß werden und ich die Übersicht behalte. Hier stoße ich wahrscheinlich tatsächlich an die Grenze. Ich dachte, ich könne solche Zustandsabfragen, (welches Programm gerade wie läuft oder so) mittels pipe abfragen. Bin da aber nicht weiter gekommen.

    OK, langfristig vielleicht doch noch mal alles (vieles) auf neu.

    Das mit Impuls setzen habe ich noch nicht verstanden.
    Ich habe keine gekaufte Rollladensteuerung. Hardwaremäßig heißt das, der jeweilige Rollladenmotor wird durch 2 Relais gesteuert, die so verdrahtet sind, dass maximal ein Relais aktiv sein kann. Und diese Relais können entweder durch einen Tastendruck von einem Menschen, oder regelbasiert bzw. webbasiert vom RasPi gesteuert werden. Im RasPi gibt es ein Skript, das nach dessen Start die Dauer des aktiven Relais festlegt. Z.B. das Skript f1r.sh fährt das Rollo von Fenster 1 runter:

    Bash
    #!/bin/bash
    #
    dauer=17
     rel1=gpio17	# R1 schwarz	F1 runter
     rel2=gpio27 	# R2 weiß		F1 hoch
     echo "0" > /sys/class/gpio/$rel2/value
     echo "1" > /sys/class/gpio/$rel1/value
     sleep $dauer
     echo "0" > /sys/class/gpio/$rel1/value
    exit 0


    Das Relais 2 ist für das Hochfahren und Relais 1 für das Runterfahren zuständig.
    Zurück zur Ausgangsfrage. Bei mir würde der Impuls 17 Sekunden dauern. So hast du das doch sicher nicht gemeint?

    EDIT:
    Mit dem Abfragen, Zielstatus - Iststatus, möchte ich mich nicht zufrieden geben. Beim Runterfahren könnte ein Stein drunter liegen, so dass man später leicht drunter fassen kann, es könnte sich was verklemmen, oder jemand könnte das Rollo nachts hochschieben, aushebeln, was weiß ich. Meiner Frau habe ich die ganzen Basteleien mit erhöhter Sicherheit verkauft ;) Dann muss es aber auch so sein. Deshalb habe ich jeweils 2 Reedkontakte für die Endstellungen eingebaut und mit Adressen versehen. Nur wenn der entsprechende Reedkontakt geschlossen ist, weiß ich aus der Ferne, ob das Rollo wirklich unten ist, und nicht, wenn der RasPi meint, er habe das Rollo runter gefahren und gut ist :) Aber vielleicht habe ich dich da falsch verstanden.

    Viele Grüße
    DocAdams

    1x RaspberryPi 2, 1x RaspberryPi 3, 1x OpenELEC, 1x RaspberryPi 4 mit ioBroker ,

    Einmal editiert, zuletzt von docadams (19. März 2015 um 14:16)

  • So hatte ich es mir ganz am Anfang gedacht. Ist mir aber zu unsicher: Reedkontakt fällt aus, oder der besagte Stein. Dann würde der Kontakt nie auslösen und der Motor dreht zu lange. OK, die Motoren haben eine Endabschaltung. Aber mein eigentliches Problem, dass solange das Relais aktiv ist, nichts anderes passieren kann, ist damit nicht gelöst.

    Viele Grüße
    DocAdams

    1x RaspberryPi 2, 1x RaspberryPi 3, 1x OpenELEC, 1x RaspberryPi 4 mit ioBroker ,

  • Hallo DocAdams,

    das Relais wird durch einen Impuls ausgelöst, dauert vielleicht 5 ms oder so. Ein Programm muss nicht warten, bis ein Aktion abgeschlossen ist. Das geschieht durch die oben geschilderte Ereignisbehandlung und Statusabfrage.

    Tip: Löse Dich einmal von der BASIC-Denke!
    Ein Vorgang wird ausgelöst... Woanders wird ein Abschluss festgestellt. Statt auf den Abschluss von irgendwas zu warten, lässt Du andere Dinge geschehen. Alles passiert quasi gleichzeitig.

    Selbst wenn Du auf den Abschluss warten möchtest, ergibt sich die Ohnmacht gegenüber ausgefallenen Reed-Konakten oder dem "Stein". Also bringt Dir explizites Warten keinen Vorteil.


    Beste Grüße

    Andreas

    Ich bin wirklich nicht darauf aus, Microsoft zu zerstören. Das wird nur ein völlig unbeabsichtigter Nebeneffekt sein.
    Linus Torvalds - "Vater" von Linux

    Linux is like a wigwam, no windows, no gates, but with an apache inside dancing samba, very hungry eating a yacc, a gnu and a bison.

    Einmal editiert, zuletzt von Andreas (19. März 2015 um 15:03)

  • Naja mit bash lässt sich eigentlich genau so viel machen wie mit jeder anderen 'Sprache'. Ob er jetzt in Python multiprocessing/threading machen muss, oder in bash mehrere Scripts bzw Funktionen verwendet - ist letztendlich schnurzpipegal :D

    Auch kann er problemlos mit bash einen modularen Aufbau realisieren - allerdings sollte er dann Funktionen setzen und "importiert" dann die jeweilige "source" in dem Script wo es gebraucht wird. So hab ich das auch schon in anderen großen bash-Projekten realisiert.

    Funktionen machen insbesondere dann Sinn wenn der selbe Code an mehreren Stellen zum Einsatz kommen soll. Das ist aber nicht nur bei bash so ;)

    Problematisch wird allerdings schon das parallele ausführen von Funktionen und Abfragen ob eine 'Aktion' erfolgreich war. Also Funktionen kann man imho nicht im Hintergrund ausführen lassen, insofern wäre es also besser ein eigenständiges Script im Hintergrund auszuführen.
    Das 'Hauptscript' müsste dann halt überwachen ob das Script läuft usw und je nach Vorhaben entsprechendes machen...

    Ich kann das jetzt schlecht einschätzen wie groß sein Projekt mittlerweile ist - aber wenn zB rollo_steuerung.sh Variablen beinhaltet welche in den anderen Scripts auch verwendet werden müssten, sollte man diese in eine separate Datei auslagern und von allen benötigen Scripts 'importieren'. So muss man dann nicht nur wegen einer Variablen 10 Scripts ändern...

    Beispiel:

    config.sh

    Code
    dauer=17
    rel1=gpio17    # R1 schwarz    F1 runter
    rel2=gpio27     # R2 weiß        F1 hoch

    script1.sh

    Bash
    #!/bin/bash
    source config.sh
    echo 0 > /sys/class/gpio/$rel2/value
    exit 0

    script2.sh

    Bash
    #!/bin/bash
    . config.sh
    echo 1 > /sys/class/gpio/$rel1/value
    sleep $dauer
    echo 0 > /sys/class/gpio/$rel1/value
    exit 0

    Das sind 2 verschiedene Möglichkeiten die Variablen von 'config.sh' in dem jeweiligen Script verfügbar zu haben. Beide erreichen das selbe. Bei der 2.Möglichkeit ist das Leerzeichen zwischen dem Punkt und dem Dateinamen wichtig! Will man den Pfad zu der Datei verwenden sähe das zB so aus:

    Code
    . /path/to/config.sh


    Und eine Funktion, um zu prüfen ob ein Script gerade ausgeführt wird, könnte wie folgt aussehen:

    Code
    function check_run() {
      local script=$1
      local PID=$(pidof $script)
      [ -n "$PID" ] && echo $PID || echo 0
    }


    Das 'local' setzen der Variablen führt dazu das diese nur innerhalb der Function verfügbar sind. So läuft man nicht Gefahr andere zu überschreiben o.ä.
    Die Funktion gibt die PID zurück falls der Prozess gefunden wurde, ansonsten 0. So kann man das einfach in einer if Abfrage oder einer while Schleife verwenden..
    (" -n " ist das selbe wie " ! -z " also nicht-leer)

    Diese Funktion ruft man dann an beliebiger Stelle mit Angabe des "Programm Namens" wie er über "ps aux" auftauchen würde, auf. Also zB. so:

    Bash
    #!/bin/bash
    . functions.sh
    
    
    check_run "python rollo.py"

  • Also Funktionen kann man imho nicht im Hintergrund ausführen lassen...

    :huh: - Doch das geht:

    Spoiler anzeigen

    Ein schöneres Beispiel dazu gibts hier:
    http://bash.cyberciti.biz/guide/Putting_…s_in_background

    *duckundweg* :)

    DON'T PANIC!

    Einmal editiert, zuletzt von joh.raspi (19. März 2015 um 16:40)

  • Hallo und vielen Dank für eure Hilfen.

    @ Andreas.
    Ich habe die irgendwie immer noch nicht verstanden.
    Irgendwer muss ja dafür zuständig sein, dass der Motor 17 Sekunden lang in die eine Richtung dreht. Bei mir macht das der RasPi, indem er den zuständigen GPIO 17 Sekunden lang schaltet und damit 17 Sekunden lang das Relais aktiviert.
    Meinst du jetzt ein zwischengeschaltetes elektronisches Bauteil, das per einige Millisekunden langen Impuls aktiviert wird, ähnlich wie eine Treppenhausschaltung?

    meigrafd
    Du hast mir 2 wichtige Tipps gegeben.
    Ich erinnere mich jetzt, dass ich das mit den Variablen in einer separaten Datei schon mal gelesen hatte, lange bevor ich überhaupt einen RasPi bestellt hatte. Da kam so viel Neues auf mich zu, dass das dann doch wieder unter gegangen war. Das setze ich sofort um, denn dass macht einiges übersichtlicher.
    Und dann muss ich mich echt mal mit Funktionen auseinander setzen, ich glaube, da könnte ich weiter kommen. Aber da brauche ich mehr Zeit, um mich da reinzuwühlen.

    Viele Grüße
    DocAdams

    1x RaspberryPi 2, 1x RaspberryPi 3, 1x OpenELEC, 1x RaspberryPi 4 mit ioBroker ,

  • Hallo DocAdams,


    Hallo und vielen Dank für eure Hilfen.

    @ Andreas.
    Ich habe die irgendwie immer noch nicht verstanden.
    Irgendwer muss ja dafür zuständig sein, dass der Motor 17 Sekunden lang in die eine Richtung dreht. Bei mir macht das der RasPi, indem er den zuständigen GPIO 17 Sekunden lang schaltet und damit 17 Sekunden lang das Relais aktiviert.
    Meinst du jetzt ein zwischengeschaltetes elektronisches Bauteil, das per einige Millisekunden langen Impuls aktiviert wird, ähnlich wie eine Treppenhausschaltung?

    Du hast geschrieben, dass Du zwei Relais einsetzt, das eine zum Herunterfahren, das andere zum Hochfahren des Rollos.

    Wenn ein Endschalter / Reed-Schalter auslöst, wenn der Rollo sein Ziel erreicht hat, dann ist der Motor stromlos - dreht also nicht weiter. Ob das jetzt mal 17 Sekunden oder 16,8 oder 30 Sekunden dauert, ist vollkommen egal.

    Laienhaft formuliert: Das Programm schaltet das Relais ein, der Motor läuft an, das Rollo fährt herunter. Statt nun eine festgelegte Zeit zu warten, macht das Programm etwas Anderes und vor allem Sinvolleres.

    Du stößt also nur einen Vorgang an. Die Rückmeldung "Motor aus" kommt über den Endschalter / Reed-Kontakt. Das heißt, das Rollo unterbricht selber den Strom, wenn es seine Endposition erreicht hat. Das Rollo kannst Du nur noch über das andere Relais zum Hochfahren bewegen - was ja auch Sinn macht.

    Du brauchst jetzt lediglich den Fehler abzufangen, wenn ein erwartetes Ereignis ausgeblieben ist.

    Statt so:

    Code
    rollo1_runter:
        GPIO_fürRollo1(HIGH)
        warten(17)
        GPIO_fürRollo1(LOW)

    machst Du so

    Ist das jetzt verständlicher geworden?


    Beste Grüße

    Andreas

    Ich bin wirklich nicht darauf aus, Microsoft zu zerstören. Das wird nur ein völlig unbeabsichtigter Nebeneffekt sein.
    Linus Torvalds - "Vater" von Linux

    Linux is like a wigwam, no windows, no gates, but with an apache inside dancing samba, very hungry eating a yacc, a gnu and a bison.

    Einmal editiert, zuletzt von Andreas (20. März 2015 um 20:41)

Jetzt mitmachen!

Du hast noch kein Benutzerkonto auf unserer Seite? Registriere dich kostenlos und nimm an unserer Community teil!