DataTransfer, transfer data between systems

Vai all indice del manuale di programmazione

Tipo: Blocco funzione

Libreria LogicLab: eLLabUtyLib

Libreria Codesys: Non disponibile

Questo blocco funzione esegue il trasferimento di un blocco di memoria tra due sistemi in File occore definire lo stream di comunicazione utilizzato (La comunicazione deve essere Full-duplex). L’uscita Linked si attiva quando si è verificata la corretta connessione tra i due sistemi, e per garantire che i due sistemi siano sempre correttamente interconnessi anche se non vi è variazione nei dati da trasmettere viene comunque inviato un pacchetto dati ogni tempo definito in Heartbeat.

Il parametro Timeout definisce il tempo massimo per il trasferimento dei dati, l’invio dei dati si conclude con la ricezione di un acknowledge da parte dell’altro sistema, un ciclo di invio dati e ricezione acknowledge richiede al minimo 2 loop di esecuzione programma. Se dopo l’invio non viene ricevuto acknowledge entro il tempo definito viene generato errore.

L’invio dei dati è automatico sulla variazione di uno qualsiasi dei bytes del buffer di trasmissione, RxDataOk si attiva per un loop ad ogni ricezione dati dall’altro sistema, TxDataSent si attiva per un loop al termine della trasmissione dei dati verso l’altro sistema.

Programma “DataExchange”

E’ disponibile il progetto LogicLab DataExchange (Download) che trasferito su 2 sistemi SlimLine, tramite una pagina web di configurazione permette di realizzare lo scambio dati tra i due sistemi con protocollo UDP. Il sistema server utilizza il FB SysUDPServer mentre il sistema client utilizza il FB SysUDPClient.

Utilizzando LogicLab è possibile modificare il programma secondo le proprie esigenze per permettere la comunicazione con protocollo TCP o utilizzando la comunicazione seriale. L’area di scambio dati può essere ridimensionata a proprio piacere per permettere lo scambio non solo di I/O logici ma anche di valori analogici o altre informazioni.

Descrizione

Enable (BOOL) Comando abilitazione.
SpyOn (BOOL) Se attivo permette di spiare il funzionamento della FB (Vedi articolo).
TXData (BOOL) Se attivato comanda la trasmissione dei dati all’altro sistema. Và resettato su attivazione di TxDataSent.
AutoTxD (BOOL) Se attivo i dati sono inviati automaticamente all’altro sistema su variazione dati in TxDBuffer.
File (eFILEP) Stream di comunicazione con l’altro sistema.
RxDBuffer (PVOID) Indirizzo buffer dove devono essere trasferiti i dati ricevuti.
RxDSize (UDINT) Dimensione buffer dati ricevuti. Deve coincidere con il valore di TxDSize dell’altro sistema.
TxDBuffer (PVOID) Indirizzo buffer dati da inviare. Ad ogni variazione del contenuto del buffer l’intero buffer è inviato all’altro sistema.
TxDSize (UDINT) Dimensione buffer dati da inviare. Deve coincidere con il valore di RxDSize dell’altro sistema.
Heartbeat (REAL) Tempo massimo in cui deve esserci uno scambio dati tra i due sistemi espresso in secondi. Se non vi è variazione nei dati da trasmettere ogni tempo definito il sistema client invia un pacchetto dati. Deve essere definito lo stesso valore in entrambi i sistemi.
Timeout (REAL) Tempo massimo ricezione acknowledge su invio dati espresso in secondi. Se a seguito di un invio dati nel tempo definito non viene ricevuto l’acknowledge si genera errore. Deve essere definito lo stesso valore in entrambi i sistemi.
Connect (BOOL) Comanda la connessione con l’altro sistema.
Linked (BOOL) Si attiva se i due sistemi client e server sono correttamente interconnessi.
Fault (BOOL) Attivo per un loop se errore esecuzione.
RxDataOk (BOOL) Attivo per un loop alla ricezione dati.
TxDataSent (BOOL) Attivo per un loop su alla ricezione dell’acknoledge dati inviati all’altro sistema.
RxPackets (UDINT) Contatore pacchetti ricevuti.
TxPackets (UDINT) Contatore pacchetti trasmessi.
CTime (REAL) Tempo comunicazione (S).
Errors (UDINT) Numero di errori.

Trigger di spy

Se SpyOn attivo è possibile utilizzare la console di spionaggio per verificare il funzionamento della FB. Sono previsti vari livelli di triggers.

Livelli di trigger

Trigger	Descrizione
16#00000001	Tx: Trasmissione dati e/o acknowledge.
16#00000002	Rx: Ricezione dati e/o acknowledge.
16#40000000	Error: Errore esecuzione.

Esempi

Come utilizzare gli esempi.
Nell’esempio è gestito lo scambio dati su di uno stesso sistema utilizzando una connessione UDP in localhost (IP 127.0.0.1).

LogicLab (Ptp114, ST_DataTransfer)

