+ Antworten
Seite 1 von 3 1 2 3 LetzteLetzte
Ergebnis 1 bis 10 von 21
  1. #1
    Registriert seit
    Sep 2009
    Ort
    Bocholt
    Beiträge
    1,131

    Standard JSON-RPC über C#/VB.NET Step by Step

    Hallo alle zusammen,

    aus gegebenen Anlass möchte ich mit diesem Thread nochmals alles zusammentragen was zur Kommunikation mit IPS über die JSON-RPC Schnittstelle zu beachten ist.

    In diesem Thread bitte keine Diskussionen oder Fragen posten. Dieser Thread dient ausschliesslich dazu das Skript in seiner aktuellen Version zugänglich zu machen ohne sich die Teile in seitenweisem Studium des Forums zusammen suchen zu müssen.


    Also:

    JSON-RPC-Schnittstelle über VB.NET/C# „Step by Step“

    Inhalt:

    #1: Inhalt und Einleitung
    #2: Jetzt geht es los. Hand an die Maus
    #3: Code-Erweiterung für SSL
    #4: Hey what's up IPS -> MessageSink von IPS
    #5: Auswerten der Antwort -> Deserialisieren (besten Dank an Kim)
    #6: Auswerten der Antwort beim MessageSink (besten Dank an Kim)
    #7: Die IPS_JSONRPC Klasse
    #8: VB.NET Beispielprojekt zum runterladen

    #16: Inhalt und Einleitung für C#
    #17: Jetzt geht es los. Hand an die Maus
    #18: Auswerten der Antwort -> Deserialisieren
    #19: Auswerten der Antwort beim MessageSink
    #20: C# Beispielprojekt zum runterladen


    Einleitung:

    JSON-RPC (JavaScript Object Notation Remote Procedure Call) ist ein Protokoll zum Aufruf entfernter Methoden in Computersystemen, ähnlich wie XML-RPC (die Daten werden jedoch in JSON statt in XML gesendet).

    Um die JSON-RPC Schnittstelle unter IPS nutzen zu können muss sie erst aktiviert werden.

    Beispiel IP-Symcon auf Windows PC:

    Das geht mit Rechst Klick auf das Tray-Icon. Danach auf "Informationen" klicken.

    Klicken Sie auf die Grafik für eine größere Ansicht 

Name:	Jason_RPC_C_1.png 
Hits:	132 
Größe:	34.6 KB 
ID:	35454

    Danach neben Fernzugriff auf „Ändern“ klicken. Dabei sollte ein sicheres Kennwort (mindestens acht Zeichen mit Sonderzeichen) vergeben werden.

    Klicken Sie auf die Grafik für eine größere Ansicht 

Name:	Jason_RPC_C_2.png 
Hits:	172 
Größe:	25.7 KB 
ID:	35455


    Beispiel SymBox :

    Über den Browser an der Symbox anmelden. Danach Einstellungen und Fernzugriff auswählen. Dann sollte auch hier ein sicheres Kennwort (mindestens acht Zeichen mit Sonderzeichen) vergeben werden.

    Klicken Sie auf die Grafik für eine größere Ansicht 

Name:	Jason_RPC_C_3.png 
Hits:	139 
Größe:	25.7 KB 
ID:	35456
    Klicken Sie auf die Grafik für eine größere Ansicht 

Name:	Jason_RPC_C_4.png 
Hits:	143 
Größe:	20.5 KB 
ID:	35457

    Sobald der Fernzugriff aktiviert wurde, kann man die JSON-RPC mit dem Benutzernamen (Lizenz-Benutzername) und dem vorher gesetzten Kennwort erreichen.

    Eine JSON-RPC Anfrage (Request):

    Eine JSON-RPC Anfrage sieht bei IPS so aus:

    {"jsonrpc":"2.0","method":"IPS_RunScript","params" :[10693],"id":"null"}
    Bestandteile eines Request-Objekts

    jsonrpc -> Ein String mit dem Namen der JSON-RPC-Version. Momentan fix "2.0"
    method -> Der IPS-Befehl als Zeichenkette. In unserem Beispiel "IPS_RunScript".
    params -> Die Parameter der IPS-Befehls in den runden Klammern. In unserem Beispiel die Script-ID.
    id -> Ein eindeutiger Identifikator für die Nachricht. Bei IPS ist die fix "null".

    Eine JSON-RPC Antwort (Response):

    Eine JSON-RPC Antwort sieht bei IPS so aus:

    {"result":true,"id":"null","jsonrpc":"2.0"}
    Bestandteile eines Response-Objekts

    result -> Das Rückgabeobjekt der Funktion, falls kein RPC-Fehler auftrat.
    id -> Enthält den gleichen Wert wie id des Requests. In unserem Fall fix "null"
    jsonrpc -> Ein String mit dem Namen der JSON-RPC-Version. Momentan fix "2.0"
    Geändert von Schablone (11.09.16 um 13:37 Uhr)
    Bis dann

    Martin

  2. #2
    Registriert seit
    Sep 2009
    Ort
    Bocholt
    Beiträge
    1,131

    Standard Jetzt geht es los. Hand an die Maus

    Als erstes erstellen wir ein neues Projekt (Windows Forms-Anwendung) mit dem Namen "IPS_JSONRPC".

    Klicken Sie auf die Grafik für eine größere Ansicht 

