DevIOLuaServer

Introduction

DevIOLuaServer est une Interface Applicative (IA) qui permet l'exécution de scripts Lua en temps réel au sein de l'environnement DevIO. Cette interface offre une plateforme de scripting avancée pour automatiser des traitements, effectuer des calculs complexes, et implémenter une logique métier personnalisée sur les données collectées par DevIO.

L'interface utilise le moteur Lua avec la bibliothèque Sol2 pour fournir une intégration native entre C++ et Lua, permettant aux utilisateurs de développer des scripts puissants avec accès complet aux données DevIO en temps réel.

Compatibilité et prérequis

Technologies supportées

Moteur de script

• Lua 5.x : Langage de script principal
• Sol2 : Bibliothèque de binding C++/Lua
• JSON Spirit : Support des structures de données JSON

Formats de données

• JSON : Format d'échange principal
• OPC : Intégration avec le serveur OPC DevIO
• XML : Configuration des scripts

Prérequis système

• DevIO Studio pour la configuration
• Serveur OPC DevIO actif
• Fichier de configuration DevIOLuaServer.xml
• Scripts Lua dans le répertoire DevIO

Fonctionnalités supportées

Exécution de scripts Lua

Modes d'exécution

• Mode One : Exécution sur changement d'une variable
• Mode All : Exécution quand toutes les variables sont disponibles
• Exécution asynchrone : Scripts non-bloquants avec gestion des tâches

Accès aux données DevIO

-- Lecture de données
local temperature = data.getValue("Equipment1", "Temperature")
local pressure = data.getValue("Equipment2", "Pressure")

-- Écriture de données
data.writeData("Equipment1", {
    {dataName = "SetPoint", dataValue = 25.5},
    {dataName = "Status", dataValue = "Active"}
})

Gestion des équipements

Structure hiérarchique

• Équipements : Conteneurs de données
• Blocs : Groupements logiques de données
• Données : Variables individuelles avec état et horodatage

Découverte automatique

• Enregistrement dynamique des nouveaux équipements
• Mise à jour automatique de la structure de données
• Gestion des déconnexions et reconnexions

Système d'événements

Types d'événements

• EventWriteVar : Écriture de variable
• EventEndCreateVars : Fin de création des variables
• Événements temporisés : Exécution périodique

File d'attente d'événements

• Traitement asynchrone des événements
• Gestion des priorités
• Mécanisme de retry automatique

Configuration de l'interface et du modèle d'équipement

Activation dans DevIO Studio

Comment déclarer l'interface applicative ?

1. Ouvrir votre projet avec DevIO Studio
2. Réaliser l'import base binaire si nécessaire
3. Basculer le projet en lecture/écriture
4. Cliquez-droit sur Serveur, puis Propriétés...
5. Dans les arguments additionnels, ajouter : -LUASERVER

Configuration XML

Fichier DevIOLuaServer.xml

La configuration s'effectue via un fichier XML DevIOLuaServer.xml placé dans le répertoire DevIO.

<?xml version="1.0" encoding="utf-8"?>
<DevIOLuaServer>
    <!-- Configuration du serveur -->
    <Server name="DevIOLuaServer" pushPeriod="45" logLevel="0" />

    <!-- Configuration des scripts -->
    <Scripts>
        <Script mode="One" file="temperature_monitor.lua">
            <Variables>
                <Variable equipmentName="Sensor1" dataName="Temperature.*" 
                         alias="temp" state="OnlyOK" />
            </Variables>
        </Script>

        <Script mode="All" file="calculation.lua">
            <Variables>
                <Variable equipmentName="Equipment1" dataName="Input1" alias="in1" />
                <Variable equipmentName="Equipment1" dataName="Input2" alias="in2" />
                <Variable equipmentName="Equipment1" dataName="Output" alias="out" />
            </Variables>
        </Script>
    </Scripts>
</DevIOLuaServer>