PROGRAM ST_DataTransfer
VAR
    i : UDINT; (* Auxiliary buffer *)
    TimeBf : UDINT; (* Time buffer (mS) *)
    SRxDBuffer : ARRAY[0..15] OF BYTE; (* Rx data buffer (Server) *)
    STxDBuffer : ARRAY[0..7] OF BYTE; (* Tx data buffer (Server) *)
    CRxDBuffer : ARRAY[0..7] OF BYTE; (* Rx data buffer (Client) *)
    CTxDBuffer : ARRAY[0..15] OF BYTE; (* Tx data buffer (Client) *)
    SDataTxfer : DataTransfer; (* Data transfer (Server) *)
    CDataTxfer : DataTransfer; (* Data transfer (Client) *)
    UDPServer : SysUDPServer; (* UDP server *)
    UDPClient : SysUDPClient; (* UDP client *)
END_VAR

// *****************************************************************************
// PROGRAM "ST_DataTransfer"
// *****************************************************************************
// Exchanges data using a localhost UDP connection.
// -----------------------------------------------------------------------------

    // -------------------------------------------------------------------------
    // INITIALIZATIONS
    // -------------------------------------------------------------------------
    // Program initializations.

    IF (SysFirstLoop) THEN

        // Set UDP server parameters.

        UDPServer.FilesArr:=ADR(SDataTxfer.File); //Files array
        UDPServer.LocalAdd:=ADR('0.0.0.0'); //Local address
        UDPServer.LocalPort:=2000; //Local port
        UDPServer.MaxConn:=1; //Accepted connections
        UDPServer.FlushTm:=50; //Flush time (mS)
        UDPServer.LifeTm:=30; //Life time (S)
        UDPServer.RxSize:=TO_UINT(SIZEOF(SRxDBuffer)+16); //Rx buffer size
        UDPServer.TxSize:=TO_UINT(SIZEOF(STxDBuffer)+16); //Tx buffer size

        // Set server data transfer parameters.

        SDataTxfer.Enable:=TRUE; //Enable
        SDataTxfer.SpyOn:=TRUE; //Spy active
        SDataTxfer.AutoTxD:=FALSE; //Auto transmit data
        SDataTxfer.RxDBuffer:=ADR(SRxDBuffer); //Rx data buffer
        SDataTxfer.RxDSize:=SIZEOF(SRxDBuffer); //Rx data size
        SDataTxfer.TxDBuffer:=ADR(STxDBuffer); //Tx data buffer
        SDataTxfer.TxDSize:=SIZEOF(STxDBuffer); //Tx data size
        SDataTxfer.Heartbeat:=2.0; //Heartbeat time (S)
        SDataTxfer.Timeout:=2.0; //Timeout time (S)

        // Set UDP client parameters.

        UDPClient.PeerAdd:=ADR('127.0.0.1'); //Peer address
        UDPClient.PeerPort:=2000; //Peer port
        UDPClient.LocalAdd:=ADR('0.0.0.0'); //Local address
        UDPClient.LocalPort:=0; //Local port
        UDPClient.FlushTm:=50; //Flush time (mS)
        UDPClient.LifeTm:=30; //Life time (S)
        UDPClient.RxSize:=TO_UINT(SIZEOF(CRxDBuffer)+16); //Rx buffer size
        UDPClient.TxSize:=TO_UINT(SIZEOF(CTxDBuffer)+16); //Tx buffer size

        // Set client data transfer parameters.

        CDataTxfer.Enable:=TRUE; //Enable
        CDataTxfer.SpyOn:=TRUE; //Spy active
        CDataTxfer.AutoTxD:=TRUE; //Auto transmit data
        CDataTxfer.RxDBuffer:=ADR(CRxDBuffer); //Rx data buffer
        CDataTxfer.RxDSize:=SIZEOF(CRxDBuffer); //Rx data size
        CDataTxfer.TxDBuffer:=ADR(CTxDBuffer); //Tx data buffer
        CDataTxfer.TxDSize:=SIZEOF(CTxDBuffer); //Tx data size
        CDataTxfer.Heartbeat:=2.0; //Heartbeat time (S)
        CDataTxfer.Timeout:=2.0; //Timeout time (S)
    END_IF;

    // -------------------------------------------------------------------------
    // SERVER TRANSFER MANAGEMENT
    // -------------------------------------------------------------------------
    // Manages the data transfer as server. It sends data on command.

    UDPServer(Enable:=SDataTxfer.Connect); //UDP server management
    SDataTxfer(); //Data transfer

    // At every defined time the data is sent.
    
    IF ((SysTimeGetMs()-TimeBf) > TO_UDINT(T#2s)) THEN
        TimeBf:=SysTimeGetMs(); //Time buffer (mS)
        SDataTxfer.TxData:=TRUE; //Transmit data
    END_IF;

    // When data is acknowledged by client the send command is reset.

    IF (SDataTxfer.TxDataSent) THEN SDataTxfer.TxData:=FALSE; END_IF;

    // -------------------------------------------------------------------------
    // CLIENT TRANSFER MANAGEMENT
    // -------------------------------------------------------------------------
    // Manages the data transfer as client. It sends data automatically when
    // they change.

    UDPClient(Connect:=CDataTxfer.Connect); //UDP client management
    CDataTxfer(File:=UDPClient.File); //Data transfer

// [End of file]

Was this article helpful?

Yes No