Go 正在获取BadMonitoredItemFilterUnsupported（0x80440000）

我正在使用库连接到OPC UA服务器。如果我在监控项目中不使用任何过滤器，一切都正常。但我想使用DataChangeFilter，以便仅当值按某个百分比或绝对值更改时，才能够接收值。下面是完整的代码

package main

import (
    "context"
    "flag"
    "fmt"
    "log"
    "time"

    "github.com/gopcua/opcua"
    "github.com/gopcua/opcua/debug"
    "github.com/gopcua/opcua/ua"
)

func main() {
    var (
        endpoint = flag.String("endpoint", "opc.tcp://192.168.189.1:49320", "OPC UA Endpoint URL")
        policy   = flag.String("policy", "None", "Security policy: None, Basic128Rsa15, Basic256, Basic256Sha256. Default: None")
        mode     = flag.String("mode", "None", "Security mode: None, Sign, SignAndEncrypt. Default: None")
        certFile = flag.String("cert", "", "Path to cert.pem. Required for security mode/policy != None")
        keyFile  = flag.String("key", "", "Path to private key.pem. Required for security mode/policy != None")
        nodeID   = flag.String("node", "ns=2;s=HONDA.DEV1.T1", "node id to subscribe to")
        interval = flag.String("interval", opcua.DefaultSubscriptionInterval.String(), "subscription interval")
    )
    flag.BoolVar(&debug.Enable, "debug", false, "enable debug logging")
    flag.Parse()
    log.SetFlags(0)

    subInterval, err := time.ParseDuration(*interval)
    if err != nil {
        log.Fatal(err)
    }

    // add an arbitrary timeout to demonstrate how to stop a subscription
    // with a context.
    d := 10 * time.Second
    ctx, cancel := context.WithTimeout(context.Background(), d)
    defer cancel()

    endpoints, err := opcua.GetEndpoints(ctx, *endpoint)
    if err != nil {
        log.Fatal(err)
    }
    ep := opcua.SelectEndpoint(endpoints, *policy, ua.MessageSecurityModeFromString(*mode))
    if ep == nil {
        log.Fatal("Failed to find suitable endpoint")
    }

    fmt.Println("*", ep.SecurityPolicyURI, ep.SecurityMode)

    opts := []opcua.Option{
        opcua.SecurityPolicy(*policy),
        opcua.SecurityModeString(*mode),
        opcua.CertificateFile(*certFile),
        opcua.PrivateKeyFile(*keyFile),
        opcua.AuthAnonymous(),
        opcua.SecurityFromEndpoint(ep, ua.UserTokenTypeAnonymous),
    }

    c := opcua.NewClient(ep.EndpointURL, opts...)
    if err := c.Connect(ctx); err != nil {
        log.Fatal(err)
    }
    defer c.Close()

    notifyCh := make(chan *opcua.PublishNotificationData)

    sub, err := c.Subscribe(&opcua.SubscriptionParameters{
        Interval: subInterval,
    }, notifyCh)
    if err != nil {
        log.Fatal(err)
    }
    defer sub.Cancel()
    log.Printf("Created subscription with id %v", sub.SubscriptionID)

    id, err := ua.ParseNodeID(*nodeID)
    if err != nil {
        log.Fatal(err)
    }

    var miCreateRequest *ua.MonitoredItemCreateRequest
    var eventFieldNames []string
    miCreateRequest = valueRequest(id)
    res, err := sub.Monitor(ua.TimestampsToReturnBoth, miCreateRequest)
    if err != nil || res.Results[0].StatusCode != ua.StatusOK {
        log.Fatal(err)
    }

    // read from subscription's notification channel until ctx is cancelled
    for {
        select {
        case <-ctx.Done():
            return
        case res := <-notifyCh:
            if res.Error != nil {
                log.Print(res.Error)
                continue
            }

            switch x := res.Value.(type) {
            case *ua.DataChangeNotification:
                for _, item := range x.MonitoredItems {
                    data := item.Value.Value.Value()
                    log.Printf("MonitoredItem with client handle %v = %v", item.ClientHandle, data)
                }

            case *ua.EventNotificationList:
                for _, item := range x.Events {
                    log.Printf("Event for client handle: %v\n", item.ClientHandle)
                    for i, field := range item.EventFields {
                        log.Printf("%v: %v of Type: %T", eventFieldNames[i], field.Value(), field.Value())
                    }
                    log.Println()
                }

            default:
                log.Printf("what's this publish result? %T", res.Value)
            }
        }
    }
}