Name:	Neues Projekt.jpg 
Hits:	372 
Größe:	63.8 KB 
ID:	24846

    Klicken Sie auf die Grafik für eine größere Ansicht 

Name:	Neues Projekt_2.PNG 
Hits:	360 
Größe:	91.5 KB 
ID:	24847

    Auf der Form haben wir folgende Elemente.

    Klicken Sie auf die Grafik für eine größere Ansicht 

Name:	Form_aufbau.PNG 
Hits:	450 
Größe:	13.0 KB 
ID:	24848

    Die Namen der Elemente habe ich im Screenshot beschriftet.

    Der Code

    Imports (benötigter Namespace)

    Imports System.Net 'Namespace für HttpWeb
    Imports System.Text 'Namespace für das Encoding
    Imports System.IO 'Namespace für den Stream
    Die Imports kommen noch vor "Public Class Form1".

    Als nächstes öffnen wir mit einem Doppelklick auf den "btSenden" Button die btSenden_Click Sub.

    Die Variablen Deklaration:

    Was wird benötigt?

    Natürlich wollen wir einen "Request" (Anfrage) verschicken und einen Response (Antwort) empfangen.
    Also schreiben wir als erstes:
    Dim request As WebRequest
    Dim response As WebResponse
    Da die Autorisierung (Benutzername und Passwort) mit übertragen wird, brauchen wir noch:
    Dim authInfo As String
    Des weiteren benötigen wir die IPS URI. Dafür benötigen wir:
    Dim IPS_URI As String
    Zu guter Letzt gibt es natürlich einen Send und Receive String:
    Dim Send As String
    Dim Rec As String
    Nun kommt der eigentliche Code.

    Als erstes erstellen wir die IPS URI. Das sieht so aus:

    IPS_URI = "http://" & tbIPS_IP.Text & ":3777/api/"
    Als nächstes kommt die Autorisierung dran. Dazu schreiben wir:

    authInfo = tbBenutzer.Text & ":" & tbPassword.Text
    authInfo = Convert.ToBase64String(Encoding.Default.GetBytes(a uthInfo))
    Nun haben wir alle Informationen zusammengestellt für den Request-Header. Der sieht dann so aus:

    request = WebRequest.Create(IPS_URI)
    request.Headers("Authorization") = "Basic " & authInfo
    request.Method = "Post"
    Als nächstes bauen wir uns den JSON-RPC Request zusammen. Wir erinnern uns an den Aufbau aus der Einleitung.

    {"jsonrpc":"2.0","method":"IPS_RunScript","params" :[10693],"id":"null"}

    Hinter "method" kommt der eigentliche IPS-Befehl und nach "params" kommt alles aus den runden Klammern des IPS-Befehls.

    Wenn wir die JSON-RPC nachbauen sieht das so aus:

    Send = "{" & Chr(34) & "jsonrpc" & Chr(34) & ":" & Chr(34) & "2.0" & Chr(34) & "," _
    & Chr(34) & "method" & Chr(34) & ":" & Chr(34) & tbBefehl.Text & Chr(34) & "," _
    & Chr(34) & "params" & Chr(34) & ":[" & tbParameter.Text & "]," _
    & Chr(34) & "id" & Chr(34) & ":" & Chr(34) & "null" & Chr(34) & "}"
    Chr(34) sind die doppelten Anführungsstriche.

    Nun habe wir alles zusammen um den Request-Stream zu versenden. Das sieht dann so aus:

    Dim StreamWriter As StreamWriter = New StreamWriter(request.GetRequestStream)
    StreamWriter.Write(Send)
    StreamWriter.Close()
    Nun kommt der zweite Teil. Empfangen des Response (Antwort). Wir wollen natürlich den Response unseres Request haben. Also kommt in der ersten Zeile:

    response = request.GetResponse
    Danach lesen wir den Stream ein und legen die Daten ab.

    Dim StreamReader As StreamReader = New StreamReader(response.GetResponseStream)
    Rec = StreamReader.ReadToEnd
    Am Ende dürfen wir nicht vergessen alles zu schliessen.

    StreamReader.Close()
    response.Close()
    Die Empfangenen Daten können nun abgelegt werden.

    Receive.Text = Rec
    Ein erster Test mit IPS_RunScript

    Klicken Sie auf die Grafik für eine größere Ansicht 

