client

This example demonstrates browsing the top-level 'Objects' folder of the server.

package main

import (
	"context"
	"fmt"

	"github.com/awcullen/opcua/client"
	"github.com/awcullen/opcua/ua"
)

func main() {

	ctx := context.Background()

	// open a connection to testserver running locally. Testserver is started if not already running.
	ch, err := client.Dial(
		ctx,
		"opc.tcp://localhost:46010",
		client.WithInsecureSkipVerify(), // skips verification of server certificate
	)
	if err != nil {
		fmt.Printf("Error opening client connection. %s\n", err.Error())
		return
	}

	// prepare browse request
	req := &ua.BrowseRequest{
		NodesToBrowse: []ua.BrowseDescription{
			{
				NodeID:          ua.ParseNodeID("i=85"), // Objects folder
				BrowseDirection: ua.BrowseDirectionForward,
				ReferenceTypeID: ua.ReferenceTypeIDHierarchicalReferences,
				IncludeSubtypes: true,
				ResultMask:      uint32(ua.BrowseResultMaskTargetInfo),
			},
		},
	}

	// send request to server. receive response or error
	res, err := ch.Browse(ctx, req)
	if err != nil {
		fmt.Printf("Error browsing Objects folder. %s\n", err.Error())
		ch.Abort(ctx)
		return
	}

	// print results
	fmt.Printf("Browse results of NodeID '%s':\n", req.NodesToBrowse[0].NodeID)
	for _, r := range res.Results[0].References {
		fmt.Printf(" + %s, browseName: %s, nodeClass: %s, nodeId: %s\n", r.DisplayName.Text, r.BrowseName, r.NodeClass, r.NodeID)
	}

	// close connection
	err = ch.Close(ctx)
	if err != nil {
		ch.Abort(ctx)
		return
	}

}

Output:

Browse results of NodeID 'i=85':
 + Server, browseName: 0:Server, nodeClass: Object, nodeId: i=2253
 + Aliases, browseName: 0:Aliases, nodeClass: Object, nodeId: i=23470
 + Demo, browseName: 2:Demo, nodeClass: Object, nodeId: ns=2;s=Demo

This example demonstrates calling an method of the server to add two integers and return the sum.

package main

import (
	"context"
	"fmt"

	"github.com/awcullen/opcua/client"
	"github.com/awcullen/opcua/ua"
)

func main() {

	ctx := context.Background()

	// open a connection to testserver running locally. Testserver is started if not already running.
	ch, err := client.Dial(
		ctx,
		"opc.tcp://localhost:46010",
		client.WithClientCertificatePaths("./pki/client.crt", "./pki/client.key"), // need secure channel to send password
		client.WithUserNameIdentity("root", "secret"),                             // need role of "operator" to call this method
		client.WithInsecureSkipVerify(),                                           // skips verification of server certificate
	)
	if err != nil {
		fmt.Printf("Error opening client connection. %s\n", err.Error())
		return
	}

	// prepare call request
	req := &ua.CallRequest{
		MethodsToCall: []ua.CallMethodRequest{
			{
				ObjectID: ua.ParseNodeID("ns=2;s=Demo.Methods"),          // parent of "MethodIO" method
				MethodID: ua.ParseNodeID("ns=2;s=Demo.Methods.MethodIO"), // "MethodIO" method
				InputArguments: []ua.Variant{
					uint32(6),
					uint32(7),
				},
			},
		},
	}

	// send request to server. receive response or error
	res, err := ch.Call(ctx, req)
	if err != nil {
		fmt.Printf("Error calling method. %s\n", err.Error())
		ch.Abort(ctx)
		return
	}

	// print results
	fmt.Printf("Call method result:\n")
	if res.Results[0].StatusCode.IsGood() {
		fmt.Println(res.Results[0].OutputArguments[0].(uint32))
	}

	// close connection
	err = ch.Close(ctx)
	if err != nil {
		ch.Abort(ctx)
		return
	}

}

Output:

Call method result:
13

This example demonstrates subscribing to the server's 'CurrentTime' variable and receiving data changes.

package main

import (
	"context"
	"fmt"

	"github.com/awcullen/opcua/client"
	"github.com/awcullen/opcua/ua"
)

