open62541

ouvert62541

open62541 (http://open62541.org) est une implémentation open source d'OPC UA (OPC Unified Architecture / IEC 62541) écrite en langage C. La bibliothèque est utilisable avec tous les principaux compilateurs et fournit les outils nécessaires pour implémenter des clients et serveurs OPC UA dédiés, ou pour intégrer la communication basée sur OPC UA dans des applications existantes. La bibliothèque open62541 est indépendante de la plate-forme : toutes les fonctionnalités spécifiques à la plate-forme sont implémentées via des plugins échangeables pour un portage facile vers différentes cibles (intégrées).

open62541 est sous licence Mozilla Public License v2.0 (MPLv2). Cela permet à la bibliothèque open62541 d'être combinée et distribuée avec n'importe quel logiciel propriétaire. Seules les modifications apportées à la bibliothèque open62541 elle-même doivent être sous licence MPLv2 lorsqu'elles sont copiées et distribuées. Les plugins, ainsi que les exemples serveur et client sont dans le domaine public (licence CC0). Ils peuvent être réutilisés sous n’importe quelle licence et les modifications ne doivent pas être publiées.

La bibliothèque est disponible sous forme source standard et binaire. De plus, la distribution source à fichier unique fusionne l'intégralité de la bibliothèque en un seul fichier .c et .h qui peut être facilement ajouté aux projets existants. Des exemples d'implémentations de serveur et de client peuvent être trouvés dans le répertoire /examples ou plus bas sur cette page.

Caractéristiques

open62541 implémente un SDK OPC UA avec prise en charge des serveurs, des clients et de la communication PubSub (publication-abonnement). Consultez la présentation des fonctionnalités pour plus de détails.

• Pile de base
  • Encodage binaire OPC UA et JSON
  • OPC UA SecureChannel basé sur TCP
  • Types de données personnalisés (générés à partir de définitions XML)
  • Portable C99 : le code spécifique à l'architecture est encapsulé derrière des interfaces standard
  • Hautement configurable avec des plugins par défaut pour le chiffrement (OpenSSL, mbedTLS), le contrôle d'accès, l'historisation, la journalisation, etc.
• Serveur
  • Prise en charge de tous les services OPC UA (à l'exception du service Query -- non implémenté par aucun SDK)
  • Prise en charge de la génération de modèles d'informations à partir de définitions XML standard (Nodeset Compiler)
  • Prise en charge de l'ajout et de la suppression de nœuds et de références au moment de l'exécution
  • Prise en charge des abonnements (notifications de modifications de données et d'événements)
• Client
  • Prise en charge de tous les services OPC UA
  • Prise en charge des demandes de service asynchrones
  • Gestion en arrière-plan des abonnements
• PubSub
  • Encodage des messages PubSub (binaire et JSON)
  • Transport sur UDP-multicast, Ethernet, MQTT
  • Configuration du runtime via le modèle d'information
  • Accès rapide configurable en temps réel

Utilisation commerciale et support officiel

open62541 est sous licence MPLv2. Autrement dit, les modifications apportées aux fichiers sous MPLv2 relèvent de la même licence open source. Mais la bibliothèque peut être combinée avec un développement privé à partir de fichiers séparés, même si un binaire statique est produit, sans que la licence n'affecte les fichiers privés. Consultez le document de licence complet pour plus de détails.

Fraunhofer IOSB emploie plusieurs développeurs open62541 et fournit un support commercial . Des fournisseurs de services supplémentaires dans l'écosystème open62541 sont répertoriés sur open62541.org.

Certification officielle

L'exemple de serveur (server_ctt) construit à l'aide d'open62541 v1.0 est conforme au profil « Micro Embedded Device Server » d'OPC Foundation prenant en charge la communication client/serveur OPC UA, les abonnements, les appels de méthode et la sécurité (cryptage) avec les politiques de sécurité « Basic128Rsa15 ». ', 'Basic256' et 'Basic256Sha256' et les facettes 'method server' et 'gestion des nœuds'. Voir https://open62541.org/certified-sdk pour plus de détails.

PubSub (UADP) est implémenté dans open62541. Mais la fonctionnalité ne peut pas être certifiée pour le moment (septembre 2019) en raison du manque de cas de test et d'outils de test officiels.

Au cours du développement, les outils de tests de conformité (CTT) de la Fondation OPC sont régulièrement appliqués. La configuration et les résultats CTT sont suivis sur https://github.com/open62541/open62541-ctt. Les profils OPC UA testés régulièrement au CTT sont actuellement :

• Serveur de périphériques micro embarqués
• Facette du serveur de méthodes
• Facette de gestion des nœuds
• Politiques de sécurité
  • Basique128Rsa15
  • De base256
  • Basique256Sha256
• Jetons utilisateur
  • Facette anonyme
  • Nom d'utilisateur Mot de passe Facette du serveur

Consultez la page sur les fonctionnalités d'open62541 pour un examen approfondi de la prise en charge des unités de conformité qui composent les profils OPC UA.

Documentation et assistance

Une introduction générale à OPC UA et la documentation open62541 sont disponibles sur http://open62541.org. Les versions antérieures de la bibliothèque peuvent être téléchargées sur https://github.com/open62541/open62541/releases.

La communauté globale open62541 gère les demandes d'assistance publiques sur Github et la liste de diffusion. Pour une discussion et une assistance individuelles, utilisez les canaux suivants :

• Liste de diffusion
• Suivi des problèmes
• Demandes de tirage

Nous voulons favoriser une communauté ouverte et accueillante. Veuillez tenir compte de notre code de conduite.

Système de construction, structure du code et dépendances

L'environnement de construction d'open62541 est généré via CMake. Consultez la documentation de construction pour plus de détails. Pour simplifier l'intégration avec les projets logiciels existants, les sources open62541 peuvent être compressées (fusionnées) en une distribution à fichier unique, une paire de fichiers open62541.c/.h . La fonctionnalité incluse dans la distribution à fichier unique dépend de la configuration actuelle de CMake.

Le code source est structuré comme suit :

• API publique ( /include ) : l'API publique est exposée aux applications utilisant open62541. Les en-têtes des implémentations de plugins se trouvent dans /plugins/include .
• Bibliothèque principale ( /src ) : la bibliothèque principale n'a aucune dépendance autre que les en-têtes standard C99.
• Prise en charge de l'architecture ( /arch ) : la prise en charge de l'architecture est implémentée via le plugin EventLoop . Cela maintient le code spécifique à l'architecture - par exemple pour utiliser les API POSIX - hors de la bibliothèque principale. Des ports vers différentes architectures (embarquées) sont fournis.
• Implémentations de plugins par défaut ( /plugins ) : Les interfaces de plugin permettent l'intégration avec différents systèmes et bibliothèques backend. Par exemple concernant les primitives cryptographiques, le stockage du modèle d'information, etc. Des implémentations par défaut sont fournies.
• Dépendances ( /deps ) : Certaines bibliothèques supplémentaires sont utilisées via les sous-modules git ou ont été internalisées dans le dossier deps/ . Plus d'informations sur les bibliothèques tierces et leurs licences respectives peuvent être trouvées dans deps/README.md
• Construction et génération de code : certains codes sont générés automatiquement à partir de définitions XML qui font partie de la norme OPC UA. Les scripts de génération de code utilisent Python dans le cadre du processus de génération.

Sur la plupart des systèmes, un open62541 simple nécessite uniquement la bibliothèque standard C. Selon la configuration de build, open62541 dépend de bibliothèques supplémentaires, telles que mbedTLS ou OpenSSL pour le chiffrement.

Développement

En tant que projet open source, les nouveaux contributeurs sont encouragés à contribuer à l'amélioration d'open62541. Le fichier CONTRIBUTING.md regroupe les bonnes pratiques que nous attendons pour les contributions de code. Les éléments suivants sont de bons points de départ pour les nouveaux contributeurs :

• Signaler des bogues
• Améliorer la documentation
• Travailler sur des numéros marqués comme « bon premier numéro »

Pour le développement personnalisé qui fera éventuellement partie de la bibliothèque open62541, veuillez tenir l'un des responsables principaux au courant.

Qualité du code

Nous mettons l'accent sur la qualité du code. Les indicateurs de qualité suivants sont vérifiés en permanence et sont garantis avant qu'une version officielle ne soit publiée :

• Zéro erreur indiquée par l'outil de test de conformité (CTT) de la Fondation OPC pour les fonctionnalités prises en charge
• Zéro avertissement du compilateur de GCC/Clang/MSVC avec des indicateurs de compilation très stricts
• Aucun problème signalé par les tests unitaires (nous visons une couverture de code supérieure à 80 %)
• Aucun problème indiqué par clang-analyzer, clang-tidy, cpp-check et les outils d'analyse de code statique Codacy
• Aucun problème non résolu lié au fuzzing de la bibliothèque dans l'infrastructure oss-fuzz de Google
• Zéro problème signalé par Valgrind (Linux), DrMemory (Windows) et Clang AddressSanitizer / MemorySanitizer pour les tests CTT, les tests unitaires et le fuzzing

Gestion de la sécurité et des vulnérabilités

Le projet a établi un processus de gestion des vulnérabilités. Consultez SECURITY.md pour plus de détails et comment divulguer les résultats de manière responsable aux responsables.

Exemples

Des exemples de code peuvent être trouvés dans le répertoire /examples. Pour construire les exemples, nous vous recommandons d'installer open62541 comme mentionné dans la section précédente. À l'aide du compilateur GCC, exécutez simplement gcc -std=c99 -lopen62541 -o server (sous Windows, vous devrez peut-être ajouter un lien supplémentaire vers la bibliothèque de sockets ws2_32 ).

Exemple d'implémentation de serveur

 #include 

int main ( int argc , char * * argv )
{
    /* Create a server listening on port 4840 (default) */
    UA_Server * server = UA_Server_new ();

    /* Add a variable node to the server */

    /* 1) Define the variable attributes */
    UA_VariableAttributes attr = UA_VariableAttributes_default ;
    attr . displayName = UA_LOCALIZEDTEXT ( "en-US" , "the answer" );
    UA_Int32 myInteger = 42 ;
    UA_Variant_setScalar ( & attr . value , & myInteger , & UA_TYPES [ UA_TYPES_INT32 ]);

    /* 2) Define where the node shall be added with which browsename */
    UA_NodeId newNodeId = UA_NODEID_STRING ( 1 , "the.answer" );
    UA_NodeId parentNodeId = UA_NS0ID ( OBJECTSFOLDER );
    UA_NodeId parentReferenceNodeId = UA_NS0ID ( ORGANIZES );
    UA_NodeId variableType = UA_NODEID_NULL ; /* take the default variable type */
    UA_QualifiedName browseName = UA_QUALIFIEDNAME ( 1 , "the answer" );

    /* 3) Add the node */
    UA_Server_addVariableNode ( server , newNodeId , parentNodeId ,
                              parentReferenceNodeId , browseName ,
                              variableType , attr , NULL , NULL );

    /* Run the server (until ctrl-c interrupt) */
    UA_StatusCode status = UA_Server_runUntilInterrupt ( server );

    /* Clean up */
    UA_Server_delete ( server );
    return status == UA_STATUSCODE_GOOD ? EXIT_SUCCESS : EXIT_FAILURE ;
}

Exemple d'implémentation client

 #include 
#include 
#include 

int main ( int argc , char * argv [])
{
    /* Create a client and connect */
    UA_Client * client = UA_Client_new ();
    UA_ClientConfig_setDefault ( UA_Client_getConfig ( client ));
    UA_StatusCode status = UA_Client_connect ( client , "opc.tcp://localhost:4840" );
    if ( status != UA_STATUSCODE_GOOD ) {
        UA_Client_delete ( client );
        return status ;
    }

    /* Read the value attribute of the node. UA_Client_readValueAttribute is a
     * wrapper for the raw read service available as UA_Client_Service_read. */
    UA_Variant value ; /* Variants can hold scalar values and arrays of any type */
    UA_Variant_init ( & value );
    status = UA_Client_readValueAttribute ( client , UA_NODEID_STRING ( 1 , "the.answer" ), & value );
    if ( status == UA_STATUSCODE_GOOD &&
       UA_Variant_hasScalarType ( & value , & UA_TYPES [ UA_TYPES_INT32 ])) {
        printf ( "the value is: %in" , * ( UA_Int32 * ) value . data );
    }

    /* Clean up */
    UA_Variant_clear ( & value );
    UA_Client_delete ( client ); /* Disconnects the client internally */
    return status == UA_STATUSCODE_GOOD ? EXIT_SUCCESS : EXIT_FAILURE ;
}