Name:	Erster Test.PNG 
Hits:	442 
Größe:	10.7 KB 
ID:	24849
    Geändert von Schablone (04.09.16 um 17:23 Uhr)
    Bis dann

    Martin

  3. #3
    Registriert seit
    Sep 2009
    Ort
    Bocholt
    Beiträge
    1,131

    Standard Code-Erweiterung für SSL

    Was braucht man an Code für den SSL-Betrieb?

    Für den SSL-Betreib braucht man zwei Erweiterungen und eine Code-Änderung.

    Als erstes die Code-Änderung.
    Natürlich läuft der SSL-Betrieb über eine https URI.
    Also wird aus der IPS URI:

    Alt:
    IPS_URI = "http://" & tbIPS_IP.Text & ":3777/api/"
    Neu:
    IPS_URI = "https://" & tbIPS_IP.Text & ":3777/api/"
    Des weiteren gibt es einen Callback mit einer Callback-Funktion.

    Der Callback sieht so aus:

    ServicePointManager.ServerCertificateValidationCal lback = New System.Net.Security.RemoteCertificateValidationCal lback(AddressOf AcceptCert)
    Die Callback-Funktion sieht so aus:

    Private Function AcceptCert(ByVal sender As Object, ByVal cert As System.Security.Cryptography.X509Certificates.X509 Certificate, _
    ByVal chain As System.Security.Cryptography.X509Certificates.X509 Chain, _
    ByVal errors As System.Net.Security.SslPolicyErrors) As Boolean
    Return True
    End Function

    Ein Test mit SSL-Betrieb:

    Klicken Sie auf die Grafik für eine größere Ansicht 

Name:	Test mit SSL.PNG 
Hits:	317 
Größe:	11.6 KB 
ID:	24850
    Geändert von Schablone (04.09.16 um 17:24 Uhr)
    Bis dann

    Martin

  4. #4
    Registriert seit
    Sep 2009
    Ort
    Bocholt
    Beiträge
    1,131

    Standard Hey what's up IPS -> MessageSink von IPS

    Wozu brauche ich den Rückkanal von IPS? Ich kann doch alle Variablen über "GetValue" auslesen.

    Das ist richtig. Bis zu einem gewissen Grad ist das mit Sicherheit auch sinnvoll. Der Rückkanal von
    IPS hat aber den Vorteil das dir IPS alle Änderungen ab einen bestimmten Zeitpunkt zurückliefert.
    Dazu gehören nicht nur Änderungen von Variableninhalten.

    Für diesen Zweck gibt es die Befehle:

    "IPS_GetSnapshot" und "IPS_GetSnapshotChanges".
    Ich benötige für mich nur den Befehl "IPS_GetSnapshotChanges".

    Beim Starten der Applikation lese ich alle benötigten Variablen gezielt ein (GetValue). Danach arbeite
    ich nur noch mit "IPS_GetSnapshotChanges".

    Um den Befehl richtig zu verstehen werden wir das Prozedere mit der eben erstellten Form händisch durchexerzieren.

    Mit dem Befehl wird immer ein Zeitstempel als Parameter übergeben.
    Beim ersten Aufruf ist der Zeitstempel "0". Das sieht dann so aus:

    Klicken Sie auf die Grafik für eine größere Ansicht 

Name:	IPS_GetSnapshotChanges_erste mal.PNG 
Hits:	300 
Größe:	15.8 KB 
ID:	25060

    Mit der ersten Antwort kommt von IPS ein gültiger Zeitstempel. Dieser Zeitstempel (TimeStamp) wird beim zweiten
    Aufruf von "IPS_GetSnapshotChanges" verwendet. In unserem Fall ist das die 2882592. Das sieht dann so aus:

    Klicken Sie auf die Grafik für eine größere Ansicht 

Name:	IPS_GetSnapshotChanges_jedes weitere mal.PNG 
Hits:	281 
Größe:	34.6 KB 
ID:	25061

    Jedes weitere mal muss der letzte Zeitstempel (TimeStamp) in der Antwort von IPS für die nächste Abfrage genommen werden.
    In dem unteren Beispiel ist es die 2883787.

    Klicken Sie auf die Grafik für eine größere Ansicht 

Name:	IPS_GetSnapshotChanges.PNG 
Hits:	298 
Größe:	36.0 KB 
ID:	25062

    Ich hoffe das ist soweit verstanden.
    Geändert von Schablone (24.02.14 um 19:33 Uhr)
    Bis dann

    Martin

  5. #5
    Registriert seit
    Sep 2009
    Ort
    Bocholt
    Beiträge
    1,131

    Standard Auswerten der Antwort -> Deserialisieren

    Um die Antworten von IPS auszuwerten hat man zwei Möglichkeiten.

    1. Den Antwort-String händisch in seine Bestandteile zerlegen.
    2. Die Antwort von IPS in ein Objekt Deserialisieren.

    Die elegantere Methode ist natürlich das Deserialisieren der Antwort durch VB.NET. Diese Möglichkeit werden wir nutzen.

    Als erstes brauchen wir einen Verweis auf "System.Web.Extensions". Dieser Verweis ist jedoch nur möglich wenn euer Projekt auf das volle NET-Framework zugreifen kann. Dazu geht ihr in die Projekteigenschaften und dort in die Lasche "Kompilieren". Unten auf der Seite gibt es einen Knopf "Erweiterte Kompilierungsoptionen".

    Klicken Sie auf die Grafik für eine größere Ansicht 