func main() {

	ctx := context.Background()

	// open a connection to testserver running locally. Testserver is started if not already running.
	ch, err := client.Dial(
		ctx,
		"opc.tcp://localhost:46010",
		client.WithInsecureSkipVerify(), // skips verification of server certificate
	)
	if err != nil {
		fmt.Printf("Error opening client connection. %s\n", err.Error())
		return
	}

	// prepare create subscription request
	req := &ua.CreateSubscriptionRequest{
		RequestedPublishingInterval: 1000.0,
		RequestedMaxKeepAliveCount:  30,
		RequestedLifetimeCount:      30 * 3,
		PublishingEnabled:           true,
	}

	// send request to server. receive response or error
	res, err := ch.CreateSubscription(ctx, req)
	if err != nil {
		fmt.Printf("Error creating subscription. %s\n", err.Error())
		ch.Abort(ctx)
		return
	}

	// prepare create monitored items request
	req2 := &ua.CreateMonitoredItemsRequest{
		SubscriptionID:     res.SubscriptionID,
		TimestampsToReturn: ua.TimestampsToReturnBoth,
		ItemsToCreate: []ua.MonitoredItemCreateRequest{
			{
				ItemToMonitor: ua.ReadValueID{
					NodeID:      ua.VariableIDServerServerStatusCurrentTime,
					AttributeID: ua.AttributeIDValue,
				},
				MonitoringMode: ua.MonitoringModeReporting,
				// specify a unique ClientHandle. The ClientHandle is returned in the PublishResponse
				RequestedParameters: ua.MonitoringParameters{
					ClientHandle: 42, QueueSize: 1, DiscardOldest: true, SamplingInterval: 1000.0},
			},
		},
	}

	// send request to server. receive response or error
	_, err = ch.CreateMonitoredItems(ctx, req2)
	if err != nil {
		fmt.Printf("Error creating item. %s\n", err.Error())
		ch.Abort(ctx)
		return
	}

	// prepare an initial publish request
	req3 := &ua.PublishRequest{
		RequestHeader:                ua.RequestHeader{TimeoutHint: 60000},
		SubscriptionAcknowledgements: []ua.SubscriptionAcknowledgement{},
	}

	// loop until 3 data changes received.
	numChanges := 0
	for numChanges < 3 {
		// send publish request to the server.
		res3, err := ch.Publish(ctx, req3)
		if err != nil {
			break
		}
		// loop thru all the notifications in the response.
		for _, data := range res3.NotificationMessage.NotificationData {
			switch body := data.(type) {
			case ua.DataChangeNotification:
				// the data change notification contains a slice of monitored item notifications.
				for _, item := range body.MonitoredItems {
					// each monitored item notification contains a clientHandle and dataValue.
					if item.ClientHandle == 42 {
						fmt.Println("<the current utc time here>" /* item.Value.Value */)
						numChanges++
					}
				}
			}
		}
		// prepare another publish request
		req3 = &ua.PublishRequest{
			RequestHeader: ua.RequestHeader{TimeoutHint: 60000},
			SubscriptionAcknowledgements: []ua.SubscriptionAcknowledgement{
				{SequenceNumber: res3.NotificationMessage.SequenceNumber, SubscriptionID: res3.SubscriptionID},
			},
		}
	}

	// success after receiving 3 data changes.

	// close connection
	err = ch.Close(ctx)
	if err != nil {
		ch.Abort(ctx)
		return
	}

}

Output:

<the current utc time here>
<the current utc time here>
<the current utc time here>

This example demonstrates reading the 'ServerStatus' variable.

package main

import (
	"context"
	"fmt"

	"github.com/awcullen/opcua/client"
	"github.com/awcullen/opcua/ua"
)

