Remote zugriff auf Zähler-Daten

[mpanter]

Hallo zusammen,

wir wollen den revPi als Impulszähler für verschiedene Maschinen nutzen. Das ist ja auch kein Problem und das funktioniert auch super einfach mit dem DIO-Modul.
Die Zählerstände möchten wir nun via IP zyklisch abfragen (alle x Sekunden) und in die Unternehmens-Datenbank ablegen. Die revPi liegen in einer DMZ und können also nur abgefragt werden, und nicht selbst per IP auf die DB schreiben.

Gibt es da irgend eine Möglichkeit die im revPi schon vorgesehen ist?
Ich habe den Thread über die OPC-UA Library schon gelesen. Muss man über diesen Weg gehen?

Für ein paar Tipps wäre ich sehr dankbar.

Grüße
Manfred

[RevPiModIO]

Eine Möglichkeit wäre über XMLRPC und Python3.

Wir entwickeln das python3-RevPiModIO Modul, was auch open source sein wird. Wenn du auf dem RevPi-Core das Modul installierst und über Python einen kleinen xmlrpc Server startest könnte man per Funktionsaufruf über das Netzwerk die Zählerstände komfortabel erhalten (als Rückgabewerte der Funktionen).

Ein ValueServer könnte so aussehen (Aktualisiert 15.02.17):

Code: Select all

import revpimodio
import signal
from concurrent import futures
from xmlrpc.server import SimpleXMLRPCServer


class RevPiValueServer():
    
    def __init__(self):
        """Init der Klasse."""
        # RevPiModIO
        self.rpi = revpimodio.RevPiModIO()
        for dev in self.rpi.devices:
            self.rpi.devices.auto_refresh(dev)

        # XMLRPC-Server
        self.xsrv =  SimpleXMLRPCServer(("", 55000), logRequests=False)
        self.xsrv.register_introspection_functions()
        self.xsrv.register_function(self.get_iovalue)

        # Signal events
        signal.signal(signal.SIGINT, self._sigexit)
        signal.signal(signal.SIGTERM, self._sigexit)

    def _sigexit(self, signum=None, frame=None):
        """Behandelt das exit-Signal."""
        self.xsrv.shutdown()

    def get_iovalue(self, device, io):
        """Gibt einen Wert zurueck.
        @param device: Modulname
        @param io: IO-Name
        @returns: IO-Wert"""
        if type(io) != str:
            raise ValueError("Nur mit IO-Namen arbeiten!")

        io = self.rpi.devices[device][io]
        return io.value

    def start(self):
        """Startet den XMLRPC-Server."""
        e = futures.ThreadPoolExecutor(max_workers=1)
        self._futsrv = e.submit(self.xsrv.serve_forever)
        print("Server gestartet!")
        e.shutdown()


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

Er startet und wartet bis Daten geholt werden. mit Strg+C kann er sauber beendet werden:

