"Introduzione a Finder Opta e agli analizzatori di rete Finder serie 6M"

"Impara a leggere i registri del Finder 6M utilizzando il protocollo Modbus su Finder Opta."

"Introduzione a Finder Opta e agli analizzatori di rete Finder serie 6M"

Guide and Tutorial | "Introduzione a Finder Opta e agli analizzatori di rete Finder serie 6M"

Panoramica

Finder Opta offre diverse opzioni di interfaccia di comunicazione, tra cui la porta seriale RS-485. Utilizzando questa porta, è possibile comunicare tramite il protocollo Modbus RTU. Questo protocollo di comunicazione noto per la sua efficienza e scalabilità, consente di monitorare dispositivi industriali su larga scala ed è di fatto uno standard nel settore dell'automazione industriale. Ciò significa che, una volta collegato ad una serie di analizzatori di rete che supportano a loro volta il protocollo Modbus RTU, Finder Opta può essere impiegato come punto focale di un sistema di monitoraggio e controllo industriale.

Se ad esempio combinassimo Finder Opta con uno o più analizzatori di rete Finder serie 6M, potremmo automatizzare la gestione energetica e la manutenzione predittiva di una linea elettrica. Questo permetterebbe di ottimizzare l'impianto, monitorandone i consumi e fornendone una panoramica utile a ridurre i costi operativi.

Per questo motivo, in questo tutorial impareremo a implementare la comunicazione Modbus RTU tramite RS-485 tra Finder Opta e un analizzatore di rete Finder serie 6M. In particolare, impareremo a:

  • Utilizzare il Finder Opta per leggere i registri di un Finder serie 6M, al fine di leggere misure dall'analizzatore di rete.
  • Utilizzare il Finder Opta per scrivere nei registri di un Finder serie 6M, al fine di configurarlo.

Infine presenteremo la libreria Finder6M, che permette di semplificare tutte le operazioni presentate nel corso di questo tutorial.

Requisiti

Hardware

  • PLC Finder Opta con supporto RS-485 (x1).
  • Analizzatore di rete Finder serie 6M (x1).
  • Alimentatore DIN rail 12VDC/500mA (x1).
  • Cavo USB-C® (x1).
  • Cavo per la connettività RS-485 con una delle seguenti specifiche (x2):
    • STP/UTP 24-18AWG (non terminato) con impedenza di 100-130Ω.
    • STP/UTP 22-16AWG (terminato) con impedenza di 100-130Ω.

Software

Connettività

Per seguire questo tutorial, sarà necessario collegare l'analizzatore di rete Finder serie 6M alla rete elettrica e fornire un carico adeguato. Sarà inoltre necessario alimentare il Finder Opta con un alimentatore da 12-24VDC/500mA e configurare correttamente la connessione seriale RS-485. Il diagramma sottostante mostra la configurazione corretta dei collegamenti tra il Finder Opta e il Finder serie 6M.

Connecting Opta and Finder 6M

La configurazione Modbus del Finder serie 6M è determinata dalla posizione degli switch DIP, come indicato alla pagina 6 del manuale utente. In questo tutorial i parametri di comunicazione previsti sono:

  • Indirizzo Modbus: 1.
  • Baudrate: 38400.

Possiamo impostare questi valori posizionando entrambi gli switch DIP del Finder serie 6M alla posizione UP, come mostrato nella figura qui sotto.

DIP switches, baudrate 38400

Finder serie 6M e il protocollo Modbus RTU

Nella panoramica di questo tutorial abbiamo discusso la possibilità di utilizzare il protocollo Modbus RTU su connessione seriale RS-485, per trasformare Finder Opta nel punto focale di un sistema di monitoraggio industriale composto di analizzatori di rete Finder serie 6M.

I Finder serie 6M mettono a disposizione una serie di holding register, a 16 bit ovvero registri dedicati alla memorizzazione di dati che possono essere letti o scritti da altri dispositivi Modbus. Ogni registro è identificato da un indirizzo ed è possibile accedere al suo contenuto tramite una richiesta.

Come specificato nel documento Modbus communication protocol, le misure fornite dagli analizzatori di rete Finder serie 6M possono essere ottenute tramite Modbus effettuando una serie di letture a 16 bit. Per esempio, la misura dell'energia è rappresentata da un valore a 32 bit ottenuto combinando la lettura di due registri da 16 bit adiacenti, situati agli indirizzi Modbus 40208 e 40209.

