Funzioni ed FB per gestione terminale di I/O -------------------------------------------- Sysfopen, file open ^^^^^^^^^^^^^^^^^^^^^^ |image0| +----------+--------------+ | **Type** | **Library** | | | | +==========+==============+ | Function | XTarget_07_0 | +----------+--------------+ Questa funzione permette l'apertura del collegamento tra la risorsa indicata dal parametro **FName**, ed un flusso di dati **stream** da impiegare nelle successive chiamate alle funzioni di I/O. La funzione ritorna il pointer alla risorsa. Se la risorsa indicata è già aperta oppure il nome della risorsa è errato, la funzione ritorna **NULL**. Se si sta aprendo un file su disco per crearlo, accertarsi che il disco sia formattato. Parametri funzione: +-----------------------------------+-----------------------------------+ | **FName** (STRING[20]) | E' il nome della risorsa da | | | utilizzare. | | | | | | | COM0: Serial port COM0 | | | | | | | | | | COM1: Serial port COM1 | | | | COM1 | | | | | | | COM2: Serial port COM2 | | | | | | | | | | PCOMx.y Porta | | | seriale y su | | | modulo | | | periferico | | | con | | | indirizzo x | | | | | | | UDPSKT: UDP socket | | | | | | | TCPSKT: TCP socket | | | | | | | pathname: Percorso | | | completo | | | comprensivo | | | del nome | | | file (es.: | | | 'Storage/myF | | | ile.txt') | +-----------------------------------+-----------------------------------+ | **Mode** (STRING[4]) | Indica il modo in cui la risorsa | | | è aperta: r=read; w=write ; | | | a=append. Per le porte seriali | | | definire 'rw'. Per creare un file | | | su disco, occorre eseguire | | | l'apertura in 'w' o 'a'. | | | | | | L'apertura in 'w' su un file | | | esistente, provoca la | | | cancellazione del contenuto. | | | | | | L'apertura in 'r' o 'w' | | | posizionano l'indicatore di | | | posizione dello stream all'inizio | | | del file, l'apertura in 'a' lo | | | posiziona alla fine. | +-----------------------------------+-----------------------------------+ La funzione ritorna: +-------------+------------------------------+ | **(FILEP)** | Pointer alla risorsa. | | | | | | **NULL:** In caso di errore. | +-------------+------------------------------+ **Codici di errore** In caso di errore la funzione torna con **NULL** e con `SysGetLastError <#FctSysGetLastError>`__ è possibile rilevare il codice di errore. +-----------+---------------------------------------------------+ | 9996100 | Nome risorsa **FName** ha lunghezza errata. | +-----------+---------------------------------------------------+ | 9996110 | Nome risorsa **FName** ha lunghezza errata. | +-----------+---------------------------------------------------+ | 9996200~2 | Impossibile utilizzare porta da programma utente. | +-----------+---------------------------------------------------+ | 9996990 | Non implementata nel simulatore. | +-----------+---------------------------------------------------+ **Esempi** """""""""""""" Viene aperta la porta seriale in read/write. +------------------------------------------------------------+ | **Definizione variabili** | +------------------------------------------------------------+ | |image1| | +------------------------------------------------------------+ **Esempio LD** 1\ |image2| **Esempio ST** *(PTP116A100, ST_Sysfopen)* .. code-block:: none IF (Fp = NULL) THEN Fp:=Sysfopen('COM0', 'rw'); (\* Port COM0 file pointer \*) END_IF; SysFIsOpen, get the file open status ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |image3| +----------+--------------+ | **Type** | **Library** | | | | +----------+--------------+ | Function | XTarget_12_0 | +----------+--------------+ Questa funzione controlla se File è aperto. La funzione ritorna TRUE se file aperto. Parametri funzione: +-----------------------------------+-----------------------------------+ | **File** (FILEP) | Flusso dati **stream** ritornato | | | dalla funzione **Sysfopen**. | +-----------------------------------+-----------------------------------+ La funzione ritorna: +-----------------------------------+-----------------------------------+ | (BOOL) | **FALSE**: File non corretto (Può | | | essere **NULL**) o chiuso. | | | **TRUE**: File aperto. | +-----------------------------------+-----------------------------------+ **Codici di errore** In caso di errore la funzione torna con **FALSE** e con `SysGetLastError <#FctSysGetLastError>`__ è possibile rilevare il codice di errore. +---------+----------------------------------+ | 9973990 | Non implementata nel simulatore. | +---------+----------------------------------+ **Esempi** """""""""""""" Viene aperta e successivamente chiusa la porta seriale **COM0**. Se la porta è correttamente chiusa viene attivata l'uscita **Do01M00**. +--------------------------------------------------------------------------+ | **Definizione variabili** | +--------------------------------------------------------------------------+ | |image4| | +--------------------------------------------------------------------------+ **Esempio ST** *(PTP116B000, ST_SysFIsOpen)* .. code-block:: none (\* Here the COM0 port is opened in read/write. \*) IF (Fp = NULL) THEN Fp:=Sysfopen('COM0', 'rw'); END_IF; (\* Here the COM0 port is closed. \*) IF (SysFIsOpen(Fp)) THEN Do01M00:=(Sysfclose(Fp) <> EOF); (\* Output is set if port is closed \*) END_IF; Sysfclose, file close ^^^^^^^^^^^^^^^^^^^^^^^^ |image5| +----------+--------------+ | **Type** | **Library** | | | | +==========+==============+ | Function | XTarget_07_0 | +----------+--------------+ Questa funzione permette la chiusura del collegamento alla risorsa indicata dal parametro **File**, precedentemente aperto dalla funzione `Sysfopen <#sysfopen-file-open>`__. In caso di errore chiusura, la funzione ritorna **EOF**. Parametri funzione: +-----------------------------------+-----------------------------------+ | **File** (FILEP) | Flusso dati **stream** ritornato | | | dalla funzione **Sysfopen**. | +-----------------------------------+-----------------------------------+ La funzione ritorna: +-------+--------------------------------+ | (INT) | **0:** Se esecuzione corretta. | | | | | | **EOF:** In caso di errore. | +-------+--------------------------------+ **Codici di errore** In caso di errore la funzione torna con **EOF** e con `SysGetLastError <#FctSysGetLastError>`__ è possibile rilevare il codice di errore. +---------+---------------------------------------------+ | 9973100 | Funzione usata in task diversa da **Back**. | +---------+---------------------------------------------+ | 9973200 | Errore nella chiusura della risorsa. | +---------+---------------------------------------------+ | 9973990 | Non implementata nel simulatore. | +---------+---------------------------------------------+ **Esempi** """""""""""""" Viene aperta e successivamente chiusa la porta seriale **COM0**. Se la porta è correttamente aperta viene attivata l'uscita **Do00M00**. Se la porta è correttamente chiusa viene attivata l'uscita **Do01M00**. +--------------------------------------------------------------------------+ | **Definizione variabili** | +--------------------------------------------------------------------------+ | |image6| | +--------------------------------------------------------------------------+ **Esempio ST** *(PTP116A100, ST_Sysfclose)* .. code-block:: none (\* Here the COM0 port is opened in read/write. \*) IF (Fp = NULL) THEN Fp:=Sysfopen('COM0', 'rw'); (\* Port COM0 file pointer \*) Do00M00:=(Fp <> NULL); (\* Output is set if port is opened \*) END_IF; (\* Here the COM0 port is closed. \*) IF (Fp <> NULL) THEN Do01M00:=(Sysfclose(Fp) <> EOF); (\* Output is set if port is closed \*) END_IF; Sysfgetc, get character from file ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |image7| +----------+--------------+ | **Type** | **Library** | | | | +----------+--------------+ | Function | XTarget_07_0 | +----------+--------------+ Questa funzione ritorna un carattere dal flusso dati **stream** indicato dal parametro **File**, precedentemente aperto dalla funzione `Sysfopen <#sysfopen-file-open>`__. La funzione ritorna il carattere letto dallo stream. In caso di errore o se nessun dato dallo stream, la funzione ritorna **EOF**. Per essere certi che vi siano caratteri dallo stream è possibile utilizzare la funzione `SysGetIChars <#FCtSysGetIChars>`__ che ne ritorna il numero. Parametri funzione: +-----------------------------------+-----------------------------------+ | **File** (FILEP) | Flusso dati **stream** ritornato | | | dalla funzione **Sysfopen**. | +-----------------------------------+-----------------------------------+ La funzione ritorna: +-------+-----------------------------------------------------------+ | (INT) | Carattere letto dal flusso di dati. | | | | | | **EOF:** In caso di errore o se nessun dato dallo stream. | +-------+-----------------------------------------------------------+ **Codici di errore** In caso di errore la funzione torna con **EOF** e con `SysGetLastError <#FctSysGetLastError>`__ è possibile rilevare il codice di errore. +---------+---------------------------------------------+ | 9972100 | Funzione usata in task diversa da **Back**. | +---------+---------------------------------------------+ | 9972990 | Non implementata nel simulatore. | +---------+---------------------------------------------+ **Esempi** """""""""""""" Viene eseguita apertura porta seriale **COM0** e controllato se caratteri disponibili dalla porta. Se almeno un carattere è disponibile ne viene eseguita lettura ed il carattere letto è trasferito nella variabile **Ch**. +-----------------------------------------------------------------------+ | **Definizione variabili** | +-----------------------------------------------------------------------+ | |image8| | +-----------------------------------------------------------------------+ **Esempio ST** *(PTP116A100, ST_Sysfgetc)* .. code-block:: none (\* Here the COM0 port is opened in read/write. \*) IF (Fp = NULL) THEN Fp:=Sysfopen('COM0', 'rw'); (\* Port COM0 file pointer \*) END_IF; (\* Here check if a character is available from port and read it. \*) IF (Fp <> NULL) THEN IF (TO_BOOL(SysGetIChars(Fp))) THEN Ch:=Sysfgetc(Fp); (\* Get input character \*) END_IF; END_IF; Sysfputc, put character to file ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |image9| +----------+--------------+ | **Type** | **Library** | | | | +----------+--------------+ | Function | XTarget_07_0 | +----------+--------------+ Questa funzione invia un carattere sul flusso dati **stream** indicato dal parametro **File**, precedentemente aperto dalla funzione `Sysfopen <#sysfopen-file-open>`__. La funzione ritorna il carattere scritto sullo stream. In caso di errore o se lo stream non accetta il dato, la funzione ritorna EOF. Per essere certi che vi sia spazio sullo stream per accettare il carattere, è possibile utilizzare la funzione `SysGetOSpace <#FctSysGetOSpace>`__ che ritorna lo spazio disponibile. Parametri funzione: +-----------------------------------+-----------------------------------+ | **Ch** (INT) | Carattere da inviare sul flusso | | | dati. | +-----------------------------------+-----------------------------------+ | **File (FILEP)** | Flusso dati **stream** ritornato | | | dalla funzione **Sysfopen**. | +-----------------------------------+-----------------------------------+ La funzione ritorna: +-----------------------------------+-----------------------------------+ | (INT) | Carattere scritto sul flusso di | | | dati. **EOF:** In caso di errore | | | o se lo stream non accetta il | | | dato. | +-----------------------------------+-----------------------------------+ **Codici di errore** In caso di errore la funzione torna con **EOF** e con `SysGetLastError <#FctSysGetLastError>`__ è possibile rilevare il codice di errore. +---------+---------------------------------------------+ | 9971100 | Funzione usata in task diversa da **Back**. | +---------+---------------------------------------------+ | 9971990 | Non implementata nel simulatore. | +---------+---------------------------------------------+ **Esempi** """""""""""""" E' riportato un semplice programma che esegue l'eco dei caratteri ricevuti dalla porta seriale **COM0**. Viene eseguita apertura porta seriale **COM0** e controllato se caratteri disponibili dalla porta. Se almeno un carattere è disponibile ne viene eseguita lettura e successiva ritrasmissione. +---------------------------------------------------------------------+ | **Definizione variabili** | +---------------------------------------------------------------------+ | |image10| | +---------------------------------------------------------------------+ **Esempio ST** *(PTP116A100, ST_Sysfputc)* .. code-block:: none (\* Here the COM0 port is opened in read/write. \*) IF (Fp = NULL) THEN Fp:=Sysfopen('COM0', 'rw'); (\* Port COM0 file pointer \*) END_IF; (\* Here execute the received characters echo. \*) IF (Fp <> NULL) THEN IF (TO_BOOL(SysGetIChars(Fp))) AND (TO_BOOL(SysGetOSpace(Fp))) THEN Ch:=Sysfgetc(Fp); (\* Get input character \*) Ch:=Sysfputc(Ch, Fp); (\* Put input character \*) END_IF; END_IF; Utilizzando le funzioni di gestione terminale di I/O è possibile realizzare un semplice programma che esegue l'echo del carattere ricevuto dalla porta seriale **COM0**. La porta viene aperta con ed impostata a 19200 e, 8, 1. Tutti i caratteri ricevuti dalla porta sono ritrasmessi. +------------------------------------------------+ | **Definizione variabili** | +------------------------------------------------+ | |image11| | +------------------------------------------------+ | **Esempio FBD** *(PTP119B000, FBD_SerialEcho)* | +------------------------------------------------+ | |image12| | +------------------------------------------------+ Sysfread, read data from file ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |image13| +----------+--------------+ | **Type** | **Library** | | | | +----------+--------------+ | Function | XTarget_07_0 | +----------+--------------+ Questa funzione esegue la lettura di un numero definito di stringhe di lunghezza definita dal flusso dati **stream** indicato dal parametro **File**, precedentemente aperto dalla funzione `Sysfopen <#sysfopen-file-open>`__. La funzione ritorna il numero di stringhe dati lette. Se nello **stream** non ci sono abbastanza stringhe da soddisfare i parametri, viene ritornato un numero minore di stringhe lette rispetto al valore definito. Parametri funzione: +-----------------------------------+-----------------------------------+ | **Buf** (@STRING) | Indirizzo della stringa dove | | | trasferire le stringhe lette. | +-----------------------------------+-----------------------------------+ | **Size** (INT) | Lunghezza in caratteri delle | | | stringhe da leggere. | +-----------------------------------+-----------------------------------+ | **Count** (INT) | Numero di stringhe da leggere. | +-----------------------------------+-----------------------------------+ | **File** (FILEP) | Flusso dati **stream** ritornato | | | dalla funzione | | | `Sysfopen <#sysfopen-file-open>`_ | | | _. | +-----------------------------------+-----------------------------------+ La funzione ritorna: +-----------------------------------+-----------------------------------+ | (INT) | Numero di stringhe lette, se il | | | valore ritornato è minore di | | | **Count**, significa che non vi | | | erano abbastanza dati nello | | | stream. | +-----------------------------------+-----------------------------------+ **Codici di errore** In caso di errore la funzione torna con **0** e con `SysGetLastError <#FctSysGetLastError>`__ è possibile rilevare il codice di errore. +---------+---------------------------------------------+ | 9970100 | Funzione usata in task diversa da **Back**. | +---------+---------------------------------------------+ | 9970990 | Non implementata nel simulatore. | +---------+---------------------------------------------+ **Esempi** """""""""""""" Vengono attesi almeno 5 caratteri ricevuti dalla porta seriale e quando ricevuti viene letta una stringa di 5 caratteri (5 stringhe di 1 carattere), la stringa letta è trasferita nella variabile **RxString**. La stringa letta viene poi ritrasmessa sulla porta seriale, notare come anche nella trasmissione è trasmessa una stringa di 5 caratteri (1 stringa di 5 caratteri) . +-----------------------------------------------------------------------+ | **Definizione variabili** | +-----------------------------------------------------------------------+ | |image15| | +-----------------------------------------------------------------------+ **Esempio ST** *(PTP116A100, ST_Sysfread)* .. code-block:: none (\* Here the COM0 port is opened in read/write. \*) IF (Fp = NULL) THEN Fp:=Sysfopen('COM0', 'rw'); (\* Port COM0 file pointer \*) END_IF; (\* Here wait until at least 5 chars are received and echoes them. \*) IF (Fp <> NULL) THEN IF (SysGetIChars(Fp) >= 5) THEN RxChars:=Sysfread(ADR(RxString), 1, 5, Fp); (\* Received characters \*) TxChars:=Sysfwrite(ADR(RxString), 5, 1, Fp); (\* Transmitted characters \*) END_IF; END_IF; Sysfwrite, write data to file ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |image16| +----------+--------------+ | **Type** | **Library** | | | | +----------+--------------+ | Function | XTarget_07_0 | +----------+--------------+ Questa funzione esegue la scrittura di un numero definito di stringhe di lunghezza definita nel flusso dati **stream** indicato dal parametro **File**, precedentemente aperto dalla funzione `Sysfopen <#sysfopen-file-open>`__. La funzione ritorna il numero di stringhe dati scritte. Se nello stream non c'è abbastanza spazio per contenere il numero di stringhe definito, viene ritornato un numero minore di stringhe scritte rispetto al valore definito. Parametri funzione: +-----------------------------------+-----------------------------------+ | **Buf** (@STRING) | Indirizzo della stringa da | | | scrivere. | +-----------------------------------+-----------------------------------+ | **Size** (INT) | Lunghezza in caratteri delle | | | stringhe da scrivere. | +-----------------------------------+-----------------------------------+ | **Count** (INT) | Numero di stringhe da scrivere. | +-----------------------------------+-----------------------------------+ | **File** (FILEP) | Flusso dati **stream** ritornato | | | dalla funzione | | | `Sysfopen <#sysfopen-file-open>`_ | | | _. | +-----------------------------------+-----------------------------------+ La funzione ritorna: +-----------------------------------+-----------------------------------+ | (INT) | Numero di stringhe scritte, se | | | valore ritornato minore di | | | **Count**, non vi era abbastanza | | | spazio nello stream. | +-----------------------------------+-----------------------------------+ **Codici di errore** In caso di errore la funzione torna con **0** e con `SysGetLastError <#FctSysGetLastError>`__ è possibile rilevare il codice di errore. +---------+---------------------------------------------+ | 9969100 | Funzione usata in task diversa da **Back**. | +---------+---------------------------------------------+ | 9969990 | Non implementata nel simulatore. | +---------+---------------------------------------------+ **Esempi** """""""""""""" Vengono attesi almeno 5 caratteri ricevuti dalla porta seriale e quando ricevuti viene letta una stringa di 5 caratteri (5 stringhe di 1 carattere), la stringa letta è trasferita nella variabile **RxString**. La stringa letta viene poi ritrasmessa sulla porta seriale, notare come anche nella trasmissione è trasmessa una stringa di 5 caratteri (1 stringa di 5 caratteri) . +-----------------------------------------------------------------------+ | **Definizione variabili** | +-----------------------------------------------------------------------+ | |image18| | +-----------------------------------------------------------------------+ **Esempio ST** .. code-block:: none (\* Here the COM0 port is opened in read/write. \*) IF (Fp = NULL) THEN Fp:=Sysfopen('COM0', 'rw'); (\* Port COM0 file pointer \*) END_IF; (\* Here wait until at least 5 chars are received and echoes them. \*) IF (Fp <> NULL) THEN IF (SysGetIChars(Fp) >= 5) THEN RxChars:=Sysfread(ADR(RxString), 1, 5, Fp); (\* Received characters \*) TxChars:=Sysfwrite(ADR(RxString), 5, 1, Fp); (\* Transmitted characters \*) END_IF; END_IF; SysFGetIChars, get input available characters from file ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |image19| +-----------------------+-----------------------+ | **Type** | **Library** | | | | +=======================+=======================+ | Function | XTarget_12_0 | +-----------------------+-----------------------+ **Alias della funzione SysGetIChars.** Questa funzione ritorna il numero di caratteri disponibili per la lettura dal flusso dati **stream** indicato dal parametro **File**, precedentemente aperto dalla funzione `Sysfopen <#sysfopen-file-open>`__. Se il valore ritornato è diverso da **0** i caratteri potranno essere letti con la funzione `Sysfgetc <#sysfgetc-get-character-from-file>`__. Parametri funzione: +-----------------------------------+-----------------------------------+ | **File** (FILEP) | Flusso dati **stream** ritornato | | | dalla funzione | | | `Sysfopen <#sysfopen-file-open>`_ | | | _. | +-----------------------------------+-----------------------------------+ La funzione ritorna: +-------+--------------------------------------------------+ | (INT) | Numero di caratteri disponibili dal flusso dati. | +-------+--------------------------------------------------+ **Codici di errore** In caso di errore la funzione torna con **0** e con `SysGetLastError <#FctSysGetLastError>`__ è possibile rilevare il codice di errore. +---------+---------------------------------------------+ | 9968100 | Funzione usata in task diversa da **Back**. | +---------+---------------------------------------------+ | 9968990 | Non implementata nel simulatore. | +---------+---------------------------------------------+ **Esempi** """""""""""""" E' riportato un semplice programma che esegue l'eco dei caratteri ricevuti dalla porta seriale **COM0**. Viene eseguita apertura porta seriale **COM0** e controllato se caratteri disponibili dalla porta. Se almeno un carattere è disponibile ne viene eseguita lettura e successiva ritrasmissione. +---------------------------------------------------------------------+ | **Definizione variabili** | +---------------------------------------------------------------------+ | |image20| | +---------------------------------------------------------------------+ **Esempio ST** .. code-block:: none (\* Here the COM0 port is opened in read/write. \*) IF (Fp = NULL) THEN Fp:=Sysfopen('COM0', 'rw'); (\* Port COM0 file pointer \*) END_IF; (\* Here execute the received characters echo. \*) IF (Fp <> NULL) THEN IF (TO_BOOL(SysGetIChars(Fp))) AND (TO_BOOL(SysGetOSpace(Fp))) THEN Ch:=Sysfgetc(Fp); (\* Get input character \*) Ch:=Sysfputc(Ch, Fp); (\* Put input character \*) END_IF; END_IF; SysFGetOSpace, get output available space on file ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |image21| +-----------------------+-----------------------+ | **Type** | **Library** | | | | | | | +=======================+=======================+ | Function | XTarget_12_0 | +-----------------------+-----------------------+ **Alias della funzione SysGetOSpace.** Questa funzione ritorna lo spazio disponibile per la scrittura dati sul flusso dati **stream** indicato dal parametro **File**, precedentemente aperto dalla funzione `Sysfopen <#sysfopen-file-open>`__. Se il valore ritornato è diverso da **0** i caratteri potranno essere scritti con la funzione `Sysfputc <#sysfputc-put-character-to-file>`__. Parametri funzione: +-----------------------------------+-----------------------------------+ | **File** (FILEP) | Flusso dati **stream** ritornato | | | dalla funzione | | | `Sysfopen <#sysfopen-file-open>`_ | | | _. | +-----------------------------------+-----------------------------------+ La funzione ritorna: +-----------------------------------+-----------------------------------+ | (INT) | Spazio disponibile sul flusso | | | dati per trasferire caratteri. | | | | | | Se buffer vuoto viene ritornata | | | la dimensione del buffer di | | | trasmissione. | +-----------------------------------+-----------------------------------+ **Codici di errore** In caso di errore la funzione torna con **0** e con `SysGetLastError <#FctSysGetLastError>`__ è possibile rilevare il codice di errore. +---------+---------------------------------------------+ | 9967100 | Funzione usata in task diversa da **Back**. | +---------+---------------------------------------------+ | 9967990 | Non implementata nel simulatore. | +---------+---------------------------------------------+ **Esempi** """""""""""""" E' riportato un semplice programma che esegue l'eco dei caratteri ricevuti dalla porta seriale **COM0**. Viene eseguita apertura porta seriale **COM0** e controllato se caratteri disponibili dalla porta. Se almeno un carattere è disponibile ne viene eseguita lettura e successiva ritrasmissione. +---------------------------------------------------------------------+ | **Definizione variabili** | +---------------------------------------------------------------------+ | |image22| | +---------------------------------------------------------------------+ **Esempio ST** .. code-block:: none (\* Here the COM0 port is opened in read/write. \*) IF (Fp = NULL) THEN Fp:=Sysfopen('COM0', 'rw'); (\* Port COM0 file pointer \*) END_IF; (\* Here execute the received characters echo. \*) IF (Fp <> NULL) THEN IF (TO_BOOL(SysGetIChars(Fp))) AND (TO_BOOL(SysGetOSpace(Fp))) THEN Ch:=Sysfgetc(Fp); (\* Get input character \*) Ch:=Sysfputc(Ch, Fp); (\* Put input character \*) END_IF; END_IF; SysFGetIBfSize, get file Rx input buffer size ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |image23| +----------+--------------+ | **Type** | **Library** | | | | | | | +==========+==============+ | Function | XTarget_12_0 | +----------+--------------+ **Alias della funzione SysGetRxBSize.** Questa funzione ritorna la dimensione del buffer di input (Ricezione) sul flusso dati **stream** indicato dal parametro **File**, precedentemente aperto dalla funzione `Sysfopen <#sysfopen-file-open>`__. Parametri funzione: +-----------------------------------+-----------------------------------+ | **File** (FILEP) | Flusso dati **stream** ritornato | | | dalla funzione **Sysfopen**. | +-----------------------------------+-----------------------------------+ La funzione ritorna: +-----------------------------------+-----------------------------------+ | (UDINT) | Dimensione buffer di input | | | espressa in numero di caratteri | | | (Bytes). | +-----------------------------------+-----------------------------------+ **Codici di errore** In caso di errore la funzione torna con **0** e con `SysGetLastError <#FctSysGetLastError>`__ è possibile rilevare il codice di errore. +---------+---------------------------------------------+ | 9966100 | Funzione usata in task diversa da **Back**. | +---------+---------------------------------------------+ | 9966990 | Non implementata nel simulatore. | +---------+---------------------------------------------+ **Esempi** """""""""""""" E' riportato un semplice programma che ritorna la dimensione del buffer di input (Ricezione) della porta seriale **COM2**. Il valore ritornato espresso in numero di caratteri (Bytes), è trasferito nella variabile **Space**. +---------------------------+ | **Definizione variabili** | +---------------------------+ | |image24| | +---------------------------+ **Esempio LD** |image25| SysFGetOBfSize, get file Tx output buffer size ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |image26| +-----------------------+-----------------------+ | **Type** | **Library** | | | | | | | | | | +=======================+=======================+ | Function | XTarget_12_0 | +-----------------------+-----------------------+ **Alias della funzione SysGetTxBSize.** Questa funzione ritorna la dimensione del buffer di output (Trasmissione) sul flusso dati **stream** indicato dal parametro **File**, precedentemente aperto dalla funzione `Sysfopen <#sysfopen-file-open>`__. Parametri funzione: +-----------------------------------+-----------------------------------+ | **File** (FILEP) | Flusso dati **stream** ritornato | | | dalla funzione **Sysfopen**. | +-----------------------------------+-----------------------------------+ La funzione ritorna: +-----------------------------------+-----------------------------------+ | (UDINT) | Dimensione buffer di output | | | espressa in numero di caratteri | | | (Bytes). | +-----------------------------------+-----------------------------------+ **Codici di errore** In caso di errore la funzione torna con **0** e con `SysGetLastError <#FctSysGetLastError>`__ è possibile rilevare il codice di errore. +---------+---------------------------------------------+ | 9965100 | Funzione usata in task diversa da **Back**. | +---------+---------------------------------------------+ | 9965990 | Non implementata nel simulatore. | +---------+---------------------------------------------+ **Esempi** """""""""""""" E' riportato un semplice programma che ritorna la dimensione del buffer di output (Trasmissione) della porta seriale **COM2**. Il valore ritornato espresso in numero di caratteri (Bytes), è trasferito nella variabile **Space**. +---------------------------+ | **Definizione variabili** | +---------------------------+ | |image27| | +---------------------------+ **Esempio LD** |image28| SysFIBfClear, file input buffer clear ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |image29| +----------+--------------+ | **Type** | **Library** | | | | +----------+--------------+ | Function | XTarget_07_0 | +----------+--------------+ Questa funzione elimina tutti i caratteri in lettura presenti sul flusso dati **stream** indicato dal parametro **File**, precedentemente aperto dalla funzione `Sysfopen <#sysfopen-file-open>`__. La funzione ritorna **FALSE** in caso di errore. Parametri funzione: +-----------------------------------+-----------------------------------+ | **File** (FILEP) | Flusso dati **stream** ritornato | | | dalla funzione **Sysfopen**. | +-----------------------------------+-----------------------------------+ La funzione ritorna: +--------+--------------------------------------------+ | (BOOL) | **FALSE:** Errore esecuzione. | | | | | | **TRUE:** Funzione eseguita correttamente. | +--------+--------------------------------------------+ **Codici di errore** In caso di errore la funzione torna **FALSE** e con `SysGetLastError <#FctSysGetLastError>`__ è possibile rilevare il codice di errore. +---------+---------------------------------------------+ | 9964100 | Funzione usata in task diversa da **Back**. | +---------+---------------------------------------------+ | 9964990 | Non implementata nel simulatore. | +---------+---------------------------------------------+ **Esempi** """""""""""""" Se è attivo l'ingresso **Di00M00** tutti i caratteri in ingresso dalla porta seriale saranno cancellati e l'uscita **Do00M00** attivata. +-------------------------------------------------------------+ | **Definizione variabili** | +-------------------------------------------------------------+ | |image30| | +-------------------------------------------------------------+ **Esempio ST** .. code-block:: none (\* Here the COM0 port is opened in read/write. \*) IF (Fp = NULL) THEN Fp:=Sysfopen('COM0', 'rw'); (\* Port COM0 file pointer \*) END_IF; (\* If the input is active the input buffer is cleared. \*) IF (Fp <> NULL) THEN IF (Di00M00) THEN Do00M00:=SysFIBfClear(Fp); END_IF; END_IF; SysFOBfClear, file output buffer clear ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |image31| +----------+--------------+ | **Type** | **Library** | | | | +----------+--------------+ | Function | XTarget_07_0 | +----------+--------------+ Questa funzione elimina tutti i caratteri in uscita presenti sul flusso dati **stream** indicato dal parametro **File**, precedentemente aperto dalla funzione `Sysfopen <#sysfopen-file-open>`__. La funzione ritorna **FALSE** in caso di errore. Parametri funzione: +-----------------------------------+-----------------------------------+ | **File** (FILEP) | Flusso dati **stream** ritornato | | | dalla funzione **Sysfopen**. | +-----------------------------------+-----------------------------------+ La funzione ritorna: +--------+--------------------------------------------+ | (BOOL) | **FALSE:** Errore esecuzione. | | | | | | **TRUE:** Funzione eseguita correttamente. | +--------+--------------------------------------------+ **Codici di errore** In caso di errore la funzione torna **FALSE** e con `SysGetLastError <#FctSysGetLastError>`__ è possibile rilevare il codice di errore. +---------+---------------------------------------------+ | 9963100 | Funzione usata in task diversa da **Back**. | +---------+---------------------------------------------+ | 9963990 | Non implementata nel simulatore. | +---------+---------------------------------------------+ **Esempi** """""""""""""" Se è attivo l'ingresso **Di00M00** tutti i caratteri in uscita dalla porta seriale saranno cancellati e l'uscita **Do00M00** attivata. +-------------------------------------------------------------+ | **Definizione variabili** | +-------------------------------------------------------------+ | |image32| | +-------------------------------------------------------------+ **Esempio ST** .. code-block:: none (\* Here the COM0 port is opened in read/write. \*) IF (Fp = NULL) THEN Fp:=Sysfopen('COM0', 'rw'); (\* Port COM0 file pointer \*) END_IF; (\* If the input is active the ouput buffer is cleared. \*) IF (Fp <> NULL) THEN IF (Di00M00) THEN Do00M00:=SysFOBfClear(Fp); END_IF; END_IF; SysFOBfFlush, file output buffer flush ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |image33| +----------+--------------+ | **Type** | **Library** | | | | +----------+--------------+ | Function | XTarget_07_0 | +----------+--------------+ Questa funzione forza l'uscita immediata dei caratteri presenti sul flusso dati **stream** indicato dal parametro **File**, precedentemente aperto dalla funzione `Sysfopen <#sysfopen-file-open>`__, sulla risorsa connessa. La funzione ritorna **FALSE** in caso di errore. Parametri funzione: +-----------------------------------+-----------------------------------+ | **File** (FILEP) | Flusso dati **stream** ritornato | | | dalla funzione **Sysfopen**. | +-----------------------------------+-----------------------------------+ La funzione ritorna: +--------+--------------------------------------------+ | (BOOL) | **FALSE:** Errore esecuzione. | | | | | | **TRUE:** Funzione eseguita correttamente. | +--------+--------------------------------------------+ **Codici di errore** In caso di errore la funzione torna **FALSE** e con `SysGetLastError <#FctSysGetLastError>`__ è possibile rilevare il codice di errore. +---------+---------------------------------------------+ | 9962100 | Funzione usata in task diversa da **Back**. | +---------+---------------------------------------------+ | 9962990 | Non implementata nel simulatore. | +---------+---------------------------------------------+ **Esempi** """""""""""""" Se è attivo l'ingresso **Di00M00** tutti i caratteri presenti nel buffer di uscita della porta seriale saranno trasmessi e l'uscita **Do00M00** attivata. +-------------------------------------------------------------+ | **Definizione variabili** | +-------------------------------------------------------------+ | |image34| | +-------------------------------------------------------------+ **Esempio ST** .. code-block:: none (\* Here the COM0 port is opened in read/write. \*) IF (Fp = NULL) THEN Fp:=Sysfopen('COM0', 'rw'); (\* Port COM0 file pointer \*) END_IF; (\* If the input is active the ouput buffer is cleared. \*) IF (Fp <> NULL) THEN IF (Di00M00) THEN Do00M00:=SysFOBfFlush(Fp); END_IF; END_IF; SysVarfprintf, variable print to file ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |image35| +----------+--------------+ | **Type** | **Library** | | | | +----------+--------------+ | Function | XTarget_07_0 | +----------+--------------+ Questa funzione esegue la stampa formattata di una variabile sullo stream collegato al parametro **File**, precedentemente aperto dalla funzione `Sysfopen <#sysfopen-file-open>`__. La stringa **Format** specifica il formato con il quale stampare la variabile. Mentre in **VarType** è indicato il tipo di variabile ed in **VarAdd** il suo indirizzo. La funzione ritorna il numero di caratteri trasferiti nello stream, **EOF** in caso di errore. Parametri funzione: +-----------------------------------+-----------------------------------+ | **File** (FILEP) | Flusso dati **stream** ritornato | | | dalla funzione **Sysfopen**. | +-----------------------------------+-----------------------------------+ | **Format** (STRING[80]) | Ha due tipi di argomenti, i | | | caratteri ordinari che vengono | | | copiati nello stream di uscita, e | | | le specifiche di conversione, | | | contraddistinte dal simbolo | | | percentuale (%) e da un carattere | | | che specifica il formato con il | | | quale stampare la variabile | | | definita. | +-----------------------------------+-----------------------------------+ | **VarType** (USINT) | Tipo variabile, come indicato | | | nella tabella `Variable types | | | definition <#TabVarTypeDefs>`__. | +-----------------------------------+-----------------------------------+ | **VarAdd** (UDINT) | Indirizzo variabile. | +-----------------------------------+-----------------------------------+ La funzione ritorna: +-----------------------------------+-----------------------------------+ | (INT) | Numero di caratteri trasferiti | | | nello stream. **EOF:** Errore | | | esecuzione. | +-----------------------------------+-----------------------------------+ **Codici di errore** In caso di errore la funzione torna con **EOF** e con `SysGetLastError <#FctSysGetLastError>`__ è possibile rilevare il codice di errore. +---------+------------------------------------------------------+ | 9998010 | Valore di **File** non definito. | +---------+------------------------------------------------------+ | 9968100 | Funzione usata in task diversa da **Back**. | +---------+------------------------------------------------------+ | 9998200 | Tipo variabile non gestito, controllare **VarType**. | +---------+------------------------------------------------------+ | 9998990 | Non implementata nel simulatore. | +---------+------------------------------------------------------+ **Esempi** """""""""""""" Su fronte attivazione ingresso **Di00M00** viene incrementata la variabile **Counter** ed il suo valore inviato sulla porta seriale **COM0**. Nella variabile **NrOfChars** viene caricato il numero di caratteri inviati in uscita sulla porta seriale. +-----------------------------------------------------------------------+ | **Definizione variabili** | +-----------------------------------------------------------------------+ | |image37| | +-----------------------------------------------------------------------+ **Esempio ST** *(PTP116A300, ST_SysVarfprintf)* .. code-block:: none (\* Here the COM0 port is opened in read/write. \*) IF (Fp = NULL) THEN Fp:=Sysfopen('COM0', 'rw'); END_IF; IF (Fp <> NULL) THEN IF (Di00M00 <> Pulse) THEN Pulse:=Di00M00; (\* Pulse flag \*) IF (Di00M00) THEN Counter:=Counter+1; (\* Counter \*) NrOfChars:=SysVarfprintf(Fp, 'Counter:%04d$r$n', UDINT_TYPE, ADR(Counter)); END_IF; END_IF; END_IF; .. |image0| image:: media/image1.jpg :width: 1.46875in :height: 0.66528in .. |image1| image:: media/image2.jpg :width: 7.08681in :height: 0.34653in .. |image2| image:: media/image3.jpg :width: 7.08681in :height: 1.08681in .. |image3| image:: media/image4.jpg :width: 1.25972in :height: 0.44861in .. |image4| image:: media/image5.jpg :width: 7.08681in :height: 0.34653in .. |image5| image:: media/image6.jpg :width: 1.25972in :height: 0.46875in .. |image6| image:: media/image7.jpg :width: 7.08681in :height: 0.34653in .. |image7| image:: media/image8.jpg :width: 1.10486in :height: 0.47986in .. |image8| image:: media/image9.jpg :width: 7.08681in :height: 0.51944in .. |image9| image:: media/image10.jpg :width: 1.15764in :height: 0.67708in .. |image10| image:: media/image11.jpg :width: 7.08681in :height: 0.51944in .. |image11| image:: media/image12.jpg :width: 7.08681in :height: 0.55139in .. |image12| image:: media/image13.jpg :width: 7.36389in :height: 4.10833in .. |image13| image:: media/image14.jpg :width: 1.25972in :height: 1.01181in .. |image14| image:: media/image15.jpg :width: 7.08681in :height: 1.04306in .. |image15| image:: media/image15.jpg :width: 7.08681in :height: 1.04306in .. |image16| image:: media/image16.jpg :width: 1.27986in :height: 1in .. |image17| image:: media/image17.jpg :width: 7.08681in :height: 1.04306in .. |image18| image:: media/image17.jpg :width: 7.08681in :height: 1.04306in .. |image19| image:: media/image18.jpg :width: 1.75972in :height: 0.5in .. |image20| image:: media/image19.jpg :width: 7.08681in :height: 0.51944in .. |image21| image:: media/image20.jpg :width: 1.70833in :height: 0.48056in .. |image22| image:: media/image21.jpg :width: 7.08681in :height: 0.51944in .. |image23| image:: media/image22.jpg :width: 1.72014in :height: 0.48056in .. |image24| image:: media/image23.jpg :width: 7.08681in :height: 0.53542in .. |image25| image:: media/image24.jpg :width: 7.08681in :height: 2.26806in .. |image26| image:: media/image25.jpg :width: 1.72014in :height: 0.51181in .. |image27| image:: media/image26.jpg :width: 7.08681in :height: 0.53542in .. |image28| image:: media/image27.jpg :width: 7.08681in :height: 2.075in .. |image29| image:: media/image28.jpg :width: 1.44861in :height: 0.44861in .. |image30| image:: media/image29.jpg :width: 7.08681in :height: 0.34653in .. |image31| image:: media/image30.jpg :width: 1.44861in :height: 0.48056in .. |image32| image:: media/image31.jpg :width: 7.08681in :height: 0.34653in .. |image33| image:: media/image32.jpg :width: 1.48056in :height: 0.45694in .. |image34| image:: media/image33.jpg :width: 7.08681in :height: 0.34653in .. |image35| image:: media/image34.jpg :width: 1.60625in :height: 1in .. |image36| image:: media/image35.jpg :width: 7.08681in :height: 0.89792in .. |image37| image:: media/image35.jpg :width: 7.08681in :height: 0.89792in