func main() {

	ctx := context.Background()

	// open a connection to testserver running locally. Testserver is started if not already running.
	ch, err := client.Dial(
		ctx,
		"opc.tcp://localhost:46010",
		client.WithInsecureSkipVerify(), // skips verification of server certificate
	)
	if err != nil {
		fmt.Printf("Error opening client connection. %s\n", err.Error())
		return
	}

	// prepare read request
	req := &ua.ReadRequest{
		NodesToRead: []ua.ReadValueID{
			{
				NodeID:      ua.VariableIDServerServerStatus,
				AttributeID: ua.AttributeIDValue,
			},
		},
	}

	// send request to server. receive response or error
	res, err := ch.Read(ctx, req)
	if err != nil {
		fmt.Printf("Error reading ServerStatus. %s\n", err.Error())
		ch.Abort(ctx)
		return
	}

	// print results
	if serverStatus, ok := res.Results[0].Value.(ua.ServerStatusDataType); ok {
		fmt.Printf("Server status:\n")
		fmt.Printf("  ProductName: %s\n", serverStatus.BuildInfo.ProductName)
		fmt.Printf("  ManufacturerName: %s\n", serverStatus.BuildInfo.ManufacturerName)
		fmt.Printf("  State: %s\n", serverStatus.State)
	} else {
		fmt.Println("Error decoding ServerStatus.")
	}

	// close connection
	err = ch.Close(ctx)
	if err != nil {
		ch.Abort(ctx)
		return
	}

}

Output:

Server status:
  ProductName: testserver
  ManufacturerName: awcullen
  State: Running

This example demonstrates reading an multidimensional array variable.

package main

import (
	"context"
	"fmt"

	"github.com/awcullen/opcua/client"
	"github.com/awcullen/opcua/ua"
)

func main() {

	ctx := context.Background()

	// open a connection to testserver running locally. Testserver is started if not already running.
	ch, err := client.Dial(
		ctx,
		"opc.tcp://localhost:46010",
		client.WithInsecureSkipVerify(), // skips verification of server certificate
	)
	if err != nil {
		fmt.Printf("Error opening client connection. %s\n", err.Error())
		return
	}

	// prepare read request
	req := &ua.ReadRequest{
		NodesToRead: []ua.ReadValueID{
			{
				NodeID:      ua.ParseNodeID("ns=2;s=Demo.Static.Arrays.Matrix"),
				AttributeID: ua.AttributeIDValue,
			},
		},
	}

	// send request to server. receive response or error
	res, err := ch.Read(ctx, req)
	if err != nil {
		fmt.Printf("Error reading ServerStatus. %s\n", err.Error())
		ch.Abort(ctx)
		return
	}

	// print results
	if val, ok := res.Results[0].Value.([][][]int32); ok {
		fmt.Println(val)
	} else {
		fmt.Println("Error decoding [][][]int32.")
	}

	// close connection
	err = ch.Close(ctx)
	if err != nil {
		ch.Abort(ctx)
		return
	}

}

Output:

[[[0 1 2] [3 4 5] [6 7 8] [9 10 11]] [[12 13 14] [15 16 17] [18 19 20] [21 22 23]]]

This example demonstrates reading the 'CustomStruct' variable.

ctx := context.Background()

// open a connection to testserver running locally. Testserver is started if not already running.
ch, err := client.Dial(
	ctx,
	"opc.tcp://localhost:46010",
	client.WithInsecureSkipVerify(), // skips verification of server certificate
)
if err != nil {
	fmt.Printf("Error opening client connection. %s\n", err.Error())
	return
}

// prepare read request
req := &ua.ReadRequest{
	NodesToRead: []ua.ReadValueID{
		{
			NodeID:      ua.ParseNodeID("ns=2;i=14"),
			AttributeID: ua.AttributeIDValue,
		},
	},
}

// send request to server. receive response or error
res, err := ch.Read(ctx, req)
if err != nil {
	fmt.Printf("Error reading CustomStruct. %s\n", err.Error())
	ch.Abort(ctx)
	return
}

// print results
if custom, ok := res.Results[0].Value.(CustomStruct); ok {
	fmt.Printf("CustomStruct:\n")
	fmt.Printf("  W1: %d\n", custom.W1)
	fmt.Printf("  W2: %d\n", custom.W2)
} else {
	fmt.Println("Error decoding CustomStruct.")
}
// close connection
err = ch.Close(ctx)
if err != nil {
	ch.Abort(ctx)
	return
}

Output:

CustomStruct:
  W1: 1
  W2: 2