Beispiel für libmodbus-Mutex und rekursives Lock

• Die libmodbus-Bibliothek bietet einige Sperrmechanismen zum Schutz von Daten, die auf Modbus-Sklaven in einer Multithread-Umgebung zugreifen. Konkret bietet die libmodbus-Bibliothek die folgenden zwei Sperrmechanismen:

1. Mutually Exclusive Lock (mutex): Die modbus_t-Struktur in der libmodbus-Bibliothek enthält ein Mutually Exclusive Lock, das mit den Funktionen modbus_mutex_lock() und modbus_mutex_unlock() gesperrt und entsperrt werden kann, um die erneute Sperrverbindung von Modbus-Slaven
2. in einer Multithread-Umgebung zu schützen.(recursive lock): Die libmodbus-Bibliothek bietet außerdem einen wiederverriegelbaren Mechanismus, mit dem Sie benutzerdefinierte RTS-Operationen über die Funktion modbus_rtu_set_custom_rts () einstellen und in der Rückruffunktion sperren und entsperren können, um den Zugriff auf Modbus-Slaven in einer Multi-Thread - Umgebung zu schützen.

Es ist wichtig zu beachten, dass die Verwendung von Sperrmechanismen mit Vorsicht benötigt wird, da eine falsche Verwendung zu Problemen wie Sackgassen oder Threadblockaden führen kann, sodass ein thread-synchronisierender Mechanismus sorgfältig gestaltet und implementiert werden muss, wenn man die libmodbus-Bibliothek in einer Multi-Thread - Umgebung verwendet.

Hier ist ein Beispielcode für ein Mutually Expulsive Lock mit der libmodbus-Bibliothek:

#include <stdio.h>
#include <modbus/modbus.h>

int main() {
    modbus_t *ctx;
    modbus_mapping_t *mapping;
    int ret;

    // 创建Modbus从站设备并分配数据存储区
    ctx = modbus_new_rtu("/dev/ttyS0", 9600, 'N', 8, 1);
    if (ctx == NULL) {
        fprintf(stderr, "Failed to create modbus contextn");
        return -1;
    }
    mapping = modbus_mapping_new(0, 0, 100, 0);
    if (mapping == NULL) {
        fprintf(stderr, "Failed to allocate mappingn");
        modbus_free(ctx);
        return -1;
    }

    // 加锁并访问Modbus从站设备
    modbus_mutex_lock(ctx);
    ret = modbus_connect(ctx);
    if (ret == -1) {
        fprintf(stderr, "Failed to connect to Modbus devicen");
        modbus_mutex_unlock(ctx);
        return -1;
    }
    ret = modbus_write_register(ctx, 0, 123);
    if (ret == -1) {
        fprintf(stderr, "Failed to write registern");
        modbus_mutex_unlock(ctx);
        return -1;
    }
    modbus_close(ctx);
    modbus_mutex_unlock(ctx);

    // 释放资源并退出
    modbus_mapping_free(mapping);
    modbus_free(ctx);
    return 0;
}

Im folgenden Code wird das Sperren durch den Aufruf der Funktion modbus_mutex_lock () durchgeführt, dann auf das Modbus-Sklavengerät zugegriffen und schließlich durch den Aufruf der Funktion modbus_mutex_unlock () entsperrt. Die Verwendung von Mutually Expulsive Sperren kann sicherstellen, dass nur ein Thread in einer Multi-Thread - Umgebung Zugriff auf Modbus-Sklaven hat, wodurch Probleme wie Konkurrenzbedingungen vermieden werden.

Hier ist ein Beispielcode für ein wiederverriegeltes Verriegeln, das die libmodbus-Bibliothek verwendet:

#include <stdio.h>
#include <modbus/modbus.h>

// 定义可重入锁
modbus_t *g_ctx = NULL;
modbus_mutex_t g_lock;

// 定义用户自定义的RTS回调函数
void custom_rts(modbus_t *ctx, int on) {
    if (on) {
        modbus_mutex_lock(&g_lock);
    } else {
        modbus_mutex_unlock(&g_lock);
    }
}

int main() {
    modbus_mapping_t *mapping;
    int ret;

    // 创建Modbus从站设备并分配数据存储区
    g_ctx = modbus_new_rtu("/dev/ttyS0", 9600, 'N', 8, 1);
    if (g_ctx == NULL) {
        fprintf(stderr, "Failed to create modbus contextn");
        return -1;
    }
    mapping = modbus_mapping_new(0, 0, 100, 0);
    if (mapping == NULL) {
        fprintf(stderr, "Failed to allocate mappingn");
        modbus_free(g_ctx);
        return -1;
    }

    // 设置用户自定义的RTS回调函数并访问Modbus从站设备
    modbus_set_rts(g_ctx, custom_rts);
    ret = modbus_write_register(g_ctx, 0, 123);
    if (ret == -1) {
        fprintf(stderr, "Failed to write registern");