Über get_iovalue(device,io) wird dann angegeben von Welchem DI/DO/DIO Modul und den Namen des Counters (piCtory-Konfiguration

Wenn er läuft kann testweise mit Python IDLE mal ein Wert abgefragt werden:

Code: Select all

>>> from xmlrpc.client import ServerProxy
>>> cli = ServerProxy("http://192.168.50.152:55000")
>>> cli.get_iovalue(32,"Counter_1_i07")
0

Modul an Positionsnummer 32 den IO mit dem Namen "Counter_1_i07" hat bei mir jetzt "0"

XMLRPC gibt es ja in vielen Programmiersprachen, so musst du auf dem "Abholsystem" nicht zwangsweise Python verwenden um die Daten dann in deine Datenbank zu schreiben

Gruß, Sven

[mpanter]

Hallo Sven,
vielen dank für den Tipp. Das hört sich schon mal nach einer guten Möglichkeit an.

Ich habe versucht das Modul zu installieren, bin aber leider nicht fündig geworden.

Gibt es da schon einen Termin für die Veröffentlichung?

Grüße
Manfred

[volker]

Hallo Manfred,
eine ganze Reihe von Herstellen fertiger Lösungen portieren gerade ihre SW auf RevPi. as meiste davon sind IoT Lösungen mit Cloud (also Internet) als Server. Allerdings gibt es aber auch solche Lösungen wie SIWIAT, die sich auf das Intranet und speziell die Übergabe an Unternehmenssoftware spezialisiert haben. Bei SIWAIT läuft das über "Apps", die wie Bausteine zusammengefügt werden. Für den RevPi soll es dann eine RevPi App geben (für die IOs). Dahinter kommt dann eine App mit Vorverarbeitung (bei Euch eventuell einfach nur ein Zähler) und dahinter dann eine Üebrgabeapp (die haben von EXCEL bis zu SAP alle möglichen Formate und natürlich auch über Ethernet). Vielleicht solltest Du da mal nachfragen.

Alternativ kannst Du den eingebauten Server nutzen, um ihn simple Webrequests beantworten zu lassen. Die dafür nötige Serversoftware hat ja Sven skizziert. Die kann natürlich auch direkt auf PiControl zugreifen (siehe Tutorial #16) um sich dort die Zählerstände abzuholen.

Logi.RTS verfügt übrigens über MQTT Zugriffsbausteine. Das wäre de eleganteste Weg: Ihr macht ein kleines ST-Programm mit logi.CAD 3, welches einfach nur die Zählestände auf einem MQTT Broke publiziert. Der kann irgendwo liegen, also auch auf dem RevPi selber (gibt es als Freeware). Die Unternehmenssoftware würde dann über MQTT auf die publizierten Zählerstände zugreifen. Die Logi.cals Mitarbeier würde da sicher auch Hilfestellung geben.

[RevPiModIO]

Nachdem wir unseren "Revolutionsumbau" programmiert haben und ein paar andere Tools hier mal die Beta von RevPiModIO

https://revpimodio.org/quellen/

Wäre schön, wenn wir ein paar Tester zusammen bekommen

Gruß, Sven

[mpanter]

Hallo Sven, Hallo Volker,
vielen Dank nochmal für die Tipps. Ich denke das eine oder andere führt zum Ziel.

@Sven
Ich werde gerne ein wenig testen. Und habs auch schon getan.

Ich hab Deine Server-Programm genommen um die Daten zu übertragen.
Leider bekomme ich keine Daten geliefert. Nur False für die Eingänge und 0 für die Zähler.
Die Konfiguration scheint korrekt eingelesen zu werden, die Collection der Ports ist da.
Die Ausgabe von

Code: Select all

for t in self.rpi.devices[device] :
            print(t)
            print(t.value)

listet alle, auch die umbenannten Eingänge, korrekt an. Als Value kommt allerdings wie gesagt immer False oder 0.

An was kann das liegen?

Grüße
Manfred

[RevPiModIO]

Hi Manfred!

Ich denke in piCtory hast du bereits den "InputMode_*" für deinen Eingang auf Counter,... gestellt.

Und dann habe ich im Eifer des Gefechts in dem Quellcode oben einen Fehler eingebaut

Es fehlt die Synchronisierung mit dem Prozessabbild! Das Modul arbeitet mit einem internen Puffer und nicht direkt auf dem /dev/piControl0 aus Leistungsgründen und auch, damit der Programmierer selber entscheiden kann WANN die Daten vom Prozessabbild gelesen und vor allem geschrieben werden.

Wenn du dich selber darum kümmern möchtest musst du VOR dem Lesen (also vor deiner for-Schleife):
self.rpi.devices.readprocimg()
aufrufen, dann werden erst alle Werte der Inputs in den Puffer gelesen, aus dem die Inputs die Daten bekommen.

Alternativ kann man auch die Devices beim auto_refresh() anmelden und er macht alles im Hintergrund zyklisch.
Dann müsste man bei meinem Quelltext noch die untersten Zeilen hinzufügen um alle Devices automatisch zu aktualisieren:

Code: Select all

(...)
def __init__(self):
        """Init der Klasse."""
        # RevPiModIO
        self.rpi = revpimodio.RevPiModIO()
        for dev in self.rpi.devices:
            self.rpi.devices.auto_refresh(dev)
            
        (...)

Sorry, wegen dem Fehler...

Gruß, Sven

PS: Wenn man Outputs setzen will und nicht das auto_refresh() verwendet, muss man diese mit
self.rpi.devices.writeprocimg()

Alternativ für lesen UND schreiben (kann man eigentlich auch immer verwenden)
self.rpi.devices.updateprocimg()

[mpanter]

Hallo Sven,
super!!!! Vielen Dank für die schnelle Hilfe.
Jetzt hat alles geklappt.

Ich werde jetzt hoffentlich zum ausführlichen Testen kommen.

Viele Grüße
Manfred