opcua_helpers.h

Go to the documentation of this file.

#include "ros_opcua_msgs/Address.h"
#include "ros_opcua_msgs/TypeValue.h"

#include <opc/ua/node.h>
#include <opc/ua/protocol/string_utils.h>


std::map<int, std::string> _TypeToStringMap = {
//     {0, "null"},
    {1, "bool"},
    {2, "int8"},
    {3, "uint8"},
    {4, "int16"},
    {5, "uint16"},
    {6, "int32"},
    {7, "uint32"},
    {8, "int64"},
    {9, "uint64"},
    {10, "float32"},
    {11, "float64"},
    {12, "string"},
//     {13, "date_time"},
//     {14, "guid"},
//     {15, "byte_string"},
//     {16, "xml_element"},
//     {17, "id"},
//     {18, "expanded_node_id"},
//     {19, "status_code"},
//     {20, "qualified_name"},
//     {21, "localized_text"},
//     {22, "extenstion_object"},
//     {23, "data_value"},
//     {24, "OpcUa::Variant"},
//     {25, "diagnostic_info"}
};

//OpcUa::NodeID convertAddressToNodeID(const ros_opcua_msgs::Address address) {
//
//    if (address.id_type == "num") {
//        return OpcUa::NumericNodeID(address.id_num, address.namespace_index);
//    }
//    else if (address.id_type == "str") {
//        return OpcUa::StringNodeID(address.id_str, address.namespace_index);
//    }
//    else if (address.id_type == "guid") {
//        return OpcUa::GuidNodeID(OpcUa::ToGuid(address.id_guid), address.namespace_index);
//    }
//    else {
//        ROS_ERROR("OPC-UA client node %s: ID type %s does not exist!!", ros::this_node::getName().c_str(), address.id_type.c_str());
//        throw std::exception();
//    }
//}

//ros_opcua_msgs::Address convertNodeIDToAddress(const OpcUa::NodeID nodeID) {
//
//    ros_opcua_msgs::Address address;
//    address.namespace_index = nodeID.GetNamespaceIndex();
//
//    if (nodeID.IsInteger()) {
//        address.id_type = "num";
//        address.id_num = nodeID.GetIntegerIdentifier();
//    }
//    else if (nodeID.IsString()) {
//        address.id_type = "str";
//        address.id_str = nodeID.GetStringIdentifier();
//    }
//    else if (nodeID.IsGuid()) {
//        address.id_type = "guid";
//        address.id_guid = OpcUa::ToString(nodeID.GetGuidIdentifier());
//    }
//    else {
//        ROS_ERROR("OPC-UA client node %s: ID type %s does not exist!!", ros::this_node::getName().c_str(), address.id_type.c_str());
//        throw std::exception();
//    }
//
//    return address;
//}

// OpcUa::NodeID convertAddressToString(const ros_opcua_msgs::Address address) {
//        
//     std::stringstream stream;
//     
//     stream << "ns=" << address.namespace_index << ";";
//     
//     if (address.id_type == "num") {
//         stream << "i=" << address.id_num << ";";
//     }
//     else if (address.id_type == "str") {
//         stream << "s=" << address.id_str << ";";
//     }
//     else if (address.id_type == "guid") {
//         stream << "g=" << address.id_guid << ";";
//     }
//     else {
//         ROS_ERROR("OPC-UA client node %s: ID type %s does not exist!!", ros::this_node::getName().c_str(), req.node.id_type.c_str());
//         throw std::exception("Read above!");
//     }
//     
//     return stream.str();
// }

ros_opcua_msgs::TypeValue convertVariantToTypeValue(const OpcUa::Variant& variant) {
    
    ros_opcua_msgs::TypeValue typeValue;
    
    typeValue.type = _TypeToStringMap[(int)variant.Type()];
    
    if (typeValue.type == "bool") {
        typeValue.bool_d = (bool)variant;
    }
    else if (typeValue.type == "int8") {
        typeValue.int8_d = (int8_t)variant;
    }
    else if (typeValue.type == "uint8") {
        typeValue.uint8_d = (uint8_t)variant;
    }
    else if (typeValue.type == "int16") {
        typeValue.int16_d = (int16_t)variant;
    }
    else if (typeValue.type == "uint16") {
        typeValue.uint16_d = (uint16_t)variant;
    }
    else if (typeValue.type == "int32") {
        typeValue.int32_d = (int32_t)variant;
    }
    else if (typeValue.type == "uint32") {
        typeValue.uint32_d = (uint32_t)variant;
    }
    else if (typeValue.type == "int64") {
        typeValue.int64_d = (int64_t)variant;
    }
    else if (typeValue.type == "uint64") {
        typeValue.uint64_d = (uint64_t)variant;
    }
    else if (typeValue.type == "float") {
        typeValue.float_d = (float)variant;
    }
    else if (typeValue.type == "double") {
        typeValue.double_d = (double)variant;
    }
    else if (typeValue.type == "string") {
        typeValue.string_d = std::string(variant);
    }
    else {
        typeValue.type = "Unknown";
    }
    
    return typeValue;    
}

OpcUa::Variant convertTypeValueToVariant(ros_opcua_msgs::TypeValue& typeValue)
{
    OpcUa::Variant variant;

    if (typeValue.type == "bool") {
        variant = bool(typeValue.bool_d);
    }
    else if (typeValue.type == "int8") {
        variant = typeValue.int8_d;
    }
    else if (typeValue.type == "uint8") {
        variant = typeValue.uint8_d;
    }
    else if (typeValue.type == "int16") {
        variant = typeValue.int16_d;
    }
    else if (typeValue.type == "uint16") {
        variant = typeValue.uint16_d;
    }
    else if (typeValue.type == "int32") {
        variant = typeValue.int32_d;
    }
    else if (typeValue.type == "uint32") {
        variant = typeValue.uint32_d;
    }
    else if (typeValue.type == "int64") {
        variant = typeValue.int64_d;
    }
    else if (typeValue.type == "uint64") {
        variant = typeValue.uint64_d;
    }
    else if (typeValue.type == "float") {
        variant = typeValue.float_d;
    }
    else if (typeValue.type == "double") {
        variant = typeValue.double_d;
    }
    else if (typeValue.type == "string") {
        variant = typeValue.string_d;
    }

    return variant;
}