È importante notare che, nei dispositivi Finder Serie 6M, gli offset sono tutti basati sul register offset, non sul byte offset. Ciò significa che useremo gli indirizzi Modbus per indicare la posizione di memoria da cui iniziare a leggere, specificando il numero di registri che desideriamo leggere a partire da tale indirizzo. Inoltre, su tali dispositivi, l'indirizzamento Modbus parte da 0, il che implica che accederemo all'indirizzo Modbus 40006 come holding register numero 5.

Ulteriori informazioni sul protocollo di comunicazione Modbus sono contennute in questo articolo sul protocollo. Tutte le funzionalità fornite dalla libreria ArduinoModbus sono supportate da Finder Opta.

Istruzioni

Configurazione dell'Arduino IDE

Per seguire questo tutorial, sarà necessaria l'ultima versione dell'Arduino IDE. Se è la prima volta che configuri il dispositivo Finder Opta, dai un'occhiata al tutorial Getting Started with Opta: in questo tutorial spieghiamo come installare il Board Manager per la piattaforma Mbed OS Opta, ovvero l'insieme di tool di base necessari a creare e utilizzare uno sketch per Finder Opta con Arduino IDE.

Assicurati di installare la versione più recente delle librerie ArduinoModbus e ArduinoRS485, poiché verranno utilizzate per implementare la comunicazione Modbus RTU. Per una breve spiegazione su come installare manualmente le librerie all'interno di Arduino IDE, consulta questo articolo.

Panoramica del codice

Lettura di misure dal Finder serie 6M

Nella prima parte di questo tutorial scriveremo uno sketch che permetta di leggere alcune misure da un analizzatore di rete Finder serie 6M, per poi a stamparle su monitor seriale. Il codice completo di questa parte di tutorial è disponibile qui. È possibile estrarre il contenuto del file .zip e copiarlo nella cartella ~/Documents/Arduino, o alternativamente creare un nuovo sketch chiamato Opta6MReadExample utilizzando Arduino IDE ed incollare il codice presente nel tutorial.

Iniziamo scrivendo un file di configurazione contenente alcune costanti da utilizzare nello sketch di lettura. In particolare, creiamo un file chiamato finder-6m-read.h all'interno della stessa cartella dello sketch, e al suo interno inseriamo:

  • I valori da utilizzare per inizializzare la comunicazione Modbus tramite porta seriale RS-485, compresi indirizzo di Modbus e baudrate del Finder serie 6M.
  • Gli indirizzi dei registri del Finder serie 6M da cui leggere le misure.
  • Il valore di errore restituito dalla libraria Modbus in caso di errori di lettura.

Il file di configurazione deve avere il seguento contenuto:

// Configurazione
#define ADDRESS 1
#define BAUDRATE 38400
#define PREDELAY 1750
#define POSTDELAY 1750
#define TIMEOUT 1000

// Registri
#define REG_FREQUENCY 204
#define REG_ACTIVE_POWER 196
#define REG_APPARENT_POWER 200
#define REG_ENERGY 208

// Errore di lettura
#define INVALID_DATA 0xFFFFFFFF

Passiamo ora a scrivere lo sketch Opta6MReadExample, che come tutti gli sketch per Arduino sarà composto da una funzione di setup() e una funzione loop():

void setup() {
  // Codice di setup, eseguito all'avvio
}

void loop() {
  // Codice di loop, eseguito all'infinito
}

All'inizio del nostro sketch importiamo le librerie ed i file necessari al funzionamento del programma:

#include <Arduino.h>
#include <ArduinoRS485.h>
#include <ArduinoModbus.h>
#include "finder-6m-read.h"

void setup() {
  // Codice di setup, eseguito all'avvio
}

void loop() {
  // Codice di loop, eseguito all'infinito
}

In particolare abbiamo importato le librerie:

  • Arduino: contiene numerose funzionalità di base per le schede Arduino, ed è quindi buona norma importarla all'inizio di tutti gli sketch.
  • ArduinoRS485: necessaria a inviare e ricevere dati su porta seriale RS-485.
  • ArduinoModbus: implementa il protocollo Modbus.

Inoltre abbiamo importato il file finder-6m-read.h creato in precedenza e contenente le costanti da utilizzare nello sketch.