Name:	Deserialisieren Projekteigenschaften.PNG 
Hits:	297 
Größe:	40.1 KB 
ID:	25035

    In den erweiterten Kompilierungseinstellungen muss das Zielframework auf .NET Framework 4 oder höher stehen.
    Die Client-Profile funktionieren hier nicht.

    Klicken Sie auf die Grafik für eine größere Ansicht 

Name:	Deserialisieren Kompilierungseinstellungen.PNG 
Hits:	243 
Größe:	38.2 KB 
ID:	25036

    Nun kann ein Verweis auf "System.Web.Extensions" gemacht werden.

    Klicken Sie auf die Grafik für eine größere Ansicht 

Name:	Deserialisieren Verweis.PNG 
Hits:	232 
Größe:	30.9 KB 
ID:	25037

    Der Code

    Als erstes brauchen wir eine Hilfs-Klasse mit den selben Elementen die auch in der Antwort von IPS enthalten sind. Wir erinnern uns:

    Eine JSON-RPC Antwort sieht bei IPS so aus:
    {"result":true,"id":"null","jsonrpc":"2.0"}

    Bestandteile eines Response-Objekts

    result -> Das Rückgabeobjekt der Funktion, falls kein RPC-Fehler auftrat.
    id -> Enthält den gleichen Wert wie id des Requests. In unserem Fall fix "null"
    jsonrpc -> Ein String mit dem Namen der JSON-RPC-Version. Momentan fix "2.0"
    Also sieht unsere Hilfsklasse so aus:

    'Hilfsklasse zum Deserialisieren der Antwort
    Public Class IPS_Request_Response
    Private myresult As Object
    Public Property result() As Object
    Get
    Return myresult
    End Get
    Set(ByVal value As Object)
    myresult = value
    End Set
    End Property

    Private myid As Object
    Public Property id() As Object
    Get
    Return myid
    End Get
    Set(ByVal value As Object)
    myid = value
    End Set
    End Property

    Private myjsonrpc As String
    Public Property jsonrpc() As String
    Get
    Return myjsonrpc
    End Get
    Set(ByVal value As String)
    myjsonrpc = value
    End Set
    End Property
    End Class
    Nachdem wir unseren Verweis auf "System.Web.Extensions" gemacht haben können wir diesen Import zufügen:

    Imports System.Web.Script.Serialization 'Namespace zum De/Serialisieren
    Der Import kommt noch vor "Public Class Form1".

    Bei der Variablendeklaration benötigen wir noch:

    Dim jsDeserializer As New JavaScriptSerializer()
    Das auswerten der Antwort sieht dann so aus:

    Dim IPS_JSResponse As IPS_Request_Response = jsDeserializer.Deserialize(Of IPS_Request_Response)(Rec)

    Nach dieser Zeile kann auf jedes Element der Antwort Zugeriffen werden. Das Ergebnis kann dann mit:

    Receive.Text = IPS_JSResponse.result
    abgefragt werden.

    Diese Auswertung der Antwort gilt nicht für "IPS_GetSnapshot" und "IPS_GetSnapshotChanges".
    Geändert von Schablone (23.02.14 um 11:49 Uhr)
    Bis dann

    Martin

  6. #6
    Registriert seit
    Sep 2009
    Ort
    Bocholt
    Beiträge
    1,131

    Standard Auswerten der Antwort beim MessageSink

    Schauen wir uns eine Antwort von IPS nach einem "IPS_GetSnapshotChanges" genauer an.

    {"result":[
    {"Message":10603,"SenderID":39800,"TimeStamp":3911 618,"Data":["\u0005",false,"\u0005",1392919667]},
    {"Message":10603,"SenderID":38994,"TimeStamp":3911 619,"Data":[false,false,false,1392919667]},
    {"Message":10804,"SenderID":38874,"TimeStamp":3911 620,"Data":[false]},
    {"Message":10803,"SenderID":38874,"TimeStamp":3911 621,"Data":[1369587830,0]},
    {"Message":11202,"SenderID":35082,"TimeStamp":3911 622,"Data":[1,9,2,1392919667]}
    ],"id":"null","jsonrpc":"2.0"}
    Es ist deutlich zu sehen das "result" ein Array ist. Dieses Array bestehend aus:

    Message ->MeldungsID. Siehe Liste der Konstanten im SDK in UIPSTypes.pas
    SenderID ->ID von demjenigen der die Meldung verursacht hat
    TimeStamp ->Zeitstempel
    Data ->die aktuellen Daten

    Ein Beispiel für Message aus der UIPSTypes.pas.

    // --- Message Constants
    // --- BASE MESSAGE
    IPS_BASE = 10000; //Base Message

    // --- VARIABLE MANAGER
    IPS_VARIABLEMESSAGE = IPS_BASE + 600; //Variable Manager Message
    VM_CREATE = IPS_VARIABLEMESSAGE + 1; //Variable Created
    VM_DELETE = IPS_VARIABLEMESSAGE + 2; //Variable Deleted
    VM_UPDATE = IPS_VARIABLEMESSAGE + 3; //On Variable Update

    Also steht in Message ein Wert von 10000 + 600 + 3 = 10603 bei einer Variablenaktualisierung.

    Der Aufbau von "Data" bei einer Variablenaktualisierung:

    Data":["Hallo",false,"Hallo",1392919667]
    Der Aufbau von "Data" bei einer Variablenänderung:

    Data":["Hallo Martin",true,"Hallo",1392919667]
    Die Bestandteil sind:

    ["Hallo Martin", true, "Hallo", 1392919667]

    [Neuer Wert, Wertänderung (true/false), Alter Wert, Zeitstempel]

    Bei einer Variablenänderung ist Data somit ein Array bestehend aus 4 Elementen (0-3)

    Bei dieser Antwort habe ich zwei Hilfsklassen. Eine Hilfsklasse für "result" und eine Hilfsklasse für die gesamte Antwort.

    Als erstes die Hilfsklasse für "result".

    'Hilfsklasse zum Deserialisieren der Antwort
    Public Class IPS_Result
    Private myMessage As Integer
    Public Property Message() As Integer
    Get
    Return myMessage
    End Get
    Set(ByVal value As Integer)
    myMessage = value
    End Set
    End Property

    Private mySenderID As Integer
    Public Property SenderID() As Integer
    Get
    Return mySenderID
    End Get
    Set(ByVal value As Integer)
    mySenderID = value
    End Set
    End Property

    Private myTimeStamp As Integer
    Public Property TimeStamp() As Integer
    Get
    Return myTimeStamp
    End Get
    Set(ByVal value As Integer)
    myTimeStamp = value
    End Set
    End Property

    Private myData As Object
    Public Property Data() As Object
    Get
    Return myData
    End Get
    Set(ByVal value As Object)
    myData = value
    End Set
    End Property

    End Class
    Danach die Hilfsklasse für die Gesamte Antwort. Man beachte das result ein Array von der ersten Klasse "IPS_Result" ist!!

    'Hilfsklasse zum Deserialisieren der Antwort
    Public Class IPS_SnapShot
    Private myresult As IPS_Result()
    Public Property result() As IPS_Result()
    Get
    Return myresult
    End Get
    Set(ByVal value As IPS_Result())
    myresult = value
    End Set
    End Property

    Private myid As Object
    Public Property id() As Object
    Get
    Return myid
    End Get
    Set(ByVal value As Object)
    myid = value
    End Set
    End Property

    Private myjsonrpc As String
    Public Property jsonrpc() As String
    Get
    Return myjsonrpc
    End Get
    Set(ByVal value As String)
    myjsonrpc = value
    End Set
    End Property
    End Class
    Das auswerten der Antwort sieht dann so aus:

    Dim IPS_JSResponse As IPS_SnapShot = jsDeserializer.Deserialize(Of IPS_SnapShot)(Rec)
    Nach dieser Zeile kann auf jedes Element der Antwort Zugeriffen werden. Das Ergebnis kann dann so abgefragt werden:

    'Bei einer Rückmeldung von IPS ist das Array gefüllt (mindestens ein Element)
    If IPS_JSResponse.result.Length Then

    'Das Array durchlaufen
    For Each msg As IPS_Result In IPS_JSResponse.result

    'Wenn es eine Variablenänderung ist
    If msg.Message = 10603 Then

    'und es ist eine bestimmte Variable
    If msg.SenderID = 23491 Then
    'dann ablegen von Neuwert und Altwert
    Receive.Text = msg.Data(0) & vbCrLf & msg.Data(2)
    End If
    End If
    Next

    'den letzten Zeitstempel ablegen für die nächste Abfrage
    tbParameter.Text = IPS_JSResponse.result(IPS_JSResponse.result.Length - 1).TimeStamp
    Geändert von Schablone (23.02.14 um 11:59 Uhr)
    Bis dann

    Martin

  7. #7
    Registriert seit
    Sep 2009
    Ort
    Bocholt
    Beiträge
    1,131

    Standard Die IPS_JSONRPC Klasse

    Mit dem Wissen das wir jetzt haben erstellen wir eine Klasse zu Kommunikation mit IPS.
    Also fügen wir unserem Projekt eine neue Klasse hinzu. Diese Klasse nennen wir IPS_JSONRPC.

    Klicken Sie auf die Grafik für eine größere Ansicht 

