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]