A questo punto abbiamo tutto il necessario per scrivere la funzione setup(), eseguita una singola volta all'avvio di Finder Opta. Nel nostro caso all'avvio del programma è necessario eseguire le seguenti operazioni:

  • Configurare i parametri di comunicazione seriale, per poter stampare le misure lette sul monitor seriale di Arduino IDE.
  • Configurare la comunicazione Modbus su seriale RS-485, settandone i parametri di configurazione contenuti nelle costanti.

Il codice qui sotto imposta la velocità di trasmissione della comunicazione seriale a 9600 e in seguito configura timeout e delay della comunicazione Modbus. Infine inizializza la comunicazione Modbus con baudrate 38400 e codifica 8N1, come previsto dal Finder serie 6M:

#include <Arduino.h>
#include <ArduinoRS485.h>
#include <ArduinoModbus.h>
#include "finder-6m-read.h"

void setup()
{
    Serial.begin(9600);

    RS485.setDelays(PREDELAY, POSTDELAY);
    ModbusRTUClient.setTimeout(TIMEOUT);
    ModbusRTUClient.begin(BAUDRATE, SERIAL_8N1);
}

void loop() {
  // Codice di loop, eseguito all'infinito
}

Terminato il codice di setup(), passiamo alla funzione di loop(). In questa funzione vogliamo leggere alcune misure contenute nei registri del Finder serie 6M, indicando:

  • Indirizzo di Modbus del Finder serie 6M.
  • Indirizzo del registro da cui iniziare la lettura.
  • Numero di bit da leggere cominciando dall'indirizzo di partenza.

In questo esempio, mostriamo come leggere frequenza, potenza attiva, potenza apparente ed energia dal Finder serie 6M. Tutte queste misure sono rappresentate con 32 bit e abbiamo definito come costanti gli indirizzi degli holding register che le contengono. La cosa più semplice è quindi scrivere una funzione che, dato un indirizzo Modbus ed un registro di partenza legga 32 bit dal dispositivo:

#include <Arduino.h>
#include <ArduinoRS485.h>
#include <ArduinoModbus.h>
#include "finder-6m-read.h"

void setup()
{
    Serial.begin(9600);

    RS485.setDelays(PREDELAY, POSTDELAY);
    ModbusRTUClient.setTimeout(TIMEOUT);
    ModbusRTUClient.begin(BAUDRATE, SERIAL_8N1);
}

void loop() {
  // Codice di loop, eseguito all'infinito
}

uint32_t Modbus6MRead32(uint8_t address, uint16_t reg)
{
    ModbusRTUClient.requestFrom(address, HOLDING_REGISTERS, reg, 2);
    uint32_t data1 = ModbusRTUClient.read();
    uint32_t data2 = ModbusRTUClient.read();
    if (data1 != INVALID_DATA && data2 != INVALID_DATA)
    {
        return data2 << 16 | data1;
    }
    else
    {
        return INVALID_DATA;
    }
}

La funzione Modbus6MRead32() legge dal dispositivo avente indirizzo Modbus address, a partire dal registro reg. Si noti che l'ultimo parametro passato alla funzione requestFrom() è il numero di registri consecutivi da leggere, a partire da reg: essendo ogni registro lungo 16 bit ed ogni misura lunga 32 bit il valore passato è 2. In seguito la funzione verifica che non ci siano errori di lettura ed in caso affermativo combina le due letture da 16 bit nei 32 bit della misura: il primo valore letto viene posto nei 16 bit meno significativi, mentre il secondo valore letto viene posto nei 16 bit più significativi.

Il codice della funzione loop() si limita a chiamare la funzione Modbus6MRead32() passandogli i giusti parametri, ed in seguito stampa le misure su monitor seriale:

#include <Arduino.h>
#include <ArduinoRS485.h>
#include <ArduinoModbus.h>
#include "finder-6m-read.h"

void setup()
{
    Serial.begin(9600);

    RS485.setDelays(PREDELAY, POSTDELAY);
    ModbusRTUClient.setTimeout(TIMEOUT);
    ModbusRTUClient.begin(BAUDRATE, SERIAL_8N1);
}

