Skip to content
TheChatArchiveThe Chat Archive
Coherecommand-a-03-2025· CohereHugging Face LMArena Human Preference 140K

so my main goal is to develop a OPC UA server on ESP32 send data of 2 sensors MAX31855…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Qwenqwen3-30b-a3b’s answer.
  1. User

    so my main goal is to develop a OPC UA server on ESP32 send data of 2 sensors MAX31855 and MPu6050 data through wifi to server there is around 3 data that i need to send dwell time, pouring time, puring temperature i am developing this project and i am stuck with OPC UA server faild becasue of heap size and i need to solev that problem so i am trying various git repo. for that can you tell me which one work in my case

    https://gitcode.com/gh_mirrors/op/opcua-esp32.git

    https://github.com/cmbahadir/opcua-esp32.git

    https://github.com/Pro/open62541-esp32.git

  2. Cohere Assistant

    Developing an OPC UA server on an ESP32 with limited heap size is indeed challenging, especially when integrating multiple sensors like the MAX31855 and MPU6050. Below, I'll analyze the repositories you mentioned and provide recommendations to address your heap size issue while achieving your project goals.


    Analysis of Repositories

    1. https://gitcode.com/gh_mirrors/op/opcua-esp32.git

      • This is a mirror of the original OPC UA ESP32 repository. It is based on the open62541 stack, which is the most widely used OPC UA implementation.
      • Pros: Well-maintained, actively developed, and widely supported.
      • Cons: The default configuration may consume significant heap memory, especially if not optimized.
      • Heap Optimization: You’ll need to customize the build flags and reduce the number of nodes, namespaces, and features (e.g., disable unnecessary security policies).
    2. https://github.com/cmbahadir/opcua-esp32.git

      • This repository is a fork of the original OPC UA ESP32 project with some modifications. It may include optimizations for the ESP32.
      • Pros: Potentially lighter and more tailored for ESP32 constraints.
      • Cons: Less actively maintained compared to the original repository.
      • Heap Optimization: Check if the fork includes specific heap optimizations or reduced feature sets.
    3. https://github.com/Pro/open62541-esp32.git

      • This repository is another port of open62541 for ESP32. It may include specific optimizations for the ESP32 platform.
      • Pros: Focused on ESP32 compatibility and performance.
      • Cons: May not be as actively maintained as the main open62541 repository.
      • Heap Optimization: Look for ESP32-specific configurations or stripped-down versions.

    Recommendation

    For your use case, I recommend starting with the original open62541-based repository (https://gitcode.com/gh_mirrors/op/opcua-esp32.git) because it is the most stable and well-supported. However, you’ll need to optimize it for the ESP32's limited resources. Here’s how:


    Steps to Solve Heap Size Issues

    1. Reduce OPC UA Stack Memory Usage:

      • Disable unnecessary features like encryption and security policies (e.g., use None security policy).
      • Limit the number of nodes and namespaces to only what you need (e.g., dwell time, pouring time, pouring temperature).
      • Use dynamic memory allocation carefully and avoid large buffers.
    2. Optimize Sensor Data Handling:

      • Read sensor data asynchronously to avoid blocking the OPC UA server.
      • Use lightweight data structures (e.g., uint16_t or float instead of double).
    3. Customize Build Flags:

      • Use the ESP-IDF SDK to customize the build process. Add the following flags to reduce memory usage:
        -DUA_ENABLE_AMALGAMATION=ON  # Combines source files to reduce flash size
        -DUA_ENABLE_SUBSCRIPTIONS=OFF  # Disable subscriptions if not needed
        -DUA_ENABLE_HISTORIZING=OFF   # Disable historizing if not needed
        -DUA_ENABLE_METHODCALLS=OFF   # Disable method calls if not needed
        
    4. Increase Heap Size (if possible):

      • In sdkconfig, increase the heap size by adjusting CONFIG_ESP32_SPIRAM_SUPPORT (if your ESP32 has external PSRAM) or optimizing other memory partitions.
    5. Test and Profile:

      • Use the ESP-IDF heap_caps_get_free_size() function to monitor heap usage during runtime.
      • Gradually add features and nodes while checking heap consumption.

    Example Configuration

    Here’s an example of how to configure the OPC UA server for minimal memory usage:

    #include "open62541.h"
    
    UA_Server *server = UA_Server_new();
    UA_ServerConfig *config = UA_Server_getConfig(server);
    
    // Disable unnecessary security policies
    UA_ServerConfig_setDefault(config);
    config->securityPolicies[0].securityPolicyUri = UA_STRING("None");
    
    // Add custom nodes for sensor data
    UA_VariableAttributes attr = UA_VariableAttributes_default;
    attr.description = UA_LOCALIZEDTEXT("en-US", "Pouring Temperature");
    attr.displayName = UA_LOCALIZEDTEXT("en-US", "Pouring Temperature");
    attr.dataType = UA_TYPES[UA_TYPES_FLOAT];
    UA_Server_addVariableNode(server, UA_NODEID_STRING(1, "PouringTemperature"),
                              UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
                              UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),
                              UA_QUALIFIEDNAME(1, "PouringTemperature"),
                              UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE),
                              attr, NULL, NULL);
    
    // Repeat for dwell time and pouring time
    

    Alternative Approach

    If heap issues persist, consider using a lightweight MQTT protocol instead of OPC UA for data transmission. You can then expose the MQTT data via an OPC UA server running on a more powerful device (e.g., Raspberry Pi).


    Final Recommendation

    Start with the original open62541-based repository and apply the optimizations mentioned above. If you still face heap issues, try the fork by cmbahadir or explore the open62541-esp32 repository for ESP32-specific optimizations.

    Let me know if you need further assistance with implementation details!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.