Funzioni ed FB per gestione stringhe ------------------------------------ Sysstrlen, string length ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |image0| +----------+--------------+ | **Type** | **Library** | | | | +----------+--------------+ | Function | XTarget_12_0 | +----------+--------------+ Questa funzione ritorna la lunghezza (Espressa in numero di caratteri) della stringa definita in **Str**. Parametri funzione: +------------------+--------------------------------------------------+ | **Str** (@USINT) | Pointer alla stringa di cui calcolare lunghezza. | +------------------+--------------------------------------------------+ La funzione ritorna: +---------+------------------------------------+ | (UDINT) | Numero di caratteri della stringa. | +---------+------------------------------------+ **Esempi** """"""""""""" Viene calcolata la lunghezza della stringa **'Hello!'** ed il numero di caratteri che compongono la stringa viene trasferito nella variabile **Length**. Il risultato del calcolo è **6**. +---------------------------+ | **Definizione variabili** | +---------------------------+ | |image1| | +---------------------------+ **Esempio LD** |image2| SysStrFind, string find ^^^^^^^^^^^^^^^^^^^^^^^^^^ |image3| +----------+--------------+ | **Type** | **Library** | | | | +----------+--------------+ | Function | XTarget_12_0 | +----------+--------------+ Questa funzione cerca la stringa **Needle** in **Haystack** , la ricerca è effettuata in base alla definizione di `Mode <#TabFindModeDefs>`__. Se la stringa **Needle** è trovata nella stringa **Haystack**, viene ritornato il puntatore all'indirizzo di **Haystack** dove si trova. In base alla definizione di **Mode** può essere ritornato l'indirizzo del primo carattere coincidente oppure l'indirizzo del carattere successivo all'ultimo carattere coincidente. Se stringa non trovata o errore viene ritornato **NULL**. Parametri funzione: +-----------------------------------+-----------------------------------+ | **Haystack** (@USINT) | Pointer alla stringa dove | | | effettuare la ricerca. | +-----------------------------------+-----------------------------------+ | **Needle** (@USINT) | Pointer alla stringa da | | | ricercare. | +-----------------------------------+-----------------------------------+ | **Mode** (USINT) | Definizione modo in cui | | | effettuare la ricerca (`Vedi | | | tabella <#TabFindModeDefs>`__). | +-----------------------------------+-----------------------------------+ La funzione ritorna: +-----------------------------------+-----------------------------------+ | (@USINT) | Posizione dove la stringa | | | **Needle** è stata trovata. | | | **NULL** se non trovata. | +-----------------------------------+-----------------------------------+ **Codici di errore** In caso di errore e con `SysGetLastError <#FctSysGetLastError>`__ è possibile rilevare il codice di errore. +---------+-------------------------------------------+ | 9926100 | Pointer non valido. | +---------+-------------------------------------------+ | 9926110 | Dimensione stringa **Needle** non valida. | +---------+-------------------------------------------+ | 9926115 | Valore di **Mode** non supportato. | +---------+-------------------------------------------+ **Esempi** """"""""""""" Viene eseguita la ricerca della stringa **'World'** nella stringa presente in **Str** **'HelloWorld!, helloworld!'** con diversi modi di ricerca. Dal pointer ritornato viene sottratto l'indirizzo di allocazione di **Str** in modo da ottenere la posizione relativa della stringa trovata nella stringa di ricerca. Vediamo i vari risultati. Ptr[0]: **5**, La ricerca parte dall'inizio e ritorna la posizione di inizio della prima occorrenza. Ptr[1]: **10**, La ricerca parte dall'inizio e ritorna la posizione successiva alla fine della prima occorrenza. Ptr[2]: **18**, La ricerca parte dalla fine e ritorna la posizione di inizio della prima occorrenza. Ptr[3]: **23**, La ricerca parte dalla fine e ritorna la posizione successiva alla fine della prima occorrenza. +-----------------------------------------------------------------------+ | **Definizione variabili** | +-----------------------------------------------------------------------+ | |image5| | +-----------------------------------------------------------------------+ **Esempio ST** *(PTP116B000, ST_SysStrFind)* .. code-block:: none Ptr[0]:=SysStrFind(ADR(Str),ADR('World'), FIND_DEFAULT)-ADR(Str); Ptr[1]:=SysStrFind(ADR(Str),ADR('World'), FIND_GET_END)-ADR(Str); Ptr[2]:=SysStrFind(ADR(Str),ADR('World'), FIND_FROM_END OR FIND_NO_CASE)-ADR(Str); Ptr[3]:=SysStrFind(ADR(Str),ADR('World'), FIND_FROM_END OR FIND_GET_END OR FIND_NO_CASE)-ADR(Str); SysMemFind, memory find ^^^^^^^^^^^^^^^^^^^^^^^^ |image6| +----------+--------------+ | **Type** | **Library** | | | | +----------+--------------+ | Function | XTarget_12_0 | +----------+--------------+ Questa funzione cerca il pattern di byte definito in **Needle** nel buffer di memoria definita in **Haystack** , la ricerca è effettuata in base alla definizione di `Mode <#TabFindModeDefs>`__. Se il pattern **Needle** è trovato nel buffer di memoria **Haystack**, viene ritornato il puntatore all'indirizzo di **Haystack** dove si trova. In base alla definizione di **Mode** può essere ritornato l'indirizzo del primo byte coincidente oppure l'indirizzo del byte successivo all'ultimo byte coincidente. Se pattern non trovato o errore viene ritornato **NULL**. Parametri funzione: +-----------------------------------+-----------------------------------+ | **Haystack** (@USINT) | Pointer al buffer di memoria dove | | | effettuare la ricerca. | +-----------------------------------+-----------------------------------+ | **HSize** (UDINT) | Dimensione del buffer di memoria | +-----------------------------------+-----------------------------------+ | **Needle** (@USINT) | Pointer al pattern da ricercare. | +-----------------------------------+-----------------------------------+ | **HSize** (UDINT) | Dimensione del pattern da | | | ricercare. | +-----------------------------------+-----------------------------------+ | **Mode** (USINT) | Definizione modo in cui | | | effettuare la ricerca (`Vedi | | | tabella <#TabFindModeDefs>`__). | +-----------------------------------+-----------------------------------+ La funzione ritorna: +-----------------------------------+-----------------------------------+ | (@USINT) | Posizione dove il pattern | | | **Needle** è stata trovato. | | | **NULL** se non trovato. | +-----------------------------------+-----------------------------------+ **Codici di errore** In caso di errore e con `SysGetLastError <#FctSysGetLastError>`__ è possibile rilevare il codice di errore. +---------+-------------------------------------------+ | 9925100 | Pointer non valido. | +---------+-------------------------------------------+ | 9925110 | Valore impostato in **NSize** non valido. | +---------+-------------------------------------------+ | 9925115 | Valore di **Mode** non supportato. | +---------+-------------------------------------------+ **Esempi** """"""""""""" Viene eseguita la ricerca del pattern 16#04, 16#05, 16#06 nel buffer di memoria definito in **Mem** con diversi modi di ricerca. Dal pointer ritornato viene sottratto l'indirizzo di allocazione di **Mem** in modo da ottenere la posizione relativa del pattern nel buffer di memoria. Vediamo i vari risultati. Ptr[0]: **3**, La ricerca parte dall'inizio e ritorna la posizione di inizio della prima occorrenza. Ptr[1]: **6**, La ricerca parte dall'inizio e ritorna la posizione successiva alla fine della prima occorrenza. Ptr[2]: **3**, La ricerca parte dalla fine e ritorna la posizione di inizio della prima occorrenza. Ptr[3]: **6**, La ricerca parte dalla fine e ritorna la posizione successiva alla fine della prima occorrenza. +-----------------------------------------------------------------------+ | **Definizione variabili** | +-----------------------------------------------------------------------+ | |image8| | +-----------------------------------------------------------------------+ **Esempio ST** .. code-block:: none Ptr[0]:=SysMemFind(ADR(Mem), SIZEOF(Mem), ADR('$04$05$06'), 3, FIND_DEFAULT)-ADR(Mem); Ptr[1]:=SysMemFind(ADR(Mem), SIZEOF(Mem), ADR('$04$05$06'), 3, FIND_GET_END)-ADR(Mem); Ptr[2]:=SysMemFind(ADR(Mem), SIZEOF(Mem), ADR('$04$05$06'), 3, FIND_FROM_END)-ADR(Mem); Ptr[3]:=SysMemFind(ADR(Mem), SIZEOF(Mem), ADR('$04$05$06'), 3, FIND_FROM_END OR FIND_GET_END)-ADR(Mem); SysVarsnprintf, variable print to string ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |image9| +----------+--------------+ | **Type** | **Library** | | | | +----------+--------------+ | Function | XTarget_08_0 | +----------+--------------+ Questa funzione trasferisce in **String** la stampa formattata di una variabile. Il valore stampato ritornato nella variabile stringa non può superare la lunghezza definita in **Size**. Vedere anche funzione `SysLWVarsnprintf <#syslwvarsnprintf-variable-print-to-string-with-append>`__. 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 nella variabile **String**. EOF in caso di errore. Parametri funzione: +-----------------------------------+-----------------------------------+ | **String** (@USINT) | Pointer all'array dove deve | | | essere trasferito il risultato | | | della stampa. | +-----------------------------------+-----------------------------------+ | **Size** (UDINT) | Numero di caratteri da trasferire | | | nella variabile **String**. Il | | | numero definito è comprensivo del | | | codice di fine stringa '\0'. Se | | | la lunghezza della stringa di | | | output supera il limite di | | | **Size** byte, viene troncata al | | | numero di byte indicato. | +-----------------------------------+-----------------------------------+ | **Format** (STRING[80]) | Ha due tipi di argomenti, i | | | caratteri ordinari che vengono | | | copiati nella variabile | | | **String** 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 comprensivo | | | codice fine stringa '\0' | | | trasferiti in variabile | | | **String**. | | | | | | **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. +-----------------------------------+-----------------------------------+ | 9997100 | Tipo variabile non gestito, | | | controllare **VarType**. | +-----------------------------------+-----------------------------------+ | 9997200 | Il valore di **Size** limita la | | | formattazione della stringa in | | | uscita. | +-----------------------------------+-----------------------------------+ **Esempi** """"""""""""" Su fronte attivazione ingresso **Di00M00** viene incrementata la variabile **Counter** e la stampa del suo valore trasferita nell'array **StringOut**. Il valore presente in **StringOut** viene poi inviato sulla porta seriale **COM0**. Nella variabile **NrOfChars** viene caricato il numero di caratteri trasferiti in **StringOut** ed inviati in uscita sulla porta seriale. +-----------------------------------------------------------------------+ | **Definizione variabili** | +-----------------------------------------------------------------------+ | |image11| | +-----------------------------------------------------------------------+ **Esempio ST** *(PTP116A100, ST_SysVarsnprintf)* .. 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; (\* Check if the COM0 port is open. \*) IF (Fp <> NULL) THEN (\* Check if input is activated. \*) IF (Di00M00 <> Pulse) THEN Pulse:=Di00M00; (\* Pulse flag \*) (\* On input raising edge the counter value is printed. \*) IF (Di00M00) THEN Counter:=Counter+1; (\* Counter \*) NrOfChars:=SysVarsnprintf(ADR(StringOut), 32, 'Counter:%04d$r$n', UDINT_TYPE, ADR(Counter)); (\* Copy the printed result to serial port. \*) FOR i:=0 TO NrOfChars DO Ch:=Sysfputc(TO_INT(StringOut[i]), Fp); END_FOR; END_IF; END_IF; END_IF; In questo esempio viene eseguito il merge tra le stampe del valore di due variabili. Eseguire il merge può essere molto utile per avere un unica stringa contenente la stampa del valore di piu variabili. Mettendo in debug la variabile **Result** vedremo la stringa **Var[0]:12 Var[1]:34**. Avendo bloccato la stampa a 12 caratteri il valore di **Var[0]** sarà stampato correttamente fino ad un massimo di 4 cifre (7 caratteri stringa, 4 caratteri valore più terminatore stringa '\0'). Per valori di **Var[0]** superiori a 9999 non saranno più stampate le cifre meno significative. Il valore di **Var[1]** sarà stampato immediatamente dopo il valore di **Var[0]**. Da notare l'offset decrementato di 1 per sovrascrivere il terminatore stringa '\0'. Per garantire la stampa di un massimo di 4 anche per **Var[1]** è stato definito un **Size** di 13, la stringa di testo inizia infatti con un carattere di space per separarla dalla stampa del valore della variabile precedente. +-----------------------------------------------------------------------+ | **Definizione variabili** | +-----------------------------------------------------------------------+ | |image13| | +-----------------------------------------------------------------------+ **Esempio ST** .. code-block:: none (\* EXECUTE A VARIABLES PRINT MERGE \*) (\* Print the variable values, merging them into a single string. \*) NrOfChars:=SysVarsnprintf(ADR(Result), 12, 'Var[0]:%d', UDINT_TYPE, ADR(Var[0])); NrOfChars:=SysVarsnprintf(ADR(Result[LEN(Result)]), 13, ' Var[1]:%d', UDINT_TYPE, ADR(Var[1])); (\* [End of file] \*) SysLWVars nprintf, variable print to string with append ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |image14| +-----------------------+-----------------------+ | **Type** | **Library** | +=======================+=======================+ | Function | XTarget_12_0 | +-----------------------+-----------------------+ Questa funzione trasferisce in **String** la stampa formattata di una variabile. Il valore stampato ritornato nella variabile stringa non può superare la lunghezza definita in **Size**. 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. A differenza dalla funzione `SysVarsnprintf <#sysvarsnprintf-variable-print-to-string>`__ la stampa formattata viene aggiunta al termine del contenuto di **String**. Questo permette di concatenare più stampe in una unica stringa. La stampa viene troncata nel caso in cui la lunghezza totale della stringa superi **Size**. La funzione ritorna il numero di caratteri totali presenti nella variabile **String**. EOF in caso di errore. Parametri funzione: +-----------------------------------+-----------------------------------+ | **String** (@USINT) | Pointer all'array dove deve | | | essere trasferito il risultato | | | della stampa. | +-----------------------------------+-----------------------------------+ | **Size** (UDINT) | Numero di caratteri da trasferire | | | nella variabile **String**. Il | | | numero definito è comprensivo del | | | codice di fine stringa '\0'. Se | | | la lunghezza della stringa di | | | output supera il limite di | | | **Size** byte, viene troncata al | | | numero di byte indicato. | +-----------------------------------+-----------------------------------+ | **Format** (STRING[80]) | Ha due tipi di argomenti, i | | | caratteri ordinari che vengono | | | copiati nella variabile | | | **String** 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 totali | | | comprensivo codice fine stringa | | | '\0' presenti nella variabile | | | **String**. | | | | | | **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. +-----------------------------------+-----------------------------------+ | 9993100 | Tipo variabile non gestito, | | | controllare **VarType**. | +-----------------------------------+-----------------------------------+ | 9932110 | Lunghezza stringa è maggiore di | | | **Size** (Impossibile eseguire la | | | funzione). | +-----------------------------------+-----------------------------------+ | 9993200 | Il valore di **Size** limita la | | | formattazione della stringa in | | | uscita. | +-----------------------------------+-----------------------------------+ **Esempi** """"""""""""" Vedere esempi della funzione `SysVarsnprintf <#sysvarsnprintf-variable-print-to-string>`__. SysVarsscanf, extracts values from string ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |image15| +-----------------------+-----------------------+ | **Type** | **Library** | +=======================+=======================+ | Function | XTarget_08_0 | +-----------------------+-----------------------+ Questa funzione legge la stringa **String** e ne interpreta il contenuto basandosi sul parametro **Format**. La stringa **Format** specifica il formato con il quale interpretare la variabile, in **VarType** è indicato il tipo di variabile ed in **VarAdd** il suo indirizzo. La funzione ritorna TRUE se valore variabile trovato, in caso contrario FALSE. Parametri funzione: +-----------------------------------+-----------------------------------+ | **String** (@USINT) | Pointer alla stringa da leggere. | +-----------------------------------+-----------------------------------+ | **Format** (STRING[80]) | Ha due tipi di argomenti, i | | | caratteri ordinari che vengono | | | controllati nella variabile | | | **String** da leggere e le | | | specifiche di conversione, | | | contraddistinte dal simbolo | | | percentuale (%) e da un carattere | | | che specifica il formato con il | | | quale stampare la variabile | | | definita. `Vedi capitolo | | | definizione <#ChpSysVarsscanfForm | | | at>`__. | +-----------------------------------+-----------------------------------+ | **VarType** (USINT) | Tipo variabile, come indicato | | | nella tabella `Variable types | | | definition <#TabVarTypeDefs>`__. | +-----------------------------------+-----------------------------------+ | **VarAdd** (UDINT) | Indirizzo variabile. | +-----------------------------------+-----------------------------------+ La funzione ritorna: +--------+---------------------------------------+ | (BOOL) | **TRUE:** Valore variabile acquisito. | +--------+---------------------------------------+ **Codici di errore** In caso di errore la funzione torna con **FALSE** e con `SysGetLastError <#7.8.4.SysGetLastError, get last error|outline>`__ è possibile rilevare il codice di errore. +---------+------------------------------------------------------+ | 9999100 | Tipo variabile non gestito, controllare **VarType**. | +---------+------------------------------------------------------+ | 9999110 | Pointer a variabile **VarAdd** errato. | +---------+------------------------------------------------------+ **Esempi** """"""""""""" E' riportato un programma che esegue la lettura di una stringa **InputString** valorizzata con il testo **Value:123**. Su fronte attivazione ingresso **Di00M00** sono eseguite tre diverse funzioni **SysVarsscanf** tutte sulla stringa **InputString** ma con diverse definizioni di **Format**. Le prime due hanno esito positivo e le variabili **Variable[0]** e **Variable[1]** saranno valorizzate con il valore **123**. La terza avrà esito negativo, la variabile **Variable[2]** sarà azzerata. +-----------------------------------------------------------------------+ | **Definizione variabili** | +-----------------------------------------------------------------------+ | |image17| | +-----------------------------------------------------------------------+ **Esempio ST** *(PTP116B200, ST_SysVarsscanf)* .. code-block:: none (\* Check if input is activated. \*) IF (Di00M00 <> Pulse) THEN Pulse:=Di00M00; (\* Pulse flag \*) IF (Di00M00) THEN Res[0]:=SysVarsscanf(ADR(IStr), 'Value:%d', UDINT_TYPE, ADR(Var[0])); Res[1]:=SysVarsscanf(SysStrFind(ADR(IStr), ADR('Value:'), FIND_GET_END), '%d', UDINT_TYPE, ADR(Var[1])); Res[2]:=SysVarsscanf(ADR(IStr), '%d', UDINT_TYPE, ADR(Var[2])); END_IF; END_IF; END_IF; .. |image0| image:: media/image1.jpg :width: 1.34236in :height: 0.51181in .. |image1| image:: media/image2.jpg :width: 7.08681in :height: 0.35069in .. |image2| image:: media/image3.jpg :width: 7.075in :height: 1.1375in .. |image3| image:: media/image4.jpg :width: 1.74028in :height: 0.87431in .. |image4| image:: media/image5.jpg :width: 7.28125in :height: 0.4125in .. |image5| image:: media/image5.jpg :width: 7.28125in :height: 0.4125in .. |image6| image:: media/image6.jpg :width: 1.91736in :height: 1.25972in .. |image7| image:: media/image7.jpg :width: 7.08681in :height: 0.55139in .. |image8| image:: media/image7.jpg :width: 7.08681in :height: 0.55139in .. |image9| image:: media/image8.jpg :width: 1.60625in :height: 1.16528in .. |image10| image:: media/image9.jpg :width: 7.08681in :height: 1.41319in .. |image11| image:: media/image9.jpg :width: 7.08681in :height: 1.41319in .. |image12| image:: media/image10.jpg :width: 7.08681in :height: 0.70486in .. |image13| image:: media/image10.jpg :width: 7.08681in :height: 0.70486in .. |image14| image:: media/image11.jpg :width: 1.79167in :height: 1.18889in .. |image15| image:: media/image12.jpg :width: 1.6375in :height: 0.99236in .. |image16| image:: media/image13.jpg :width: 7.08681in :height: 0.91319in .. |image17| image:: media/image13.jpg :width: 7.08681in :height: 0.91319in