Structure de configuration

Élément	Attributs	Description
<Server>	name, pushPeriod, logLevel	Configuration générale du serveur
<Script>	mode, file	Définition d'un script Lua
<Variable>	equipmentName, dataName, alias, state	Mapping des variables DevIO

Variables de configuration

Configuration du serveur

• name : Nom du serveur Lua (défaut: "DevIOLuaServer")
• pushPeriod : Période de publication en secondes (défaut: 45)
• logLevel : Niveau de journalisation (0-3)

Configuration des scripts

• mode : Mode d'exécution ("One", "All")
• file : Chemin vers le fichier script Lua
• equipmentName : Nom de l'équipement (regex supportée)
• dataName : Nom de la donnée (regex supportée)
• alias : Alias pour la variable dans le script
• state : Filtre d'état ("OnlyOK", etc.)

Utilisation et supervision

Développement de scripts Lua

API DevIO disponible

-- Interface de données DevIO
data = {
    -- Écriture de données
    writeData = function(equipmentName, dataArray)
        -- dataArray: table de {dataName, dataValue}
    end,

    -- Lecture de valeur (via variable mappée)
    getValue = function(equipmentName, dataName)
        -- Retourne la valeur de la donnée
    end,

    -- Journalisation
    log = function(message)
        -- Écrit dans les logs DevIO
    end
}

-- Variables mappées automatiquement disponibles
-- selon la configuration XML (alias)

Exemple de script de monitoring

-- temperature_monitor.lua
-- Surveillance de température avec alarmes

function process()
    local currentTemp = temp.value  -- Variable mappée via alias
    local timestamp = temp.timestamp
    local state = temp.state

    -- Vérification des seuils
    if currentTemp > 80 then
        data.writeData("AlarmSystem", {
            {dataName = "HighTempAlarm", dataValue = true},
            {dataName = "AlarmMessage", dataValue = "Temperature critique: " .. currentTemp}
        })
        data.log("ALARM: Température critique détectée: " .. currentTemp .. "°C")
    elseif currentTemp < 5 then
        data.writeData("AlarmSystem", {
            {dataName = "LowTempAlarm", dataValue = true},
            {dataName = "AlarmMessage", dataValue = "Température trop basse: " .. currentTemp}
        })
        data.log("ALARM: Température trop basse détectée: " .. currentTemp .. "°C")
    else
        -- Réinitialiser les alarmes
        data.writeData("AlarmSystem", {
            {dataName = "HighTempAlarm", dataValue = false},
            {dataName = "LowTempAlarm", dataValue = false},
            {dataName = "AlarmMessage", dataValue = ""}
        })
    end
end

-- Point d'entrée principal
process()

Exemple de script de calcul

-- calculation.lua
-- Calculs complexes avec plusieurs variables

function calculate()
    -- Variables mappées automatiquement
    local input1 = in1.value
    local input2 = in2.value

    -- Vérification de la validité des données
    if in1.state ~= "GOOD" or in2.state ~= "GOOD" then
        data.log("WARNING: Données d'entrée non valides")
        return
    end

    -- Calcul complexe
    local result = math.sqrt(input1^2 + input2^2)
    local efficiency = (result / (input1 + input2)) * 100

    -- Écriture du résultat
    data.writeData("Equipment1", {
        {dataName = "CalculatedResult", dataValue = result},
        {dataName = "Efficiency", dataValue = efficiency},
        {dataName = "LastCalculation", dataValue = os.date("%Y-%m-%d %H:%M:%S")}
    })

    data.log("Calcul effectué: " .. result .. " (efficacité: " .. efficiency .. "%)")
end

calculate()

Monitoring et supervision

Journalisation

• Logs système : DevIOLuaServer.log
• Logs scripts : Intégrés dans les logs DevIO
• Rotation automatique des fichiers de logs
• Niveaux de log configurables

Surveillance des performances

