Rtop 100 opc ua

core/src/CMakeLists.txt

@@ -40,6 +40,7 @@ add_executable(plc_main
     ${CMAKE_SOURCE_DIR}/core/src/plc_app/scan_cycle_manager.c
     ${CMAKE_SOURCE_DIR}/core/src/drivers/plugin_driver.c
     ${CMAKE_SOURCE_DIR}/core/src/drivers/plugin_config.c
+    ${CMAKE_SOURCE_DIR}/core/src/drivers/plugin_utils.c
     ${CMAKE_SOURCE_DIR}/core/src/plc_app/unix_socket.c
     ${CMAKE_SOURCE_DIR}/core/src/plc_app/debug_handler.c
 )

core/src/drivers/plugin_driver.c

@@ -18,6 +18,7 @@
 #include "../plc_app/utils/log.h"
 #include "plugin_config.h"
 #include "plugin_driver.h"
+#include "plugin_utils.h"
 #include <dlfcn.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -504,10 +505,19 @@ int plugin_driver_stop(plugin_driver_t *driver)
     // Signal all plugins to stop
     for (int i = 0; i < driver->plugin_count; i++)
     {
+        plugin_instance_t *plugin = &driver->plugins[i];
+
+        // Skip disabled plugins
+        if (!plugin->config.enabled)
+        {
+            printf("[PLUGIN]: Skipping disabled plugin during stop: %s\n", plugin->config.name);
+            continue;
+        }
+
         printf("[PLUGIN]: Stopping plugin %d/%d: %s\n", i + 1, driver->plugin_count,
                driver->plugins[i].config.name);
-        if (driver->plugins[i].python_plugin && driver->plugins[i].python_plugin->pFuncStop &&
-            driver->plugins[i].running)
+        if (plugin->python_plugin && plugin->python_plugin->pFuncStop &&
+            plugin->running)
         {
             plugin_instance_t *plugin = &driver->plugins[i];
             if (plugin->config.enabled == 0)
@@ -531,10 +541,9 @@ int plugin_driver_stop(plugin_driver_t *driver)
             plugin->running = 0;
         }
 
-        else if (driver->plugins[i].native_plugin && driver->plugins[i].native_plugin->stop &&
-                 driver->plugins[i].running)
+        else if (plugin->native_plugin && plugin->native_plugin->stop &&
+                 plugin->running)
         {
-            plugin_instance_t *plugin = &driver->plugins[i];
             plugin->native_plugin->stop();
             printf("[PLUGIN]: Native plugin %s stopped successfully.\n", plugin->config.name);
             plugin->running = 0;
@@ -733,6 +742,9 @@ void *generate_structured_args_with_driver(plugin_type_t type, plugin_driver_t *
     // Initialize mutex functions
     args->mutex_take = plugin_mutex_take;
     args->mutex_give = plugin_mutex_give;
+    args->get_var_list = get_var_list;
+    args->get_var_size = get_var_size;
+    args->get_var_count = get_var_count;
     // Set buffer mutex from driver
     args->buffer_mutex = &driver->buffer_mutex;
 
@@ -1143,9 +1155,8 @@ void plugin_driver_cycle_end(plugin_driver_t *driver)
 // Cleanup Python plugin
 static void python_plugin_cleanup(plugin_instance_t *plugin)
 {
-    (void)plugin; // Suppress unused parameter warning
     // Cleanup Python resources
-    if (plugin && plugin->python_plugin)
+    if (plugin && plugin->python_plugin && plugin->config.enabled)
     {
         // Call cleanup function if available
         if (plugin->python_plugin->pFuncCleanup)

core/src/drivers/plugin_types.h

@@ -17,6 +17,7 @@
 
 #include "../lib/iec_types.h"
 #include <pthread.h>
+#include <stdint.h>
 
 /**
  * @brief Logging function pointer types
@@ -87,6 +88,11 @@ typedef struct
     int (*mutex_give)(pthread_mutex_t *mutex);
     pthread_mutex_t *buffer_mutex;
 
+    /* Variable access functions */
+    void (*get_var_list)(size_t num_vars, size_t *indexes, void **result);
+    size_t (*get_var_size)(size_t idx);
+    uint16_t (*get_var_count)(void);
+
     /* Plugin configuration */
     char plugin_specific_config_file_path[256];
 

core/src/drivers/plugin_utils.c

@@ -0,0 +1,59 @@
+#include "plugin_utils.h"
+#include "../plc_app/image_tables.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// Wrapper function to get list of variable addresses
+// Returns NULL for all addresses if no PLC program is loaded
+void get_var_list(size_t num_vars, size_t *indexes, void **result)
+{
+    // Validate input parameters
+    if (!indexes || !result || num_vars == 0)
+    {
+        return;
+    }
+
+    // Check if PLC program is loaded (function pointers are set)
+    if (!ext_get_var_count || !ext_get_var_addr)
+    {
+        for (size_t i = 0; i < num_vars; i++)
+        {
+            result[i] = NULL;
+        }
+        return;
+    }
+
+    for (size_t i = 0; i < num_vars; i++)
+    {
+        size_t idx = indexes[i];
+        if (idx >= ext_get_var_count())
+        {
+            result[i] = NULL;
+        }
+        else
+        {
+            result[i] = ext_get_var_addr(idx);
+        }
+    }
+}
+
+// Returns 0 if no PLC program is loaded
+size_t get_var_size(size_t idx)
+{
+    if (!ext_get_var_size)
+    {
+        return 0;
+    }
+    return ext_get_var_size(idx);
+}
+
+// Returns 0 if no PLC program is loaded
+uint16_t get_var_count(void)
+{
+    if (!ext_get_var_count)
+    {
+        return 0;
+    }
+    return ext_get_var_count();
+}

core/src/drivers/plugin_utils.h

@@ -0,0 +1,11 @@
+#ifndef PLUGIN_UTILS_H
+#define PLUGIN_UTILS_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+void get_var_list(size_t num_vars, size_t *indexes, void **result);
+size_t get_var_size(size_t idx);
+uint16_t get_var_count(void);
+
+#endif // PLUGIN_UTILS_H

core/src/drivers/plugins/python/opcua/SUBSCRIPTION_IMPLEMENTATION.md

@@ -0,0 +1,85 @@
+# OPC-UA Subscription Implementation Plan
+
+## Overview
+
+This document outlines the implementation plan for adding OPC-UA subscription support to the OpenPLC OPC-UA plugin. Subscriptions enable push-based data updates, replacing inefficient polling with server-initiated notifications.
+
+## Current State (UPDATED)
+
+The plugin now supports subscriptions via asyncua's built-in subscription handling:
+1. Reads PLC memory every `cycle_time_ms` (default 100ms)
+2. Updates OPC-UA node values using `write_attribute_value()` with DataValue
+3. Clients can create subscriptions and receive push notifications on value changes
+4. Proper timestamps (SourceTimestamp, ServerTimestamp) are included
+
+## Implementation Status
+
+### Phase 1: Enable Native Subscription Support - COMPLETED
+- [x] Verified asyncua server subscription handling works
+- [x] Updated `_update_opcua_node()` to use `write_attribute_value()` with DataValue
+- [x] Server reference passed to SynchronizationManager
+
+### Phase 2: Optimize Value Updates - COMPLETED
+- [x] Using `write_attribute_value()` with proper DataValue objects
+- [x] SourceTimestamp set to PLC cycle time (when value was read)
+- [x] ServerTimestamp set to processing time
+- [x] StatusCode set to Good for valid values
+
+### Phase 3: Subscription Configuration - PENDING
+- [ ] Add subscription-related settings to config
+- [ ] Configure default publishing intervals
+- [ ] Set limits on max subscriptions/monitored items
+
+### Phase 4: Advanced Features - PENDING
+- [ ] Deadband filtering for analog values
+- [ ] Queue size configuration
+- [ ] Sampling interval limits
+
+## Key asyncua APIs
+
+### Server Value Updates (IMPLEMENTED)
+```python
+# Our implementation in synchronization.py:
+from datetime import datetime, timezone
+from asyncua import ua
+
+# Create DataValue with timestamps
+data_value = ua.DataValue(
+    Value=ua.Variant(opcua_value, expected_type),
+    StatusCode_=ua.StatusCode(ua.StatusCodes.Good),
+    SourceTimestamp=self._cycle_timestamp,  # PLC cycle time
+    ServerTimestamp=datetime.now(timezone.utc)
+)
+
+# Use write_attribute_value for optimal subscription triggering
+await self.server.write_attribute_value(
+    var_node.node.nodeid,
+    data_value
+)
+```
+
+This approach:
+- Triggers data change notifications for subscribed clients
+- Is faster than `write_value()` (fewer validation checks)
+- Includes proper timestamps for audit trail
+- Bypasses PreWrite callbacks (server-internal operation)
+
+### Subscription Parameters
+- **PublishingInterval**: How often server sends notifications (ms)
+- **LifetimeCount**: Number of publishing intervals before subscription expires
+- **MaxKeepAliveCount**: Max intervals without notification before keep-alive
+- **MaxNotificationsPerPublish**: Limit notifications per publish response
+- **Priority**: Relative priority among subscriptions
+
+## Testing Strategy
+
+1. **Unit Tests**: Mock asyncua server, verify notification triggers
+2. **Integration Tests**: Real server with Python client
+3. **Manual Testing**: UAExpert, Prosys OPC UA Browser
+4. **Performance Tests**: Compare bandwidth with polling vs subscriptions
+
+## References
+
+- [asyncua Documentation](https://opcua-asyncio.readthedocs.io/)
+- [OPC UA Part 4: Services - Subscription Services](https://reference.opcfoundation.org/Core/Part4/)
+- [OPC UA Part 5: Information Model - Subscription](https://reference.opcfoundation.org/Core/Part5/)

core/src/drivers/plugins/python/opcua/__init__.py

@@ -0,0 +1,31 @@
+"""
+OpenPLC OPC UA Plugin.
+
+This package implements an OPC UA server for the OpenPLC runtime,
+providing industrial-grade connectivity using the asyncua library.
+
+Architecture:
+    - plugin.py: Entry point with init/start_loop/stop_loop/cleanup
+    - config.py: Configuration loading and validation
+    - opcua_logging.py: Centralized logging singleton
+    - server.py: OpcuaServerManager (main orchestrator)
+    - address_space.py: AddressSpaceBuilder (node creation)
+    - synchronization.py: SynchronizationManager (bidirectional sync)
+    - user_manager.py: OpenPLCUserManager (authentication)
+    - callbacks.py: PermissionCallbackHandler (access control)
+    - opcua_types.py: Type definitions (VariableNode, VariableMetadata)
+    - opcua_utils.py: Utility functions (type mapping, conversion)
+    - opcua_security.py: OpcuaSecurityManager (certificates, policies)
+    - opcua_memory.py: Direct memory access utilities
+    - opcua_endpoints_config.py: Endpoint URL utilities
+
+Usage:
+    The plugin is loaded by the OpenPLC runtime plugin system.
+    Configuration is provided via JSON file specified in plugins.conf.
+"""
+
+# Re-export plugin interface for runtime compatibility
+from .plugin import init, start_loop, stop_loop, cleanup
+
+__version__ = "2.0.0"
+__all__ = ['init', 'start_loop', 'stop_loop', 'cleanup']