void loop()
{
    int32_t frequency = Modbus6MRead32(ADDRESS, REG_FREQUENCY);
    int32_t activePower = Modbus6MRead32(ADDRESS, REG_ACTIVE_POWER);
    int32_t apparentPower = Modbus6MRead32(ADDRESS, REG_APPARENT_POWER);
    int32_t energy = Modbus6MRead32(ADDRESS, REG_ENERGY);

    Serial.print("Frequency = " + (frequency != INVALID_DATA ? String(frequency) : String("read error!")));
    Serial.print(", Active power = " + (activePower != INVALID_DATA ? String(activePower) : String("read error!")));
    Serial.print(", Apparent power = " + (apparentPower != INVALID_DATA ? String(apparentPower) : String("read error!")));
    Serial.println(", Energy = " + (energy != INVALID_DATA ? String(energy) : String("read error!")));

    delay(1000);
}

uint32_t Modbus6MRead32(uint8_t address, uint16_t reg)
{
    ModbusRTUClient.requestFrom(address, HOLDING_REGISTERS, reg, 2);
    uint32_t data1 = ModbusRTUClient.read();
    uint32_t data2 = ModbusRTUClient.read();
    if (data1 != INVALID_DATA && data2 != INVALID_DATA)
    {
        return data2 << 16 | data1;
    }
    else
    {
        return INVALID_DATA;
    }
}

A questo punto sul monitor seriale di Arduino IDE dovremmo vedere un output di questo tipo ripetuto una volta al secondo:

Frequency = 4991, Active power = 0, Apparent power = 0, Energy = 0

Configurazione del Finder serie 6M

Nella seconda parte di questo tutorial scriviamo uno sketch che configura il Finder serie 6M, cambiando indirizzo di Modbus del dispositivo. Questo step è particolarmente importante se si desidera utilizzare più di un Finder serie 6M, poichè ciascuno dovrà avere un indirizzo di Modbus diverso e univoco. Il codice completo di questo secondo sketch è disponibile qui. È possibile estrarre il contenuto del file .zip e copiarlo nella cartella ~/Documents/Arduino, o alternativamente creare un nuovo sketch chiamato Opta6MConfigExample utilizzando Arduino IDE ed incollare il codice presente nel tutorial.

Iniziamo scrivendo un file di configurazione contenente alcune costanti da utilizzare nello sketch. In particolare, creeremo un file chiamato finder-6m-config.h all'interno della stessa cartella dello sketch, e al suo interno inseriremo:

  • I valori da utilizzare per inizializzare la comunicazione Modbus tramite porta seriale RS-485, compresi indirizzo di Modbus e baudrate del Finder serie 6M.
  • Gli indirizzi dei registri del Finder serie 6M in cui scrivere i comandi di configurazione.
  • I valori in byte dei comandi di configurazione da mandare al Finder serie 6M.
  • L'indirizzo del Finder serie 6M da cui effettuare una lettura di test, e il valore di errore restituito dal dispositivo in caso di errori.

Il file di configurazione ha il seguento contenuto:

// Configurazione
#define ADDRESS 1
#define BAUDRATE 38400
#define PREDELAY 1750
#define POSTDELAY 1750
#define TIMEOUT 1000

// Registri
#define REG_Modbus_ADDRESS 2
#define REG_BAUDRATE 4
#define REG_FREQUENCY 204
#define REG_COMMAND 251

// Comandi
#define BAUDRATE_CODE_38400 5
#define COMMAND_SAVE 0xC1C0

// Errore di lettura
#define INVALID_DATA 0xFFFFFFFF

Passiamo ora a scrivere lo sketch Opta6MConfigExample, che sarà composto dalla sola funzione di setup(): in questo caso dopo la configurazione non vogliame fare altro e la funzione loop() rimarrà vuota:

void setup() {
  // Codice di setup, eseguito all'avvio
}

void loop() {
  // Non utilizzata
}

All'inizio del nostro sketch importiamo le librerie ed i file necessari al funzionamento del programma:

#include <Arduino.h>
#include <ArduinoRS485.h>
#include <ArduinoModbus.h>
#include "finder-6m-read.h"

void setup() {
  // Codice di setup, eseguito all'avvio
}

void loop() {
  // Non utilizzata
}

In particolare abbiamo importato le stesse librerie dello sketch precendente e il file finder-6m-config.h creato in precedenza e contenente le costanti da utilizzare nello sketch.