• Temps d'exécution des scripts
• Utilisation mémoire du moteur Lua
• File d'attente des événements
• Statistiques d'exécution

Rechargement à chaud

• Surveillance automatique du fichier de configuration
• Rechargement des scripts modifiés
• Mise à jour sans redémarrage du serveur

FAQ et dépannage

Questions fréquentes

Comment déboguer un script Lua ?

1. Activer le niveau de log détaillé (logLevel="3")
2. Utiliser data.log() pour tracer l'exécution
3. Vérifier les logs DevIO pour les erreurs
4. Tester le script en mode isolé avant intégration

Pourquoi mon script ne s'exécute pas ?

• Vérifier la syntaxe Lua du script
• S'assurer que les variables mappées existent
• Contrôler les filtres d'état (state="OnlyOK")
• Vérifier que le mode d'exécution est correct

Comment optimiser les performances ?

• Éviter les boucles infinies dans les scripts
• Utiliser le mode "One" pour les traitements simples
• Limiter les écritures de données fréquentes
• Optimiser la logique des scripts

Problèmes courants

Erreurs de configuration

# Erreur : Script non trouvé
ERROR: Cannot load script file: temperature_monitor.lua
→ Vérifier le chemin du fichier script

# Erreur : Variable non mappée
ERROR: Variable 'temp' not found in script context
→ Vérifier la configuration XML des variables

# Erreur : Syntaxe Lua invalide
ERROR: Lua syntax error in script
→ Valider la syntaxe du script Lua

Problèmes de performance

# Script trop lent
WARNING: Script execution time exceeded 5 seconds
→ Optimiser la logique du script

# Mémoire insuffisante
ERROR: Lua memory allocation failed
→ Réduire la complexité des scripts

Annexes et références utiles

Documentation technique

Architecture interne

• Moteur Lua : Sol2 binding library
• Threading : Exécution asynchrone avec pool de threads
• Événements : Système de file d'attente thread-safe
• OPC Integration : Interface native avec le serveur OPC DevIO

Structure des données

// Structure interne des données
struct Data {
    std::string equipmentName;
    std::string dataName;
    json_spirit::mValue value;
    USHORT state;
    FILETIME timestamp;
};

// Structure des équipements
struct Equipment {
    std::string name;
    std::string address;
    std::map<std::string, Data::Ptr> dataList;
};

Ressources externes

• Documentation Lua : Manuel officiel du langage Lua
• Sol2 Documentation : Documentation de la bibliothèque Sol2
• JSON Spirit : Bibliothèque JSON pour C++

Exemples avancés

Script de régulation PID

-- pid_controller.lua
-- Contrôleur PID simple

local PID = {
    kp = 1.0,      -- Gain proportionnel
    ki = 0.1,      -- Gain intégral
    kd = 0.01,     -- Gain dérivé

    prev_error = 0,
    integral = 0,
    dt = 1.0       -- Période d'échantillonnage
}

function PID:calculate(setpoint, process_value)
    local error = setpoint - process_value

    -- Terme proportionnel
    local proportional = self.kp * error

    -- Terme intégral
    self.integral = self.integral + error * self.dt
    local integral_term = self.ki * self.integral

    -- Terme dérivé
    local derivative = (error - self.prev_error) / self.dt
    local derivative_term = self.kd * derivative

    -- Sortie PID
    local output = proportional + integral_term + derivative_term

    self.prev_error = error
    return output
end

-- Utilisation
local setpoint = target.value
local current_value = sensor.value
local control_output = PID:calculate(setpoint, current_value)

data.writeData("Controller", {
    {dataName = "ControlOutput", dataValue = control_output},
    {dataName = "Error", dataValue = setpoint - current_value}
})

Cette documentation fournit une vue complète de DevIOLuaServer en tant qu'Interface Applicative, couvrant son architecture, sa configuration, son utilisation et ses capacités de scripting avancées.