Betriebsarten werden durch ein Event gestartet

Der Programmstart sieht so aus:

  • Wir Instanziieren die Klasse RevPiRevolution(), wodurch die Einstellungen geladen werden
  • Dort wird unser RevPiModIO Modul konfiguriert
  • Ein Modul mit dem Namen funccatalog bietet die Grundfunktionen, welche wir hier konfigurieren
  • Und das wichtige Event für den Taster „t_start“ wird registriert
  • Dann gehen wir in den mainloop()
class RevPiRevolution():

    """Hauptklasse fuer den Revolutionsumbau."""

    def __init__(self):
        """Instanziiert diese Klasse."""
        self.rpi = None

        # Gesamte Logik für den Automatikbetrieb
        self.th_automatik = None

        # Gesamte Logik für den Handbetrieb
        self.th_hand = None

        # Alles Konfigurieren
        self.loadconfig()

        # Signale zum Beenden einrichten
        signal.signal(signal.SIGINT, self.stop)
        signal.signal(signal.SIGTERM, self.stop)

    def loadconfig(self):
        """Konfiguriert alles fuer die Ausfuehrung."""

        # RevPiModIO konfigurieren mit auto_refresh
        self.rpi = revpimodio.RevPiModIO(auto_refresh=True)

        # Globale Steuerungsthreads vorbereiten
        funccatalog.anlage = funccatalog.Anlage(self.rpi)
        funccatalog.anlage.start()
        funccatalog.band = funccatalog.Band(self.rpi)
        funccatalog.band.start()
        funccatalog.zylinder = funccatalog.Zylinder(self.rpi)
        funccatalog.zylinder.start()

        # Funktions Thrads vorbereiten
        self.th_automatik = Automatik(self.rpi)
        self.th_hand = Hand(self.rpi)

        # Event für Start-Raster registrieren
        self.rpi.devices["di01"].reg_event("t_start", self.evt_start)

        # Druckverlust
        self.rpi.devices["di02"].reg_event(
            "m_druck_ok", self.evt_keindruck, edge=revpimodio.FALLING
        )

        # Notaus
        self.rpi.devices["di01"].reg_event(
            "notaus_ok", self.evt_notaus, edge=revpimodio.FALLING
        )

    def evt_keindruck(self, ioname, iovalue):
        """Eventfunktion fuer Druckabfall.
        @param ioname Name des IO, der Event ausloest
        @param iovalue Wert des IO, der Event ausloest"""
        funccatalog.anlage.stoerung = True
        self.th_automatik.stop()

    def evt_notaus(self, ioname, iovalue):
        """Eventfunktion fuer Notaus.
        @param ioname Name des IO, der Event ausloest
        @param iovalue Wert des IO, der Event ausloest"""
        funccatalog.anlage.stoerung = True
        self.th_automatik.stop()
        self.th_hand.stop()

    def evt_start(self, ioname, iovalue):
        """Eventfunktion fuer den Taster t_start.

        @param ioname Name des IO, der Event ausloest
        @param iovalue Wert des IO, der Event ausloest
        @return None

        """
        # Laufende Threads beenden
        self.th_automatik.stop()
        self.th_hand.stop()

        # Wenn Notaus nicht OK ist, abbrechen
        if not self.rpi.devices["di01"]["notaus_ok"]:
            return None

        # Wenn t_start gesetzt ist, wird gewählter Betriebsmodus gestartet
        if iovalue:
            if self.rpi.devices["di01"]["t_automatik"]:
                # Automatikbetrieb starten, wenn Druck und noch nicht läuft
                if self.rpi.devices["di02"]["m_druck_ok"] \
                        and not self.th_automatik.is_alive() \
                        and not funccatalog.anlage.stoerung:
                    self.th_automatik = Automatik(self.rpi)
                    self.th_automatik.start()

            else:
                # Handbetrieb starten, wenn noch nicht läuft
                if not self.th_hand.is_alive():
                    self.th_hand = Hand(self.rpi)
                    self.th_hand.start()

    def start(self):
        """Startet das Revolutionsumbauprogramm."""
        # LED A1 grün schalten
        self.rpi.devices.core.A1 = 1

        # Druckventil öffnen
        self.rpi.devices["do01"]["v_druck"] = True

        # In den mainloop() gehen und auf Events warten
        self.rpi.devices.mainloop()

        # LED A1 ausschalten
        self.rpi.devices.core.A1 = 0

        # Druckventil schließen
        self.rpi.devices["do01"]["v_druck"] = False

        # Prozessabbild schreiben, da auto_refresh hier nicht mehr läuft
        self.rpi.devices.writeprocimg()

        # RevPiModIO herunterfahren
        self.rpi.cleanup()

    def stop(self, signum=None, frame=None):
        """Beendet das Revolutionsumbauprogramm."""
        # Alle Steuerungsthreads beenden
        self.th_automatik.stop()
        self.th_hand.stop()

        # Alle Funktionsthrads beenden
        funccatalog.anlage.stop()
        funccatalog.band.stop()
        funccatalog.zylinder.stop()

        # mainloop() verlassen und auto_refresh beenden
        self.rpi.devices.exit()


if __name__ == "__main__":
    root = RevPiRevolution()
    root.start()

 

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.