func valueRequest(nodeID *ua.NodeID) *ua.MonitoredItemCreateRequest {
    handle := uint32(42)

    attributeID := ua.AttributeIDValue

    filter := ua.DataChangeFilter{}
    filter.Trigger = ua.DataChangeTriggerStatusValue
    filter.DeadbandType = uint32(ua.DeadbandTypeNone)
    filter.DeadbandValue = 0.0

    filterExtObj := ua.ExtensionObject{
        EncodingMask: ua.ExtensionObjectBinary,
        TypeID: &ua.ExpandedNodeID{
            NodeID: nodeID,
        },
        Value: filter,
    }


    request := &ua.MonitoredItemCreateRequest{
        ItemToMonitor: &ua.ReadValueID{
            NodeID:       nodeID,
            AttributeID:  attributeID,
            DataEncoding: &ua.QualifiedName{},
        },
        MonitoringMode: ua.MonitoringModeReporting,
        RequestedParameters: &ua.MonitoringParameters{
            ClientHandle:     handle,
            DiscardOldest:    true,
            Filter:           &filterExtObj,
            QueueSize:        10,
            SamplingInterval: 0.0,
        },
    }
    return request
}

服务器发送的响应

4/15/2021  5:24:07.474 PM [gopcua-1618489446170158449] CreateMonitoredItemsResponse
    0000000000: Event started
    0000000000:    Response Header: 
    0000000000:       timestamp (UTC): 2021-04-15T12:24:07.474 
    0000000000:       requestHandle: 5 
    0000000000:       serviceResult: 0x00000000 (Good) 
    0000000000:    Parameters: 
    0000000000:       monitoredItemCreateResults []: Size: 1 
    0000000000:          monitoredItemCreateResults [ 0 ]: 
    0000000000:             statusCode: 0x80440000 (BadMonitoredItemFilterUnsupported) 
    0000000000:             monitoredItemId: 0 
    0000000000:             revisedSamplingInterval: 0 
    0000000000:             revisedQueueSize: 0 
    0000000000:             filterResult: [empty] 
    0000000000: Event complete

---

在我看来，您正在尝试使用要为其创建MonitoredItem的节点的NodeId而不是标识所用过滤器结构的DataTypeEncoding的NodeId来构建包含过滤器结构的ExtensionObject。

是，你是对的，我使用的节点ID与我用来创建监控项的节点ID相同。我使用相同的nodeId创建ExpandedNodeID，然后这个ExpandedNodeID被用作过滤器扩展对象中的TypeID。请详细说明如何为筛选器扩展对象创建expandedNodeId。我对这个库不太熟悉，它似乎很难对结构进行编码。它可能需要是

DataChangeFilter

的二进制编码id，即

ns=0；i=724

。谢谢，成功了！

4/15/2021  5:24:07.474 PM [gopcua-1618489446170158449] CreateMonitoredItemsResponse
    0000000000: Event started
    0000000000:    Response Header: 
    0000000000:       timestamp (UTC): 2021-04-15T12:24:07.474 
    0000000000:       requestHandle: 5 
    0000000000:       serviceResult: 0x00000000 (Good) 
    0000000000:    Parameters: 
    0000000000:       monitoredItemCreateResults []: Size: 1 
    0000000000:          monitoredItemCreateResults [ 0 ]: 
    0000000000:             statusCode: 0x80440000 (BadMonitoredItemFilterUnsupported) 
    0000000000:             monitoredItemId: 0 
    0000000000:             revisedSamplingInterval: 0 
    0000000000:             revisedQueueSize: 0 
    0000000000:             filterResult: [empty] 
    0000000000: Event complete