Name:	IPS_JSONRPC.PNG 
Hits:	253 
Größe:	63.7 KB 
ID:	25058

    Als erstes brauchen wir einen Verweis auf "System.Web.Extensions".
    Dieser Verweis sollte ja noch bestehen! Für kommende Projekte ist
    der natürlich zwingend erforderlich.

    Oberhalb von "Public Class IPS_JSONRPC" kommen die Imports:

    Imports System.Net 'Namespace für HttpWeb
    Imports System.Text 'Namespace für das Encoding
    Imports System.IO 'Namespace für den Stream
    Imports System.Web.Script.Serialization 'Namespace zum De/Serialisieren
    In der Klasse kommen als erstes die Variablen die von "Aussen "erreichbar sein sollen.

    'Deklaration
    Public TimeStamp As Integer = 0
    Public MSValidData As Boolean = False
    Die Klasse hat zwei Funktionen. Als erstes kommt der " IPS_Request".

    Public Function IPS_Request(ByVal IPS_IP As String, ByVal IPS_User As String, ByVal IPS_Password As String, ByVal IPS_Method As String, ByVal IPS_Params As String, ByVal SSL As Boolean) As Object

    'Deklaration
    Dim request As WebRequest
    Dim response As WebResponse
    Dim authInfo As String
    Dim IPS_URI As String
    Dim Send As String
    Dim Rec As String
    Dim jsDeserializer As New JavaScriptSerializer()

    'Call-Back für SSL
    ServicePointManager.ServerCertificateValidationCal lback = New System.Net.Security.RemoteCertificateValidationCal lback(AddressOf AcceptCert)

    'erstellen der IPS-URI -> wenn SSL dann https
    If SSL Then
    IPS_URI = "https://" & IPS_IP & ":3777/api/"
    Else
    IPS_URI = "http://" & IPS_IP & ":3777/api/"
    End If

    'erstellen der Authorisierung
    authInfo = IPS_User & ":" & IPS_Password
    authInfo = Convert.ToBase64String(Encoding.Default.GetBytes(a uthInfo))

    'erstellen des Request Headers
    request = WebRequest.Create(IPS_URI)
    request.Headers("Authorization") = "Basic " & authInfo
    request.Method = "Post"

    'erstellen der JSON-RPC
    '{"jsonrpc":"2.0","method":"IPS_RunScript","params ":[10693],"id":"null"}
    Send = "{" & Chr(34) & "jsonrpc" & Chr(34) & ":" & Chr(34) & "2.0" & Chr(34) & "," _
    & Chr(34) & "method" & Chr(34) & ":" & Chr(34) & IPS_Method & Chr(34) & "," _
    & Chr(34) & "params" & Chr(34) & ":[" & IPS_Params & "]," _
    & Chr(34) & "id" & Chr(34) & ":" & Chr(34) & "null" & Chr(34) & "}"

    Try

    'Den request-Stream versenden
    Dim StreamWriter As StreamWriter = New StreamWriter(request.GetRequestStream)
    StreamWriter.Write(Send)
    StreamWriter.Close()

    'Den response-Stream empfangen
    response = request.GetResponse
    Dim StreamReader As StreamReader = New StreamReader(response.GetResponseStream)
    Rec = StreamReader.ReadToEnd
    StreamReader.Close()
    response.Close()

    Dim IPS_JSResponse As IPS_Request_Response = jsDeserializer.Deserialize(Of IPS_Request_Response)(Rec)
    IPS_Request = IPS_JSResponse.result

    Catch ex As Exception

    IPS_Request = "IPS Comm. Fault"

    End Try

    End Function
    Danach kommt die Funktion " IPS_MessageSink".

    Public Function IPS_MessageSink(ByVal IPS_IP As String, ByVal IPS_User As String, ByVal IPS_Password As String, ByVal SSL As Boolean) As Object

    'Deklaration
    Dim request As WebRequest
    Dim response As WebResponse
    Dim authInfo As String
    Dim IPS_URI As String
    Dim Send As String
    Dim Rec As String
    Dim jsDeserializer As New JavaScriptSerializer()

    'Call-Back für SSL
    ServicePointManager.ServerCertificateValidationCal lback = New System.Net.Security.RemoteCertificateValidationCal lback(AddressOf AcceptCert)

    'erstellen der IPS-URI -> wenn SSL dann https
    If SSL Then
    IPS_URI = "https://" & IPS_IP & ":3777/api/"
    Else
    IPS_URI = "http://" & IPS_IP & ":3777/api/"
    End If

    'erstellen der Authorisierung
    authInfo = IPS_User & ":" & IPS_Password
    authInfo = Convert.ToBase64String(Encoding.Default.GetBytes(a uthInfo))

    'erstellen des Request Headers
    request = WebRequest.Create(IPS_URI)
    request.Headers("Authorization") = "Basic " & authInfo
    request.Method = "Post"

    'erstellen der JSON-RPC
    '{"jsonrpc":"2.0","method":"IPS_RunScript","params ":[10693],"id":"null"}
    Send = "{" & Chr(34) & "jsonrpc" & Chr(34) & ":" & Chr(34) & "2.0" & Chr(34) & "," _
    & Chr(34) & "method" & Chr(34) & ":" & Chr(34) & "IPS_GetSnapshotChanges" & Chr(34) & "," _
    & Chr(34) & "params" & Chr(34) & ":[" & TimeStamp & "]," _
    & Chr(34) & "id" & Chr(34) & ":" & Chr(34) & "null" & Chr(34) & "}"

    Try

    'Den request-Stream versenden
    Dim StreamWriter As StreamWriter = New StreamWriter(request.GetRequestStream)
    StreamWriter.Write(Send)
    StreamWriter.Close()

    'Den response-Stream empfangen
    response = request.GetResponse
    Dim StreamReader As StreamReader = New StreamReader(response.GetResponseStream)
    Rec = StreamReader.ReadToEnd
    StreamReader.Close()
    response.Close()

    'Meldungsarray von IPS Deserialisieren
    Dim IPS_JSResponse As IPS_SnapShot = jsDeserializer.Deserialize(Of IPS_SnapShot)(Rec)

    'Bei einer Rückmeldung von IPS ist das Array gefüllt (mindestens ein Element)
    If IPS_JSResponse.result.Length Then
    'und kann ausgegeben werden
    IPS_MessageSink = IPS_JSResponse.result
    MSValidData = True
    TimeStamp = IPS_JSResponse.result(IPS_JSResponse.result.Length - 1).TimeStamp
    Else
    IPS_MessageSink = vbNull
    MSValidData = False
    End If

    Catch ex As Exception

    IPS_MessageSink = vbNull
    MSValidData = False

    End Try

    End Function
    Danach kommt die Call-Back Funktion für den SSL - Betrieb.

    'Wird benötigt für SSL (https)
    Private Function AcceptCert(ByVal sender As Object, ByVal cert As System.Security.Cryptography.X509Certificates.X509 Certificate, _
    ByVal chain As System.Security.Cryptography.X509Certificates.X509 Chain, _
    ByVal errors As System.Net.Security.SslPolicyErrors) As Boolean
    Return True
    End Function
    Unterhab der Klasse sind noch die Hilfsklassen zum Deserialisieren.

    'Hilfsklasse zum Deserialisieren der Antwort
    Public Class IPS_Request_Response
    Private myresult As Object
    Public Property result() As Object
    Get
    Return myresult
    End Get
    Set(ByVal value As Object)
    myresult = value
    End Set
    End Property

    Private myid As Object
    Public Property id() As Object
    Get
    Return myid
    End Get
    Set(ByVal value As Object)
    myid = value
    End Set
    End Property

    Private myjsonrpc As String
    Public Property jsonrpc() As String
    Get
    Return myjsonrpc
    End Get
    Set(ByVal value As String)
    myjsonrpc = value
    End Set
    End Property
    End Class

    'Hilfsklasse zum Deserialisieren der Antwort
    Public Class IPS_Result
    Private myMessage As Integer
    Public Property Message() As Integer
    Get
    Return myMessage
    End Get
    Set(ByVal value As Integer)
    myMessage = value
    End Set
    End Property

    Private mySenderID As Integer
    Public Property SenderID() As Integer
    Get
    Return mySenderID
    End Get
    Set(ByVal value As Integer)
    mySenderID = value
    End Set
    End Property

    Private myTimeStamp As Integer
    Public Property TimeStamp() As Integer
    Get
    Return myTimeStamp
    End Get
    Set(ByVal value As Integer)
    myTimeStamp = value
    End Set
    End Property

    Private myData As Object
    Public Property Data() As Object
    Get
    Return myData
    End Get
    Set(ByVal value As Object)
    myData = value
    End Set
    End Property

    End Class

    'Hilfsklasse zum Deserialisieren der Antwort
    Public Class IPS_SnapShot
    Private myresult As IPS_Result()
    Public Property result() As IPS_Result()
    Get
    Return myresult
    End Get
    Set(ByVal value As IPS_Result())
    myresult = value
    End Set
    End Property

    Private myid As Object
    Public Property id() As Object
    Get
    Return myid
    End Get
    Set(ByVal value As Object)
    myid = value
    End Set
    End Property

    Private myjsonrpc As String
    Public Property jsonrpc() As String
    Get
    Return myjsonrpc
    End Get
    Set(ByVal value As String)
    myjsonrpc = value
    End Set
    End Property
    End Class
    Einbinden der Klasse in unsere Form:

    Nach "Public Class Form1" kommt:

    Dim IPS_Comm As New IPS_JSONRPC
    Der Request:

    Private Sub btSenden_Click_1(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btSenden.Click

    Receive.Text = IPS_Comm.IPS_Request(tbIPS_IP.Text, tbBenutzer.Text, tbPassword.Text, tbBefehl.Text, tbParameter.Text, cbSSL.Checked)

    End Sub
    Der MessageSink (Beispiel für eine Variable und Anzeige des letzten Zeitstempels):

    Private Sub btStartStop_MessageSink_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btStartStop_MessageSink.Click

    'MessageSink
    Dim Result As Object = IPS_Comm.IPS_MessageSink(tbIPS_IP.Text, tbBenutzer.Text, tbPassword.Text, cbSSL.Checked)

    'Bei validen Daten
    If IPS_Comm.MSValidData Then

    'umpacken in ein Array vom Typ IPS_Result
    Dim IPS_MessageSink() As IPS_Result
    IPS_MessageSink = Result

    ' Das Array durchlaufen
    For Each msg As IPS_Result In IPS_MessageSink

    'bei einer Variablenänderung
    If msg.Message = 10603 Then

    'bei einer bestimmten Variablen
    If msg.SenderID = 23491 Then

    'ablegen des "Neuwertes"
    tbReceiveMS.Text = msg.Data(0)

    End If
    End If
    Next
    End If

    'ablegen des aktuellen Zeitstempels
    tbTimeStamp.Text = IPS_Comm.TimeStamp

    End Sub
    Das war's!
    Geändert von Schablone (04.09.16 um 17:30 Uhr)
    Bis dann

    Martin

  8. #8
    Registriert seit
    Sep 2009
    Ort
    Bocholt
    Beiträge
    1,131

    Standard Beispielprojekt zum runterladen

    Für alle die keine lust haben selber zu tippen ist hier das Beispielprojekt zum runterladen

    IPS_JSONRPC.zip

    Das war's dann.

    Wenn es sonst noch Fragen, Anregungen oder Verbesserungen gibt, meldet Euch bitte.
    Geändert von Schablone (04.09.16 um 17:34 Uhr)
    Bis dann

    Martin

  9. #9
    Registriert seit
    Oct 2010
    Beiträge
    45

    Hallo,

    da ja mit der Version 4.0 die SOAP Schnittstelle nicht mehr existiert, habe ich meine VB-Visualisierung auf die JSON Schnittstelle mit Nutzung dieser Anleitung hier umgestellt. In der Version 3.4 lief alles soweit gut. Ich konnte mit GetValue den Status der IPS-Variablen abfragen und mit SetValue die Variablen setzen. Nun habe ich IPS auf die Version 4.0 umgestellt. Dabei ergab sich, dass die Abfrage der Variablen wie vorher funktioniert. Wenn ich aber eine Variable setzen will, z.B. so:

    Code:
     Private Sub Tuner_Click(sender As Object, e As EventArgs) Handles Tuner.Click
            CMD = Not IPS_Comm.IPS_Request("GetValue", "41776")
            IPS_Comm.IPS_Request("SetValue", "41776, " & Convert.ToString(CMD))
            Play(1)
        End Sub
    erfolgt die Rückmeldung:

    Code:
     "{"jsonrpc":"2.0","error":{"code":-32700,"message":"Parse error"},"id":null}"
    Irgendwie kommt JSON mit dem übersendeten String:

    Code:
    "{"jsonrpc":"2.0","method":"SetValue","params":[39742, True],"id":"null"}"
    seit der Umstellung auf die Version 4.0 nicht zurecht.


    Viele Grüße Frank

  10. #10
    Registriert seit
    Feb 2005
    Ort
    Lübeck
    Beiträge
    24,087

    Fügst du denn korrekt den Content-Type als "application/json" ein?

    paresy

Ähnliche Themen

  1. IPSLibrary Step by Step für Dummies!
    Von Schablone im Forum IPSLibrary
    Antworten: 160
    Letzter Beitrag: 21.01.19, 21:07
  2. JSON-RPC über VB.NET Step by Step - Diskussionsthread
    Von Schablone im Forum Entwicklung mit PHP-SDK/Delphi-SDK
    Antworten: 8
    Letzter Beitrag: 24.02.14, 19:39
  3. Dummy sucht: Wago - Step by Step
    Von jwka im Forum SPS Automatisierungstechnik
    Antworten: 25
    Letzter Beitrag: 20.02.12, 10:39
  4. SOAP über VB.NET "Step by Step"
    Von Schablone im Forum Entwicklung mit PHP-SDK/Delphi-SDK
    Antworten: 7
    Letzter Beitrag: 30.06.11, 18:55
  5. Antworten: 30
    Letzter Beitrag: 21.03.10, 23:58