A questo punto abbiamo tutto il necessario per scrivere la funzione setup(), eseguita una singola volta all'avvio di Finder Opta. Nel nostro caso all'avvio del programma è necessario eseguire le seguenti operazioni:

  • Configurare i parametri di comunicazione seriale, per poter stampare alcuni messaggi sul monitor seriale di Arduino IDE.
  • Configurare la comunicazione Modbus su seriale RS-485, settandone i parametri di configurazione contenuti nelle costanti.
  • Configurare un indirizzo di Modbus ed un baudrate sul Finder serie 6M, poi stampare dei messaggi di aiuto per l'utente ed attendere che esso segua le istruzioni.

Infatti, una volta che lo sketch avrà configurato indirizzo di Modbus e baudarate sarà necessario spegnere il Finder serie 6M, posizionare gli switch DIP in posizione DOWN e riavviare il dispositivo. La posizione degli switch DIP desiderata è mostrata nella figura sotto, e come specificato nel manuale utente del Finder serie 6M garantisce che il dispositivo utilizzi la configurazione Modbus custom.

DIP switches, custom

Il codice qui sotto esegue alcune delle stesse operazioni viste nello sketch precedente, ma in più si occupa di effettuare alcune scritture sul Finder serie 6M chiamando la funzione Modbus6MWrite16() che scriveremo a breve:

#include <Arduino.h>
#include <ArduinoRS485.h>
#include <ArduinoModbus.h>
#include "finder-6m-config.h"

constexpr uint8_t NEW_ADDRESS = 20;

void setup()
{
    Serial.begin(9600);

    RS485.setDelays(PREDELAY, POSTDELAY);
    ModbusRTUClient.setTimeout(TIMEOUT);
    ModbusRTUClient.begin(BAUDRATE, SERIAL_8N1);

    // Cambia indirizzo Modbus
    Modbus6MWrite16(ADDRESS, REG_Modbus_ADDRESS, NEW_ADDRESS);
    // Imposta baudarate
    Modbus6MWrite16(ADDRESS, REG_BAUDRATE, BAUDRATE_CODE_38400);

    // Salva la configurazione
}

void loop() {
  // Non utilizzata
}

void Modbus6MWrite16(uint8_t address, uint16_t reg, uint16_t value)
{
  // Scrive value nel registro reg del dispositivo con indirizzo address
}

La funzione Modbus6MWrite16() si coccupa di scrivere comandi da 16 bit nel registro indicato del dispositivo con indirizzo Modbus pari ad address:

#include <Arduino.h>
#include <ArduinoRS485.h>
#include <ArduinoModbus.h>
#include "finder-6m-config.h"

constexpr uint8_t NEW_ADDRESS = 20;

void setup()
{
    Serial.begin(9600);

    RS485.setDelays(PREDELAY, POSTDELAY);
    ModbusRTUClient.setTimeout(TIMEOUT);
    ModbusRTUClient.begin(BAUDRATE, SERIAL_8N1);

    // Cambia indirizzo Modbus
    Modbus6MWrite16(ADDRESS, REG_Modbus_ADDRESS, NEW_ADDRESS);
    // Imposta baudarate
    Modbus6MWrite16(ADDRESS, REG_BAUDRATE, BAUDRATE_CODE_38400);

    // Salva la configurazione
}

void loop() {
  // Non utilizzata
}

void Modbus6MWrite16(uint8_t address, uint16_t reg, uint16_t value)
{
    ModbusRTUClient.holdingRegisterWrite(address, reg, value);
}

A questo punto non ci resta che salvare la configurazione mandando un nuovo comando e stampare a terminale le istruzioni per l'utente:

#include <Arduino.h>
#include <ArduinoRS485.h>
#include <ArduinoModbus.h>
#include "finder-6m-config.h"

constexpr uint8_t NEW_ADDRESS = 20;

void setup()
{
    Serial.begin(9600);

    RS485.setDelays(PREDELAY, POSTDELAY);
    ModbusRTUClient.setTimeout(TIMEOUT);
    ModbusRTUClient.begin(BAUDRATE, SERIAL_8N1);

    // Cambia indirizzo Modbus
    Modbus6MWrite16(ADDRESS, REG_Modbus_ADDRESS, NEW_ADDRESS);
    // Imposta baudarate
    Modbus6MWrite16(ADDRESS, REG_BAUDRATE, BAUDRATE_CODE_38400);

    Modbus6MWrite16(ADDRESS, REG_COMMAND, COMMAND_SAVE);
    delay(3000);
    Serial.println("Modbus address has been changed. Please, execute the following steps:");
    Serial.println("1. Power OFF the 6M.");
    Serial.println("2. Set both DIP switches DOWN.");
    Serial.println("3. Power back ON the 6M.");
}

void loop() {
  // Non utilizzata
}

void Modbus6MWrite16(uint8_t address, uint16_t reg, uint16_t toWrite)
{
    ModbusRTUClient.holdingRegisterWrite(address, reg, toWrite);
}

Si noti che, prima di stampare le istruzioni aspettiamo 3 secondi per dare all'utente tempo di collegarsi al monitor seriale di Arduino IDE. L'output mostrato sarà il seguente:

Modbus address has been changed. Please, execute the following steps:
1. Power OFF the 6M.
2. Set both DIP switches DOWN.
3. Power back ON the 6M.

Utilizzo della libreria Finder6M

Per semplificare tutte le operazioni eseguite in questo tutorial, è possibile utilizzare la libreria Finder6M. In questo caso, il codice di setup() del primo sketch diventa molto più semplice, poiché la libreria fornisce funzioni integrate per configurare i parametri Modbus:

#include <Finder6M.h>
#include "finder-6m-read.h"

Finder6M f6m;

void setup()
{
    Serial.begin(38400);

    f6m.init(BAUDRATE);
}

void loop()
{
    // Codice di loop, eseguito all'infinito 
}

Anche il codice nel loop() diventa più semplice, e non è più necessario scrivere funzioni per interagire con i registri, ne conoscere gli indirizzi dei registri:

#include <Finder6M.h>

Finder6M f6m;
constexpr uint8_t ADDRESS = 1;
constexpr uint16_t BAUDRATE = 38400;

void setup()
{
    Serial.begin(38400);

    f6m.init(BAUDRATE);
}

void loop()
{
    int32_t frequency = f6m.getFrequency(ADDRESS);
    int32_t activePower = f6m.getActivePower(ADDRESS);
    int32_t apparentPower = f6m.getApparentPower(ADDRESS);
    int32_t energy = f6m.getEnergy(ADDRESS);

    Serial.println("Frequency = " + (frequency != INVALID_DATA ? String(frequency) : String("read error!")));
    Serial.println("Active power = " + (activePower != INVALID_DATA ? String(activePower) : String("read error!")));
    Serial.println("Apparent power = " + (apparentPower != INVALID_DATA ? String(apparentPower) : String("read error!")));
    Serial.println("Energy = " + (energy != INVALID_DATA ? String(energy) : String("read error!")));

    delay(1000);
}

Si noti inoltre che i valori letti dai registri del Finder serie 6M sono in centesimi, mentre la libreria fornisce direttamente le funzioni per ottenere le misure convertite.

Anche il codice del secondo sketch viene semplificato se si utilizza la libreria Finder6M:

#include <Finder6M.h>

Finder6M f6m;
constexpr uint8_t ADDRESS = 1;
constexpr uint8_t NEW_ADDRESS = 20;
constexpr uint16_t BAUDRATE = 38400;

void setup()
{
    Serial.begin(9600);

    f6m.init();

    f6m.setModbusAddress(NEW_ADDRESS, ADDRESS);
    f6m.setBaudrate(ADDRESS, 38400);

    f6m.saveSettings(ADDRESS);
    delay(5000);
    Serial.println("Modbus address has been changed. Please, execute the following steps:");
    Serial.println("1. Power OFF the 6M.");
    Serial.println("2. Set both DIP switches DOWN.");
    Serial.println("3. Power back ON the 6M.");
}

void loop()
{
    // Non utilizzata
}

In questo caso non è necessario nemmeno conoscere i codici dei comandi da inviare al Finder serie 6M. Per saperne di più sulla libreria, visita la repository ufficiale.

Conclusioni

In questo tutorial abbiamo imparato ad implementare la comunicazione Modbus tramite porta seriale RS-485 tra un Finder Opta ed un analizzatore di rete Finder serie 6M. Attraverso esempi pratici, abbiamo visto come leggere misure e configurare i Finder serie 6M utilizzando Finder Opta. Inoltre, abbiamo presentato la libreria Finder6M per semplificare ulteriormente queste operazioni.

Con le conoscenze acquisite sarà possibile implementare soluzioni di monitoraggio e analisi delle reti industriale, impiegando Finder Opta come fulcro di un sistema composto da multiple analizzatori di rete Finder serie 6M.