SIMOTION ST Structured Text - cache. · PDF fileSIMOTION ST Structured Text Manuale di programmazione e d'uso, 02/2012 3 Prefazione Campo di validità Il presente documento fa parte

� �SIMOTION ST Structured Text

___________________

___________________

___________________

___________________

___________________

___________________

___________________

___________________

SIMOTION

SIMOTION SCOUT SIMOTION ST Structured Text

Manuale di programmazione e d'uso

02/2012

Prefazione

Premessa 1

Guida introduttiva di ST 2

Principi fondamentali di ST 3

Funzioni, blocchi funzionali e programmi

4

Implementazione di ST in SIMOTION

5

Fonti di errore e test del programma

6

Appendice A

Avvertenze di legge

Avvertenze di legge Concetto di segnaletica di avvertimento

Questo manuale contiene delle norme di sicurezza che devono essere rispettate per salvaguardare l'incolumità personale e per evitare danni materiali. Le indicazioni da rispettare per garantire la sicurezza personale sono evidenziate da un simbolo a forma di triangolo mentre quelle per evitare danni materiali non sono precedute dal triangolo. Gli avvisi di pericolo sono rappresentati come segue e segnalano in ordine descrescente i diversi livelli di rischio.

PERICOLO questo simbolo indica che la mancata osservanza delle opportune misure di sicurezza provoca la morte o gravi lesioni fisiche.

AVVERTENZA il simbolo indica che la mancata osservanza delle relative misure di sicurezza può causare la morte o gravi lesioni fisiche.

CAUTELA con il triangolo di pericolo indica che la mancata osservanza delle relative misure di sicurezza può causare lesioni fisiche non gravi.

CAUTELA senza triangolo di pericolo indica che la mancata osservanza delle relative misure di sicurezza può causare danni materiali.

ATTENZIONE indica che, se non vengono rispettate le relative misure di sicurezza, possono subentrare condizioni o conseguenze indesiderate.

Nel caso in cui ci siano più livelli di rischio l'avviso di pericolo segnala sempre quello più elevato. Se in un avviso di pericolo si richiama l'attenzione con il triangolo sul rischio di lesioni alle persone, può anche essere contemporaneamente segnalato il rischio di possibili danni materiali.

Personale qualificato Il prodotto/sistema oggetto di questa documentazione può essere adoperato solo da personale qualificato per il rispettivo compito assegnato nel rispetto della documentazione relativa al compito, specialmente delle avvertenze di sicurezza e delle precauzioni in essa contenute. Il personale qualificato, in virtù della sua formazione ed esperienza, è in grado di riconoscere i rischi legati all'impiego di questi prodotti/sistemi e di evitare possibili pericoli.

Uso conforme alle prescrizioni di prodotti Siemens Si prega di tener presente quanto segue:

AVVERTENZA I prodotti Siemens devono essere utilizzati solo per i casi d’impiego previsti nel catalogo e nella rispettiva documentazione tecnica. Qualora vengano impiegati prodotti o componenti di terzi, questi devono essere consigliati oppure approvati da Siemens. Il funzionamento corretto e sicuro dei prodotti presuppone un trasporto, un magazzinaggio, un’installazione, un montaggio, una messa in servizio, un utilizzo e una manutenzione appropriati e a regola d’arte. Devono essere rispettate le condizioni ambientali consentite. Devono essere osservate le avvertenze contenute nella rispettiva documentazione.

Marchio di prodotto Tutti i nomi di prodotto contrassegnati con ® sono marchi registrati della Siemens AG. Gli altri nomi di prodotto citati in questo manuale possono essere dei marchi il cui utilizzo da parte di terzi per i propri scopi può violare i diritti dei proprietari.

Esclusione di responsabilità Abbiamo controllato che il contenuto di questa documentazione corrisponda all'hardware e al software descritti. Non potendo comunque escludere eventuali differenze, non possiamo garantire una concordanza perfetta. Il contenuto di questa documentazione viene tuttavia verificato periodicamente e le eventuali correzioni o modifiche vengono inserite nelle successive edizioni.

Siemens AG Industry Sector Postfach 48 48 90026 NÜRNBERG GERMANIA

Copyright © Siemens AG 2012. Tutti i diritti riservati

SIMOTION ST Structured Text Manuale di programmazione e d'uso, 02/2012 3

Prefazione

Campo di validità Il presente documento fa parte del pacchetto di documentazione SIMOTION Programmazione.

La documentazione è valida per il SIMOTION SCOUT, il sistema di engineering della famiglia di prodotti SIMOTION, nella versione V4.3 con riferimento a:

● Un apparecchio SIMOTION con un SIMOTION Kernel delle seguenti versioni:

– V4.3

– V4.2

– V4.1

– V4.0

– V3.2

● I seguenti pacchetti tecnologici SIMOTION nella versione adatta al rispettivo Kernel

– Cam

– Path (dal Kernel V4.1)

– Cam_ext

– TControl

Il documento descrive la sintassi del linguaggio di programmazione SIMOTION ST Structured Text di questa versione di SIMOTION SCOUT e l'uso del linguaggio stesso. Sono inoltre presenti informazioni sulle tematiche seguenti:

● Editor ST e compilatore con programmi d'esempio

● Conservazione e gestione dei dati sugli apparecchi SIMOTION

● Possibilità di diagnostica e correzione degli errori

Il repertorio del linguaggio di programmazione SIMOTION ST può contenere nuovi elementi sintattici rispetto alle versioni precedenti. Tali elementi sono stati testati solo con la versione attuale del SIMOTION kernel e sono abilitati solo a partire da questa versione.

Prefazione

SIMOTION ST Structured Text 4 Manuale di programmazione e d'uso, 02/2012

Conversione dei progetti esistenti nella versione attuale di SIMOTION SCOUT È possibile convertire verso l'alto i progetti esistenti nella versione attuale di SIMOTION SCOUT e del linguaggio di programmazione SIMOTION ST. Una ricompilazione con la versione corrente del compilatore modifica, in determinate circostanze, gli identificatori di versione nelle aree dati dei programmi e provoca così una cancellazione e inizializzazione di tutti i dati ritentivi e non ritentivi sull'apparecchio SIMOTION. Eccezionalmente possono rendersi necessari degli adattamenti di minima entità nelle sorgenti del programma.

Se si utilizzano i nuovi elementi sintattici del linguaggio di programmazione SIMOTION ST su un apparecchio SIMOTION con una versione precedente del SIMOTION kernel, il compilatore emette l'avviso 16700. Se si utilizzano ugualmente questi elementi sintattici, il progetto può essere salvato nel vecchio formato ma non più compilato con il compilatore di una versione precedente di SIMOTION SCOUT.

Sezioni del manuale Le sezioni che seguono descrivono la finalità e le modalità d'uso del manuale.

● Introduzione (Capitolo 1)

● Guida introduttiva di ST (Capitolo 2)

Presupposti per la creazione del programma e programma esemplificativo

● Principi fondamentali di ST (Capitolo 3)

Elementi del linguaggio di programmazione ST, dichiarazioni delle variabili e del tipo di dati, istruzioni

● Funzioni, blocchi funzionali, programmi (Capitolo 4)

Programmazione e richiamo delle unità di organizzazione programma (POE)

● Implementazione di ST in SIMOTION SCOUT (Capitolo 5)

Comportamento delle variabili, accesso a ingressi/uscite, librerie, preprocessore

● Fonti di errore e test del programma (Capitolo 6)

Avvertenze relative alle fonti di errore, alla programmazione efficiente e al test dei programmi

● Appendici

– Descrizione formale del linguaggio (Appendice A.1)

– Messaggi di errore del compilatore e informazioni per la loro rimozione (Appendice A.2)

– Template per Unit di esempio (Appendice A.3)

● indice

Se si desidera iniziare subito, partire dal Capitolo 2.

Prefazione


Documentazione SIMOTION La panoramica della documentazione SIMOTION è riportata in una bibliografia separata.

La documentazione è compresa in versione elettronica nella fornitura di SIMOTION SCOUT e consiste in 10 pacchetti di documenti.

Per la versione di prodotto SIMOTION V4.3 sono disponibili i seguenti pacchetti di documentazione:

● SIMOTION Engineering System Utilizzo

● SIMOTION Descrizione del sistema e delle funzioni

● SIMOTION Service e Diagnostica

● SIMOTION IT

● Programmazione SIMOTION

● Programmazione SIMOTION - Riferimenti

● SIMOTION C

● SIMOTION P

● SIMOTION D

● Documentazione integrativa SIMOTION

Hotline e indirizzi Internet

Ulteriori informazioni Al seguente link sono disponibili informazioni relative:

● all'ordinazione della documentazione / alla panoramica manuali

● altri link per il download di documenti

● all'utilizzo della documentazione online (manuali/cercare e sfogliare informazioni)

http://www.siemens.com/motioncontrol/docu

Per domande relative alla documentazione tecnica (ad es. suggerimenti, correzioni) si prega di inviare una e-mail al seguente indirizzo: [email protected]

My Documentation Manager Al seguente link sono disponibili informazioni per strutturare individualmente la documentazione sulla base di contenuti Siemens ed adattarli alla propria documentazione della macchina:

http://www.siemens.com/mdm

Prefazione


Training Al seguente link sono disponibili informazioni su SITRAIN - il Training di Siemens per prodotti, sistemi e soluzioni della tecnica di automazione:

http://www.siemens.com/sitrain

Domande frequenti Le FAQ (Frequently Asked Questions) si trovano nelle SIMOTION Utilities & Applications incluse nella fornitura di SIMOTION SCOUT e nelle pagine di Service&Support alla voce Product Support:

http://support.automation.siemens.com

Technical Support Per i numeri telefonici dell'assistenza tecnica specifica dei vari Paesi, vedere in Internet in Contatti:

http://www.siemens.com/automation/service&support


Sommario

Prefazione ................................................................................................................................................. 3

1 Premessa ................................................................................................................................................ 15

1.1 Linguaggio di programmazione evoluto.......................................................................................15

1.2 Linguaggio di programmazione con istruzioni tecnologiche ........................................................15

1.3 Livelli di svolgimento ....................................................................................................................16

1.4 Editor ST con tool per la creazione ed il test dei programmi .......................................................16

2 Guida introduttiva di ST ........................................................................................................................... 17

2.1 Implementazione di ST in SCOUT...............................................................................................17 2.1.1 Approccio agli elementi della workbench.....................................................................................19

2.2 Requisiti per la creazione di programmi ......................................................................................20

2.3 Uso dell'editor ST e del compilatore ............................................................................................21 2.3.1 Inserimento sorgente ST..............................................................................................................21 2.3.2 Apertura di una sorgente ST esistente ........................................................................................24 2.3.3 Modifica delle proprietà di una sorgente ST ................................................................................25 2.3.4 Uso dell'editor ST.........................................................................................................................27 2.3.4.1 Syntaxcoloring..............................................................................................................................27 2.3.4.2 Drag&Drop ...................................................................................................................................28 2.3.4.3 Impostazioni dell'editor ST...........................................................................................................29 2.3.4.4 Rientri e tabulazioni .....................................................................................................................31 2.3.4.5 Espandere/comprimere (visualizzare e nascondere i blocchi) ....................................................33 2.3.4.6 Suddivisione finestra dell'editor ...................................................................................................36 2.3.4.7 Visualizzazione di spazi vuoti e tabulazioni .................................................................................38 2.3.4.8 Modifica della dimensione del carattere nell'editor ST ................................................................39 2.3.4.9 Selezione di testo.........................................................................................................................40 2.3.4.10 Creazione di una successione numerica semplice (creazione sequenza)..................................42 2.3.4.11 Utilizzo dei segnalibri ...................................................................................................................45 2.3.4.12 Completamento automatico .........................................................................................................46 2.3.4.13 Apri blocco richiamato..................................................................................................................48 2.3.4.14 Altri strumenti dell'editor ST .........................................................................................................48 2.3.4.15 Uso della libreria comandi............................................................................................................49 2.3.4.16 Barra delle funzioni editor ST.......................................................................................................50 2.3.4.17 Menu contestuale editor ST.........................................................................................................51 2.3.4.18 Tasti di scelta rapida (shortcut)....................................................................................................54 2.3.5 Avvio del compilatore...................................................................................................................58 2.3.5.1 Guida alla correzione degli errori .................................................................................................58 2.3.6 Applicazione delle impostazioni per il compilatore ......................................................................58 2.3.6.1 Impostazioni globali del compilatore............................................................................................59 2.3.6.2 Impostazioni locali del compilatore ..............................................................................................61 2.3.6.3 Efficacia delle impostazioni globali o locali del compilatore ........................................................65 2.3.6.4 Significato delle classi di avviso...................................................................................................67 2.3.6.5 Visualizzazione delle opzioni del compilatore..............................................................................67

Sommario


2.3.7 Protezione del know-how per sorgenti ST .................................................................................. 69 2.3.8 Impostazione delle definizioni del preprocessore ....................................................................... 70 2.3.9 Esportazione, importazione e stampa delle sorgenti ST ............................................................ 71 2.3.9.1 Esportazione delle sorgenti ST come file di testo (ASCII) .......................................................... 71 2.3.9.2 Esportazione della sorgente ST in formato XML ........................................................................ 72 2.3.9.3 Importazione di file di testo (ASCII) come sorgente ST.............................................................. 73 2.3.9.4 Importazione di dati XML in una sorgente ST............................................................................. 73 2.3.9.5 Stampa della sorgente ST........................................................................................................... 74 2.3.10 Uso di editor esterni .................................................................................................................... 74 2.3.11 Menu sorgente ST....................................................................................................................... 76 2.3.11.1 Menu sorgente ST....................................................................................................................... 76 2.3.11.2 Menu contestuale sorgente ST ................................................................................................... 77

2.4 Creazione di un programma esemplificativo............................................................................... 79 2.4.1 Presupposti ................................................................................................................................. 79 2.4.2 Apertura o creazione di un progetto............................................................................................ 79 2.4.3 Rilevazione dell'hardware ........................................................................................................... 80 2.4.4 Immissione del testo sorgente con l'editor ST ............................................................................ 81 2.4.4.1 Funzioni dell'editor ...................................................................................................................... 83 2.4.4.2 Testo sorgente del programma esemplificativo .......................................................................... 83 2.4.5 Compilazione del programma esemplificativo ............................................................................ 84 2.4.5.1 Avvio del compilatore .................................................................................................................. 84 2.4.5.2 Correzione errori ......................................................................................................................... 84 2.4.5.3 Esempio di messaggi di errore ................................................................................................... 85 2.4.6 Esecuzione del programma esemplificativo................................................................................ 86 2.4.6.1 Assegnazione del programma esemplificativo a un livello esecutivo ......................................... 86 2.4.6.2 Creazione del collegamento con il sistema di destinazione ....................................................... 87 2.4.6.3 Caricamento del programma esemplificativo sul sistema di destinazione (download)............... 88 2.4.6.4 Avvio e test del programma esemplificativo................................................................................ 89

3 Principi fondamentali di ST ...................................................................................................................... 91

3.1 Strumenti per la descrizione del linguaggio ................................................................................ 91 3.1.1 Diagramma della sintassi ............................................................................................................ 91 3.1.2 Blocchi nei diagrammi della sintassi ........................................................................................... 92 3.1.3 Significato delle regole (semantica) ............................................................................................ 92

3.2 Elementi base del linguaggio ...................................................................................................... 93 3.2.1 Il set di caratteri ST ..................................................................................................................... 93 3.2.2 Identificatori in ST ....................................................................................................................... 93 3.2.2.1 Regole per gli identificatori.......................................................................................................... 93 3.2.2.2 Esempi per l'identificatore ........................................................................................................... 94 3.2.3 Identificatori riservati ................................................................................................................... 95 3.2.3.1 Identificatori protetti del linguaggio di programmazione ST........................................................ 95 3.2.3.2 Identificatori riservati del linguaggio di programmazione ST .................................................... 100 3.2.3.3 Altri identificatori riservati .......................................................................................................... 101 3.2.4 Numeri e valori booleani ........................................................................................................... 102 3.2.4.1 Numeri interi .............................................................................................................................. 102 3.2.4.2 Numeri a virgola mobile ............................................................................................................ 103 3.2.4.3 Esponenti .................................................................................................................................. 103 3.2.4.4 Valori booleani .......................................................................................................................... 104 3.2.4.5 Tipi di dati dei numeri ................................................................................................................ 104 3.2.5 Stringhe di caratteri ................................................................................................................... 104

Sommario


3.3 Struttura dei file sorgente ST .....................................................................................................105 3.3.1 Istruzioni.....................................................................................................................................107 3.3.2 Commenti...................................................................................................................................108

3.4 Tipi di dati...................................................................................................................................109 3.4.1 Tipi di dati elementari.................................................................................................................110 3.4.1.1 Tipi di dati elementari.................................................................................................................110 3.4.1.2 Limiti di campo dei valori dei tipi di dati elementari....................................................................112 3.4.1.3 Tipi di dati generali .....................................................................................................................113 3.4.1.4 Tipi di dati elementari del sistema..............................................................................................113 3.4.2 Tipi di dati definiti dall'utente......................................................................................................114 3.4.2.1 Tipi di dati definiti dall'utente......................................................................................................114 3.4.2.2 Sintassi dei tipi di dati definiti dall'utente (dichiarazione del tipo) ..............................................115 3.4.2.3 Derivazione di tipi di dati elementari o derivati ..........................................................................117 3.4.2.4 Tipo di dati derivato ARRAY - Campo .......................................................................................118 3.4.2.5 Tipo di dati derivato enumerazione - Enumeratore....................................................................120 3.4.2.6 Tipo di dati derivato STRUCT - Struttura...................................................................................122 3.4.3 Tipi di dati degli oggetti tecnologici ............................................................................................124 3.4.3.1 Descrizione dei tipi di dati degli oggetti tecnologici....................................................................124 3.4.3.2 Ereditarietà delle proprietà per gli assi ......................................................................................125 3.4.3.3 Esempi per l'utilizzo dei tipi di dati degli oggetti tecnologici.......................................................126 3.4.4 Tipi di dati di sistema .................................................................................................................127

3.5 Dichiarazione delle variabili .......................................................................................................128 3.5.1 Sintassi della dichiarazione delle variabili..................................................................................128 3.5.2 Panoramica di tutte le dichiarazioni di variabili ..........................................................................130 3.5.3 Inizializzazione di variabili o tipi di dati ......................................................................................131 3.5.4 costanti.......................................................................................................................................135

3.6 Assegnazione del valore e espressioni .....................................................................................137 3.6.1 Assegnazione del valore............................................................................................................137 3.6.1.1 Sintassi dell'assegnazione del valore ........................................................................................137 3.6.1.2 Assegnazioni di valori con variabili di un tipo di dati elementare...............................................139 3.6.1.3 Assegnazioni di valori con variabili del tipo di dati elementare STRING...................................139 3.6.1.4 Assegnazioni del valore con variabili di un tipo di dati a bit.......................................................141 3.6.1.5 Assegnazioni di valori con variabili del tipo di dati derivato enumerazione (Enumerator).........143 3.6.1.6 Assegnazioni di valori con variabili del tipo di dati derivato ARRAY (campo) ...........................143 3.6.1.7 Assegnazioni di valori con variabili del tipo di dati derivato STRUCT (struttura) ......................144 3.6.2 Espressioni.................................................................................................................................145 3.6.2.1 Risultato di un'espressione ........................................................................................................145 3.6.2.2 Sequenza di analisi di un'espressione.......................................................................................146 3.6.3 Operandi ....................................................................................................................................147 3.6.4 Espressioni aritmetiche..............................................................................................................148 3.6.4.1 Esempi per le espressioni aritmetiche .......................................................................................150 3.6.5 Espressioni di confronto.............................................................................................................151 3.6.6 Espressioni logiche e espressioni a sequenza di bit .................................................................154 3.6.7 Ordine degli operatori ................................................................................................................156

3.7 Istruzioni di controllo ..................................................................................................................156 3.7.1 Istruzione IF ...............................................................................................................................156 3.7.2 Istruzione CASE.........................................................................................................................158 3.7.3 Istruzione FOR...........................................................................................................................161 3.7.4 Istruzione WHILE .......................................................................................................................163 3.7.5 Istruzione REPEAT ....................................................................................................................164

Sommario


3.7.6 Istruzione EXIT.......................................................................................................................... 165 3.7.7 Istruzione RETURN................................................................................................................... 165 3.7.8 Istruzione WAITFORCONDITION............................................................................................. 166 3.7.9 Istruzione GOTO ....................................................................................................................... 168

3.8 Conversioni dei tipi di dati ......................................................................................................... 169 3.8.1 Conversione dei tipi di dati elementari ...................................................................................... 169 3.8.1.1 Conversioni implicite dei tipi di dati ........................................................................................... 170 3.8.1.2 Conversioni esplicite del tipo di dati .......................................................................................... 173 3.8.2 Conversioni integrative.............................................................................................................. 174

4 Funzioni, blocchi funzionali e programmi ............................................................................................... 175

4.1 Creazione e richiamo di funzioni e blocchi funzionali ............................................................... 176 4.1.1 Definizione delle funzioni .......................................................................................................... 176 4.1.2 Definizione di blocchi funzionali ................................................................................................ 177 4.1.3 Sezione di dichiarazione di FB e FC......................................................................................... 177 4.1.4 Sezione istruzioni di FB e FC.................................................................................................... 180 4.1.5 ARRAY con lunghezza dinamica (a partire dal kernel V4.2) .................................................... 182 4.1.6 Richiamo di funzioni e di blocchi funzionali............................................................................... 184 4.1.6.1 Principio di trasferimento dei parametri .................................................................................... 184 4.1.6.2 Trasferimento di parametri di ingresso ..................................................................................... 184 4.1.6.3 Trasferimento dei parametri di passaggio................................................................................. 185 4.1.6.4 Trasferimento di parametri di uscita (solo per FB).................................................................... 186 4.1.6.5 Tempi di accesso ai parametri .................................................................................................. 187 4.1.6.6 Richiamo delle funzioni ............................................................................................................. 187 4.1.6.7 Richiamo dei blocchi funzionali (dichiarazione e richiamo delle istanze) ................................. 188 4.1.6.8 Accesso al corrispondente parametro di uscita all'esterno del blocco funzionale.................... 190 4.1.6.9 Accesso al corrispondente parametro di ingresso all'esterno del blocco funzionale................ 190 4.1.6.10 Fonti di errore nel richiamo di un blocco funzionale ................................................................. 191

4.2 Confronto tra funzioni e blocchi funzionali ................................................................................ 192 4.2.1 Descrizione dell'esempio .......................................................................................................... 192 4.2.2 File sorgente con commenti ...................................................................................................... 193

4.3 Programmi................................................................................................................................. 195 4.3.1 Assegnazione di un programma nel sistema esecutivo............................................................ 195 4.3.2 Richiamo di un programma nel programma ("program in program")........................................ 196

4.4 Espressioni................................................................................................................................ 197

5 Implementazione di ST in SIMOTION.................................................................................................... 201

5.1 Sezioni del file sorgente ............................................................................................................ 201 5.1.1 Uso delle sezioni del file sorgente ............................................................................................ 201 5.1.1.1 Sezione interfaccia.................................................................................................................... 202 5.1.1.2 Sezione implementazione......................................................................................................... 204 5.1.1.3 Unità di organizzazione del programma (POE) ........................................................................ 205 5.1.1.4 Funzioni (FC) ............................................................................................................................ 206 5.1.1.5 Blocchi funzionali (FB) .............................................................................................................. 207 5.1.1.6 Programmi................................................................................................................................. 208 5.1.1.7 Espressioni................................................................................................................................ 209 5.1.1.8 Sezione dichiarazione ............................................................................................................... 210 5.1.1.9 Sezione istruzioni ...................................................................................................................... 210 5.1.1.10 Definizione del tipo di dati ......................................................................................................... 211 5.1.1.11 Dichiarazione delle variabili....................................................................................................... 211

Sommario


5.1.2 Importazione ed esportazione tra sorgenti ST...........................................................................214 5.1.2.1 Definizione della Unit .................................................................................................................214 5.1.2.2 Sezione interfaccia di una Unit da esportare .............................................................................214 5.1.2.3 Esempio di Unit da esportare.....................................................................................................216 5.1.2.4 Istruzione USES in una Unit da importare .................................................................................217 5.1.2.5 Esempio di una Unit da importare..............................................................................................219

5.2 Variabili in SIMOTION................................................................................................................220 5.2.1 Modello di variabile ....................................................................................................................220 5.2.1.1 Variabili Unit ...............................................................................................................................223 5.2.1.2 Variabili Unit non ritentive ..........................................................................................................224 5.2.1.3 Variabili Unit ritentive .................................................................................................................225 5.2.1.4 Variabili locali (variabili statiche e temporanee).........................................................................226 5.2.1.5 Variabili statiche.........................................................................................................................229 5.2.1.6 Variabili temporanee ..................................................................................................................230 5.2.2 Uso di variabili utente globali dell'apparecchio ..........................................................................231 5.2.3 Aree di memoria dei tipi di variabili ............................................................................................232 5.2.3.1 Esempio per settori di memoria .................................................................................................234 5.2.3.2 Memoria necessaria per le variabili nello stack dati locali .........................................................237 5.2.4 Istante di inizializzazione delle variabili .....................................................................................237 5.2.4.1 Inizializzazione delle variabili globali ritentive............................................................................238 5.2.4.2 Inizializzazione delle variabili globali non ritentive.....................................................................240 5.2.4.3 Inizializzazione delle variabili locali............................................................................................243 5.2.4.4 Inizializzazione variabili statiche dei programmi........................................................................244 5.2.4.5 Inizializzazione delle istanze dei blocchi funzionali (FB) ...........................................................245 5.2.4.6 Inizializzazione delle variabili di sistema degli oggetti tecnologici .............................................246 5.2.4.7 Identificazione della versione delle variabili globali e relativa inizializzazione in fase di

download....................................................................................................................................247 5.2.5 Variabili e apparecchi HMI .........................................................................................................248

5.3 Accesso agli ingressi e alle uscite (immagine di processo, variabili I/O)...................................251 5.3.1 Panoramica dell'accesso a ingressi e uscite .............................................................................251 5.3.2 Proprietà importanti dell'accesso diretto e dell'immagine di processo ......................................252 5.3.3 Accesso diretto e immagine di processo dei task ciclici ............................................................256 5.3.3.1 Area indirizzi degli apparecchi SIMOTION ................................................................................259 5.3.3.2 Regole degli indirizzi I/O per l'accesso diretto e l'immagine di processo dei task ciclici ...........260 5.3.3.3 Creazione della variabile I/O per l'accesso diretto all'immagine di processo dei task ciclici .....261 5.3.3.4 Sintassi per l'immissione degli indirizzi I/O ................................................................................264 5.3.3.5 Tipi di dati possibili delle variabili I/O .........................................................................................265 5.3.3.6 Stato dettagliato delle variabili I/O (a partire dal kernel V.4.2) ..................................................265 5.3.4 Accesso all'immagine di processo dei BackgroundTask ...........................................................267 5.3.4.1 Immagine di processo comune (a partire dal kernel V4.2) ........................................................269 5.3.4.2 Immagine di processo separata (a partire dal kernel V4.1).......................................................272 5.3.4.3 Accesso assoluto all'immagine di processo fissa del BackgroundTask (Accesso assoluto

all'immagine di processo)...........................................................................................................275 5.3.4.4 Sintassi per l'identificatore dell'accesso assoluto all'immagine di processo..............................275 5.3.4.5 Accesso simbolico all'immagine di processo fissa del BackgroundTask (Accesso

simbolico all'immagine di processo) ..........................................................................................276 5.3.4.6 Tipi di dati possibili dell'accesso simbolico all'immagine di processo........................................277 5.3.4.7 Esempio di accesso simbolico all'immagine di processo ..........................................................278 5.3.4.8 Creazione di una variabile I/O per l'accesso a una immagine di processo fissa di

BackgroundTask ........................................................................................................................278 5.3.5 Accesso alle variabili I/O............................................................................................................279

Sommario


5.4 Uso delle librerie ....................................................................................................................... 280 5.4.1 Compilazione delle librerie ........................................................................................................ 281 5.4.2 Protezione del know-how per le librerie .................................................................................... 283 5.4.3 Uso di tipi di dati, funzioni e blocchi funzionali delle librerie ..................................................... 284

5.5 Uso di identificatori uguali, spazi del nome............................................................................... 285 5.5.1 Uso di identificatori uguali ......................................................................................................... 285 5.5.2 Spazi del nome ......................................................................................................................... 288

5.6 Dati di riferimento ...................................................................................................................... 292 5.6.1 Elenco dei riferimenti incrociati ................................................................................................. 292 5.6.1.1 Creazione elenco dei riferimenti incrociati ................................................................................ 292 5.6.1.2 Contenuto dell'elenco dei riferimenti incrociati.......................................................................... 293 5.6.1.3 Uso dell'elenco dei riferimenti incrociati .................................................................................... 295 5.6.1.4 Filtraggio dell'elenco di riferimenti incrociati ............................................................................. 296 5.6.2 Struttura del programma ........................................................................................................... 296 5.6.2.1 Contenuto della struttura di programma ................................................................................... 297 5.6.3 Attributi di codice....................................................................................................................... 298 5.6.3.1 Contenuto degli attributi di codice............................................................................................. 299

5.7 Controllo del preprocessore e del compilatore tramite pragma................................................ 299 5.7.1 Comando del preprocessore..................................................................................................... 300 5.7.1.1 Istruzione del preprocessore..................................................................................................... 301 5.7.1.2 Esempio di istruzioni per il preprocessore ................................................................................ 303 5.7.2 Gestione del compilatore tramite attributi ................................................................................. 304

5.8 Apparecchi SIMOTION ............................................................................................................. 307 5.8.1 Regole per gli identificatori di apparecchi SIMOTION .............................................................. 307 5.8.2 Esecuzione delle impostazioni sull'apparecchio (dal kernel V4.2) ........................................... 309

5.9 Dichiarazioni anticipative........................................................................................................... 310

5.10 Istruzioni di salto ed etichette di salto ....................................................................................... 313

6 Fonti di errore e test del programma...................................................................................................... 315

6.1 Indicazioni su come evitare gli errori ed eseguire una programmazione efficace .................... 315

6.2 Test del programma.................................................................................................................. 316 6.2.1 Modi operativi per il test del programma................................................................................... 316 6.2.1.1 Modi operativi degli apparecchi SIMOTION.............................................................................. 316 6.2.1.2 Informazioni importanti sulla sorveglianza della funzionalità vitale........................................... 319 6.2.1.3 Parametri sorveglianza della funzionalità vitale ........................................................................ 321 6.2.2 Modifica delle sorgenti di programma in modalità online.......................................................... 322 6.2.3 Browser dei simboli ................................................................................................................... 323 6.2.3.1 Proprietà del browser dei simboli .............................................................................................. 323 6.2.3.2 Uso del browser dei simboli ...................................................................................................... 323 6.2.4 Monitoraggio delle variabili nella tabella Watch........................................................................ 327 6.2.4.1 Variabili nella tabella Watch...................................................................................................... 327 6.2.4.2 Uso della tabella Watch ............................................................................................................ 327 6.2.5 Stato variabile ........................................................................................................................... 329 6.2.6 Esecuzione del programma ...................................................................................................... 330 6.2.6.1 Esecuzione del programma: Visualizzazione di punto di codice e percorso di richiamo ......... 330 6.2.6.2 Parametro Esecuzione del programma .................................................................................... 331 6.2.6.3 Barra degli strumenti Esecuzione del programma.................................................................... 331

Sommario


6.2.7 Stato programma .......................................................................................................................332 6.2.7.1 Proprietà dello stato programma................................................................................................332 6.2.7.2 Uso di Stato programma............................................................................................................334 6.2.7.3 Percorso di richiamo per Stato programma...............................................................................336 6.2.7.4 Parametro percorso di richiamo stato programma ....................................................................337 6.2.8 Punti di arresto...........................................................................................................................338 6.2.8.1 Procedura generale per l'impostazione dei punti di arresto.......................................................338 6.2.8.2 Impostazione della modalità debug ...........................................................................................339 6.2.8.3 Definire il gruppo di task debug .................................................................................................341 6.2.8.4 Parametri del gruppo di task di debug .......................................................................................343 6.2.8.5 Tabella del parametro debug.....................................................................................................344 6.2.8.6 Impostazione dei punti di arresto...............................................................................................344 6.2.8.7 Barra delle funzioni dei punti di arresto .....................................................................................347 6.2.8.8 Definizione del percorso di richiamo per un singolo punto di arresto........................................348 6.2.8.9 Parametri Percorso di richiamo/Selezione del task Punto di arresto.........................................350 6.2.8.10 Definizione del percorso di richiamo per tutti i punti di arresto ..................................................352 6.2.8.11 Parametri Percorso di richiamo/Selezione task Tutti i punti di arresto per POE .......................354 6.2.8.12 Attivazione dei punti di arresto...................................................................................................355 6.2.8.13 Visualizzazione di Call Stack .....................................................................................................358 6.2.8.14 Parametro Callstack punto di arresto ........................................................................................359 6.2.9 Barra delle funzioni Stato del task .............................................................................................359 6.2.10 Trace ..........................................................................................................................................360 6.2.11 Confronto progetti ......................................................................................................................361

A Appendice.............................................................................................................................................. 363

A.1 Descrizione formale del linguaggio............................................................................................363 A.1.1 Strumenti per la descrizione del linguaggio ...............................................................................363 A.1.1.1 Regole con formato definito (regole lessicali)............................................................................363 A.1.1.2 Regole senza formato definito (regole sintattiche) ....................................................................364 A.1.2 Elementi base (terminali) ...........................................................................................................365 A.1.2.1 Lettere, cifre e altri caratteri .......................................................................................................365 A.1.2.2 Caratteri di formattazione e di separazione nelle regole ...........................................................365 A.1.2.3 Caratteri di formattazione e di separazione per le costanti .......................................................367 A.1.2.4 Identificatori predefiniti per l'accesso all'immagine di processo ................................................368 A.1.2.5 Identificatori dell'informazione di avvio dei task.........................................................................368 A.1.2.6 Operatori ....................................................................................................................................369 A.1.2.7 Parole riservate..........................................................................................................................370 A.1.3 Regole........................................................................................................................................379 A.1.3.1 Definizioni...................................................................................................................................379 A.1.3.2 Scrittura delle costanti (letterale) ...............................................................................................380 A.1.3.3 Commenti...................................................................................................................................388 A.1.3.4 Sezioni della sorgente ST..........................................................................................................389 A.1.3.5 Struttura delle sorgenti ST .........................................................................................................389 A.1.3.6 Unità organizzative di programma (POE) ..................................................................................391 A.1.3.7 Componenti di dichiarazione......................................................................................................393 A.1.3.8 Costruzione dei blocchi di dichiarazione....................................................................................395 A.1.3.9 Tipi di dati...................................................................................................................................402 A.1.3.10 Sezione istruzioni.......................................................................................................................406 A.1.3.11 Assegnazioni del valore e operazioni ........................................................................................407 A.1.3.12 Richiamo di funzioni e di blocchi funzionali ...............................................................................413 A.1.3.13 Istruzioni di controllo ..................................................................................................................416

Sommario


A.2 Messaggi di errore del compilatore e informazioni per la loro rimozione ................................. 421 A.2.1 Errori di accesso al file (1000 - 1100) ....................................................................................... 421 A.2.2 Errori dello scanner (2001, 2002) ............................................................................................. 421 A.2.3 Errori di dichiarazione nella POE (3002 - 3027) ....................................................................... 422 A.2.4 Errori di dichiarazione nelle dichiarazioni del tipo di dati (4001 - 4051) ................................... 423 A.2.5 Errori di dichiarazione nelle dichiarazioni delle variabili (5001 - 5509)..................................... 424 A.2.6 Errori di espressione (6001 - 6201) .......................................................................................... 425 A.2.7 Errori di sintassi, errori di espressione (7000 - 7014) ............................................................... 429 A.2.8 Errore nel collegamento di una sorgente (8001, 8100) ............................................................ 430 A.2.9 Errore nel caricamento dell'interfaccia di un'altra UNIT o di un pacchetto tecnologico

(10000 - 10101)......................................................................................................................... 430 A.2.10 Limitazioni d'implementazione (15001 - 15700) ....................................................................... 433 A.2.11 Avvisi (16001 - 16700) .............................................................................................................. 434 A.2.12 Informazioni (32010 - 32653).................................................................................................... 439

A.3 Template per Unit di esempio ................................................................................................... 440 A.3.1 Informazioni in anteprima.......................................................................................................... 440 A.3.2 Definizione del tipo in Interface................................................................................................. 442 A.3.3 Dichiarazione delle variabili in Interface.................................................................................... 444 A.3.4 Implementation.......................................................................................................................... 445 A.3.5 Function..................................................................................................................................... 446 A.3.6 Function Block........................................................................................................................... 448 A.3.7 Program..................................................................................................................................... 449

indice ..................................................................................................................................................... 451


Premessa 1

Oltre ai normali compiti di controllo e di regolazione, i sistemi di automazione devono eseguire sempre più spesso anche la gestione dei dati e calcoli matematici complessi. A tal fine viene fornito il linguaggio di programmazione ST (Structured Text), che semplifica la programmazione in conformità con la norma IEC 61131-3 (in Germania DIN EN-61131-3).

1.1 Linguaggio di programmazione evoluto ST è un linguaggio di programmazione ad alto livello orientato al PASCAL. Il linguaggio si basa sulla norma IEC 61131-3. Questa norma fornisce lo standard dei linguaggi di programmazione per i controllori a logica programmabile (PLC). Il linguaggio ST è basato sul testo strutturato.

La programmazione dei controllori mediante un linguaggio evoluto come ST fornisce molteplici possibilità, tra cui:

● gestione dei dati

● ottimizzazione del processo

● calcoli matematici/statistici

1.2 Linguaggio di programmazione con istruzioni tecnologiche Oltre al linguaggio di programmazione standardizzato secondo IEC 61131-3, SIMOTION ST dispone di istruzioni per gli apparecchi SIMOTION, Motion Control e oggetti tecnologici.

Questi ultimi costituiscono una funzionalità tecnologica, ad esempio il posizionamento degli assi o la parametrizzazione di camme. Le istruzioni tecnologiche sono dei comandi che vengono messi a disposizione dagli oggetti tecnologici. Questi comandi servono per attivare il sincronismo delle camme elettroniche o per controllare le sequenze di movimenti, ad esempio per il posizionamento di un asse.

Premessa 1.3 Livelli di svolgimento


1.3 Livelli di svolgimento Il sistema esecutivo SIMOTION mette a disposizione diversi livelli esecutivi (ciclico, sincrono, con controllo a tempo, con controllo tramite allarmi, sequenziale) per supportare al meglio i vari task durante la programmazione dei programmi utente.

SIMOTION SCOUT rappresenta il sistema di engineering della famiglia di prodotti SIMOTION. ST è il linguaggio ad alto livello per la programmazione di programmi utente per i differenti livelli di esecuzione.

I programmi possono essere realizzati con gestione a tempo se devono essere eseguiti sincroni con il clock di sistema oppure con una determinata base tempi. il controllo tramite interrupt viene eseguito quando i programmi vengono avviati al verificarsi di un evento ed è prevista una sola esecuzione. È possibile però anche l'esecuzione sequenziale o ciclica nel livello di esecuzione Round Robin.

1.4 Editor ST con tool per la creazione ed il test dei programmi Per la realizzazione dei programmi è disponibile un confortevole editor di testo.

Il compilatore ST traduce il programma editato in codice eseguibile e segnala ogni errore di sintassi con l'indicazione della riga di programma e la causa dell'errore.

Per testare i programmi ST sono disponibili le relative funzioni di SIMOTION SCOUT. È possibile visualizzare e testare online i programmi utente.


Guida introduttiva di ST 2

Questo capitolo descrive con un semplice esempio come creare un programma, compilarlo in un codice eseguibile, eseguirlo e testarlo.

2.1 Implementazione di ST in SCOUT L'ambiente di programmazione di ST è costituito dai seguenti componenti:

● un editor per la programmazione di programmi, costituito da funzioni (FC), blocchi funzionali (FB), tipi di dati definiti dall'utente (UDT), eccetera;

● un compilatore per compilare il programma ST precedentemente modificato in un codice macchina eseguibile;

● diverse funzioni di diagnostica (ad es. Stato programma) per il supporto della ricerca di errori logici di programmazione nel programma in esecuzione;

● una visualizzazione dei dettagli, nella quale ad es. vengono visualizzati i messaggi di errore del compilatore. Una scheda importante nella visualizzazione dei dettagli è il browser dei simboli, nel quale è possibile monitorare e modificare le variabili.

I singoli componenti vengono gestiti in modo semplice e agevole. Essi sono collegati direttamente nella workbench di SIMOTION SCOUT.

Per ulteriori informazioni sull'uso della workbench e dei relativi strumenti, consultare il Manuale di progettazione di SIMOTION SCOUT.

Guida introduttiva di ST 2.1 Implementazione di ST in SCOUT


① Editor ② Compilatore ③ Stato programma ④ Visualizzazione dei dettagli (scheda Compila / verifica output)

Figura 2-1 Ambiente di sviluppo di ST

Guida introduttiva di ST 2.1 Implementazione di ST in SCOUT


2.1.1 Approccio agli elementi della workbench La workbench rappresenta la struttura di SIMOTION SCOUT. Gli strumenti che vi sono contenuti consentono di eseguire tutte le operazioni necessarie per configurare, ottimizzare e programmare una macchina in modo da poter svolgere il task richiesto.

① Barra dei menu ② Barre delle funzioni ③ Navigazione di progetto ④ Area di lavoro ⑤ Visualizzazione dei dettagli (scheda Browser dei simboli)

Figura 2-2 Elementi della workbench

Guida introduttiva di ST 2.2 Requisiti per la creazione di programmi


La workbench comprende i seguenti elementi:

● Menu

I menu contengono comandi che consentono di controllare la workbench, richiamare gli strumenti, ecc.

● Barre delle funzioni

Per eseguire molti dei comandi disponibili, è possibile fare clic sul simbolo corrispondente in una delle barre delle funzioni.

● Navigazione di progetto

La navigazione di progetto consente di visualizzare in una struttura ad albero l'intero progetto e gli elementi che lo costituiscono (ad es. la CPU, gli assi, i programmi e le camme elettroniche).

● Area di lavoro

In questa finestra si eseguono i task specifici, in modo automatico (programmazione) o con l'aiuto di un wizard (configurazione).

● Visualizzazione dei dettagli

Oltre agli elementi selezionati nella navigazione di progetto vengono visualizzate ulteriori informazioni, ad es. tutte le variabili globali associate a un programma o la finestra Compilazione/verifica dell'output.

2.2 Requisiti per la creazione di programmi Questo capitolo delinea i requisiti generali necessari per la creazione di programmi. Per informazioni dettagliate consultare il Manuale di progettazione SIMOTION SCOUT e le descrizioni delle funzioni SIMOTION Motion Control.

Inserimento o apertura di un progetto Il progetto è il livello superiore nella gerarchia della gestione dei dati. Tutti i dati, che ad es. appartengono a una macchina di produzione, vengono salvati da SIMOTION SCOUT nella directory facente parte del progetto.

In questo modo, il progetto raggruppa tutti gli apparecchi e gli azionamenti SIMOTION appartenenti a una macchina.

Soltanto dopo aver creato un progetto è possibile eseguire le seguenti operazioni:

● configurare l'hardware

● Inserimento e configurazione di oggetti tecnologici

Guida introduttiva di ST 2.3 Uso dell'editor ST e del compilatore


configurare l'hardware Il sistema deve riconoscere l'hardware utilizzato all'interno del progetto, in particolare:

● Apparecchio SIMOTION

● la periferia centralizzata (con indirizzi I/O)

● la periferia decentrata (con indirizzi I/O)

Le sorgenti ST possono essere inserite o modificate solo dopo aver configurato l'apparecchio SIMOTION.

Inserimento e configurazione di oggetti tecnologici La funzionalità di assi, camme, ecc. viene rappresentata in SIMOTION dagli oggetti tecnologici (TO).

Solo dopo l'inserimento e la configurazione è possibile programmare gli oggetti tecnologici mediante le funzioni di sistema e accedere alle variabili di sistema corrispondenti.

2.3 Uso dell'editor ST e del compilatore Nel presente capitolo si apprende come utilizzare l'editor ST e il compilatore.

2.3.1 Inserimento sorgente ST Le sorgenti ST vengono assegnate all'apparecchio SIMOTION su cui successivamente devono essere eseguiti i programmi contenuti nella sorgente (ad es. SIMOTION C240).

Sono memorizzate nella cartella PROGRAMMI della navigazione di progetto dell'apparecchio SIMOTION.

Nota

Nella cartella PROGRAMMI nell'apparecchio SIMOTION vengono memorizzate anche le sorgenti MCC, le sorgenti KOP/FUP, e gli schemi DCC.

Per una descrizione del linguaggio di programmazione SIMOTION MCC (Motion Control Chart), consultare il manuale di programmazione e d'uso SIMOTION MCC.

Per una descrizione dei linguaggi di programmazione SIMOTION KOP e SIMOTION FUP, consultare il manuale di programmazione e d'uso SIMOTION KOP/FUP.



Procedura 1. Aprire l'apparecchio SIMOTION nella relativa navigazione di progetto.

2. Selezionare la cartella PROGRAMMI.

3. Selezionare il menu Incolla > Programma Sorgente ST.

4. Immettere il nome della sorgente ST.

Per i nomi delle sorgenti di programma è necessario attenersi alleRegole per gli identificatori (Pagina 93): Essi sono costituiti da lettere (A … Z, a … z), cifre (0 … 9) o singoli caratteri di sottolineatura (_) nella sequenza desiderata, dove il primo carattere deve essere una lettera o un carattere di sottolineatura. Non viene operata alcuna distinzione fra lettere maiuscole e minuscole.

La lunghezza dei nomi consentita dipende dalla versione del SIMOTION Kernel:

– A partire dalla versione V4.1 del SIMOTION Kernel: max. 128 caratteri.

– fino alla versione V4.0 del SIMOTION Kernel: max. 8 caratteri.

I nomi devono essere univoci all'interno dell'apparecchio SIMOTION.

Non sono ammessi identificatori (Pagina 95) protetti o riservati.

Vengono visualizzate le sorgenti di programma (ad es. ST e MCC) esistenti fino a quel momento.

5. È inoltre possibile immettere l'autore, la versione e un commento.

6. Selezionare la casella di controllo Apri editor automaticamente.

7. Selezionare eventualmente altre schede per definirvi le impostazioni locali (valido solo per questa sorgente ST):

– Scheda Compilatore: impostazioni locali del compilatore (Pagina 61) per la generazione del codice e la visualizzazione dei messaggi.

– Scheda Altre impostazioni: Definizioni del preprocessore (Pagina 70)

8. Confermare con OK.



Figura 2-3 Inserimento sorgente ST

ATTENZIONE Selezionando OK la sorgente ST viene applicata solo nel progetto. I dati vengono salvati sul supporto dati soltanto assieme al progetto, ad es. con Progetto > Salva o Progetto > Salva e compila modifiche o Progetto > Salva e ricompila tutto.



2.3.2 Apertura di una sorgente ST esistente

Procedura Per aprire una sorgente ST, procedere come segue:

1. Nella navigazione di progetto, aprire la sottostruttura ad albero del relativo apparecchio SIMOTION.

2. Aprire la cartella PROGRAMMI.

3. Selezionare la sorgente ST desiderata.

4. Selezionare il menu Modifica > Apri oggetto.

5. Solo per sorgenti ST dotate di protezione del know-how:

Se la sorgente ST non è ancora stata aperta e il login assegnato alla stessa sorgente non è ancora stato registrato:

– Immettere la password relativa al login indicato.

La protezione del know-how per questa sorgente è temporaneamente disattivata (fino alla relativa chiusura).

– Eventualmente attivare la casella di controllo "Usa il login come login standard".

La registrazione avverrà con questo login e le altre sorgenti, cui è associato lo stesso login, possono venire aperte senza che sia necessario reimmettere la password.

La sorgente ST viene aperta con le informazioni nascoste (Pagina 33) e i segnalibri (Pagina 45) salvati. È possibile aprire più sorgenti.

Nota

È possibile fare doppio clic sulla sorgente ST per aprirla.



2.3.3 Modifica delle proprietà di una sorgente ST

Procedura 1. In corrispondenza dell'apparecchio SIMOTION, aprire la cartella PROGRAMMI.

2. Selezionare la sorgente ST desiderata.

3. Selezionare il menu Modifica > Proprietà dell'oggetto.

4. Selezionare eventualmente altre schede per definirvi le impostazioni locali (valido solo per questa sorgente ST):

– Scheda Generale: indicazioni generali sulla sorgente ST, ad es. dimensioni del codice al momento dell'ultima compilazione, indicazione oraria dell'ultima modifica e percorso di salvataggio del progetto (vedere figura).

– Scheda Compilatore: impostazioni locali del compilatore (Pagina 61) per la generazione del codice e la visualizzazione dei messaggi.

– Scheda Altre impostazioni: definizioni del preprocessore (Pagina 70) come la visualizzazione delle opzioni del compilatore (Pagina 67) in base alle sue impostazioni attuali.

– Scheda Compilazione: visualizzazione delle opzioni del compilatore (Pagina 67) all'ultima compilazione della sorgente ST.

– Scheda Indirizzo oggetto: impostazione dell'indirizzo interno dell'oggetto della sorgente ST. Vengono visualizzati gli indirizzi dell'oggetto di altre sorgenti del programma.



Figura 2-4 Proprietà di una sorgente ST

Modifica del nome di una sorgente ST È possibile modificare anche il nome della sorgente ST premendo il pulsante [...] .

Per i nomi delle sorgenti di programma è necessario attenersi alle regole per gli identificatori: Questi sono costituiti da lettere (A … Z, a … z), cifre (0 … 9) o singoli caratteri di sottolineatura (_) nella sequenza desiderata, dove il primo carattere deve essere una lettera o un carattere di sottolineatura. Non viene operata alcuna distinzione fra lettere maiuscole e minuscole.

La lunghezza dei nomi consentita dipende dalla versione del SIMOTION kernel:

● A partire dalla versione V4.1 del SIMOTION kernel: max. 128 caratteri.

● fino alla versione V4.0 del SIMOTION kernel: max. 8 caratteri.

I nomi devono essere univoci all'interno dell'apparecchio SIMOTION.

Non sono ammessi identificatori (Pagina 95) protetti o riservati.



Vengono visualizzate le sorgenti di programma (ad es. ST e MCC) esistenti fino a quel momento.

ATTENZIONE Con le versioni fino alla V4.0 del SIMOTION kernel si rileva in determinate circostanze un superamento della lunghezza consentita del nome di una sorgente di programma non appena si avvia una verifica della coerenza o il download della sorgente di programma.

2.3.4 Uso dell'editor ST L'editor ST facilita l'uso della sorgente ST, delle variabili e degli oggetti tecnologici grazie ai seguenti elementi di comando:

● Syntaxcoloring

● Drag&Drop

● Comandi di menu e tasti di scelta rapida

Figura 2-5 Sorgente ST aperta nell'editor ST

2.3.4.1 Syntaxcoloring L'editor ST distingue gli elementi linguistici con diversi colori:

● Blu: Parole chiave e funzioni incorporate del compilatore

● Magenta: numeri, valori

● Verde: Commenti

● Nero: oggetti tecnologici, codice utente, variabili



2.3.4.2 Drag&Drop

Drag&Drop Il Drag&Drop (trascinamento tenendo premuto il tasto sinistro del mouse) consente di eseguire le operazioni seguenti:

● Spostamento delle aree di testo selezionate all'interno della sorgente ST o in un'altra sorgente ST aperta.

● Copia dei nomi delle variabili dal browser dei simboli nella sorgente ST.

● Copia dei nomi (ad es. di oggetti tecnologici, funzioni e blocchi funzionali) dalla navigazione di progetto nella sorgente ST.

● Copia delle funzioni di sistema dalla libreria comandi nella sorgente ST

Per copiare i nomi delle variabili dal browser dei simboli nella sorgente ST, procedere come segue:

1. Selezionare l'intera riga delle variabili desiderate nel browser dei simboli. Fare clic sul numero di riga all'inizio della riga.

2. Trascinare il numero di riga nella posizione desiderata all'interno della sorgente ST tenendo premuto il tasto sinistro del mouse.

Il nome della variabile selezionata viene inserito nella sorgente ST.

Per copiare il nome di un elemento (ad es. un oggetto tecnologico, una funzione o un blocco funzionale) dalla navigazione di progetto nella sorgente ST, procedere come segue:

1. Selezionare nella navigazione di progetto la scheda Progetto.

2. Selezionare l'elemento nella navigazione di progetto.

3. Trascinare l'elemento nella posizione desiderata all'interno della sorgente ST tenendo premuto il tasto sinistro del mouse.

Il nome dell'elemento selezionato viene inserito nella sorgente ST.

Per copiare una funzione di sistema dalla libreria comandi nella sorgente ST:

1. Selezionare nella navigazione di progetto la scheda Libreria comandi.

2. Contrassegnare la funzione di sistema nella libreria comandi.

3. Trascinare la funzione di sistema nella posizione desiderata all'interno della sorgente ST tenendo premuto il tasto sinistro del mouse.

La funzione di sistema viene incollata con i relativi parametri nella sorgente ST.



2.3.4.3 Impostazioni dell'editor ST

Procedura: 1. Selezionare il menu Strumenti > Impostazioni.

2. Selezionare la scheda Editor ST / Scripting.

3. Effettuare le impostazioni desiderate.

4. Confermare con OK o Applica.

Figura 2-6 Impostazioni editor ST / scripting

Le impostazioni sono valide anche per l'editor di script.

La tabella seguente riporta una descrizione dei singoli parametri:

Tabella 2- 1 Parametri impostazioni editor ST / scripting

Parametro Descrizione Visualizza numerazione righe Se questo parametro è attivo, viene visualizzato il numero

di righe. Vedere: Altri strumenti dell'editor ST (Pagina 48).

Sostituisci tabulazioni con spazi Selezionare qui come avviene il rientro del testo (rientro automatico o inserimento di tabulazioni con il tasto TAB): • Se attivo: tramite l'immissione del numero

corrispondente di spazi vuoti ($20). • Se inattivo: tramite l'immissione di tabulazioni ($09). Vedere: Rientri e tabulazioni (Pagina 31).



Parametro Descrizione Ampiezza tabulazione Numero di caratteri saltati da una tabulazione.

Vedere: Rientri e tabulazioni (Pagina 31). Descrizione comando per parametri funzionali

Se attiva, con le funzioni i parametri vengono visualizzati sotto forma di descrizione comando.

Inserimento/disinserimento automatici Se attivo, all'immissione del testo vengono automaticamente inseriti dei rientri per le sezioni del file sorgente e per i blocchi con l'ampiezza di tabulazione impostata. Vedere: Rientri e tabulazioni (Pagina 31).

Folding attivo Se attivo, nella colonna a sinistra accanto all'area di modifica vengono visualizzate le informazioni che erano nascoste. È quindi possibile nascondere i blocchi di una sorgente ST in modo da visualizzare unicamente la prima riga del blocco. Vedere: Espandere/comprimere (visualizzare e nascondere i blocchi) (Pagina 33).

Visualizza livelli di rientro Se attivo, i rientri dei blocchi verso destra e verso sinistra vengono visivamente evidenziati da linee di riferimento verticali (secondo l'ampiezza di tabulazione impostata). Vedere: Rientri e tabulazioni (Pagina 31).

Visualizzazione delle coppie di parentesi

Se attivo, la parentesi associata a un'altra parentesi posta accanto al cursore viene ricercata ed evidenziata visivamente. Vedere: Altri strumenti dell'editor ST (Pagina 48).

Tipo di carattere Tipo di carattere per la visualizzazione del testo nell'editor. Sono disponibili per la selezione tutti i caratteri non proporzionali installati sul PC.

Grandezza carattere Grandezza carattere (in pt) per la visualizzazione del testo nell'editor. Vedere: Modifica della grandezza del carattere nell'editor ST (Pagina 39).

Formato per la visualizzazione di stato 1

Formato in cui i valori di variabili con tipo di dati bit vengono visualizzati per Stato programma oppure Stato variabile (solo per editor ST). Vedere: Proprietà di Stato programma (Pagina 332), Stato variabile (Pagina 329)

1 Solo per editor ST



2.3.4.4 Rientri e tabulazioni

Impostazione dell'ampiezza di tabulazione L'ampiezza di tabulazione standard per tutte le sorgenti ST si definisce in Impostazioni dell'editor ST (Pagina 29).

Questa impostazione è valida per tutte le sorgenti ST che verranno aperte.

Rientri tramite tabulazioni o spazi In Impostazioni dell'editor ST (Pagina 29) è possibile scegliere come effettuare il rientro del testo (ad es. con il rientro automatico verso destra o verso sinistra o tramite l'inserimento di tabulazioni con il tasto TAB):

● tramite l'immissione del numero corrispondente di spazi vuoti ($20).

● tramite l'immissione di tabulazioni ($09).

Questa impostazione è valida per tutte le sorgenti ST che verranno aperte.

Rientro automatico dei blocchi verso destra o verso sinistra L'editor ST riconosce i blocchi che iniziano con una parola chiave e terminano con un'altra parola chiave, ad es.:

● INTERFACE / END_INTERFACE

● IMPLEMENTATION / END_IMPLEMENTATION

● Blocchi di dichiarazione (ad es. TYPE / END_TYPE, VAR / END_VAR)

● Unità di organizzazione del programma (ad es. PROGRAM / END_PROGRAM)

● Istruzioni di controllo (ad es. IF / END_IF, FOR / END_FOR)

Durante l'immissione dei testi l'editor ST consente di rientrare automaticamente i testi di un'ampiezza di tabulazione all'interno dei blocchi. L'ultima riga del blocco viene automaticamente rientrata.

Questa funzione si attiva in Impostazioni dell'editor ST (Pagina 29).

Nota

Questa impostazione influisce solo sul comportamento all'immissione del testo. Non ha alcun effetto sui testi già inseriti nelle sorgenti ST.

Formatta la selezione attuale Con questa funzione è possibile forzare il rientro di un'ampiezza di tabulazione dei blocchi di un testo già inserito (vedere sopra) in base alla loro gerarchia. Il numero degli spazi vuoti o delle tabulazioni viene adattato:

● all'ampiezza di tabulazione attuale della sorgente ST.

● all'impostazione attuale del tipo di rientro (con tabulazioni o con spazi vuoti).



Procedere come segue:

1. Selezionare nell'editor ST l'area di testo che si desidera formattare (vedere Seleziona testo (Pagina 40)).

2. Selezionare il menu contestuale Vista > Formatta selezione attuale.

ATTENZIONE Le tabulazioni o gli spazi vuoti in una riga vengono sostituiti solo se il loro numero cambia durante la formattazione.

Rientro dell'area selezionata verso destra o verso sinistra Con questa funzione è possibile far rientrare di un'ampiezza di tabulazione verso destra o verso sinistra le sezioni di testo selezionate.


1. Selezionare nell'editor ST l'area di testo che si desidera far rientrare verso destra o verso sinistra (vedere Seleziona testo (Pagina 40)).

L'area di testo selezionata deve comprendere più righe.

2. Selezionare il menu contestuale Rientro dell'area selezionata o Annulla rientro.

Guida rientro (visualizza livelli di rientro) I rientri dei blocchi verso destra e verso sinistra possono essere visivamente evidenziati da linee di riferimento verticali (in corrispondenza dell'ampiezza di tabulazione impostata).

Figura 2-7 Sorgente ST con linea di riferimento del rientro visualizzata



È possibile attivare/disattivare questa funzione:

● Per la sorgente ST attiva

– Selezionare il menu contestuale Vista > Guida rientro.

Questa impostazione non viene salvata alla chiusura della sorgente ST.

● Per tutte le sorgenti ST aperte:

– Attivare o disattivare la casella di controllo Visualizza livelli di rientro in Impostazioni dell'editor ST (Pagina 29).

Questa impostazione è valida anche per tutte le sorgenti ST che verranno aperte.

2.3.4.5 Espandere/comprimere (visualizzare e nascondere i blocchi) È possibile nascondere i blocchi di una sorgente ST in modo da visualizzare unicamente la prima riga del blocco. Con questa impostazione migliora la visibilità durante la modifica o la lettura di una sorgente ST più lunga.

Un blocco inizia con una parola chiave e termina con un'altra parola chiave, ad es.:

● INTERFACE / END_INTERFACE

● IMPLEMENTATION / END_IMPLEMENTATION

● Blocchi di dichiarazione (ad es. TYPE / END_TYPE, VAR / END_VAR)

● Unità di organizzazione del programma (ad es. PROGRAM / END_PROGRAM)

● Istruzioni di controllo (ad es. IF / END_IF, FOR / END_FOR)

● Commento a blocchi (* / *)

Per visualizzare e nascondere i blocchi l'espansione/compressione deve essere attiva, vedere sotto. La colonna con le informazioni che erano nascoste (a sinistra accanto all'area di modifica) viene quindi visualizzata.

Per riconoscere che con l'espansione/compressione attiva un blocco è visualizzato:

● All'altezza della prima riga del blocco compare il segno (meno).

Per riconoscere che un blocco è nascosto:

● All'altezza della prima riga visibile del blocco compare il segno (più).

● Sotto questa riga è visualizzata una barra. Questa barra è visibile anche se la colonna con le informazioni nascoste non è visualizzata.



Figura 2-8 Sorgente ST con tutti i blocchi visualizzati

Figura 2-9 Sorgente ST con blocco IF nascosto (incluso commento blocco)

Attivazione o disattivazione espansione/compressione Per poter visualizzare e nascondere i blocchi la funzione espansione/compressione deve essere attiva. La colonna con le informazioni che erano nascoste (a sinistra dell'area di modifica) viene quindi visualizzata.

Per attivare o disattivare la funzione espansione/compressione:



● Per la sorgente ST attiva:

– Selezionare il menu contestuale Vista > Folding.



– Attivare o disattivare la casella di controllo Folding attivo in Impostazioni dell'editor ST (Pagina 29).


Visualizzare e nascondere blocchi È possibile visualizzare o nascondere blocchi solo se per la sorgente è attiva la funzione espansione/compressione (vedere sopra). La colonna con le informazioni nascoste viene quindi visualizzata.

Per visualizzare o nascondere un blocco:

● Per nascondere singoli blocchi (alternativa):

– Fare clic con il mouse sul segno (meno) nella colonna con le informazioni nascoste.

– Posizionare il cursore nella riga corrispondente del blocco e premere la combinazione di tasti CTRL+ALT+T.

Rimane visibile solo la prima riga del blocco. Tutte le righe successive del blocco (incluse le righe dei blocchi subordinati) vengono nascoste.

Lo stato di visualizzazione o compressione dei blocchi subordinati viene memorizzato e viene ripristinato alla visualizzazione di singoli blocchi.

● Per visualizzare singoli blocchi (alternativa):

– Fare clic con il mouse sul segno (più) nella colonna con le informazioni nascoste.

– Posizionare il cursore nella riga visibile del blocco e premere la combinazione di tasti CTRL+ALT+T.

Tutte le righe successive del blocco vengono visualizzate. I blocchi subordinati vengono segnalati come segue: Se è stato memorizzato lo stato di visualizzazione e compressione (ad es. in caso di compressione di singoli blocchi), questo viene ripristinato.

● Per nascondere tutti i blocchi:

– Premere la combinazione di tasti CTRL+ALT+C.

Tutti i blocchi della sorgente ST (inclusi tutti i blocchi subordinati) vengono nascosti. Soltanto la prima riga di ciascun blocco del 1° ordine resta visibile (normalmente INTERFACE e IMPLEMENTATION).

● Per visualizzare tutti i blocchi:

– Premere la combinazione di tasti CTRL+ALT+D.

Tutti i blocchi della sorgente ST (inclusi tutti i blocchi subordinati) vengono visualizzati. Tutte le righe della sorgente ST sono visibili.



● Per nascondere i blocchi subordinati:

– Posizionare il cursore nella riga corrispondente del blocco e premere la combinazione di tasti CTRL+ALT+V.

Tutti i blocchi subordinati al blocco attuale vengono nascosti, il blocco attuale viene visualizzato. Soltanto le righe del blocco attuale e le prime righe dei blocchi dell'ordine successivo sono visibili.

● Per visualizzare i blocchi subordinati:

– Posizionare il cursore nella riga corrispondente del blocco e premere la combinazione di tasti CTRL+ALT+R.

Il blocco attuale e tutti i blocchi subordinati vengono visualizzati. Tutte le righe di questi blocchi sono visibili.

Nota

Le informazioni sui blocchi visualizzati e nascosti vengono salvate alla chiusura della sorgente ST nel progetto.

Durante l'esportazione della sorgente ST (Pagina 71) queste informazioni non vengono applicate.

2.3.4.6 Suddivisione finestra dell'editor È possibile suddividere la finestra dell'editor ST in due segmenti. Ciò consente di ottenere due viste della stessa sorgente ST.

Suddivisione della finestra o eliminazione della suddivisione Procedere come segue per suddividere l'attuale finestra dell'editor in due segmenti o per eliminare la suddivisione.

● Selezionare il menu Sorgente ST > Suddividi finestra.

Il cursore si trova accanto alla suddivisione, nel segmento superiore della finestra.

Le impostazioni per la suddivisione della finestra dell'editor non vengono salvate alla chiusura della sorgente ST. Le sorgenti ST vengono sempre aperte in una finestra non suddivisa.

Nota

Se si utilizza la funzione di test Stato programma (Pagina 334) la finestra dell'editor non può essere suddivisa.



Figura 2-10 Editor ST con suddivisione finestra

Adattamento altezza del segmento È possibile adattare l'altezza dei due segmenti alle proprie esigenze specifiche:

1. Con il mouse spostare il cursore sulla linea di separazione dei due segmenti, finché non assume la forma di una doppia freccia (vedere figura sopra).

2. Trascinare la linea di separazione nella posizione desiderata tenendo premuto il pulsante sinistro del mouse.



2.3.4.7 Visualizzazione di spazi vuoti e tabulazioni È possibile visualizzare gli spazi vuoti e le tabulazioni nelle sorgenti ST.

Figura 2-11 Sorgente ST con spazi vuoti e tabulazioni visibili

Procedura Per visualizzare/nascondere gli spazi vuoti e le tabulazioni nella sorgente ST attiva:

1. Posizionare il cursore nella sorgente ST aperta.

2. Selezionare il menu contestuale Vista > Simboli di formattazione.




2.3.4.8 Modifica della dimensione del carattere nell'editor ST Nell'editor è possibile modificare la dimensione del carattere della sorgente ST. Eseguendo questa operazione vengono adattate anche la dimensione del carattere dei numeri di riga e quella di altri elementi di visualizzazione (ad es. segni di piegatura, segnalibri).

Figura 2-12 Visualizzazione ingrandita della sorgente ST

Procedura È possibile modificare la dimensione del carattere:

● della sorgente ST attiva

● delle sorgenti ST da aprire in seguito

Per modificare la dimensione del carattere della sorgente ST attuale (alternativa):

● Premere il tasto CTRL e ruotare al contempo la rotellina del mouse.

● Premere contemporaneamente il tasto CTRL e uno dei seguenti tasti del tastierino numerico:

– PIÙ (+) per ingrandire,

– MENO (-) per rimpicciolire,

– DIV per visualizzare al 100 % delle proporzioni.

Per modificare la dimensione del carattere delle sorgenti ST da aprire in seguito

1. Aprire il menu di impostazione dell'editor ST (vedere Impostazioni dell'editor ST (Pagina 29)).

2. Impostare la dimensione del carattere desiderata.

L'impostazione si applicherà a tutte le sorgenti ST che verranno aperte. Non ha invece effetto sulle sorgenti ST già aperte.



2.3.4.9 Selezione di testo

Selezione del testo per righe Per selezionare il testo per righe, procedere come segue:

● Con il mouse:

– Tenendo premuto il tasto sinistro del mouse, passare sopra al testo da selezionare.

oppure

● Con la tastiera o con il mouse:

– Posizionare il cursore all'inizio del testo da selezionare utilizzando i tasti freccia della tastiera o il mouse.

– Premere il tasto CTRL e spostare al contempo il cursore alla fine del testo da selezionare. A questo proposito vedere anche i tasti di scelta rapida o shortcut (Pagina 54).

Figura 2-13 Sorgente ST con testo selezionato per righe



Selezione del testo per colonne Per selezionare il testo per colonne, procedere come segue:

● Con il mouse:

– Premere il tasto ALT e passare sopra al testo da selezionare tenendo premuto contemporaneamente il tasto sinistro del mouse.

oppure

● Con la tastiera o con il mouse:

– Posizionare il cursore all'inizio del testo da selezionare utilizzando i tasti freccia della tastiera o il mouse.

– Premere la combinazione di tasti ALT+SHIFT e spostare al contempo il cursore alla fine del testo da selezionare. A questo proposito vedere anche i tasti di scelta rapida o shortcut (Pagina 54).

Figura 2-14 Sorgente ST con testo selezionato per colonne

Selezione di singole righe Per selezionare il testo per singole righe, procedere come segue:

● Fare clic con il tasto sinistro del mouse sul numero di riga a destra della riga corrispondente.

Selezione dell'intero testo Per selezionare l'intero testo, procedere come segue (alternative):

● Premere il tasto CTRL e fare contemporaneamente clic con il pulsante sinistro del mouse nella colonna con i numeri di riga.

● Premere la combinazione di tasti Ctrl+A.



2.3.4.10 Creazione di una successione numerica semplice (creazione sequenza) Per creare nell'editor ST delle successioni di numeri interi semplici (sequenze), secondo un determinato modello, procedere come segue. Ciò può essere utile ad es. per l'inizializzazione di un campo.

Procedura 1. Selezionare nell'editor ST i numeri da sostituire con una successione numerica (ad es.

per colonna), vedere Seleziona testo (Pagina 40)).

2. Premere la combinazione di tasti CTRL+SHIFT+F7.

L'editor ST interpreta tutti i numeri selezionati come possibili componenti di una successione e tenta di riconoscere dai componenti iniziali il modello della successione e di calcolare i componenti successivi (vedere sotto). I componenti iniziali della successione devono essere numeri interi. Dopo il calcolo l'editor ST sostituisce tutti i numeri selezionati che seguono i componenti iniziali con i valori calcolati.

Figura 2-15 Esempio per la creazione di successioni numeriche nell'editor ST



Calcolo dei componenti della successione Tutti i numeri selezionati nell'editor ST vengono interpretati come possibili componenti successivi. I componenti iniziali dai quali viene calcolata la successione devono essere numeri interi.

Dalla definizione della successione numerica si evince che un componente successivo an+1 viene calcolato dal componente precedente an con una funzione lineare con i coefficienti interi j e k. Vale così la seguente formula:

an+1 = f(an) = j · an + k

I coefficienti j e k vengono calcolati dai componenti iniziali della successione:

1. Per prima cosa si tenta di definire dai 3 componenti iniziali della successione numerica a1, a2 e a3 i coefficienti interi j e k (j ≥ 0).

2. Se ciò non è possibile, per la valutazione vengono definiti solo i primi due componenti successivi a1 e a2:

– Il coefficiente j viene impostato = 1.

– Il coefficiente k viene definito dalla formula risultante a2 = a1 + k.

Con questi valori viene calcolata la successione numerica. Tutti i numeri selezionati vengono sostituiti dai componenti calcolati; i componenti iniziali della successione rimangono invariati.

La tabella seguente mostra alcuni esempi per le successioni numeriche calcolate in questo modo.

Tabella 2- 2 Esempi per successioni numeriche con componenti iniziali predefiniti.

Componenti iniziali delle successioni

Risultato calcolato

a1 a2 a3 j k Formula

Successione numerica risultante

0 1 2 1 1 an+1 = an + 1 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 … 1 2 3 1 1 an+1 = an + 1 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 … 0 2 4 1 2 an+1 = an + 2 0, 2, 4, 6, 8, 10, 12, 14, 16, 18 … 1 2 4 2 0 an+1 = 2an 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 … 2 3 5 2 -1 an+1 = 2an - 1 2, 3, 5, 9, 17, 33, 65, 129, 257, 513 … 2 1 1 0 1 an+1 = 1 2, 1, 1, 1, 1, 1, 1, 1, 1, 1 … 3 2 1 1 -1 an+1 = an - 1 3, 2, 1, 0, -1, -2, -3, -4, -5, -6 … 0 1 0 1 1 1 an+1 = an + 1 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 … 0 0 2 1 1 0 an+1 = an 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 …

1 Solo i componenti iniziali a1 e a2 della successione vengono considerati, a3 non è preso in considerazione e viene calcolato.



ATTENZIONE I componenti iniziali della successione utilizzati per il calcolo devono essere numeri interi. Possono però essere definiti anche nella rappresentazione con numeri a virgola mobile.

I numeri da considerare per il calcolo della successione devono essere selezionati completamente.

Nell'area selezionata possono trovarsi solo numeri e caratteri speciali selezionati (ad es. parentesi di apertura e di chiusura, virgole).

Se il primo carattere nell'area selezionata non è consentito, il calcolo della successione viene interrotto.

Vedere esempi nella figura seguente.

Figura 2-16 Esempi di come selezioni errate possono portare a risultati indesiderati nella creazione

di una successione numerica nell'editor ST



2.3.4.11 Utilizzo dei segnalibri Nell'editor ST è possibile impostare dei segnalibri. I segnalibri consentono di spostarsi su righe selezionate all'interno della sorgente ST.

Figura 2-17 Sorgente ST con segnalibri

Impostazione ed eliminazione dei segnalibri Per impostare un segnalibro su una riga della sorgente ST attiva o per eliminare un segnalibro già inserito, procedere come segue:

● Con tastiera e mouse:

– Premere il tasto CTRL.

– Fare contemporaneamente clic con il pulsante sinistro del mouse sul numero di riga a destra della riga corrispondente.

● Con il mouse:

– Posizionare il cursore nella riga corrispondente della sorgente ST.

– Selezionare il menu contestuale Segnalibro > Inserisci/rimuovi segnalibro.

Nota

I segnalibri vengono salvati alla chiusura della sorgente ST.



Utilizzo dei segnalibri Per spostarsi al segnalibro successivo all'interno della sorgente ST, procedere come segue:

● Selezionare il menu contestuale Segnalibro > Segnalibro successivo.

Per spostarsi al segnalibro precedente all'interno della sorgente ST, procedere come segue:

● Selezionare il menu contestuale Segnalibro > Segnalibro precedente.

Eliminazione di tutti i segnalibri Per eliminare tutti i segnalibri in una sorgente ST, procedere come segue:

● Selezionare il menu contestuale Segnalibro > Rimuovi tutti i segnalibri.

2.3.4.12 Completamento automatico Nell'editor ST è possibile impostare il completamento automatico degli identificatori. Viene visualizzato un elenco di selezione degli identificatori che iniziano con il carattere finora immesso.

Figura 2-18 Completamento automatico di un identificatore nell'editor ST (ad es. END_)

Procedura Per completare automaticamente un identificatore, procedere come segue:

1. Scrivere i primi caratteri dell'identificatore (ad es. le lettere di una parola).

2. Premere la combinazione di tasti CTRL+spazio.

Le opzioni vengono visualizzate in una finestra.



3. Ampliare o affinare le possibilità di selezione visualizzate:

– Immettere ulteriori caratteri.

– Cancellare alcuni caratteri.

– Spostare il cursore con i tasti freccia a sinistra/destra.

4. Selezionare l'identificatore desiderato con i tasti freccia in alto/in basso.

5. Applicare l'identificatore. La parola attuale viene sovrascritta.

Nota

Se l'identificatore selezionabile è solo uno, la finestra di selezione non viene visualizzata e l'identificatore viene immesso direttamente.

Modo di funzionamento È possibile scegliere tra i seguenti identificatori che iniziano con il carattere preimpostato:

● Parole chiave del linguaggio Structured Text

● Identificatori della libreria dei comandi

● Oggetti tecnologici, incluse relative variabili di sistema e dati di configurazione

● Identificatori della rispettiva sorgente ST:

– Unità di organizzazione del programma (POE)

– Tipi di dati

– Variabili e costanti

– Elementi della struttura

● Identificatori di sorgenti di programma importate

Nota

Gli identificatori della rispettiva sorgente ST o di sorgenti di programma importate vengono correttamente visualizzati solo se è stata compilata la sorgente di programma corrispondente.

La visualizzazione è sensibile al contesto; ciò significa che vengono visualizzati soli i tipi di identificatori che hanno un significato nella rispettiva posizione della sorgente ST: • all'interno di un blocco di dichiarazione solo i tipi di dati e le parole chiave • all'interno di un'unità di organizzazione del programma (POE) nessun tipo di dati • con una struttura (ad es. var_struct.xx) solo i componenti strutturali



2.3.4.13 Apri blocco richiamato Dall'editor ST è possibile aprire e modificare direttamente un'unità di organizzazione del programma (POE) definita dall'utente e richiamata nella sorgente ST, ad es. una funzione o un blocco funzionale.

1. Impostare il cursore nell'identificatore di un'unità di organizzazione del programma (POE), ad es. al richiamo di una funzione o alla dichiarazione di istanza di un blocco funzionale.

2. Nel menu contestuale, selezionare Apri blocco richiamato.

Il comportamento dipende dal linguaggio di programmazione in cui è registrata la sorgente della POE richiamata:

● Linguaggio di programmazione SIMOTION ST:

La sorgente ST corrispondente viene eventualmente aperta. Il cursore viene posizionato all'inizio della POE corrispondente, nella sezione implementazione.

All'interno della stessa sorgente ST il cursore passa all'inizio della POE nella sezione implementazione.

● Linguaggi di programmazione SIMOTION MCC o SIMOTION KOP/FUP

La POE corrispondente (MCC-Chart, programma KOP/FUP) viene aperta nel relativo editor.

2.3.4.14 Altri strumenti dell'editor ST

Visualizzazione delle coppie di parentesi Le due parentesi di una coppia di parentesi possono essere evidenziate visivamente.

Posizionare il cursore accanto a una parentesi. L'editor cerca di rilevare l'altra parentesi che forma la coppia e all'occorrenza visualizza entrambe le parentesi. Questo ne facilita l'individuazione, soprattutto in caso di annidamenti.

Per attivare o disattivare questa funzione, procedere come segue:


– Selezionare il menu contestuale Vista > Visualizza coppia di parentesi.



– Attivare o disattivare la casella di controllo Visualizza coppie di parentesi nelle impostazioni dell'editor ST (Pagina 29).




Visualizza e nascondi numeri di righe Nell'editor ST è possibile visualizzare i numeri di riga:

Per attivare o disattivare questa funzione, procedere come segue:


– Selezionare il menu contestuale Vista > Numerazione righe.



– Attivare o disattivare la casella di controllo Visualizza numerazione righe nelle impostazioni dell'editor ST (Pagina 29).


Modifica scrittura maiuscola e minuscola È possibile modificare la grafia di un testo selezionato in lettere maiuscole o minuscole:

1. Selezionare il testo di cui si desidera modificare la grafia, vedere Seleziona testo).

2. Selezionare il menu contestuale Selezione in maiuscole o Selezione in minuscole.

Visualizzazione descrizione comandi Per alcuni identificatori l'editor ST fornisce un supporto tramite la visualizzazione di una descrizione dei comandi. Per visualizzare la descrizione, soffermarsi per alcuni istanti sull'identificatore con il puntatore del mouse.

Ad esempio, per l'identificatore delle variabili nella descrizione viene indicato il relativo tipo di dati. Ulteriori descrizioni dei comandi in preparazione.

2.3.4.15 Uso della libreria comandi La libreria comandi è una scheda della navigazione di progetto. Essa contiene le funzioni di sistema, i blocchi di funzioni di sistema e gli operatori disponibili.

Questi elementi possono essere spostati con Drag&Drop dalla libreria comandi nella finestra dell'editor ST.



2.3.4.16 Barra delle funzioni editor ST La barra degli strumenti consente di eseguire importanti operazioni di programmazione:

Tabella 2- 3 Barra degli strumenti dell'editor ST

Simbolo Significato

Applicazione e compilazione Fare clic su questa icona per applicare la sorgente ST attiva al progetto e compilarla in un codice eseguibile. Vedere: Avvio del compilatore (Pagina 58).

Inserimento sorgente ST Fare clic su questa icona per creare una nuova sorgente ST. Il pulsante è attivo solo se nella navigazione di progetto è evidenziata la cartella PROGRAMMI in cui memorizzare la sorgente ST. Vedere: Inserimento sorgente ST (Pagina 21).

Stato programma Fare clic su questa icona per avviare la modalità di test Stato programma. Durante l'esecuzione del programma è possibile monitorare i valori delle variabili selezionate nella sorgente ST. Sono necessari i presupposti seguenti: 1. Il programma deve essere compilato con le opzioni del compilatore

corrispondenti. 2. Il progetto e il programma devono essere caricati nel sistema di destinazione. 3. Deve essere presente un collegamento ONLINE al sistema di destinazione. Fare nuovamente clic su questa icona per chiudere Stato programma. Vedere: Uso di Stato programma (Pagina 334).

Sospensione della supervisione delle variabili del programma Fare clic su questa icona per sospendere la supervisione delle variabili del programma nella modalità di test Stato programma. Vedere Uso di Stato programma (Pagina 334).

Proseguimento della supervisione delle variabili del programma Fare clic su questa icona per proseguire la supervisione delle variabili del programma nella modalità di test Stato programma. Vedere: Uso di Stato programma (Pagina 334).

Aggiorna Fare clic su questa icona per forzare l'aggiornamento dei valori visualizzati nella modalità di test Stato programma. La supervisione delle variabili del programma deve essere attivata. Vedere: Uso di Stato programma (Pagina 334).

Formatta la selezione attuale Fare clic su questa icona per far rientrare verso destra di un'ampiezza di tabulatore i blocchi nell'area di testo selezionata in base alla relativa gerarchia. Vedere Rientri e tabulazioni (Pagina 31).

Simboli di formattazione on / off Fare clic su questa icona per visualizzare o nascondere gli spazi vuoti e le tabulazioni nella sorgente ST attiva. Vedere Visualizzazione di spazi vuoti e tabulazioni (Pagina 38).



Simbolo Significato

Inserisci/rimuovi segnalibro Fare clic su questa icona per impostare un segnalibro nella riga attuale della sorgente ST attiva o per eliminare un segnalibro presente. Vedere: Utilizzo dei segnalibri (Pagina 45).

Segnalibro successivo Fare clic su questa icona per passare al segnalibro successivo nella sorgente ST attiva. Vedere: Utilizzo dei segnalibri (Pagina 45).

Segnalibro precedente Fare clic su questa icona per passare al segnalibro precedente nella sorgente ST attiva. Vedere: Utilizzo dei segnalibri (Pagina 45).

Cancella tutti i segnalibri Fare clic su questa icona per rimuovere tutti i segnalibri dalla sorgente ST attiva. Vedere: Utilizzo dei segnalibri (Pagina 45).

Vai a inizio blocco Fare clic su questa icona per spostare il cursore all'inizio del blocco attuale o superiore.

Vai a fine blocco Fare clic su questa icona per spostare il cursore alla fine del blocco attuale.

2.3.4.17 Menu contestuale editor ST Se in una sorgente ST aperta si preme il pulsante destro del mouse, viene visualizzato il menu contestuale Editor ST.

A seconda dell'applicazione attiva / dell'editor attivo o della modalità (ONLINE/OFFLINE), determinati comandi non vengono visualizzati o non possono essere selezionati.

Il menu contestuale, per quanto concerne le funzioni editor, è valido anche per l'editor di script.

È possibile selezionare le seguenti funzioni:

Tabella 2- 4 Menu contestuale editor ST ed editor script

Funzione Significato/note Apri blocco richiamato 1 Se il cursore si trova nell'identificatore di un'unità di organizzazione del

programma (POE) definita dall'utente, ad es. al richiamo di una funzione o alla dichiarazione di istanza di un blocco funzionale: Selezionare questo comando per aprire e modificare la sorgente di questa POE (ad es. sorgente ST, MCC-Chart, programma KOP/FUP). Vedere: Apri blocco richiamato (Pagina 48).

Taglia Selezionare questo comando per tagliare l'area selezionata nella sorgente ST e salvarla negli Appunti.

Copy Selezionare questo comando per copiare negli Appunti l'area selezionata. Inserimento Selezionare questo comando per aggiungere nella sorgente ST il contenuto

degli Appunti in corrispondenza della posizione attuale del cursore.



Funzione Significato/note Elimina Selezionare questo comando per eliminare l'area selezionata o il carattere a

destra del cursore. Seleziona tutto Selezionare questo comando per contrassegnare l'intero testo nella sorgente

ST. Vedere: Selezione di testo (Pagina 40).

Parametrizza richiamo In preparazione. Vista

Numerazione righe on / off Selezionare questo comando per visualizzare o nascondere la numerazione righe nella sorgente ST attiva. Vedere: Altri strumenti dell'editor ST (Pagina 48).

Guida rientro Selezionare questo comando per evidenziare visivamente nella sorgente ST attiva i rientri dei blocchi verso destra e verso sinistra mediante linee di riferimento verticali (secondo l'ampiezza di tabulazione impostata). Vedere: Rientri e tabulazioni (Pagina 31).

Visualizzazione delle coppie di parentesi

Selezionare questo comando per evidenziare visivamente nella sorgente ST attiva le due parentesi di una coppia di parentesi se il cursore si trova su una delle due parentesi. Vedere: Altri strumenti dell'editor ST (Pagina 48).

Simboli di formattazione Selezionare questo comando per visualizzare o nascondere gli spazi vuoti e le tabulazioni nella sorgente ST attiva. Vedere: Visualizzazione di spazi vuoti e tabulazioni (Pagina 38).

Folding Selezionare questo comando per attivare o disattivare l'espansione/la compressione nella sorgente ST attiva. Le informazioni di espansione nella sorgente ST attiva vengono quindi visualizzate o nascoste. Vedere: Espandere/comprimere (visualizzare e nascondere i blocchi) (Pagina 33).

Formatta la selezione attuale Selezionare questo comando per far rientrare verso destra di un'ampiezza di tabulatore i blocchi nell'area di testo selezionata in base alla relativa gerarchia. Vedere: Rientri e tabulazioni (Pagina 31).

Suddividi finestra Selezionare questo comando per suddividere orizzontalmente in due segmenti la finestra attiva dell'editor ST. Ciò consente di ottenere due viste della stessa sorgente ST. Vedere: Suddivisione finestra dell'editor (Pagina 36).

Segnalibro Inserisci/rimuovi segnalibro Selezionare questo comando per impostare un segnalibro nella riga attuale

della sorgente ST attiva o per eliminare un segnalibro già impostato. Vedere: Utilizzo dei segnalibri (Pagina 45).

Segnalibro successivo Selezionare questo comando per passare al segnalibro successivo nella sorgente ST attiva. Vedere: Utilizzo dei segnalibri (Pagina 45).

Segnalibro precedente Selezionare questo comando per passare al segnalibro precedente nella sorgente ST attiva. Vedere: Utilizzo dei segnalibri (Pagina 45).

Cancella tutti i segnalibri Selezionare questo comando per rimuovere tutti i segnalibri dalla sorgente ST attiva. Vedere: Utilizzo dei segnalibri (Pagina 45).



Funzione Significato/note Selezione nella scrittura maiuscola Selezionare questo comando per modificare il testo selezionato in lettere

maiuscole. Vedere: Altri strumenti dell'editor ST (Pagina 48).

Selezione in scrittura minuscola Selezionare questo comando per modificare il testo selezionato in lettere minuscole. Vedere: Altri strumenti dell'editor ST (Pagina 48).

Rientro selezione • Se non è selezionato alcun testo:

Selezionare questo comando per spostare il testo a destra del cursore nella posizione di tabulazione successiva.

• Se è selezionato il testo in un'unica riga:

Selezionare questo comando per eliminare il testo selezionato e spostare il testo seguente nella posizione di tabulazione successiva.

• Se è selezionato del testo in più righe:

Selezionare questo comando per far rientrare verso destra l'area selezionata (Pagina 31).

A seconda delle Impostazioni dell'editor ST (Pagina 29) viene inserito un carattere di tabulazione ($09) oppure il corrispondente numero di spazi vuoti ($20).

Annulla rientro • Se non è selezionato alcun testo:

Selezionare questo comando per spostare il cursore nella posizione di tabulazione precedente.

• Se è selezionato il testo in un'unica riga:

Selezionare questo comando per rimuovere la selezione e spostare il cursore nella posizione di tabulazione precedente.


Selezionare questo comando per far rientrare verso sinistra l'area selezionata (Pagina 31).

Vai a inizio blocco Selezionare questo comando per spostare il cursore all'inizio del blocco attuale o superiore.

Vai a fine blocco Selezionare questo comando per spostare il cursore alla fine del blocco attuale.Vai a inizio blocco, livello 0 Selezionare questo comando per spostare il cursore all'inizio del blocco

superiore del 1° ordine. Vai a inizio blocco, livello 1 Selezionare questo comando per spostare il cursore all'inizio del blocco

superiore del 2° ordine. Imposta/rimuovi punto di arresto 1 Selezionare questo comando per impostare un punto di arresto nel punto di

codice selezionato, oppure per rimuovere un punto di arresto. Vedere: Impostazione dei punti di arresto (Pagina 344).

Attiva/disattiva punto di arresto 1 Selezionare questo comando per attivare o disattivare un punto di arresto nel punto di codice selezionato. Vedere: Attivazione dei punti di arresto (Pagina 355).

1 Non nel menu contestuale dell'editor script.



2.3.4.18 Tasti di scelta rapida (shortcut) L'editor ST rende disponibili anche tasti di scelta rapida (shortcut). Ad esempio è possibile richiamare i comandi anche mediante i menu Modifica o Editor ST:

I tasti di scelta rapida, che riguardano le funzioni dell'editor, sono validi anche per l'editor di script.

Tabella 2- 5 Tasti di scelta rapida (shortcut), editor ST ed editor script

Tasto di scelta rapida / shortcut

Descrizione

F2 Passa al segnalibro successivo F3 Trova successivo (menu Modifica > Trova successivo). F9 1 Imposta/rimuovi punto di arresto (menu Debug > Imposta/rimuovi punto di arresto). F12 1 Attiva/disattiva punto di arresto impostato (menu Debug > Attiva/disattiva punto di

arresto). BACK Cancella il carattere a sinistra del cursore. INS Passa dalla modalità di inserimento alla modalità di sovrascrittura e viceversa. CANC Cancella l'area selezionata o il carattere a destra del cursore (menu Modifica > Elimina). Tasto freccia Sposta cursore. POS1 Sposta il cursore all'inizio della riga. FINE Sposta il cursore alla fine della riga. PGSU Scorri indietro di una pagina. Il cursore viene spostato nella nuova posizione. PGGIù Scorri avanti di una pagina. Il cursore viene spostato nella nuova posizione. TAB • Se non è selezionato alcun testo:

Sposta il testo a destra del cursore nella posizione di tabulazione successiva. • Se è selezionato il testo in un'unica riga:

Cancella il testo selezionato e sposta il testo che segue nella posizione di tabulazione successiva.


Rientro selezione. A seconda delle Impostazioni dell'editor ST viene inserito un carattere di tabulazione ($09) oppure il corrispondente numero di spazi vuoti ($20).

MAIUSC+F2 Torna al segnalibro precedente. SHIFT+BACK Cancella il carattere a sinistra del cursore. SHIFT+INS Incolla il contenuto degli Appunti (menu Modifica > Incolla). SHIFT+CANC Taglia l'area selezionata (menu Modifica > Taglia). SHIFT+tasto freccia Seleziona testo per righe. SHIFT+POS1 Seleziona il testo fino a inizio riga. SHIFT+FINE Seleziona il testo fino a fine riga. SHIFT+PGSU Scorri indietro di una pagina. Seleziona il testo fino alla nuova posizione del cursore. SHIFT+PGGIù Scorri avanti di una pagina. Seleziona il testo fino alla nuova posizione del cursore.




Descrizione

SHIFT+TAB • Se non è selezionato alcun testo:

Passa alla posizione di tabulazione precedente. • Se è selezionato il testo in un'unica riga:

Passa alla posizione di tabulazione precedente. • Se è selezionato del testo in più righe:

Rientro selezione verso sinistra. CTRL+A Seleziona tutto il testo (menu Modifica > Seleziona tutto). CTRL+B 1 Applica e compila la sorgente ST (menu Sorgente ST > Applica e compila). CTRL+C Copia l'area selezionata negli Appunti (menu Modifica > Copia). CTRL+D Duplica la riga corrente o l'area selezionata. CTRL+F Ricerca testi all'interno della sorgente ST (menu Modifica > Cerca). CTRL+H Sostituisci testi all'interno della sorgente ST (menu Modifica > Sostituisci). CTRL+J Visualizza il successivo risultato della ricerca nel progetto (menu Modifica > Visualizza

posizione successiva). CTRL+L Copia la riga corrente o le righe selezionate negli Appunti. CTRL+U Trasforma in minuscole il testo selezionato. CTRL+V Incolla il contenuto degli Appunti (menu Modifica > Incolla). CTRL+X Taglia l'area selezionata (menu Modifica > Taglia). CTRL+Y Ripeti l'ultima azione (menu Modifica > Ripeti). CTRL+Z Annulla l'ultima azione (menu Modifica > Annulla). CTRL+spazio Completamento automatico. CTRL+F2 Imposta o rimuovi segnalibri. CTRL+F4 Chiudi finestra attiva (ad es. menu Sorgente ST > Chiudi). CTRL+F5 1 Rimuovi tutti i punti di arresto (in tutte le sorgenti di programma) dell'apparecchio

SIMOTION (menu Debug > Rimuovi tutti i punti di arresto). CTRL+F7 1 Attiva o disattiva la funzione Stato programma (menu Sorgente ST >

Attiva/disattiva stato programma). CTRL+F8 1 Prosegui il programma nel punto di arresto attivato (menu Debug > Prosegui). CTRL+BACK Cancella la parola a sinistra del cursore. CTRL+INS Copia l'area selezionata negli Appunti (menu Modifica > Copia). CTRL+CANC Cancella la parola a destra del cursore. CTRL+Tasto freccia a sinistra/a destra

Sposta il cursore di una parola verso sinistra o verso destra.

CTRL+Tasto freccia su/giù Scorri la pagina di una riga verso l'alto o verso il basso. La posizione del cursore non cambia finché resta visibile nella finestra.

CTRL+POS1 Sposta il cursore all'inizio della sorgente ST. CTRL+FINE Sposta il cursore alla fine della sorgente ST. CTRL+MAIUSC+B Evidenzia le coppie di parentesi nella sorgente ST attuale. CTRL+MAIUSC+F Ricerca testi all'interno del progetto (menu Modifica > Cerca nel progetto). CTRL+MAIUSC+G Sostituisci testi all'interno del progetto (menu Modifica > Sostituisci nel progetto). CTRL+SHIFT+H Parametrizza richiamo. In preparazione.




Descrizione

CTRL+SHIFT+U Trasforma in maiuscole il testo selezionato. CTRL+MAIUSC+F2 Rimuovi tutti i segnalibri nella sorgente ST. CTRL+MAIUSC+F3 Affianca finestre orizzontalmente. CTRL+MAIUSC+F5 Affianca finestre verticalmente. CTRL+MAIUSC+F7 Genera successioni numeriche semplici (sequenza) nell'area selezionata. CTRL+MAIUSC+F8 Formatta l'area selezionata. CTRL+MAIUSC+F9 Sposta il cursore all'inizio del blocco corrente o superiore. CTRL+MAIUSC+F10 Sposta il cursore alla fine del blocco corrente. CTRL+MAIUSC+F11 Sposta il cursore all'inizio del blocco superiore del 1° ordine. CTRL+MAIUSC+F12 Sposta il cursore all'inizio del blocco superiore del 2° ordine. CTRL+SHIFT+BACK Cancella il testo a sinistra del cursore fino a inizio riga. CTRL+SHIFT+CANC Cancella il testo a destra del cursore fino a fine riga. CTRL+SHIFT+Tasto freccia a sinistra/a destra

Seleziona la parola a sinistra o a destra del cursore.

STRG+SHIFT+POS1 Seleziona il testo per righe fino all'inizio della sorgente ST. CTRL+MAIUSC+FINE Seleziona il testo per righe fino alla fine della sorgente ST. CTRL+ALT+C Espandi/comprimi: Nascondi tutti i blocchi della sorgente ST attuale. CTRL+ALT+D Espandi/comprimi: Visualizza tutti i blocchi della sorgente ST attuale. CTRL+ALT+F Espandi/comprimi: Visualizza/nascondi le informazioni nascoste nella sorgente ST

attuale. CTRL+ALT+I Visualizza il livello di rientro nella sorgente ST attuale. CTRL+ALT+L Visualizza/nascondi i numeri di righe nella sorgente ST attuale. CTRL+ALT+O 1 Se il cursore si trova nell'identificatore di un'unità di organizzazione del programma

(POE): Apri blocco richiamato, cioè apri sorgente di programma della POE e posiziona il cursore.

CTRL+ALT+R Espandi/comprimi: Visualizza tutti i blocchi subordinati. CTRL+ALT+S Suddividi finestra oppure rimuovi suddivisione (menu Sorgente ST > Suddividi finestra). CTRL+ALT+T Espandi/comprimi: Visualizza/nascondi blocco. CTRL+ALT+V Espandi/comprimi: Nascondi tutti i blocchi subordinati. CTRL+ALT+W Visualizza/nascondi spazi e tabulazioni nella sorgente ST attuale. CTRL+PIÙ (tastierino numerico)

Ingrandisci la grandezza carattere nella sorgente ST attuale.

CTRL+MENO (tastierino numerico)

Riduci la grandezza carattere nella sorgente ST attuale.

CTRL+DIV (tastierino numerico)

Grandezza carattere al 100% nella sorgente ST attuale.

ALT+SHIFT+L Trasforma in maiuscole il testo selezionato. ALT+SHIFT+U Trasforma in minuscole il testo selezionato. ALT+SHIFT+tasto freccia Seleziona testo per colonne. ALT+SHIFT+POS1 Seleziona il testo per colonne fino a inizio riga. ALT+SHIFT+FINE Seleziona il testo per colonne fino a fine riga.




Descrizione

ALT+SHIFT+PGSU Scorri avanti di una pagina. Seleziona il testo per colonne fino alla nuova posizione del cursore.

ALT+SHIFT+PGGIÙ Scorri avanti di una pagina. Seleziona il testo per colonne fino alla nuova posizione del cursore.

1 Tasto di scelta rapida non valido per l'editor script.

Tabella 2- 6 Azioni combinate tasti/mouse, editor ST ed editor script

Tastiera Mouse Descrizione Clic singolo con il pulsante sinistro nel testo Posizionare cursore Doppio clic con il pulsante sinistro nel testo Selezionare parola. Premere il pulsante sinistro e spostare il mouse Seleziona testo per righe. Clic singolo con il pulsante sinistro sul numero di riga Selezionare riga. Ruotare la rotellina del mouse Scorrere la pagina verticalmente. Il

cursore resta invariato. SHIFT Clic singolo con il pulsante sinistro nel testo Seleziona testo per righe. SHIFT Ruotare la rotellina del mouse Scorrere la pagina orizzontalmente. CTRL Clic singolo con il pulsante sinistro sul numero di riga Selezionare tutto il testo (menu Modifica

> Seleziona tutto). CTRL Clic singolo con il pulsante sinistro nella colonna dei

segnalibri Inserire o eliminare segnalibri.

CTRL Ruotare la rotellina del mouse Modificare grandezza carattere. ALT Premere il pulsante sinistro e spostare il mouse Seleziona testo per colonne. ALT+SHIFT Clic singolo con il pulsante sinistro nel testo Seleziona testo per colonne.



2.3.5 Avvio del compilatore

Presupposto La sorgente ST viene aperta con l'editor ST.

Procedura 1. Fare clic sulla finestra dell'editor ST. Viene visualizzato il menu dinamico della sorgente

ST.

2. Selezionare il menu Sorgente ST > Applica e compila.

Nota

Il menu della sorgente ST è dinamico e viene visualizzato solo quando la finestra dell'editor ST è attiva.

Il compilatore verifica la sintassi della sorgente ST. Nella scheda "Compila / verifica output" della visualizzazione dei dettagli vengono visualizzate le compilazioni riuscite del testo sorgente o gli errori del compilatore. Le informazioni sugli errori comprendono: il nome della sorgente ST, il numero della riga in cui si è verificato l'errore, il numero e la descrizione dell'errore.

2.3.5.1 Guida alla correzione degli errori Per la correzione degli errori l'utente viene assistito dal sistema:

● Fare doppio clic sul messaggio di errore nella scheda Compila / verifica output della visualizzazione dei dettagli.

Il cursore si posiziona sulla riga corrispondente della sorgente ST.

2.3.6 Applicazione delle impostazioni per il compilatore È possibile definire le impostazioni del compilatore (opzioni del compilatore) nel modo seguente:

● globalmente per il progetto SIMOTION, valida per tutti i linguaggi di programmazione, vedere Impostazioni globali del compilatore (Pagina 59)

● localmente per una singola sorgente ST all'interno del progetto SIMOTION, vedere Impostazioni globali del compilatore (Pagina 61)



2.3.6.1 Impostazioni globali del compilatore Le impostazioni globali sono valide all'interno del progetto SIMOTION per tutti i linguaggi di programmazione.

Procedura 1. Selezionare il menu Strumenti > Impostazioni.

2. Selezionare la scheda Compilatore.

3. Applicare le impostazioni in base alla seguente tabella.


Figura 2-19 Impostazioni globali del compilatore

Parametro

Tabella 2- 7 Parametri per le impostazioni globali del compilatore

Parametro Descrizione Visualizza classi di avviso1 Oltre ai messaggi di errore, il compilatore può emettere avvisi e informazioni. È possibile

definire l'ambito dei messaggi di avviso emessi: Attivo: Il compilatore emette avvisi ed informazioni della classe selezionata. Non attivo: Il compilatore sopprime gli avvisi e le informazioni della classe corrispondente. Vedere anche Significato delle classi di avviso (Pagina 67).

Connessione selettiva1 Attivo (standard): Il codice non utilizzato viene rimosso dal programma eseguibile. Non attivo: Il codice non utilizzato viene mantenuto nel programma eseguibile...



Parametro Descrizione Uso del preprocessore1 Attivo: Il preprocessore viene utilizzato (vedere Comando del preprocessore (Pagina 300)).

Inattivo (standard): Il preprocessore non viene utilizzato. Consenti stato programma1 Attivo: Viene creato un codice programma aggiuntivo che consente la supervisione delle

variabili di programma (anche variabili locali). Inattivo (standard): Stato programma impossibile. Vedere Proprietà dello stato programma (Pagina 332).

Consenti estensioni lingua1 Attivo: Sono consentiti elementi linguistici che non sono conformi alla IEC 61131-3. • Accesso bit diretto alle variabili di un tipo di dati bit (Pagina 141). • Accesso al corrispondente parametro di ingresso all'esterno di un blocco funzionale

(Pagina 190). • Richiamo di un programma all'interno di un altro programma (Pagina 196). Inattivo (standard): Sono consentiti solo elementi linguistici che sono conformi alla norma IEC 61131-3.

Crea dati di istanza del programma solo una volta1

Attivo: Le variabili locali di un programma vengono memorizzate una sola volta all'interno della memoria utente della unit. Questa impostazione è necessaria al momento del richiamo di un programma all'interno di un altro programma (Pagina 196). Inattivo (standard): Le variabili locali di un programma vengono create in base all'assegnazione del task corrispondente all'interno della relativa memoria utente. Vedere Aree di memoria dei tipi di variabili (Pagina 232).

Consenti dichiarazioni anticipative (ST)

Solo per linguaggio di programmazione ST. Le dichiarazioni anticipative consentono l'uso delle unità organizzative di programma (POE) prima della loro definizione completa. La dichiarazione di prototipi delle POE è possibile prima del loro utilizzo, ma è necessaria solo in caso di una dichiarazione di istanza di un blocco funzionale. Attivo: Le dichiarazioni anticipative sono consentite. Inattivo (standard): le dichiarazioni anticipative non sono consentite. Vedere Dichiarazioni anticipative (Pagina 310). Per i linguaggi di programmazione MCC e KOP/FUP le dichiarazioni anticipative sono sempre consentite. Possibile anche l'impostazione locale nella sorgente ST (Pagina 61). Vedere anche la descrizione relativa all'efficacia delle impostazioni globali o locali del compilatore (Pagina 65).

Consenti passo singolo (MCC)

Solo per linguaggio di programmazione MCC. Attivo: Creazione di un ulteriore codice programma che consente di osservare i singoli passi del programma. Non attivo: Passo singolo non possibile. Questa funzione facilita la ricerca degli errori (Debugging). Vedere "Controllo dei passi singoli nel programma" nel manuale di programmazione MCC. Possibile anche l'impostazione locale nella sorgente MCC. Vedere anche la descrizione relativa all'efficacia delle impostazioni globali o locali del compilatore (Pagina 65).



Parametro Descrizione Consenti traccia luminosa (MCC - solo per versione RT >= 4.2)

Solo per linguaggio di programmazione MCC e a partire da V4.2 del SIMOTION Kernel. Attivo: Creazione di un ulteriore codice programma che consente di osservare lo svolgimento del programma in diramazioni di programma cicliche. Non attivo: Traccia luminosa non possibile. Questa funzione facilita la ricerca degli errori (Debugging). Vedere "Osservazione dello svolgimento del programma tramite traccia luminosa" nel manuale di programmazione MCC. Possibile anche l'impostazione locale nella sorgente MCC. Vedere anche la descrizione relativa all'efficacia delle impostazioni globali o locali del compilatore (Pagina 65).

Con "Salva e compila modifiche" vengono visualizzati tutti i messaggi2

Qui è possibile definire le dimensioni del protocollo errori che viene mostrato nella visualizzazione dei dettagli di workbench richiamando in SIMOTION SCOUT il comando Salva e compila modifiche. Attivo: Viene creato un protocollo errori dettagliato in modo simile alla compilazione singola di una sorgente ST. Non attivo: Viene creato un protocollo errori compresso.

Ottimizzazione della sequenza di esecuzione (KOP/FUP)

Solo per linguaggio di programmazione KOP/FUP. Attivo: Le reti KOP/FUP vengono calcolate nella sequenza di esecuzione ottimizzata. Non attivo: Le reti KOP/FUP non vengono calcolate nella sequenza di esecuzione ottimizzata.

1 Possibili anche le impostazioni locali, vedere Impostazioni locali del compilatore (Pagina 61). Vedere anche la descrizione relativa all'efficacia delle impostazioni globali o locali del compilatore (Pagina 65). 2 Impostazione specifica per l'utente. Valida per tutti i progetti SIMOTION elaborati dall'utente.

ATTENZIONE Potrebbe essere necessario salvare e compilare il progetto per rendere efficaci le impostazioni.

2.3.6.2 Impostazioni locali del compilatore Le impostazioni locali vengono definite singolarmente per ciascuna sorgente ST e sovrascrivono le impostazioni globali.

Procedura 1. Aprire la finestra delle proprietà della sorgente ST, vedere Modifica delle proprietà di una

sorgente ST (Pagina 25):

Nella navigazione di progetto, selezionare la sorgente ST e scegliere il menu Modifica > Proprietà oggetto.

2. Selezionare la scheda Compilatore.

3. Applicare le impostazioni in base alla seguente tabella.




Figura 2-20 Impostazioni locali del compilatore sulla sorgente ST

Parametro

Tabella 2- 8 Parametri per le impostazioni locali del compilatore sulla sorgente ST

Parametro Descrizione Usa impostazioni globali Questa casella di controllo è disponibile per ciascun parametro per il quale esiste anche

un'impostazione globale. È selezionabile solo se la casella di controllo "Non ricompilare la sorgente se sono state cambiate le impostazioni globali del compilatore" = non è attiva. In questo modo si definisce se vengono applicate le impostazioni globali o se hanno effetto le impostazioni locali. Vedere la descrizione contenuta alla sezione "Efficacia delle impostazioni globali o locali (Pagina 65)". Le impostazioni locali dei rispettivi parametri, descritti di seguito, possono essere definite con la seconda casella di controllo o con le altre caselle di controllo.

Connessione selettiva1 Attivo: Il codice non utilizzato viene rimosso dal programma eseguibile. Non attivo: Il codice non utilizzato viene mantenuto nel programma eseguibile. In grigio (solo visualizzazione): L'impostazione globale visualizzata viene acquisita (con "Usa impostazioni globali" = attivo).

Uso del preprocessore1 Attivo: Il preprocessore viene utilizzato. Non attivo: Il preprocessore non viene utilizzato. In grigio (solo visualizzazione): L'impostazione globale visualizzata viene acquisita (con "Usa impostazioni globali" = attivo). Vedere Comando del preprocessore (Pagina 300).



Parametro Descrizione Consenti stato programma1 Attivo: Viene creato un codice programma aggiuntivo che consente la supervisione delle

variabili di programma (anche variabili locali) Non attivo: Stato programma impossibile. In grigio (solo visualizzazione): L'impostazione globale visualizzata viene acquisita (con "Usa impostazioni globali" = attivo). Vedere Proprietà dello stato programma (Pagina 332).

Consenti estensioni lingua1 Attivo: Sono consentiti elementi linguistici che non sono conformi alla IEC 61131-3. • Accesso bit diretto alle variabili di un tipo di dati bit (Pagina 141). • Accesso al corrispondente parametro di ingresso all'esterno di un blocco funzionale

(Pagina 190). • Richiamo di un programma all'interno di un altro programma (Pagina 196). Non attivo: Sono consentiti solo elementi linguistici che sono conformi alla norma IEC 61131-3. In grigio (solo visualizzazione): L'impostazione globale visualizzata viene acquisita (con "Usa impostazioni globali" = attivo).

Crea dati di istanza del programma solo una volta1

Attivo: Le variabili locali di un programma vengono memorizzate una sola volta all'interno della memoria utente della unit. Questa impostazione è necessaria al momento del richiamo di un programma all'interno di un altro programma (Pagina 196). Non attivo: Le variabili locali di un programma vengono create in base all'assegnazione del task corrispondente all'interno della relativa memoria utente. In grigio (solo visualizzazione): L'impostazione globale visualizzata viene acquisita (con "Usa impostazioni globali" = attivo). Vedere Aree di memoria dei tipi di variabili (Pagina 232). Ulteriori informazioni sono contenute nel manuale di guida alle funzioni Funzioni di base SIMOTION.

Emetti avvisi Classi di avviso1

Oltre ai messaggi di errore, il compilatore può emettere avvisi e informazioni. È possibile definire l'ambito dei messaggi di avviso emessi. Casella di controllo "Emetti avvisi": Attivo: Il compilatore emette gli avvisi e le informazioni in base alla successiva scelta delle classi di avviso. Non attivo: Il compilatore sopprime tutti gli avvisi e le informazioni riferiti a questa sorgente. Le caselle di controllo per le classi di avviso vengono nascoste. In grigio (solo visualizzazione): Come impostazione globale il compilatore emette sempre avvisi e informazioni in base alla scelta globale delle classi di avviso visualizzata di seguito (con "Usa impostazioni globali" = attivo). Caselle di controllo "Classi di avviso" (solo con "Emetti avvisi" = attivo): Attivo: Il compilatore emette avvisi ed informazioni della classe selezionata. Non attivo: Il compilatore sopprime gli avvisi e le informazioni della classe corrispondente. In grigio (solo visualizzazione): L'impostazione globale visualizzata viene acquisita (con "Usa impostazioni globali" = attivo). Vedere anche Significato delle classi di avviso (Pagina 67).



Parametro Descrizione Consenti dichiarazioni anticipative1

Le dichiarazioni anticipative consentono l'uso delle unità organizzative di programma (POE) prima della loro definizione completa. La dichiarazione di prototipi delle POE è possibile prima del loro utilizzo, ma è necessaria solo in caso di una dichiarazione di istanza di un blocco funzionale. Attivo: Le dichiarazioni anticipative sono consentite. Inattivo (standard): Le dichiarazioni anticipative non sono consentite. In grigio (solo visualizzazione): L'impostazione globale visualizzata viene acquisita (con "Usa impostazioni globali" = attivo). Vedere Dichiarazioni anticipative (Pagina 310).

Consenti OPC-XML Attivo: Le informazioni sui simboli delle variabili Unit della sorgente ST sono disponibili nell'apparecchio SIMOTION. Ciò è necessario per: • le funzioni _exportUnitDataSet e _importUnitDataSet, vedere Manuale di guida alle

funzioni Funzioni di base SIMOTION. • la funzione Watch di IT DIAG. Non attivo: Le informazioni sui simboli non vengono create.

Non ricompilare la sorgente se sono state cambiate le impostazioni globali del compilatore

Attivo: Le impostazioni globali del compilatore sono inattive per tutti i parametri. Le caselle di controllo "Usa impostazioni globali" non sono selezionabili e vengono visualizzate in grigio. Qualora le impostazioni del compilatore globali vengano modificate, la sorgente ST non viene ricompilata. Questa impostazione è necessaria per le librerie che sono dotate di un programma di protezione know-how (Pagina 69) di grado"elevato": • Per tutte le sorgenti di programma in questa libreria. • Per la libreria stessa. Non attivo: Le caselle di controllo "Usa impostazioni globali" sono selezionabili per tutti i parametri e vengono visualizzate su sfondo bianco. Con queste caselle di controllo si stabilisce se applicare le proprietà globali per il parametro corrispondente. Questa impostazione fa sì che nel caso successivo la sorgente ST venga compilata, sebbene tutte le caselle di controllo "Applica le impostazioni globali" non siano attive: • -Le impostazioni globali del compilatore sono state modificate e il menu Progetto >

Salva e compila modifiche viene selezionato. Vedere la descrizione contenuta alla sezione "Efficacia delle impostazioni globali o locali (Pagina 65)".

1 Possibili anche le impostazioni globali, vedere Impostazioni globali del compilatore (Pagina 59). Vedere anche la descrizione relativa all'efficacia delle impostazioni globali o locali del compilatore (Pagina 65).



2.3.6.3 Efficacia delle impostazioni globali o locali del compilatore L'efficacia delle impostazioni globali e locali di un parametro viene controllata con le impostazioni locali del compilatore (Pagina 61).

Casella di controllo "Non ricompilare la sorgente se sono state cambiate le impostazioni globali del compilatore"

Con la casella di controllo "Non ricompilare la sorgente se sono state cambiate le impostazioni globali del compilatore" si stabilisce se le proprietà globali del compilatore influiscono sulla sorgente del programma.

● Attivo: Le impostazioni globali del compilatore sono inattive per tutti i parametri. Le caselle di controllo "Usa impostazioni globali" non sono selezionabili e vengono visualizzate in grigio. Qualora le impostazioni del compilatore globali vengano modificate, la sorgente ST non viene ricompilata.

Questa impostazione è necessaria per le librerie che sono dotate di un programma di protezione know-how (Pagina 69) di grado"elevato":

– Per tutte le sorgenti di programma in questa libreria.

– Per la libreria stessa.

● Non attivo: Le caselle di controllo "Usa impostazioni globali" sono selezionabili per tutti i parametri e vengono visualizzate su sfondo bianco. Con queste caselle di controllo si stabilisce se applicare le proprietà globali per il parametro corrispondente.

Questa impostazione fa sì che nel caso successivo la sorgente di programma venga compilata, sebbene tutte le caselle di controllo "Applica le impostazioni globali" non siano attive:

– Le impostazioni globali del compilatore sono state modificate e il menu Progetto > Salva e compila modifiche viene selezionato.

Ciò comporta problemi nelle librerie che sono dotate di un programma di protezione know-how (Pagina 69) di grado"elevato". Inoltre nel caso dei progetti che sono stati convertiti da una versione precedente di SIMOTION SCOUT possono insorgere incoerenze in linea.



Caselle di controllo per ulteriori parametri Inoltre ciascun parametro, per il quale esiste anche un'impostazione globale, dispone di almeno 2 caselle di controllo:

● Casella di controllo "Applica le impostazioni globali":

con questa casella di controllo si stabilisce se le impostazioni globali vengono applicate. È selezionabile solo se la casella di controllo "Non ricompilare la sorgente se sono state cambiate le impostazioni globali del compilatore" = non è attiva.

Sono possibili le seguenti impostazioni:

– Attivo:

Per i parametri corrispondenti vengono applicate le impostazioni globali.

Le ulteriori caselle di controllo per questo parametro non sono selezionabili. Vengono mostrate in grigio e indicano l'impostazione globale.

– Non attivo:

Per i parametri corrispondenti vengono ignorate le impostazioni globali. Sono efficaci solo le impostazioni locali, che si definiscono con ulteriori caselle di controllo.

● Una o più caselle di controllo per l'impostazione locale:

La funzione di queste caselle di controllo dipende dalla casella di controllo "Applica impostazioni globali".

– Con casella di controllo "Applica le impostazioni globali" attiva:

Per i parametri corrispondenti vengono applicate le impostazioni globali. Le caselle di controllo per l'impostazione locale non sono selezionabili. Vengono mostrate in grigio e indicano l'impostazione globale.

– Con casella di controllo "Applica le impostazioni globali" non attiva:

Le caselle di controllo per le impostazioni locali sono selezionabili e vengono visualizzate su sfondo bianco. In questo modo si definiscono le impostazioni locali per il parametro corrispondente. Le impostazioni globali vengono ignorate.

Questo vale anche per le seguenti impostazioni del compilatore

● Connessione selettiva

● Usa preprocessore

● Consenti Stato programma

● Consenti estensioni lingua

● Crea dati di istanza del programma solo una volta

● Visualizza avvisi con classi di avviso

● Consenti dichiarazioni anticipative (solo con linguaggio di programmazione ST)

● Consenti passaggio singolo (solo con linguaggio di programmazione MCC)

● Consenti traccia luminosa (solo per linguaggio di programmazione MCC e a partire dalla versione V4.2 del SIMOTION Kernel)



Nota

È possibile verificare le attuali opzioni del compilatore, che saranno attive alla successiva compilazione della sorgente di programma: • Selezionare la scheda "Altre impostazioni" (Pagina 67) nella finestra delle proprietà della

sorgente di programma.

2.3.6.4 Significato delle classi di avviso La tabella riporta le classi di avviso e il loro significato.

Tabella 2- 9 Significato delle classi di avviso

Classe di avviso Significato 0 Avvisi di parti di codice e dati non referenziati o utilizzati 1 Avvisi di identificatori nascosti 2 Avvisi durante la conversione del tipo di dati, ad es. alla modifica dei dati 3 Avvisi relativi alle opzioni impostate del compilatore 4 Avvisi relativi a semafori (funzioni che potenzialmente potrebbero contenere

errori) 5 Avvisi relativi alle funzioni di allarme 6 Avvisi relativi a strutture contenute nelle librerie (variabili Unit dichiarate) 7 Messaggi del preprocessore

Nella descrizione completa dei messaggi di errore del compilatore viene indicato a quali classi di avviso sono assegnati i singoli avvisi (16001 - 16700) (Pagina 434) o le singole informazioni (32010 - 32653) (Pagina 439).

2.3.6.5 Visualizzazione delle opzioni del compilatore Per una sorgente di programma è possibile visualizzare:

● Le opzioni del compilatore attuali in base alle relative impostazioni globali o locali.

● Le opzioni del compilatore utilizzate durante l'ultima compilazione della sorgente di programma.



Presupposto La finestra delle proprietà della sorgente di programma (Pagina 25) è aperta.

Procedura Per visualizzare le opzioni del compilatore attuali in base alle impostazioni del compilatore (Pagina 58) globali o locali, procedere come segue:

● Selezionare la scheda Altre impostazioni.

Vengono visualizzate le opzioni del compilatore attuali per la sorgente di programma. Queste opzioni sono valide per una compilazione futura.

Per visualizzare le opzioni del compilatore utilizzate durante l'ultima compilazione della sorgente di programma, procedere come segue:

● Selezionare la scheda Compilazione.

Per l'ultima compilazione della sorgente di programma vengono visualizzati:

– La versione del compilatore utilizzato.

– Le opzioni del compilatore utilizzate.

Significato delle opzioni del compilatore Opzione compilatore Significato -c2 Nessuna creazione di informazioni di debug e sui simboli. -C lang_ext -C lang_iec

"Consenti estensioni lingua"1 attivo. "Consenti estensioni lingua" non attivo.

-C opcsym -C no_opcsym

"Consenti OPC-XML"1 attivo. "Consenti OPC-XML" non attivo.

-C preproc -C no_preproc

"Usa preprocessore"1 attivo. "Usa preprocessore" non attivo.

-C prog_once -C prog_multi

"Crea dati di istanza del programma solo una volta"1 attivo. "Crea dati di istanza del programma solo una volta" non attivo.

-C scan_twice -C scan_once

"Consenti dichiarazione anticipativa"1 attivo. "Consenti dichiarazione anticipativa" non attivo.

-D text Definizione del preprocessore (Pagina 70). -e user2 -e local

Efficaci solo le impostazioni globali. "Non ricompilare la sorgente se sono state cambiate le impostazioni globali del compilatore"1 attiva. Efficaci solo le impostazioni locali. Nessuna indicazione (preimpostazione): "Non ricompilare la sorgente se sono state cambiate le impostazioni globali del compilatore" non attivo. Le impostazioni globali vengono integrate con le impostazioni locali.

-I2 Applicazione delle impostazioni dei pacchetti di apparecchio o libreria. -l sel -l no_sel

"Connessione selettiva"1 attivo. "Connessione selettiva" non attivo.



Opzione compilatore Significato -s -s_off

"Consenti stato programma"1 attivo. "Consenti stato programma" non attivo.

-w no_warn -w all_warn -w n_off -w n_on

"Sopprimi gli avvisi"1 attivo. Visualizzare tutti gli avvisi. Classe di avviso n attivo1. Classe di avviso n non attivo1.

Altre opzioni Opzioni interne del compilatore SIMOTION. 1 Per il significato dell'opzione del compilatore: vedere "Impostazioni locali del compilatore (Pagina 61)". 2 Solo richiamando il compilatore tramite la riga di comando, ad es. mediante lo scripting.

Nota

Le opzioni del compilatore possono essere indicate anche al richiamo del compilatore tramite la riga di comando, ad es. mediante lo scripting.

2.3.7 Protezione del know-how per sorgenti ST È possibile proteggere le sorgenti ST dall'accesso non autorizzato di terzi. Le sorgenti ST protette possono essere aperte oppure esportate come file di testo in chiaro solo inserendo la password.

Per maggiori informazioni sui programmi di protezione know-how consultare la Guida in linea SIMOTION.

Nota

Per l'esportazione nel formato XML le sorgenti ST vengono codificate. Durante l'importazione dei file XML codificati viene mantenuta la protezione know-how, inclusi login e password.

Vedere anche Protezione del know-how per le librerie (Pagina 283)



2.3.8 Impostazione delle definizioni del preprocessore Le definizioni per il preprocessore (vedere Comando del preprocessore (Pagina 300)) possono essere effettuate nella finestra di dialogo delle proprietà della sorgente ST. È possibile controllare il preprocessore anche nelle sorgenti STQ con protezione del know-how (vedere Protezione del know-how per le sorgenti ST (Pagina 69)).

Impostazione delle definizioni del preprocessore nella finestra di dialogo Proprietà 1. Aprire la finestra delle proprietà della sorgente ST

(vedere Modifica delle proprietà di una sorgente ST (Pagina 25)):

Nella navigazione di progetto, selezionare la sorgente ST e scegliere il menu Modifica > Proprietà oggetto.

2. Selezionare la scheda Altre impostazioni.

3. Immettere le definizioni del preprocessore (sintassi secondo la tabella seguente).


Figura 2-21 Definizioni del preprocessore



Tabella 2- 10 Sintassi delle definizioni del preprocessore

Sintassi Significato Identificatore=Testo ’Identificatore=Testo’ "Identificatore=Testo"

L'identificatore specificato viene definito e sostituito nella sorgente ST dal testo indicato. Caratteri consentiti: vedere ultima riga della tabella. Se l'espressione contiene degli spazi (ad es. nel testo), è necessario utilizzare la sintassi "Identificatore=Testo"

Identificatore L'identificatore specificato viene definito e sostituito nella sorgente ST da un testo vuoto. Caratteri consentiti: vedere ultima riga della tabella.

Più definizioni del preprocessore sono separate da virgole: Definizione_1, Definizione_2, … Caratteri consentiti: • Per gli identificatori: In base alle regole per gli identificatori: la sequenza di lettere (A … Z, a … z),

cifre (0 … 9) o singoli caratteri di sottolineatura (_) nella sequenza desiderata, dove il primo carattere deve essere una lettera o un carattere di sottolineatura. Non viene operata alcuna distinzione fra lettere maiuscole e minuscole.

• Per il testo: stringa di caratteri qualsiasi tranne \ (backlash), ' (virgoletta singola - single quote), " (virgoletta doppia - double quote). Le parole chiave USES, USELIB e USEPACKAGE non sono ammesse.

Nota

Le definizioni del preprocessore realizzate con pragma all'interno di una sorgente ST sovrascrivono le definizioni nella finestra di dialogo Proprietà.

Rispettare le avvertenze fornite in Istruzione del preprocessore (Pagina 301).

2.3.9 Esportazione, importazione e stampa delle sorgenti ST Di seguito si può avere una panoramica sull'esportazione, l'importazione e la stampa di una sorgente ST.

2.3.9.1 Esportazione delle sorgenti ST come file di testo (ASCII) È possibile esportare una sorgente ST come file di testo in formato ASCII. Il file viene quindi reimportato come sorgente ST o modificato utilizzando un editor ASCII.

Procedura Per esportare una sorgente ST come file ASCII, procedere come segue:

1. Aprire la sorgente ST (Pagina 24), eventualmente immettendo la password (per le sorgenti ST dotate di protezione know-how (Pagina 69)).

2. Verificare che il cursore sia posizionato sull'editor ST.



3. Selezionare la voce di menu Sorgente ST > Esporta.

4. Indicare la directory e il nome del file per il file ASCII e confermare con Salva.

La sorgente ST viene salvata come file ASCII; per impostazione predefinita il nome file avrà l'estensione *.st.

In alternativa si può anche procedere come segue:

1. Selezionare la sorgente ST nella navigazione di progetto.

2. Nel menu contestuale, selezionare Esporta.

3. Solo per sorgenti ST dotate di Protezione know-how (Pagina 69) e non ancora aperte:

Solo se il login assegnato alla sorgente ST non è ancora stato effettuato:

– Immettere la password relativa al login indicato.

La protezione know-how per questa sorgente è temporaneamente disattivata (per questa esportazione).

– Eventualmente attivare la casella di controllo "Usa il login come login standard".

La registrazione avverrà con questo login e le altre sorgenti, cui è associato lo stesso login, possono venire esportate o aperte senza che sia necessario reimmettere la password.

4. Indicare la directory e il nome del file per il file ASCII e confermare con Salva.

Nota

Le informazioni nascoste (Pagina 33) e i segnalibri (Pagina 45) non vengono esportati.

2.3.9.2 Esportazione della sorgente ST in formato XML Per esportare una sorgente ST in formato XML, procedere come segue:


2. Selezionare il menu contestuale Esperti > Salva progetto ed esporta oggetto.

3. Indicare la directory per l'esportazione XML e premere OK per confermare.

Nella directory indicata vengono salvati un file XML con il nome della sorgente ST e una cartella contenente gli altri file XML associati.

Nota

È possibile esportare in formato XML anche le sorgenti ST con protezione knowhow. Le sorgenti ST vengono esportate in formato codificato. Durante l'importazione dei file XML codificati viene mantenuta la protezione know-how, inclusi login e password.

Le informazioni nascoste (Pagina 33) e i segnalibri (Pagina 45) non vengono esportati.



2.3.9.3 Importazione di file di testo (ASCII) come sorgente ST Per importare un file ASCII come sorgente ST, procedere come segue:

1. Nella navigazione di progetto, selezionare la cartella PROGRAMMI in corrispondenza dell'apparecchio SIMOTION desiderato.

2. Selezionare il menu Incolla > Sorgente esterna > Sorgente ST.

3. Selezionare il file ASCII da importare e confermare con Apri.

Si apre la finestra di dialogo per l'inserimento di una sorgente ST.

4. Immettere il nome della sorgente ST e selezionare le altre opzioni (vedere Inserimento sorgente ST (Pagina 21)).

Il file ASCII viene inserito come sorgente ST nella directory corrente del progetto e può quindi essere aperto.

2.3.9.4 Importazione di dati XML in una sorgente ST Per importare i dati XML in una sorgente ST, procedere come segue:

1. Inserire, se necessario, una nuova sorgente ST (vedere Inserimento sorgente ST (Pagina 21)).


3. Selezionare il menu contestuale Esperti > Importa oggetto.

4. Selezionare i dati XML da importare.

I dati XML importati sovrascrivono i dati presenti nella sorgente ST selezionata. L'intero progetto viene salvato e nuovamente compilato.

Alternativa:

1. Nella navigazione di progetto, selezionare la cartella PROGRAMMI.

2. Scegliere il menu contestuale Importa oggetto.

3. Selezionare i dati XML da importare.

Viene creata una nuova sorgente ST e vengono importati i dati XML. Questa sorgente ST contiene il nome salvato nei dati XML; in caso di conflitto in merito al nome la sorgente viene automaticamente rinominata. L'intero progetto viene salvato e nuovamente compilato.

Nota

Prestare attenzione alla situazione in cui i dati XML da importare sono stati esportati da una sorgente ST per cui è stata prevista una protezione know-how: Durante l'importazione dei dati XML codificati viene mantenuta la protezione know-how, inclusi login e password.



2.3.9.5 Stampa della sorgente ST Per esportare una sorgente ST, procedere come segue:

1. Aprire la sorgente ST.

2. Verificare che il cursore sia posizionato sull'editor ST.

3. Selezionare il menu Progetto > Stampa.

Il programma viene stampato con l'indicazione del nome e della data.

2.3.10 Uso di editor esterni

Quali editor esterni si possono utilizzare? Anziché utilizzare l'editor ST standard, è possibile utilizzare qualsiasi editor ASCII che disponga della seguente funzione:

● I programmi esterni (ad es. il compilatore) possono essere richiamati e agiscono sulla finestra attiva.

L'editor deve inoltre essere in grado di evidenziare con dei colori i punti specifici del testo della sorgente ST (colori della sintassi).

Nota

Se si utilizza un editor esterno, il menu dinamico della sorgente ST e le voci in esso contenute non sono disponibili. Anche la barra degli strumenti corrispondente non è attiva.

Di conseguenza, la compilazione della sorgente ST deve poter essere avviata dall'editor esterno.

Lo Stato programma continua ad essere eseguito con l'editor ST.

Impostazione per l'utilizzo di un editor esterno Le impostazioni vengono applicate nella workbench SCOUT:

1. Selezionare il menu Strumenti > Impostazioni.

2. Selezionare la scheda Editor ST esterno (vedere la figura).

3. Selezionare la casella di controllo Utilizza editor ST esterno.

4. Indicare la directory dell'editor esterno:

– Fare clic su Sfoglia e selezionare la directory e il nome del file dell'editor.



Figura 2-22 Impostazione per l'utilizzo di un editor esterno

Impostazioni dell'editor esterno Le istruzioni seguenti sono di tipo generico. Consultare anche il manuale dell'editor esterno.

1. Configurare il percorso del compilatore ST nell'editor esterno. Il compilatore si trova nella directory di installazione STEP7 s7bin\u7wstcax.exe.

2. Per editor diversi si utilizzano file di sintassi che consentono all'editor di evidenziare alcuni punti del testo con dei colori (colori della sintassi). Copiare i file di sintassi nella directory corrispondente e configurare l'editor di conseguenza.

Attenersi scrupolosamente alle seguenti indicazioni per l'uso di un editor esterno:

CAUTELA Chiudere tutte le finestre dell'editor esterno prima di chiudere un progetto o uscire da SIMOTION SCOUT. In caso contrario potrebbero verificarsi perdite di dati.



2.3.11 Menu sorgente ST

2.3.11.1 Menu sorgente ST A seconda dell'applicazione attiva / dell'editor attivo o della modalità (ONLINE/OFFLINE), determinati comandi non vengono visualizzati o non possono essere selezionati. Il menu viene visualizzato solo se nell'area di lavoro è attivo l'editor ST.


Tabella 2- 11 Menu sorgente ST

Funzione Significato/note Chiudi Selezionare questo comando per chiudere la sorgente ST attiva. In caso di variazioni è

possibile scegliere se applicare la sorgente modificata al progetto. Proprietà Selezionare questo comando per visualizzare le proprietà della sorgente ST attiva. Le

impostazioni locali per questa sorgente possono essere applicate in diverse schede. Vedere: Modifica delle proprietà di una sorgente ST (Pagina 25).

Applica e compila Selezionare questo comando per applicare la sorgente ST attuale al progetto e compilarla in un codice eseguibile. Vedere: Avvio del compilatore (Pagina 58).

Esecuzione del preprocessore Il preprocessore può effettuare una scansione di una sorgente ST prima della compilazione e può ad es. sostituire sequenze di caratteri, che verranno poi tenute in considerazione durante la compilazione. Questo comando del menu consente di eseguire in modo mirato le istruzioni del preprocessore.

Esporta Selezionare questo comando per esportare la sorgente ST attiva come file di testo (ASCII). Vedere: Esportazione della sorgente ST come file di testo (ASCII) (Pagina 71).

Suddividi finestra Selezionare questo comando per suddividere orizzontalmente in due segmenti la finestra attiva dell'editor ST. Ciò consente di ottenere due viste della stessa sorgente ST. Vedere: Suddivisione finestra dell'editor (Pagina 36).

Attiva/disattiva Stato programma

Fare clic su questo comando per avviare la modalità di test Stato programma. Durante l'esecuzione del programma è possibile monitorare i valori delle variabili selezionate nella sorgente ST. Sono necessari i presupposti seguenti: 1. Il programma deve essere compilato con le opzioni del compilatore corrispondenti. 2. Il progetto e il programma devono essere caricati nel sistema di destinazione. 3. Deve essere presente un collegamento ONLINE al sistema di destinazione. Fare nuovamente clic su questo comando per terminare Stato programma. Vedere: Uso di Stato programma (Pagina 334).

Salvataggio delle variabili Con questo comando di menu si possono salvare le variabili Retain, le variabili unità e le variabili globali. Queste variabili possono essere salvate dalla memoria RAM o ROM dell'apparecchio di destinazione su un supporto dati come file XML. Durante il ripristino queste variabili possono essere scritte dal supporto dati nella memoria RAM o ROM dell'apparecchio di destinazione.

Ripristino delle variabili Questo comando di menu consente di ripristinare le variabili Retain, le variabili unità e le variabili globali dalle variabili esportate in precedenza. Durante il ripristino queste variabili possono essere scritte dal supporto dati nella memoria RAM o ROM dell'apparecchio di destinazione.



2.3.11.2 Menu contestuale sorgente ST Il menu contestuale Sorgente ST viene visualizzato se nella navigazione di progetto si seleziona una sorgente ST e si preme il pulsante destro del mouse.

A seconda dell'applicazione attiva / dell'editor attivo o della modalità (ONLINE/OFFLINE), determinati comandi non vengono visualizzati o non possono essere selezionati.


Tabella 2- 12 Menu contestuale sorgente ST

Funzione Significato/note Aprire Selezionare questo comando per aprire la sorgente ST selezionata.

Vedere: Apertura di una sorgente ST esistente (Pagina 24). Taglia Le sorgenti ST selezionate vengono rimosse e memorizzate negli Appunti. Copy Le sorgenti ST selezionate vengono copiate negli Appunti. Inserimento Il contenuto degli Appunti viene inserito nella cartella selezionata. Elimina La sorgente ST selezionata viene eliminata insieme a tutti i dati. Rinomina Selezionare questo comando per modificare il nome della sorgente ST

selezionata. Durante la modifica del nome, fare attenzione a non modificare i riferimento al nome stesso e assicurarsi che il nuovo nome sia conforme alle regole per gli identificatori (Pagina 93).

Salvataggio delle variabili Con questo comando di menu si possono salvare le variabili Retain, le variabili unità e le variabili globali. Queste variabili possono essere salvate dalla memoria RAM o ROM dell'apparecchio di destinazione su un supporto dati come file XML. Durante il ripristino queste variabili possono essere scritte dal supporto dati nella memoria RAM o ROM dell'apparecchio di destinazione.

Ripristino delle variabili Questo comando di menu consente di ripristinare le variabili Retain, le variabili unità e le variabili globali dalle variabili esportate in precedenza. Durante il ripristino queste variabili possono essere scritte dal supporto dati nella memoria RAM o ROM dell'apparecchio di destinazione.

Esperti Importa oggetto Selezionare questo comando per importare nella sorgente ST selezionata i dati

XML di un'altra sorgente ST che erano stati esportati in un altro progetto. I dati presenti nella sorgente ST da importare vengono sovrascritti. Vedere: Importazione di dati XML in una sorgente ST (Pagina 73).

Salva progetto ed esporta oggetto Selezionare questo comando per esportare la sorgente ST selezionata in formato XML. I dati esportati si possono importare in altri progetti. Vedere: Esportazione della sorgente ST in formato XML (Pagina 72).

Applica e compila Selezionare questo comando per applicare la sorgente ST attuale al progetto e compilarla in un codice eseguibile. Vedere: Avvio del compilatore (Pagina 58).

Esecuzione del preprocessore Il preprocessore può effettuare una scansione di una sorgente ST prima della compilazione e può ad es. sostituire sequenze di caratteri, che verranno poi tenute in considerazione durante la compilazione. Questo comando del menu consente di eseguire in modo mirato le istruzioni del preprocessore.



Funzione Significato/note Attiva/disattiva Stato programma Fare clic su questo comando per avviare la modalità di test Stato programma.

Durante l'esecuzione del programma è possibile monitorare i valori delle variabili selezionate nella sorgente ST. Sono necessari i presupposti seguenti: 1. Il programma deve essere compilato con le opzioni del compilatore

corrispondenti. 2. Il progetto e il programma devono essere caricati nel sistema di

destinazione. 3. Deve essere presente un collegamento ONLINE al sistema di destinazione. Fare nuovamente clic su questo comando per terminare Stato programma. Vedere: Uso di Stato programma (Pagina 334).

Esportazione Selezionare questo comando per esportare la sorgente ST selezionata come file di testo (ASCII). Vedere: Esportazione della sorgente ST come file di testo (ASCII) (Pagina 71).

Protezione know-how Impostazione Selezionare questo comando per proteggere la sorgente ST selezionata

dall'accesso di terzi non autorizzati. Le sorgenti ST protette possono essere aperte ed esportate come file di testo in chiaro solo inserendo una password. Vedere: Protezione know-how per sorgenti ST (Pagina 69).

Elimina Selezionare questo comando per eliminare in modo permanente la protezione know-how della sorgente selezionata. A tale scopo è necessario immettere la password. Vedere: Protezione know-how per sorgenti ST (Pagina 69).

Dati di riferimento Creazione Selezionare questo comando per creare i dati di riferimento (elenco dei

riferimenti incrociati, struttura del programma, attributi di codice) della sorgente ST selezionata. Dopo l'esecuzione del comando viene visualizzato l'elenco dei riferimenti incrociati della sorgente ST selezionata. Vedere: Dati di riferimento (Pagina 292), Creazione elenco dei riferimenti incrociati (Pagina 292).

Visualizzazione Riferimenti incrociati Dai dati di riferimento precedentemente creati viene generato e visualizzato

l'elenco dei riferimenti incrociati della sorgente ST selezionata. L'elenco dei riferimenti incrociati contiene la dichiarazione e l'utilizzo di tutti gli identificatori della sorgente ST selezionata. Vedere: Contenuto dell'elenco dei riferimenti incrociati (Pagina 293).

Struttura del programma Dai dati di riferimento precedentemente creati viene generata e visualizzata la struttura del programma della sorgente ST selezionata. La struttura del programma contiene tutti i richiami dei sottoprogrammi e la relativa nidificazione nell'ambito della sorgente ST selezionata. Vedere: Contenuto della struttura del programma (Pagina 297).

Attributi di codice Dai dati di riferimento precedentemente creati vengono generati e visualizzati gli attributi di codice della sorgente ST selezionata. Gli attributi di codice contengono informazioni sui requisiti di memoria di diversi settori dati della sorgente ST selezionata. Vedere: Contenuto degli attributi di codice (Pagina 299).

Guida introduttiva di ST 2.4 Creazione di un programma esemplificativo


Funzione Significato/note Stampa Selezionare questo comando per stampare la sorgente ST selezionata. È

possibile stabilire se stampare il testo della sorgente ST e/o le relative proprietà.

Anteprima di stampa Selezionare questo comando per ottenere un'anteprima del risultato di stampa previsto.

Proprietà Selezionare questo comando per visualizzare le proprietà della sorgente ST selezionata. Le impostazioni locali per questa sorgente possono essere applicate in diverse schede. Vedere: Modifica delle proprietà di una sorgente ST (Pagina 25).

2.4 Creazione di un programma esemplificativo L'obiettivo è creare un breve programma esemplificativo che mostri tutti passaggi operativi necessari, dalla creazione all'avvio fino al test di un programma. Il test è descritto in test del programma (Pagina 316).

Descrizione del problema Il programma Flash definisce un bit su un byte in uscita del relativo sistema di destinazione e lo ruota nel byte. In questo modo vengono impostati e ripristinati uno dopo l'altro tutti i bit del byte in uscita. Dopo l'ultimo bit del byte occorre nuovamente impostare il primo bit. Nelle uscite del sistema di destinazione si può vedere il risultato del programma.

2.4.1 Presupposti Per creare il programma esemplificativo è necessario

● un progetto SIMOTION e,

● all'interno del progetto, un'apparecchiatura SIMOTION (ad es. SIMOTIONC C240) la cui uscita sia configurata all'indirizzo 62.

2.4.2 Apertura o creazione di un progetto I progetti contengono tutte le informazioni relative all'hardware e alla configurazione, oltre che i programmi per il controllo dell'hardware.

Procedimento Se non è presente alcun progetto, procedere come segue:

1. Selezionare Progetto dalla barra dei menu.

2. Selezionare Nuovo oppure Apri.

3. Assegnare un nome al nuovo progetto e premere OK per confermare.



Per i dettagli vedere la guida in linea.

Figura 2-23 Creazione di un nuovo progetto

2.4.3 Rilevazione dell'hardware

Questa operazione comprende: 1. Creazione e configurazione di un nuovo apparecchio SIMOTION (ad. es. C240 V4.2).

2. Configurazione dell'uscita nella Config HW all'indirizzo 62.

Per ulteriori dettagli sui passaggi operativi 1 e 2 vedere la guida in linea.



Figura 2-24 Modifica in Config HW

2.4.4 Immissione del testo sorgente con l'editor ST

Procedura 1. Nella navigazione di progetto, aprire la struttura gerarchica dell'apparecchio SIMOTION

utilizzato (i programmi sono assegnati all'apparecchio SIMOTION su cui verranno successivamente eseguiti).

2. Selezionare la cartella Programmi e la voce di menu Inserisci > Programma > Sorgente ST.

3. Immettere un nome di massimo 128 caratteri per la sorgente ST (vedere figura), ad es. ST_1 e premere OK per confermare.

L'editor ST viene visualizzato nell'area di lavoro, mentre la sorgente ST ST_1 viene inserita nella navigazione di progetto.



4. Immettere il testo sorgente seguendo le indicazioni fornite in Testo sorgente del programma esemplificativo (Pagina 83), possibilmente con capoversi rientranti. Per eseguire questa operazione, premere il tasto Tab.

Le opzioni dell'editor ST sono descritte dettagliatamente in Uso dell'editor ST (Pagina 27); la struttura di una sorgente ST è descritta dettagliatamente in Struttura della sorgente ST (Pagina 105) e in Sezioni del file sorgente (Pagina 201).

5. Utilizzare il più possibile i commenti. Se si tratta di una sola riga di testo, i commenti vanno immessi dopo le barre //. Se il commento occupa più di una riga, racchiuderlo tra due parentesi (* e *).

6. Salvare l'intero progetto selezionando Progetto > Salva.

Figura 2-25 Assegnazione di un nome alla sorgente ST



2.4.4.1 Funzioni dell'editor Oltre alla semplice immissione del testo, l'editor ST mette a disposizione anche le seguenti funzioni aggiuntive, utili per documentare la funzionalità del testo sorgente:

● in Windows, le normali funzioni operative (ad es. Annulla con CTRL + Z o Ripeti con CTRL + Y)

● i colori della sintassi (colori differenti per i diversi elementi del linguaggio)

● la stampa del file sorgente nella forma più appropriata con il numero di pagina, il nome del file sorgente e la data di stampa

● Esportazione/importazione del file sorgente

● l'archiviazione del file sorgente (per tutto il progetto)

Per una descrizione completa delle funzioni vedere Uso dell'editor ST (Pagina 27) e Applicazione delle impostazioni per il compilatore (Pagina 58).

2.4.4.2 Testo sorgente del programma esemplificativo La tabella mostra il testo sorgente del programma esemplificativo e mostra come deve essere immesso per poter creare un codice eseguibile.

Tabella 2- 13 Programma esemplificativo Flash

INTERFACE

VAR_GLOBAL

counterVar : INT := 1; // Variabile contatore

outputVar : BYTE := 1; // Variabile ausiliaria

END_VAR

PROGRAM Flash;

END_INTERFACE

IMPLEMENTATION

PROGRAM Flash

IF counterVar >= 500 THEN // ogni 500 esecuzioni

%QB62 := outputVar; // imposta byte di uscita

outputVar := ROL (in := outputVar, n := 1);

(* ruota bit in byte

di una posizione verso sinistra *)

counterVar := 0; // azzera contatore

END_IF;

counterVar := counterVar + 1; // aumenta contatore

END_PROGRAM

END_IMPLEMENTATION



2.4.5 Compilazione del programma esemplificativo Prima di eseguire il programma e sottoporlo a test è necessario compilarlo con un codice macchina eseguibile. Questo task viene svolto dal compilatore.

2.4.5.1 Avvio del compilatore Prima di eseguire il programma e sottoporlo a test è necessario compilarlo con un codice macchina eseguibile. Questo task viene svolto dal compilatore ST.

Per avviare il compilatore, procedere come segue:

1. Fare clic nella finestra dell'editor ST per visualizzare il menu Sorgente ST. Questo menu dinamico viene visualizzato solo quando la finestra dell'editor ST è attiva.

2. Avviare il compilatore della voce di menu Sorgente ST > Applica e compila.

2.4.5.2 Correzione errori Il compilatore verifica la sintassi della sorgente ST. Nella scheda Compila / verifica output della visualizzazione dei dettagli vengono visualizzate le compilazioni riuscite del testo sorgente o gli errori del compilatore. Le informazioni sugli errori comprendono: nome della sorgente ST, numero di riga in cui si è verificato l'errore, numero e descrizione dell'errore.

Per correggere un errore nel programma esemplificativo, procedere come segue:

1. Fare doppio clic sul messaggio di errore. Il cursore si posiziona sulla riga corrispondente della sorgente ST. Vedere Esempio di messaggi di errore (Pagina 85).

2. Iniziare la correzione degli errori dal primo errore.

3. Ripetere il processo di compilazione.

4. Ripetere l'intero processo finché non viene più visualizzato alcun errore (0 errors).

Con una compilazione riuscita si crea un programma utente denominato flash, visualizzato nella navigazione di progetto sotto la sorgente di programma ST_1.



2.4.5.3 Esempio di messaggi di errore

Figura 2-26 Messaggio di errore nella compilazione di una sorgente ST

La figura mostra un esempio di compilazione della sorgente ST ST_1 (vedere Testo sorgente del programma esemplificativo (Pagina 83)) nella quale è stata apportata la seguente modifica: al termine della riga 18 contenente l'istruzione "counterVar := counterVar + 1" manca il punto e virgola.

Il compilatore riconosce l'errore soltanto alla riga 19, poiché continua la compilazione dopo il punto e virgola mancante.

Se si aggiunge il punto e virgola mancante, la sorgente ST viene compilata correttamente.

Per un elenco dettagliato di tutti i messaggi di errore del compilatore, vedere Messaggi di errore del compilatore e relativa risoluzione (Pagina 421).



2.4.6 Esecuzione del programma esemplificativo Prima di eseguire il programma esemplificativo è necessario assegnare un livello esecutivo o un task. Una volta soddisfatto questo requisito, si può stabilire un collegamento con il sistema di destinazione, caricare il programma e infine avviare.

2.4.6.1 Assegnazione del programma esemplificativo a un livello esecutivo I livelli esecutivi stabiliscono la sequenza temporale dei programmi. Ciascun livello esecutivo contiene uno o più task ai quali è possibile assegnare dei programmi.

L'assegnazione di un programma a un task può avvenire soltanto dopo la compilazione e prima del caricamento del programma sul sistema di destinazione.

Assegnare il programma esemplificativo a BackgroundTask. Il BackgroundTask è concepito per la programmazione di processi ciclici senza griglia temporale fissa. Esso viene eseguito ciclicamente nel livello Round-Robin, ovvero viene riavviato automaticamente una volta terminato.

Assegnare il programma esemplificativo a BackgroundTask:

1. Fare doppio clic sull'elemento Sistema esecutivo nella navigazione di progetto per aprire la finestra del sistema esecutivo e dell'assegnazione del programma nell'area di lavoro.

2. Fare clic su BackgroundTask per selezionare il task per l'assegnazione del programma.

Nella parte sinistra dell'assegnazione del programma sono presenti tutti i programmi compilati che possono essere assegnati ai task.

3. Fare clic nel campo Programmi del programma esemplificativo ST_1.flash e sul pulsante >> per assegnare il programma a BackgroundTask.

Il risultato dell'assegnazione è mostrato nella seguente figura; nel campo Programmi utilizzati viene visualizzato il programma ST_1.flash.

Ulteriori informazioni sul sistema esecutivo e sull'assegnazione dei programmi ai task sono disponibili nella descrizione delle funzioni Funzioni di base SIMOTION Motion Control.



Figura 2-27 Assegnazione del programma esemplificativo al task di background

2.4.6.2 Creazione del collegamento con il sistema di destinazione È necessario che la scheda di interfaccia del PC sia configurata e collegata al sistema di destinazione.

Per creare un collegamento con il sistema di destinazione, procedere come segue:

1. Selezionare dalla barra dei menu Progetto > Collega al sistema di destinazione selezionato.

Nella visualizzazione dei dettagli viene aperta la scheda Panoramica della diagnostica. La panoramica della diagnostica visualizza lo stato operativo, lo spazio in memoria e il fattore di utilizzo della CPU per l'apparecchio con cui si è collegati. Sul lato inferiore destro dello schermo viene segnalato il collegamento con il sistema di destinazione.

Nota

Per informazioni dettagliate vedere il Manuale di progettazione SIMOTION SCOUT e la Guida in linea SIMOTION SCOUT.



Figura 2-28 Creazione del collegamento con il sistema di destinazione

2.4.6.3 Caricamento del programma esemplificativo sul sistema di destinazione (download) Per caricare il programma esemplificativo sul sistema di destinazione, procedere come segue:

1. Impostare il sistema di destinazione su STOP.

2. Selezionare dalla barra dei menu Sistema di destinazione > Carica > Carica progetto nel sistema di destinazione.

3. Confermare tutte le altre domande.

Nella visualizzazione dei dettagli si apre la finestra Output sistema di destinazione e viene visualizzato il risultato del download.



Figura 2-29 Caricamento del programma esemplificativo sul sistema di destinazione (download)

2.4.6.4 Avvio e test del programma esemplificativo

Avvio del programma esemplificativo Per avviare il programma esemplificativo, procedere come segue:

● Impostare il sistema di destinazione su RUN (vedere la descrizione dell'hardware).

I LED sulle uscite del sistema di destinazione lampeggiano in sequenza.

Test del programma esemplificativo Vedere Test del programma (Pagina 316).




Principi fondamentali di ST 3

Questo capitolo spiega quali mezzi vengono messi a disposizione dal linguaggio ST e come utilizzarli. Le funzioni, i blocchi funzionali e il comando dei task sono trattati nei capitoli successivi. Per una descrizione formale completa del linguaggio con tutti i diagrammi della sintassi vedere l'appendice Regole (Pagina 379).

3.1 Strumenti per la descrizione del linguaggio I diagrammi della sintassi costituiscono la base per la descrizione del linguaggio nei capitoli seguenti. Essi offrono una valida introduzione alla struttura sintattica (ossia grammaticale) di ST.

3.1.1 Diagramma della sintassi Il diagramma della sintassi è una rappresentazione grafica della struttura del linguaggio. La struttura viene descritta mediante una serie di regole. Una regola può quindi basarsi su regole già introdotte.

Figura 3-1 Diagramma della sintassi

Il diagramma della sintassi presentato nella precedente figura va letto da sinistra a destra. Prestare attenzione alle seguenti strutture delle regole:

● Sequenza: successione di blocchi

● Opzione: istruzione(i) di salto

● Iterazione: ripetizione di una o più istruzioni

● Alternativa: diramazione

Principi fondamentali di ST 3.1 Strumenti per la descrizione del linguaggio


3.1.2 Blocchi nei diagrammi della sintassi Un blocco è un elemento base o un elemento composto nuovamente da blocchi. La figura illustra i tipi di simboli che corrispondono ai blocchi:

Figura 3-2 Blocchi

Nel caso di immissione di testo sorgente, ossia quando i blocchi o gli elementi di un diagramma della sintassi devono essere convertiti in testo sorgente, occorre rispettare le regole con formato definito e le regole senza formato (vedere Strumenti per la descrizione del linguaggio (Pagina 363)).

Vedere anche Descrizione formale del linguaggio (Pagina 363)

3.1.3 Significato delle regole (semantica) Nelle regole è possibile rappresentare solo la struttura formale del linguaggio. Il significato, vale a dire la semantica, non è sempre evidente. Per questo motivo, nei punti importanti, oltre alle regole vengono fornite informazioni supplementari. Ecco alcuni esempi:

● Per gli elementi dello stesso tipo con significato diverso viene indicato un nome aggiuntivo. Ad esempio nella regola Indicazione della data per ogni elemento Sequenza di cifre decimali viene indicata un'aggiunta, Anno, Mese o Giorno (vedere Letterali (Pagina 380)). Il nome rimanda all'uso.

● Le limitazioni importanti vengono annotate accanto alla regola. Ad esempio nella regola Numero intero viene indicato che il segno - (meno) può trovarsi solo davanti a una sequenza di numeri decimali dei tipi di dati SINT, INT e DINT (siehe Letterali (Pagina 380)).

Vedere anche Descrizione formale del linguaggio (Pagina 363)

Principi fondamentali di ST 3.2 Elementi base del linguaggio


3.2 Elementi base del linguaggio Sono elementi base del linguaggio ST il set di caratteri ST, gli identificatori riservati creati con tale set (ad es. comandi del linguaggio), identificatori autodefiniti e cifre.

Il set di caratteri ST e gli identificatori riservati sono elementi base (terminali), in quanto non vengono spiegati mediante un'altra regola, bensì verbalmente. Gli identificatori autodefiniti e le cifre non sono terminali, poiché vengono spiegati mediante altre regole.

Nei diagrammi della sintassi i terminali sono rappresentati tramite cerchi o ovali, gli elementi composti mediante rettangoli (vedere Blocchi nei diagrammi della sintassi (Pagina 92)). Qui sono rappresentati i terminali più importanti, mentre la panoramica completa è riportata in Elementi di base (terminali) (Pagina 365).

3.2.1 Il set di caratteri ST Il linguaggio ST utilizza le lettere e i numeri seguenti del set di caratteri ASCII:

● lettere minuscole e maiuscole dalla A alla Z

● i numeri arabi da 0 a 9

Le lettere e le cifre sono i caratteri più utilizzati. L'identificatore (vedere Identificatore in ST (Pagina 93)) è costituito ad esempio lettere, cifre e carattere di sottolineatura. Quest'ultimo appartiene agli altri caratteri (diversi da lettere e cifre).

Caratteri speciali in ST hanno un significato specifico (vedere Descrizione formale del linguaggio (Pagina 363) , Elementi base (terminali) (Pagina 365)).

3.2.2 Identificatori in ST Gli identificatori in ST sono nomi. Possono essere nomi impostati dal sistema, ad es. comandi del linguaggio, ma possono anche essere nomi assegnati dall'utente, ad es. per una costante, variabile o funzione.

3.2.2.1 Regole per gli identificatori

Identificatori validi Gli identificatori sono costituiti da lettere (A … Z, a … z), cifre (0 … 9) o singoli caratteri di sottolineatura (_) nella sequenza desiderata, dove il primo carattere deve essere una lettera o un carattere di sottolineatura.

Non viene operata alcuna distinzione fra lettere maiuscole e minuscole (ad es. il compilatore identifica come identiche le espressioni Anna e AnNa).

Un identificatore può essere rappresentato in modo formale tramite il seguente diagramma della sintassi:



Figura 3-3 Sintassi: Identificatore

Questo diagramma della sintassi indica che il primo carattere di un identificatore deve essere una lettera o un carattere di sottolineatura. Un carattere di sottolineatura deve essere obbligatoriamente seguito da una lettera o da un numero, ciò significa che non sono ammessi più caratteri di sottolineatura. Quindi è possibile utilizzare caratteri di sottolineatura, lettere o cifre con la frequenza e nella successione desiderata. L'unica eccezione è rappresentata dal carattere di sottolineatura che non può essere utilizzato più volte in successione.

Identificatori consentiti, che si possono definire (identificatori definiti dall'utente) Gli identificatori definiti dall'utente (ad es. nelle dichiarazioni delle variabili, nella dichiarazione del tipo di dati, nei nomi di funzione) non possono coincidere con identificatori riservati (Pagina 95). Nell'assegnazione dei nomi scegliere nomi univoci e significativi che agevolino la comprensione del programma.

3.2.2.2 Esempi per l'identificatore

Esempi di identificatori validi I nomi riportati di seguito sono identificatori validi:

x y12 sum temperature P_CONTROLLER name area myFB table



Esempi di identificatori non validi I nomi riportati di seguito non sono identificatori validi:

Identificatori non validi Causa 4ter Il primo carattere deve essere una lettera o una sottolineatura. *#AB I caratteri speciali (ad eccezione della sottolineatura) non sono consentiti. RR__20 Due caratteri di sottolineatura consecutivi non sono consentiti. S valore Gli spazi non sono ammessi, poiché sono caratteri speciali. Array REAL _sizeOf

ARRAY, REAL e _sizeOf sono identificatori validi dal punto di vista formale, ma riservati (Pagina 95), quindi possono essere utilizzati soltanto nella forma predefinita. Di conseguenza, questi nomi non possono essere assegnati dall'utente, ad esempio per una variabile.

3.2.3 Identificatori riservati Gli identificatori riservati possono essere utilizzati esclusivamente come prescritto. Nessuna variabile e nessun tipo di dati deve essere ad es. dichiarata/o con il nome di un identificatore riservato.

Non viene fatta alcuna distinzione tra lettere maiuscole e minuscole.

● Identificatori protetti del linguaggio di programmazione ST (Pagina 95)

● Identificatori riservati del linguaggio di programmazione ST (Pagina 100)

● Ulteriori identificatori riservati (Pagina 101), ad es. funzioni standard, funzioni di sistema, variabili di sistema

Un elenco di tutti gli identificatori con significato predefinito è disponibile nel Manuale di guida alle funzioni Funzioni di base SIMOTION.

3.2.3.1 Identificatori protetti del linguaggio di programmazione ST Nella tabella è possibile vedere gli identificatori protetti del linguaggio ST. Possono essere utilizzati esclusivamente come prescritto. Una breve spiegazione è disponibile nell'appendice, alla voce Parole riservate (Pagina 370). I relativi diagrammi della sintassi (Pagina 91) sono disponibili nell'appendice alla voce Regole (Pagina 379).

Tabella 3- 1 Identificatori protetti del linguaggio ST

A ABS ACOS AND ANYOBJECT ANYOBJECT_TO_OBJECT ANYTYPE_TO_BIGBYTEARRAY

ANYTYPE_TO_LITTLEBYTEARRAY ARRAY AS ASIN AT ATAN



B BIGBYTEARRAY_TO_ANYTYPE BOOL BOOL_TO_BYTE BOOL_TO_DWORD BOOL_TO_WORD BOOL_VALUE_TO_DINT BOOL_VALUE_TO_INT BOOL_VALUE_TO_LREAL BOOL_VALUE_TO_REAL BOOL_VALUE_TO_SINT BOOL_VALUE_TO_UDINT BOOL_VALUE_TO_UINT BOOL_VALUE_TO_USINT

BY BYTE BYTE_TO_BOOL BYTE_TO_DINT BYTE_TO_DWORD BYTE_TO_INT BYTE_TO_SINT BYTE_TO_UDINT BYTE_TO_UINT BYTE_TO_USINT BYTE_TO_WORD BYTE_VALUE_TO_LREAL BYTE_VALUE_TO_REAL

C CASE CONCAT CONCAT_DATE_TOD CONSTANT COS CTD CTD_DINT

CTD_UDINT CTU CTU_DINT CTU_UDINT CTUD CTUD_DINT CTUD_UDINT

D DATE DATE_AND_TIME DATE_AND_TIME_TO_DATE DATE_AND_TIME_TO_TIME_OF_DAY DELETE DINT DINT_TO_BYTE DINT_TO_DWORD DINT_TO_INT DINT_TO_LREAL DINT_TO_REAL DINT_TO_SINT DINT_TO_STRING DINT_TO_UDINT DINT_TO_UINT DINT_TO_USINT DINT_TO_WORD DINT_VALUE_TO_BOOL

DO DT DT_TO_DATE DT_TO_TOD DWORD DWORD_TO_BOOL DWORD_TO_BYTE DWORD_TO_DINT DWORD_TO_INT DWORD_TO_REAL DWORD_TO_SINT DWORD_TO_UDINT DWORD_TO_UINT DWORD_TO_USINT DWORD_TO_WORD DWORD_VALUE_TO_LREAL DWORD_VALUE_TO_REAL



E ELSE ELSIF END_CASE END_EXPRESSION END_FOR END_FUNCTION END_FUNCTION_BLOCK END_IF END_IMPLEMENTATION END_INTERFACE END_LABEL END_PROGRAM

END_REPEAT END_STRUCT END_TYPE END_VAR END_WAITFORCONDITION END_WHILE ENUM_TO_DINT EXIT EXP EXPD EXPRESSION EXPT

F F_TRIG FALSE FIND

FOR FUNCTION FUNCTION_BLOCK

G GOTO I IF IMPLEMENTATION INSERT INT INT_TO_BYTE INT_TO_DINT INT_TO_DWORD INT_TO_LREAL INT_TO_REAL

INT_TO_SINT INT_TO_TIME INT_TO_UDINT INT_TO_UINT INT_TO_USINT INT_TO_WORD INT_VALUE_TO_BOOL INTERFACE

L LABEL LEFT LEN LIMIT LITTLEBYTEARRAY_TO_ANYTYPE LN LOG LREAL LREAL_TO_DINT LREAL_TO_INT

LREAL_TO_REAL LREAL_TO_SINT LREAL_TO_STRING LREAL_TO_UDINT LREAL_TO_UINT LREAL_TO_USINT LREAL_VALUE_TO_BOOL LREAL_VALUE_TO_BYTE LREAL_VALUE_TO_DWORD LREAL_VALUE_TO_WORD

M MAX MID MIN

MOD MUX



N NOT O OF OR P PROGRAM R R_TRIG REAL REAL_TO_DINT REAL_TO_DWORD REAL_TO_INT REAL_TO_LREAL REAL_TO_SINT REAL_TO_STRING REAL_TO_TIME REAL_TO_UDINT REAL_TO_UINT REAL_TO_USINT REAL_VALUE_TO_BOOL

REAL_VALUE_TO_BYTE REAL_VALUE_TO_DWORD REAL_VALUE_TO_WORD REPEAT REPLACE RETAIN RETURN RIGHT ROL ROR RS RTC

S SEL SHL SHR SIN SINT SINT_TO_BYTE SINT_TO_DINT SINT_TO_DWORD SINT_TO_INT SINT_TO_LREAL SINT_TO_REAL SINT_TO_UDINT SINT_TO_UINT SINT_TO_USINT

SINT_TO_WORD SINT_VALUE_TO_BOOL SQRT SR STRING STRING_TO_DINT STRING_TO_LREAL STRING_TO_REAL STRING_TO_UDINT STRUCT StructAlarmId STRUCTALARMID_TO_DINT StructTaskId

T TAN THEN TIME TIME_OF_DAY TIME_TO_INT TIME_TO_REAL TO

TOD TOF TON TP TRUE TRUNC TYPE



U UDINT UDINT_TO_BYTE UDINT_TO_DINT UDINT_TO_DWORD UDINT_TO_INT UDINT_TO_LREAL UDINT_TO_REAL UDINT_TO_SINT UDINT_TO_STRING UDINT_TO_UINT UDINT_TO_USINT UDINT_TO_WORD UDINT_VALUE_TO_BOOL UINT UINT_TO_BYTE UINT_TO_DINT UINT_TO_DWORD UINT_TO_INT UINT_TO_LREAL UINT_TO_REAL UINT_TO_SINT

UINT_TO_UDINT UINT_TO_USINT UINT_TO_WORD UINT_VALUE_TO_BOOL UNIT UNTIL USELIB USEPACKAGE USES USINT USINT_TO_BYTE USINT_TO_DINT USINT_TO_DWORD USINT_TO_INT USINT_TO_LREAL USINT_TO_REAL USINT_TO_SINT USINT_TO_UDINT USINT_TO_UINT USINT_TO_WORD USINT_VALUE_TO_BOOL

V VAR VAR_GLOBAL VAR_IN_OUT VAR_INPUT

VAR_OUTPUT VAR_TEMP VOID

W WAITFORCONDITION WHILE WITH WORD WORD_TO_BOOL WORD_TO_BYTE WORD_TO_DINT WORD_TO_DWORD

WORD_TO_INT WORD_TO_SINT WORD_TO_UDINT WORD_TO_UINT WORD_TO_USINT WORD_VALUE_TO_LREAL WORD_VALUE_TO_REAL

X XOR



3.2.3.2 Identificatori riservati del linguaggio di programmazione ST La tabella contiene altri identificatori riservati, destinati a future estensioni del linguaggio di programmazione ST.

Tabella 3- 2 Identificatori riservati del linguaggio di programmazione ST

A ACTION ADD ADD_DT_TIME

ADD_TIME ADD_TOD_TIME

B BCD_TO_BYTE BCD_TO_DINT BCD_TO_DWORD BCD_TO_INT

BCD_TO_LWORD BCD_TO_SINT BCD_TO_WORD BYTE_TO_BCD

C CONFIGURATION CTD_LINT CTD_ULINT CTU_LINT

CTU_ULINT CTUD_LINT CTUD_ULINT

D DINT_TO_BCD DIV

DIVTIME DWORD_TO_BCD

E EN END_ACTION END_CONFIGURATION END_RESOURCE

END_STEP END_TRANSITION ENO EQ

F F_EDGE FROM G GE GT I INITIAL_STEP INT_TO_BCD L LE LINT LT

LWORD LWORD_TO_BCD

M MUL MULTIME N NE R R_EDGE RESOURCE



S SEMA SINT_TO_BCD STEP SUB SUB_DATE_DATE

SUB_DT_DT SUB_DT_TIME SUB_TIME SUB_TOD_TIME SUB_TOD_TOD

T TRANSITION U ULINT V VAR_ACCESS VAR_ALIAS

VAR_EXTERNAL VAR_OBJECT

W WORD_TO_BCD

3.2.3.3 Altri identificatori riservati Nelle definizioni utente oltre agli identificatori protetti (Pagina 95) e agli identificatori riservati (Pagina 100) del linguaggio di programmazione ST vanno evitati anche identificatori che hanno un significato definito in SIMOTION oppure sono concepiti per future estensioni.

Identificatore con significato definito in SIMOTION Non dichiarare (ad es. nelle dichiarazioni delle variabili o nelle dichiarazioni dei tipi di dati) identificatori già definiti in SIMOTION. In caso contrario gli identificatori definiti in SIMOTION possono essere nascosti dalla dichiarazione e se possibile non risultare più raggiungibili. Può accadere che il compilatore non emetta alcun avviso corrispondente, ad es.: se il relativo pacchetto tecnologico non è importato.

In SIMOTION vengono definiti identificatori:

● Funzioni standard generali, compresi i relativi tipi di dati (vedere anche Manuale di guida alle funzioni Funzioni di base SIMOTION)

● Blocchi funzionali standard generali, compresi i relativi tipi di dati (vedere anche Manuale di guida alle funzioni Funzioni di base SIMOTION)

● Funzioni per controllo task, misurazione del runtime e programmazione dei messaggi, compresi i relativi tipi di dati (vedere anche Manuale di guida alle funzioni Funzioni di base SIMOTION)

● Funzioni e variabili di sistema degli apparecchi SIMOTION, compresi i relativi tipi di dati (vedere i Libretti di descrizione parametri degli apparecchi SIMOTION)

● Funzioni di sistema, variabili di sistema e dati di configurazione degli oggetti tecnologici, compresi i relativi tipi di dati (vedere anche i Libretti di descrizione parametri dei pacchetti tecnologici)

● Identificatori protetti e riservati di altri linguaggi di programmazione



Un elenco di tutti gli identificatori con significato definito è disponibile nel Manuale di guida alle funzioni Funzioni di base SIMOTION.

Identificatori concepiti per future espansioni di SIMOTION Evitare gli identificatori definiti dall'utente, concepiti per future espansioni di SIMOTION. Si fa così in modo che anche nelle versioni future gli identificatori definiti dall'utente non nascondano identificatori definiti in SIMOTION.

Per future espansioni di SIMOTION sono concepiti in particolare tutti gli identificatori che iniziano con le seguenti sequenza di caratteri:

● _ (carattere di sottolineatura)

● Command

● Enum

● Struct

Per la dichiarazione di un identificatore che inizia con questa sequenza di caratteri viene emesso un avviso corrispondente (ad es. numero di avviso 16026).

3.2.4 Numeri e valori booleani Nel linguaggio ST i numeri possono essere scritti in modo diverso. Un numero può contenere a scelta un segno, una virgola decimale o un esponente. I seguenti principi valgono per tutti i numeri:

● I numeri non possono contenere virgole e spazi vuoti.

● Per la separazione visiva è possibile utilizzare il carattere di sottolineatura ( _ ).

● Al numero può essere anteposto un segno più ( + ) o un segno meno ( – ). Se il numero non è preceduto da alcun segno, significa che ha valore positivo.

● I numeri non devono superare i valori minimo e massimo stabiliti.

3.2.4.1 Numeri interi Un numero intero non può contenere né virgola decimale né esponente. Un numero intero è quindi semplicemente una serie di cifre eventualmente precedute da un segno.

Sono numeri interi validi:

0 1 +1 -1 743 -5280 60_000 -32_211_321

I seguenti numeri interi sono errati per i motivi indicati:

123,456 Le virgole non sono ammesse. 36. Un numero intero non può contenere la virgola decimale. 10 20 30 Gli spazi non sono ammessi.



Nel linguaggio ST i numeri interi possono essere rappresentati in sistemi numerici diversi. A tale scopo, è sufficiente anteporre una parola chiave per il sistema numerico.

Si ha:

● 2# per il sistema binario,

● 8# per il sistema a base otto e

● 16# per il sistema esadecimale.

Rappresentazioni valide per il numero decimale 15 sono:

2#1111 8#17 16#F

3.2.4.2 Numeri a virgola mobile Un numero a virgola mobile può contenere una virgola decimale o un esponente (o entrambi). Una virgola decimale deve trovarsi fra due cifre. Pertanto, un numero a virgola mobile non può iniziare né finire con una virgola decimale.

Sono numeri a virgola mobile validi:

0.0 1.3 -0.2 827.602 0000.0 +0.000743 60_000.15 -315.0066

I seguenti numeri a virgola mobile sono errati:

1. La virgola decimale deve essere preceduta e seguita da una cifra. 1,000.0 Le virgole non sono ammesse. 1.333.333 I due punti non sono ammessi.

3.2.4.3 Esponenti L'esponente è ammesso per stabilire la posizione del punto decimale. Se il punto decimale non è presente, si presuppone che si trovi a destra della cifra. L'esponente deve essere un numero intero positivo o negativo. La base 10 viene indicata mediante la lettera E.

La grandezza 3 x 108 può essere rappresentata nel linguaggio ST dai seguenti numeri esatti a virgola mobile:

3.0E+8 3.0E8 3e+8 3E8 0.3E+9 0.3e9 30.0E+7 30e7

I seguenti numeri a virgola mobile sono errati:

3.E+8 La virgola decimale deve essere preceduta e seguita da una cifra. 8e2.3 L'esponente deve essere un numero intero. .333e-3 La virgola decimale deve essere preceduta e seguita da una cifra.



30 E8 Gli spazi non sono ammessi.

3.2.4.4 Valori booleani I valori booleani sono costanti di bit. Devono essere rappresentati con il valore zero (0) o uno (1) o tramite le parole chiave FALSE o TRUE.

Esempio:

a := 1; // corrisponde a := TRUE

b := FALSE; // corrisponde a b := 0

3.2.4.5 Tipi di dati dei numeri Il compilatore seleziona automaticamente il tipo di dati elementare adatto al numero in base al relativo valore e all'uso (espressione o assegnazione del valore).

Inoltre, è possibile specificare direttamente il tipo di dati: anteporre al numero il tipo di dati (numerico o bit) e il carattere "#".

Esempi:

INT#255 INT#16#FF INT#8#377 WORD#255 WORD#16#FF WORD#8#377 REAL#255 REAL#16#FF REAL#8#377 REAL#255.0 REAL#2.55E2 LREAL#255.0

Nota

Ai numeri a virgola mobile è possibile assegnare solo i tipi di dati REAL e LREAL.

3.2.5 Stringhe di caratteri

Che cos'è una stringa di caratteri? Una stringa di caratteri è una sequenza di 0 o più caratteri delimitati da un apostrofo (virgoletta) all'inizio e alla fine. Ogni carattere viene codificato nella stringa con 1 byte (8 bit).

Un carattere può essere immesso nel seguente modo:

● come carattere stampabile (codice ASCII da $20 a $7E, da $80 a $FF), tranne il segno di dollaro (codice ASCII $24) e l'apostrofo (codice ASCII $27) poiché questi hanno una funzione speciale all'interno delle stringhe,

● mediante il codice ASCII esadecimale a due posizioni del carattere corrispondente con il segno di dollaro ($) anteposto,

● come combinazione di due caratteri secondo la seguente tabella:

Principi fondamentali di ST 3.3 Struttura dei file sorgente ST


Tabella 3- 3 Combinazioni di due caratteri per i caratteri speciali nelle stringhe

Combinazione di caratteri Significato $$ Segno di dollaro $ ($24) $’ Apostrofo (virgoletta) ’ ($27) $L oppure $l Line Feed LF ($0A) $N oppure $n Carriage Return + Line Feed CR + LF ($0D$0A) $P oppure $p Form Feed FF ($0C) $R oppure $r Carriage Return CR ($0D) $T oppure $t Horizontal Tab (HT) ($09)

Esempi:

’’ Stringa vuota (lunghezza 0). ’A’ Stringa di lunghezza 1 che contiene la lettera A. ’ ’ Stringa di lunghezza 1 che contiene uno spazio vuoto. ’$’’ Stringa di lunghezza 1 che contiene un apostrofo (virgoletta singola). ’$R$L’ ’$0D$0A’ Due rappresentazioni equivalenti per una stringa di lunghezza 2 che contiene i

caratteri CR e LF. ’$$1.00’ Stringa di lunghezza 5 che contiene $1.00. ’Text$R$L’ Stringa di lunghezza 6 che contiene la parola Text seguita dai caratteri CR e LF. ’ÄÖÜ’ ’$C4$D6$FC’ Due rappresentazioni equivalenti per una stringa di lunghezza 3 che contiene le

dieresi tedesche ÄÖü (A, O, u con dieresi).

3.3 Struttura dei file sorgente ST Un file sorgente in linguaggio ST è costituito essenzialmente da testo continuo, che può essere suddiviso e strutturato in segmenti logici Le regole dettagliate sono descritte nelle sezioni del file sorgente (Pagina 201).

Di seguito viene fornito un breve riepilogo:

● Una sorgente ST è un'unità logica che può essere creata nel progetto e comparire più volte. Viene definita anche unit.

● Le parti logiche di una sorgente ST vengono identificate come sezioni (vedere tabella).

● Un programma utente è la somma di tutte le sorgenti di programma (ad es. sorgente ST, sorgente MCC).

Ciascuna sezione logica della sorgente ST ha un inizio e una fine, contrassegnati da parole chiave specifiche:



FUNCTION Test1 : REAL

VAR CONSTANT PI : REAL := 3.1415; END _ VAR

VAR _ INPUT r1 : REAL; END _ VAR

Test1 := PI * r1 * r1; : : END _ FUNCTION

Figura 3-4 Struttura di una sorgente ST

Non tutte le funzioni richiedono la programmazione. È anche possibile fare ricorso ai componenti di sistema di SIMOTION. Si tratta di segmenti predefiniti come le funzioni di sistema o le funzioni degli oggetti tecnologici (funzioni TO).



Tabella 3- 4 Sezioni importanti di una sorgente ST

Sezione file sorgente Descrizione Istruzione Unit (opzionale) Contiene il nome della ST. Sezione interfaccia Contiene le istruzioni per l'importazione e l'esportazione

di variabili, tipi e unità di organizzazione del programma (POE).

Sezione implementazione Contiene le sezioni eseguibili della sorgente ST. POE (unità di organizzazione del programma)

Sezione della sorgente ST eseguibile singolarmente (programma, funzione, blocco funzionale)

Sezione dichiarazione Contiene dichiarazioni (ad es. di variabili e tipi), può essere contenuto nella sezione di interfaccia e implementazione in una POE.

Sezione istruzioni Contiene le istruzioni eseguibili di una POE.

Nota

Nella guida in linea è disponibile un Template per Unit di esempio con un commento dettagliato. Esso può essere utilizzato come modello per una nuova sorgente ST.

Richiamare la guida dell'editor ST e fare clic sul collegamento corrispondente. Copiare il testo nella finestra aperta dell'editor ST e adattare il template alle proprie esigenze.

Template per Unit di esempio contiene una versione stampata del template.

3.3.1 Istruzioni La sezione istruzioni di una unità di organizzazione del programma (POE – programma, funzione, blocco funzionale) è costituita da singole istruzioni ripetute. Segue la sezione dichiarazione di una POE e finisce con la fine della POE. Alla sezione istruzioni non sono assegnate parole chiave esplicite per l'inizio e la fine.

Il linguaggio ST dispone di tre istruzioni base:

● Assegnazione del valore

Assegnazione di un'espressione a una variabile, vedere Dichiarazione variabili (Pagina 128)

● Istruzioni di controllo

Ripetizione o diramazione di istruzioni, vedere Istruzioni di controllo (Pagina 156)

● Elaborazione sottoprogramma

Funzioni (FC) e blocchi funzionali (FB), vedere Funzioni, blocchi funzionali, programmi (Pagina 175)



Tabella 3- 5 Esempi di istruzioni

...

// Assegnazione del valore

Status := 17;

// Istruzione di controllo

IF a = b THEN

FOR c := 1 TO 10 DO

b := b + c;

END_FOR;

END_IF;

// Richiamo della funzione

retVal := Test1(10.0);

...

3.3.2 Commenti I commenti sono utili nella documentazione e migliorano la comprensione di una sezione del file sorgente. Dopo la compilazione, non hanno più alcun significato ai fini dell'esecuzione del programma.

Sono disponibili due tipi di commenti:

● commento a righe e

● commento a blocchi.

Il commento a righe inizia con //. Il testo che segue viene considerato dal compilatore come commento fino alla fine della riga.

Il commento a blocchi può essere immesso su più righe che iniziano con (* e finiscono con *).

Fare attenzione all'uso dei commenti:

● È possibile utilizzare il set di caratteri ASCII esteso.

● All'interno del commento a righe le coppie di segni (* e *) non hanno alcun significato.

● L'annidamento di commenti a blocchi non è consentito. È tuttavia possibile annidare i commenti a righe nei commenti a blocchi.

● I commenti possono essere inseriti in qualsiasi posizione, tranne che nelle regole, che devono essere rigidamente rispettate, come ad es., nei nomi degli identificatori. Per ulteriori informazioni sulle regole, vedere Strumenti per la descrizione del linguaggio (Pagina 363).

Principi fondamentali di ST 3.4 Tipi di dati


Tabella 3- 6 Esempi di commenti

// Questo è un commento di una sola riga.

a := 5;

// È un esempio di commento a una riga

// utilizzato più volte in successione.

b := 23;

(* L'esempio precedente è relativo a un commento a più righe

semplificato.

*)

c := 87;

3.4 Tipi di dati Il tipo di dati permette di definire come viene memorizzato e utilizzato il valore di una variabile o costante in una sorgente di programma.

L'utente ha a disposizione i seguenti tipi di dati:

● Tipi di dati elementari

● Tipi di dati definiti dall'utente (UDT)

– Derivazioni semplici

– Campi (array)

– Enumerazioni (enumeratori)

– Strutture (Struct)

● Tipi di dati degli oggetti tecnologici

● Tipi di dati di sistema

Vedere anche Tipi di dati elementari (Pagina 110)

Descrizione dei tipi di dati degli oggetti tecnologici (Pagina 124)

Tipi di dati di sistema (Pagina 127)



3.4.1 Tipi di dati elementari

3.4.1.1 Tipi di dati elementari I tipi di dati elementari definiscono la struttura dei dati che non possono essere scomposti in unità più piccole. Un tipo di dati elementare descrive un'area di memoria di lunghezza fissa e indica dati di bit, numeri interi, numeri a virgola mobile, durata, data e ora e stringhe di caratteri.

La seguente tabella contiene un elenco di tutti i tipi di dati elementari:

Tabella 3- 7 Larghezza di bit e campo di valori dei tipi di dati elementari

Tipo Riserv. parola Larghezza bit

Campo di valori

Tipo di dati bit I dati di questo tipo occupano 1 bit, 8 bit, 16 bit o 32 bit. Il valore di inizializzazione di una variabile di questo tipo di dati è 0.

Bit BOOL 1 0, 1 oppure FALSE, TRUE Byte BYTE 8 da 16#0 a 16#FF parola WORD 16 da 16#0 a 16#FFFF

Parola doppia DWORD 32 da 16#0 a 16#FFFF_FFFF Tipi numerici Questi tipi sono disponibili per l'elaborazione dei valori numerici. Il valore di inizializzazione di una variabile di questo tipo di dati è 0 (tutti i numeri interi) oppure 0.0 (tutti i numeri a virgola mobile).

Numero intero breve SINT 8 -128 - 127 (-2**7 - 2**7-1) Numero intero breve senza segno

USINT 8 0 - 255 (0 - 2**8-1)

Numero intero (integer)

INT 16 -32_768 - 32_767 (-2**15 - 2**15-1)

Numero intero senza segno

UINT 16 0 - 65_535 (0 - 2**16-1)

Numero intero a doppia larghezza

DINT 32 -2_147_483_648 - 2_147_483_647 (-2**31 - 2**31-1)

Numero intero senza segno a doppia larghezza

UDINT 32 0 - 4_294_96_7295 (0 - 2**32-1)

Numero a virgola mobile (secondo IEEE-754)

REAL 32 -3.402_823_466E+38 ... -1.175_494_351E-38, 0.0, +1.175_494_351E-38 ... +3.402_823_466E+38 Precisione: 23 bit mantissa (corrisponde a 6 cifre decimali), 8 bit esponente, 1 bit segno.



Tipo Riserv. parola Larghezza bit

Campo di valori

Numero a virgola mobile lungo (secondo IEEE -754)

LREAL 64 -1.797_693_134_862_315_8E+308 ... -2.225_073_858_507_201_4E-308, 0.0, +2.225_073_858_507_201_4E-308 ... +1.797_693_134_862_315_8E+308 Precisione: 52 bit mantissa (corrisponde a 15 cifre decimali), 11 bit esponente, 1 bit segno.

Tipi di tempo I dati di questo tipo rappresentano i diversi valori di tempo e di data.

Durata in progressioni di 1 ms

TIME 32 T#0d_0h_0m_0s_0ms ...T#49d_17h_2m_47s_295ms Max. 2 cifre per i valori di giorno, ora, minuti, secondi e max. 3 cifre per i millisecondi Inizializzazione con T#0d_0h_0m_0s_0ms

Data in progressioni di 1 giorno

DATE 32 D#1992-01-01 ... D#2200-12-31 Si tiene conto degli anni bisestili, l'anno è di quattro cifre, mese e giorno sono di due cifre Inizializzazione con D#0001-01-01

Ora in progressioni di 1 ms

TIME_OF_DAY (sigla TOD)

32 TOD#0:0:0.0 ...TOD#23:59:59.999 Max 2 cifre per i valori di ora, minuti, secondi e max 3 cifre per i millisecondi Inizializzazione con TOD#0:0:0.0

Data e ora DATE_AND_TIME (sigla DT)

64 DT#1992-01-01-0:0:0.0 ... DT#2200-12-31-23:59:59.999 DATE_AND_TIME è costituito dai tipi di dati DATE e TIME. Inizializzazione con DT#0001-01-01-0:0:0.0

Tipo di stringa I dati di questo tipo rappresentano stringhe di caratteri nelle quali ogni carattere viene codificato con il numero indicato. La lunghezza della stringa può essere predefinita nella dichiarazione. A tale scopo immettere la lunghezza in "[" e "]", ad es. STRING[100]. La preimpostazione è di 80 caratteri. Il numero dei caratteri occupati (inizializzati) può essere inferiore alla lunghezza dichiarata. Stringa con 1

byte/carattere STRING 8 Sono ammessi tutti i caratteri con codice ASCII compreso

tra $00 e $FF. Impostazione predefinita con ’ ’ (stringa vuota)

ATTENZIONE Durante l'esportazione delle variabili in altri sistemi vanno rispettati i campi di valori dei tipi di dati corrispondenti nel sistema di destinazione.



Figura 3-5 Sintassi: Tipo di dati STRING

3.4.1.2 Limiti di campo dei valori dei tipi di dati elementari I limiti dei campi dei valori di alcuni tipi di dati elementari sono disponili come costanti.

Tabella 3- 8 Costanti simboliche per i limiti di campo dei valori di tipi di dati elementari

Costanti simboliche Tipo di dati Valore Rappresentazione Hex

SINT#MIN SINT -128 16#80SINT#MAX SINT 127 16#7FINT#MIN INT -32768 16#8000INT#MAX INT 32767 16#7FFFDINT#MIN DINT -2147483648 16#8000_0000DINT#MAX DINT 2147483647 16#7FFF_FFFFUSINT#MIN USINT 0 16#00USINT#MAX USINT 255 16#FFUINT#MIN UINT 0 16#0000UINT#MAX UINT 65535 16#FFFFUDINT#MIN UDINT 0 16#0000_0000UDINT#MAX UDINT 4294967295 16#FFFF_FFFFT#MIN TIME#MIN

TIME T#0ms 16#0000_00001

T#MAX TIME#MAX

TIME T#49d_17h_2m_47s_295ms 16#FFFF_FFFF1

TOD#MIN TIME_OF_DAY#MIN

TOD TOD#00:00:00.000 16#0000_00001

TOD#MAX TIME_OF_DAY#MAX

TOD TOD#23:59:59.999 16#0526_5BFF1

1 Solo rappresentazione interna



3.4.1.3 Tipi di dati generali I tipi di dati generali vengono usati spesso nei parametri di ingresso e di uscita di funzioni e blocchi funzionali di sistema. Il sottoprogramma può essere richiamato con variabili di ogni tipo di dati che sia contenuto nel tipo di dati generale.

La tabella seguente mostra i tipi di dati disponibili:

Tabella 3- 9 Tipi di dati generali

Tipo di dati generale Tipi di dati contenuti ANY_BIT BOOL, BYTE, WORD, DWORD ANY_INT SINT, INT, DINT, USINT, UINT, UDINT ANY_REAL REAL, LREAL ANY_NUM ANY_INT, ANY_REAL ANY_DATE DATE, TIME_OF_DAY (TOD),DATE_AND_TIME (DT) ANY_ELEMENTARY ANY_BIT, ANY_NUM, ANY_DATE, TIME, STRING ANY ANY_ELEMENTARY, tipo di dati definito dall'utente (UDT), tipi di dati di

sistema, tipi di dati degli oggetti tecnologici

Nota

I tipi di dati generali non possono essere utilizzati come identificatori del tipo nelle variabili o nelle dichiarazioni del tipo.

Il tipo di dati generale viene mantenuto quando un tipo di dati definito dall'utente (UDT) viene ricavato direttamente da un tipo di dati elementare (possibile solo con il linguaggio di programmazione SIMOTION ST).

3.4.1.4 Tipi di dati elementari del sistema Nel sistema SIMOTION i tipi di dati seguenti indicati nella tabella vengono considerati come tipi di dati elementari. Vengono usati in numerose funzioni di sistema.

Tabella 3- 10 Tipi di dati di sistema elementari e loro utilizzo

Identificatore Larghezza bit

Utilizzo

StructAlarmId 32 Tipo di dati di AlarmId per l'identificazione dei messaggi univoca a livello di tutto il progetto. AlarmId viene usato nella generazione dei messaggi. Vedere Manuale di guida alle funzioni Funzioni di base SIMOTION. Inizializzazione con STRUCTALARMID#NIL

StructTaskId 32 Tipo di dati di TaskId per l'identificazione dei task nel sistema esecutivo univoca a livello di tutto progetto. Vedere Manuale di guida alle funzioni Funzioni di base SIMOTION. Inizializzazione con STRUCTTASKID#NIL



Tabella 3- 11 Costanti simboliche per i valori non validi di tipi di dati di sistema elementari

Costanti simboliche Tipo di dati Significato STRUCTALARMID#NIL StructAlarmId AlarmId non valido STRUCTTASKID#NIL StructTaskId TaskId non valido

3.4.2 Tipi di dati definiti dall'utente

3.4.2.1 Tipi di dati definiti dall'utente Per creare tipi di dati definiti dall'utente o UDT (user defined data types), utilizzare il costrutto TYPE / END_TYPE nelle sezioni dichiarazione delle sezioni successive del file sorgente (vedere Strutturazione della sorgente ST (Pagina 105) e Sezioni del file sorgente (Pagina 201)):

● della sezione interfaccia

● della sezione implementazione

● di una POE

I tipi di dati creati possono essere utilizzati nuovamente nella sezione dichiarazione. La sezione file sorgente definisce la portata della dichiarazione del tipo.

Vedere anche Sintassi dei tipi di dati definiti dall'utente (dichiarazione del tipo) (Pagina 115)

Derivazione di tipi di dati elementari o derivati (Pagina 117)

Tipo di dati derivato ARRAY - Campo (Pagina 118)

Tipo di dati derivato enumerazione - Enumeratore (Pagina 120)

Tipo di dati derivato STRUCT - Struttura (Pagina 122)



3.4.2.2 Sintassi dei tipi di dati definiti dall'utente (dichiarazione del tipo)

Figura 3-6 Sintassi: Tipo di dati definito dall'utente

La dichiarazione degli UDT viene introdotta dalla parola chiave TYPE.

Seguono quindi per ogni tipo di dati da dichiarare (vedere figura):



1. Identificazione (nome):

L'identificazione del tipo di dati deve essere conforme alle regole per gli identificatori.

2. Specifica del tipo di dati:

Il concetto tipo di dati si riferisce a (vedere Derivazione di tipi di dati elementari o derivati (Pagina 117)):

– Tipi di dati elementari

– Tipi di dati definiti dall'utente definiti in precedenza

– Tipi di dati TO

– Tipi di dati di sistema

Sono inoltre possibili le seguenti specifiche di tipi di dati:

– Specifica del tipo di dati ARRAY (vedere Tipo di dati derivato ARRAY - Campo (Pagina 118))

– Specifica del tipo di dati di enumerazione (vedere Tipo di dati derivato enumerazione – Enumeratore (Pagina 120))

– Specifica del tipo di dati STRUCT(vedere Tipo di dati derivato STRUCT – Struttura (Pagina 122))

I rimandi tra parentesi si riferiscono alle sezioni seguenti, nelle quali le specifiche dei tipi di dati vengono descritte dettagliatamente.

3. Facoltativamente inizializzazione:

Per il tipo di dati si può definire un valore di inizializzazione. Se in seguito si dichiara una variabile di questo tipo di dati, viene assegnato il valore di inizializzazione della variabile.

Eccezione: Nella specifica del tipo di dati STRUCT l'inizializzazione avviene per ogni singolo componente nell'ambito della specifica del tipo di dati.

Vedere anche Inizializzazione delle variabili o dei tipi di dati (Pagina 131).

La dichiarazione totale di un UDT viene conclusa con la parola chiave END_TYPE. All'interno del costrutto TYPE / END_TYPE è possibile creare molti tipi di dati. I tipi di dati definiti possono essere utilizzati per la dichiarazione di variabili o parametri.

Tra i tipi di dati definiti dall'utente UDT è possibile qualsiasi annidamento, purché sia rispettata la sintassi illustrata nella figura. Per esempio, è possibile utilizzare come specifica del tipo di dati gli UDT già definiti o le strutture annidate. Anche le dichiarazioni dei tipi possono essere utilizzate solo in modo sequenziale e non possono essere annidate.

Nota

La Panoramica di tutte le dichiarazioni delle variabili (Pagina 130) spiega come dichiarare variabili e parametri; la Sintassi dell'assegnazione di un valore (Pagina 137) spiega come assegnare i valori con i tipi di dati UDT.

Di seguito vengono spiegate le singole specifiche dei tipi di dati per l'UDT e viene dimostrato il relativo uso in base agli esempi.



3.4.2.3 Derivazione di tipi di dati elementari o derivati Nella derivazione dei tipi di dati, nel costrutto TYPE / END_TYPE al tipo di dati da definire viene assegnato un tipo elementare o definito dall'utente (UDT):

Identificatore TYPE : Tipo di dati elementare { := inizializzazione } ; END_TYPE

Identificatore TYPE : Tipo di dati definito dall'utente { := inizializzazione} ; END_TYPE

Oltre alla dichiarazione del tipo di dati, è possibile definire variabili del tipo di dati derivato identificatore. Ciò corrisponde alla dichiarazione di variabili del tipo di dati elementare.

Tabella 3- 12 Esempi di derivazione dei tipi di dati elementari

TYPE

I1: INT; // Tipo di dati elementare

R1: REAL; // Tipo di dati elementare

R2: R1; // Tipo di dati derivato (UDT)

END_TYPE

VAR

// Queste variabili possono essere sempre utilizzate nella posizione

// in cui possono essere utilizzate le variabili del tipo INT.

myI1 : I1;

myI2 : INT; // Nessun tipo di dati rilevato!

// Queste variabili possono essere sempre utilizzate nella posizione

// in cui possono essere utilizzate le variabili del tipo REAL.

myR1 : R1;

myR2 : R2;

END_VAR

myI1 := 1;

myI2 := 2;

myR1 := 2.22;

myR2 := 3.33;



3.4.2.4 Tipo di dati derivato ARRAY - Campo Il tipo di dati derivato ARRAY o campo riunisce nel costrutto TYPE / END_TYPE un numero stabilito di elementi di un singolo tipo di dati. Nel diagramma della sintassi della figura successiva è possibile vedere questo tipo di dati, specificato in modo più preciso dopo l'identificatore riservato OF.

Identificatore TYPE : Specifica del tipo di dati ARRAY { := inizializzazione } ; END_TYPE

Figura 3-7 Sintassi: Specifica del tipo di dati ARRAY

La Specifica dell'indice descrive i limiti del campo:

● I limiti dell'array forniscono il valore minimo e massimo per l'indice. Possono essere impostati tramite costanti o espressioni di costanti; il tipo di dati è DINT (o un tipo convertibile implicitamente in DINT – vedere Conversione di tipi di dati elementari (Pagina 169)).

● I limiti dell'array devono essere separati da due punti.

● La specifica dell'indice totale è racchiusa tra parentesi angolari.

● L'indice stesso può essere un valore intero del tipo di dati DINT (o di un tipo convertibile implicitamente in DINT – vedere Conversione di tipi di dati elementari (Pagina 169)).

Nota

La violazione dei limiti dell'array al runtime provoca un errore di elaborazione nel programma (vedere Manuale di guida alle funzioni "Funzioni di base SIMOTION").

Con la Specifica del tipo di dati inserire il tipo di dati degli elementi di campo (tipo di dati base). Come tipi di dati sono ammesse tutte le possibilità descritte in questo capitolo, ad esempio anche un tipo di dati definito dall'utente (UDT).

La capacità dello spazio di memoria occupata dall'ARRAY può essere definita con _sizeOf (in := array-name). Vale quanto segue: _sizeOf (in := array_of_type) := _lengthIndexOf (in := array_of_type) * _sizeOf (in := type).



La sintassi di queste funzioni è descritta nel Manuale di guida alle funzioni Funzioni di base SIMOTION.

Nota

A partire dalla versione 4.2 del SIMOTION Kernel si possono dichiarare campi con lunghezza dinamica quali parametri di passaggio in funzioni e blocchi funzionali. A tale scopo vedere la sezione corrispondente (Pagina 182) per la sezione dichiarazione di FB e FC (Pagina 177).

Campi a una e più dimensioni Esistono vari tipi di ARRAY:

● Il tipo ARRAY unidimensionale è un elenco di elementi di dati assegnati in ordine crescente.

● Il tipo ARRAY bidimensionale è una tabella di dati costituita da righe e colonne. La prima dimensione si riferisce al numero di riga, la seconda al numero di colonna.

● Il tipo ARRAY a più dimensioni è un'estensione del tipo ARRAY bidimensionale.

Tabella 3- 13 Esempi di campi unidimensionali

TYPE

x : ARRAY [0..9] OF REAL;

y : ARRAY[1..10] OF C1;

END_TYPE

I campi bidimensionali sono paragonabili a una tabella con righe e colonne. È possibile creare campi a due o più dimensioni utilizzando una dichiarazione del tipo a più livelli, vedere l'esempio:

Tabella 3- 14 Esempi di campi a più dimensioni

TYPE

a: ARRAY[1..3] OF INT; // unidim. unidim. (3 colonne)

matrix1: ARRAY[1..4] OF a; // bidim. Campo

// (4 righe con 3 colonne)

b: ARRAY[4..8] OF INT; // unidim. unidim. (5 colonne)

matrix2: ARRAY[10..16] OF a; // bidim. Campo

// (7 righe con 5 colonne)

END_TYPE

VAR

m : matrix1; // Variabile m del tipo di dati bidim. Campo

n: matrix2; // Variabile m del tipo di dati bidim. Campo

END_VAR

m[4][3] := 9; // Scrivere nella matrice1 nella riga 4, colonna 3

n[16][8] := 10; // Scrivere nella matrice2 nella riga 7, colonna 5



Nell'esempio si definiscono:

1. Le colonne della tabella a[1] ... a[3] come campo unidimensionale che deve contenere numeri interi.

2. Le righe della tabella matrix1[1] ... matrix2[4] come campo, tuttavia come specifica del tipo di dati va ripreso il campo appena creato con le colonne della tabella.

Per creare una seconda dimensione, indicare un campo come specifica del tipo di dati. Ulteriori dimensioni possono essere create in modo analogo.

Con il tipo di dati creato per la tabella si può dichiarare una variabile. Racchiudere ciascuna dimensione della tabella tra parentesi angolari; in questo caso specificare colonna e riga.

Ridichiarazione Le definizioni dei tipi di dati dei campi (ARRAY) vengono riconosciute come identiche (anche in sorgenti differenti) se sono soddisfatte le condizioni seguenti:

1. L'identificatore del tipo di dati è identico.

2. I due limiti dell'array sono identici.

3. Il tipo di dati degli elementi di campo è identico.

4. L'elenco di inizializzazione del campo opzionale è identico (compresi fattori di ripetizione ed espressioni di costanti).

Inizializzazione Generalmente gli elementi di campo ricevono il valore di inizializzazione del tipo di dati base. In alternativa è possibile modificare il valore di inizializzazione degli elementi di campo mediante l'assegnazione di un elenco di inizializzazione del campo, racchiuso tra parentesi quadre [ ], vedere "Inizializzazione delle variabili o dei tipi di dati" (Pagina 131).

3.4.2.5 Tipo di dati derivato enumerazione - Enumeratore Per i tipi di dati di enumerazione, nel costrutto TYPE / END_TYPE, al tipo di dati da definire viene assegnato un numero limitato di identificatori o di nomi:

Identificatore TYPE : Specifica del tipo di dati di enumerazione { := inizializzazione }; END_TYPE

Figura 3-8 Sintassi: specifica del tipo di dati di enumerazione



Dopo aver dichiarato il tipo di dati identificatore si possono definire le variabili di questo tipo di dati di enumerazione. Nella sezione istruzioni, è possibile assegnare a queste variabili solo elementi dell'elenco degli identificatori definiti (elementi di enumerazione).

Inoltre, è possibile specificare direttamente il tipo di dati: Anteporre all'elemento di enumerazione l'identificatore del tipo di dati di enumerazione e il carattere "#" (vedere la tabella Esempi dei tipi di dati di enumerazione).

Il primo e/o l'ultimo valore di un tipo di dati di enumerazione si ottiene con enum_type#MIN oppure enum_type#MAX, dove enum_type rappresenta l'identificatore del tipo di dati di enumerazione.

Con la funzione di conversione ENUM_TO_DINT si ricava il valore numerico dell'elemento di enumerazione.

Esempio

Tabella 3- 15 Esempi dei tipi di dati di enumerazione

TYPE

C1: (RED, GREEN, BLUE);

END_TYPE

VAR

myC11, myC12, myC13 : C1;

END_VAR

myC11 := GREEN;

myC1l := C1#GREEN;

myC12 := C1#MIN; // RED

myC13 := C1#MAX; // BLUE

Nota

I tipi di dati di enumerazione sono anche tipi di dati di sistema.

I tipi di dati di enumerazione possono essere componenti di strutture e quindi possono trovarsi a un livello più basso nella struttura di dati definiti dall'utente.

Ridichiarazione Le definizioni dei tipi di dati di enumerazione vengono riconosciute come identiche (anche in sorgenti differenti) se sono soddisfatte le condizioni seguenti:


2. Tutti gli elementi di enumerazione sono identici.

3. La sequenza degli elementi di enumerazione è identica, pertanto i relativi valori numerici sono identici.

4. Il valore di inizializzazione opzionale è identico.



Inizializzazione Generalmente un tipo di dati di enumerazione riceve il 1° valore dell'enumerazione come valore di inizializzazione. In alternativa è possibile modificare il valore di inizializzazione mediante l'assegnazione di un altro elemento di enumerazione, vedere "Inizializzazione delle variabili o dei tipi di dati" (Pagina 131).

3.4.2.6 Tipo di dati derivato STRUCT - Struttura Il tipo di dati derivato STRUCT o struttura riunisce nel costrutto TYPE / END_TYPE un intervallo di un numero di componenti fisso, il cui tipo di dati deve essere diverso:

Identificatore TYPE : Specifica del tipo di dati STRUCT ; END_TYPE

Figura 3-9 Sintassi: Specifica del tipo di dati STRUCT

La sintassi della dichiarazione dei componenti è riportata di seguito nella seguente figura.

Figura 3-10 Sintassi: Dichiarazione dei componenti

Sono ammessi i seguenti tipi di dati:

● Tipi di dati elementari

● Tipi di dati definiti dall'utente definiti in precedenza

● Tipi di dati di sistema

● Tipi di dati TO

● Specifica del tipo di dati ARRAY



In alternativa è possibile preimpostare i valori di inizializzazione dei componenti, vedere "Inizializzazione" in questa sezione.

Nota

Nella dichiarazione dei componenti non è possibile utilizzare direttamente le seguenti specifiche dei tipi di dati: • Specifica del tipo di dati STRUCT • Specifica del tipo di dati di enumerazione

Rimedio: dichiarare prima un UDT (tipo di dati definito dall'utente) con le specifiche sopra indicate e utilizzarlo nella dichiarazione dei componenti.

In questo modo è possibile annidare i tipi di dati STRUCT.

I tipi di dati STRUCT sono anche tipi di dati di sistema.

Esempio L'esempio mostra la definizione di un UDT e l'uso di questo tipo di dati nella dichiarazione di una variabile.

Tabella 3- 16 Esempi del tipo di dati derivato STRUCT

TYPE // Definizione UDT

S1: STRUCT

var1 : INT;

var2 : WORD := 16#AFA1;

var3 : BYTE := 16#FF;

var4 : TIME := T#1d_1h_10m_22s_2ms;

END_STRUCT;

END_TYPE

VAR

myS1 : S1;

END_VAR

myS1.var1 := -4;

myS1.var4 := T#2d_2h_20m_33s_2ms;



Ridichiarazione Le definizioni dei tipi di dati delle strutture vengono riconosciute come identiche (anche in sorgenti differenti) se sono soddisfatte le condizioni seguenti:


2. Tutti i componenti della struttura sono identici per quanto concerne:

– Sequenza

– Identificatore

– Tipi di dati o specifiche del tipo di dati ARRAY

– Valori di inizializzazione (compresi eventuali elenchi di inizializzazione di campo o struttura)

Inizializzazione Generalmente ciascun componente riceve il valore di inizializzazione del proprio tipo di dato. In alternativa, è possibile modificare il valore di inizializzazione dei componenti mediante l'assegnazione di un'inizializzazione corrispondente.

Utilizzando la struttura in un'altra dichiarazione (ad es. dichiarazione di variabili o di tipo di dati), è possibile modificare i valori di inizializzazione dei singoli componenti mediante l'assegnazione di un elenco di inizializzazione delle strutture, racchiuso in parentesi tonde ( ).

Vedere "Inizializzazione delle variabili o dei tipi di dati" (Pagina 131).

3.4.3 Tipi di dati degli oggetti tecnologici

3.4.3.1 Descrizione dei tipi di dati degli oggetti tecnologici È possibile dichiarare le variabili con il tipo di dati di un oggetto tecnologico (TO). La seguente tabella indica i tipi di dati per gli oggetti tecnologici disponibili nei singoli pacchetti tecnologici.

Ad esempio è possibile dichiarare una variabile con il tipo di dati posaxis e assegnarle una relativa istanza di un asse di posizionamento. Una variabile di questo tipo viene spesso indicata come riferimento.

Tabella 3- 17 Tipi di dati degli oggetti tecnologici

Oggetto tecnologico Tipo di dati Contenuto nel pacchetto tecnologico

Asse a velocità impostata DriveAxis CAM, PATH1, CAM_EXT Encoder esterno ExternalEncoderType CAM, PATH1, CAM_EXT Tastatore di misura MeasuringInputType CAM, PATH1, CAM_EXT Camma OutputCamType CAM, PATH1, CAM_EXT Traccia camma _CamTrackType CAM, PATH1, CAM_EXT



Oggetto tecnologico Tipo di dati Contenuto nel pacchetto tecnologico

Asse di posizionamento PosAxis CAM, PATH1, CAM_EXT Asse sincrono FollowingAxis CAM, PATH1, CAM_EXT Oggetto sincrono FollowingObjectType CAM, PATH1, CAM_EXT Camma elettronica CamType CAM, PATH1, CAM_EXT Asse di interpolazione1 _PathAxis PATH1, CAM_EXT Oggetto vettoriale1 _PathObjectTpye PATH1, CAM_EXT Riduttore fisso _FixedGearType CAM_EXT Oggetto addizione _AdditionObjectType CAM_EXT Oggetto formula _FormulaObjectType CAM_EXT Sensore _SensorType CAM_EXT Oggetto regolatore _ControllerObjectType CAM_EXT Canale di temperatura TemperatureControllerType TControl Tipo di dati generale che può essere assegnato a ciascun oggetto tecnologico.

ANYOBJECT

1 disponibile dalla versione V4.1.

Tramite le strutture è possibile accedere agli elementi dei pacchetti tecnologici, dei dati di configurazione e delle variabili di sistema (vedere Manuale di guida alle Funzioni di base SIMOTION).

Tabella 3- 18 Costanti simboliche per i valori non validi dei tipi di dati degli oggetti tecnologici

Costanti simboliche Tipo di dati Significato TO#NIL ANYOBJECT Oggetto tecnologico non valido

Vedere anche Ereditarietà delle proprietà per gli assi (Pagina 125)

Esempi per l'utilizzo dei tipi di dati degli oggetti tecnologici (Pagina 126)

3.4.3.2 Ereditarietà delle proprietà per gli assi Nel caso degli assi, l'ereditarietà significa che tutti i tipi di dati, le variabili di sistema e le funzioni dell'asse a velocità impostata dell'oggetto tecnologico sono interamente contenuti nell'oggetto tecnologico asse di posizionamento. L'asse di posizionamento è a sua volta contenuto interamente nell'oggetto tecnologico asse sincrono, l'asse sincrono nell'oggetto tecnologico asse vettoriale. Ciò ha ad es. gli effetti seguenti:

● Se una funzione o un blocco funzionale attende un parametro di ingresso del tipo di dati driveAxis (asse a velocità impostata), per via dell'ereditarietà con il richiamo si può anche utilizzare un asse di posizionamento o un asse sincrono o un asse vettoriale.

● Se una funzione o un blocco funzionale attende un parametro di ingresso del tipo di dati posAxis (asse a velocità di posizionamento), per via dell'ereditarietà con il richiamo si può anche utilizzare un asse sincrono o un asse vettoriale.



3.4.3.3 Esempi per l'utilizzo dei tipi di dati degli oggetti tecnologici Di seguito è riportato un esempio per l'uso opzionale di una variabile del tipo di dati di un oggetto tecnologico (un esempio per l'uso forzato di una variabile del tipo di dati TO è riportato nel Manuale di guida alle funzioni Funzioni di base SIMOTION). Un secondo esempio illustra l'alternativa che rinuncia all'uso di una variabile del tipo di dati TO.

Si deve abilitare un asse nella parte principale di un programma tramite la funzione TO per poterlo posizionare. Dopo il posizionamento, si deve determinare la posizione effettiva dell'asse tramite l'accesso alla struttura.

Il primo esempio utilizza una variabile del tipo di dati TO per di mostrarne l'uso.

Tabella 3- 19 Esempio di uso di un tipo di dati per gli oggetti tecnologici

VAR

myAxis : posAxis; // Dichiarazione variabile per l'asse

myPos : LREAL; // Variabile per la posizione dell'asse

retVal : DINT; // Variabile per il valore di ritorno della

// funzione TO

END_VAR

myAxis := Axis1; // Il nome Axis1 è stato stabilito durante la

configurazione dell'asse

// nella navigazione di progetto.

// Richiamo della funzione con variabili del tipo di dati TO:

retVal := _enableAxis(axis := myAxis, commandId := _getCommandId());

// L'asse viene posizionato.

retVal := _pos(axis := myAxis,

position := 100,

commandId := _getCommandId());

// Query della posizione tramite accesso alla struttura

myPos := myAxis.positioningState.actualPosition;



Il secondo esempio non utilizza una variabile del tipo di dati TO.

Tabella 3- 20 Esempio d'uso di un oggetto tecnologico

VAR

myPos : LREAL; // Variabile per la posizione dell'asse

retVal : DINT; // Variabile per il valore di ritorno della funzione

TO

END_VAR

// Richiamo della funzione senza variabile del tipo di dati TO

// Il nome Axis1 è stato stabilito durante la configurazione dell'asse

// nella navigazione di progetto.

retVal := _enableAxis(axis := Axis1,


// L'asse viene posizionato.

retVal := _pos(axis := Axis1

position := 100,


// Query della posizione tramite accesso alla struttura

myPos := Axis1.positioningState.actualPosition;

Le caratteristiche per la configurazione di oggetti tecnologici sono descritte nelle descrizioni delle funzioni di SIMOTION Motion Control.

3.4.4 Tipi di dati di sistema Sono disponibili molti tipi di dati di sistema che possono essere utilizzati senza precedente dichiarazione. Anche ogni pacchetto tecnologico importato mette a disposizione una libreria di tipi di dati di sistema.

Altri tipi di dati di sistema (soprattutto i tipi di dati di enumerazione e STRUCT) si trovano

● nei parametri delle funzioni standard generali (vedere Manuale di guida alle funzioni Funzioni di base SIMOTION)

● nei parametri dei blocchi funzionali standard generali (vedere Manuale di guida alle funzioni Funzioni di base SIMOTION)

● nelle variabili di sistema degli apparecchi SIMOTION (vedere i relativi manuali contenenti le liste di riferimento)

● nei parametri delle funzioni di sistema degli apparecchi SIMOTION (vedere i relativi manuali contenenti le liste di riferimento)

● nelle variabili di sistema e nei dati di configurazione degli oggetti tecnologici (vedere i relativi manuali contenenti le liste di riferimento)

● nei parametri delle funzioni di sistema degli oggetti tecnologici (vedere i relativi manuali contenenti le liste di riferimento)

Principi fondamentali di ST 3.5 Dichiarazione delle variabili


3.5 Dichiarazione delle variabili Una variabile definisce un dato di contenuto variabile che può essere utilizzato nella sorgente ST. Una variabile è costituita da un identificatore liberamente selezionabile (ad es. myVar1) e da un tipo di dati (ad es. BOOL). Gli identificatori riservati (vedere Identificatori riservati (Pagina 95)) non possono essere utilizzati come identificatori.

3.5.1 Sintassi della dichiarazione delle variabili Le variabili nella sezione dichiarazione di una sezione di file sorgente vengono aggiunte sempre in base allo stesso modello:

1. Iniziare un blocco di dichiarazione con la parola chiave corrispondente (ad es. VAR, VAR_GLOBAL – vedere Panoramica di tutte le dichiarazioni delle variabili (Pagina 130)).

2. Quindi seguono le dichiarazioni di variabili vere e proprie (vedere figura), che possono essere create in un numero qualsiasi. La successione non è significativa.

3. Chiudere il blocco dichiarazione con END_VAR.

4. Si possono creare ulteriori blocchi di dichiarazione (anche con la stessa parola chiave)

Figura 3-11 Sintassi: Dichiarazione delle variabili



Tenere inoltre presente che:

● il nome della variabile deve essere un identificatore, ossia può contenere solo lettere, cifre o il carattere di sottolineatura, ma nessun carattere speciale.

● I tipi di dati ammessi sono:

– Tipi di dati elementari

– UDT (tipi di dati definiti dall'utente)

– Tipi di dati di sistema

– Tipi di dati TO

– Specifiche del tipo di dati ARRAY (campi)

– Definizione di un blocco funzionale (dichiarazione dell'istanza – vedere Richiamo delle funzioni e dei blocchi funzionali (Pagina 184)).

● L'assegnazione di valori iniziali alle variabili è possibile già nella dichiarazione. È ciò che si chiama inizializzazione (vedere Inizializzazione delle variabili o dei tipi di dati (Pagina 131)).

Variazioni rispetto al modello descritto si trovano:

● durante la dichiarazione di costanti (una costante deve essere inizializzata con un valore, vedere Costanti (Pagina 135)),

● durante gli accessi all'immagine di processo (vedere Panoramica di tutte le dichiarazioni delle variabili (Pagina 130)):

– nessuna dichiarazione di variabile è necessaria per l'accesso assoluto all'immagine di processo,

– nessuna inizializzazione è ammessa per l'accesso simbolico all'immagine di processo.

Tabella 3- 21 Esempi di dichiarazioni di variabili

VAR CONSTANT

PI : REAL := 3.1415;

END_VAR

VAR

// Dichiarazione di una variabile ...

var1 : REAL;

// ... o se esistono più variabili dello stesso tipo:

var2, var3, var4 : INT;

// Dichiarazione di un campo unidimensionale:

a1 : ARRAY[1..100] OF REAL;

// Dichiarazione di una sequenza di caratteri (stringa):

str1 : STRING[40];

END_VAR



3.5.2 Panoramica di tutte le dichiarazioni di variabili Le dichiarazioni di variabili e parametri riuniscono nomi, tipi di dati e valori iniziali per le variabili. Eseguire queste dichiarazioni sempre nelle sezioni dichiarazione delle sezioni seguenti del file sorgente:

● Sezione interfaccia

● Sezione implementazione

● POE (programma, funzione, blocco funzionale, espressione)

La sezione del file sorgente determina inoltre quali variabili è possibile dichiarare (vedere tabella) e la relativa portata.

Per maggiori informazioni sulle sezioni del file sorgente, consultare Strutturazione della sorgente ST (Pagina 105) e Sezioni del file sorgente (Pagina 201).

Tabella 3- 22 Parole chiave per i blocchi di dichiarazione

Parola chiave Significato Dichiarazione nelle seguenti sezioni della dichiarazione

VAR Dichiarazione delle variabili statiche vedere Modello di variabile (Pagina 220)

qualsiasi POE

VAR_GLOBAL Dichiarazione di variabili Unit vedere Modello di variabile (Pagina 220)

Sezione interfaccia Sezione implementazione

VAR_IN_OUT Dichiarazione variabili del parametro di passaggio; la POE accede direttamente a questa variabile (su riferimento) e può modificarla immediatamente. vedere Definizione delle funzioni (Pagina 176), Definizione dei blocchi funzionali (Pagina 177)

Funzione Blocco funzionale Espressione

VAR_INPUT Dichiarazione variabili del parametro di ingresso; il valore viene fornito dall'esterno e non è modificabile all'interno della POE. vedere Definizione delle funzioni (Pagina 176), Definizione dei blocchi funzionali (Pagina 177)

Funzione Blocco funzionale Espressione

VAR_OUTPUT Dichiarazione variabili del parametro di uscita; il valore viene fornito dal blocco funzionale per l'esterno vedere Definizione delle funzioni (Pagina 176), Definizione dei blocchi funzionali (Pagina 177)

Blocco funzionale



Parola chiave Significato Dichiarazione nelle seguenti sezioni della dichiarazione

VAR_TEMP Dichiarazione di variabili temporanee vedere Modello di variabile (Pagina 220)

Programma Blocco funzionale

RETAIN Dichiarazione di variabili ritentiva vedere Modello di variabile (Pagina 220)

Solo come supplemento per VAR_GLOBAL nella sezione interfaccia e implementazione

CONSTANT Dichiarazione di costanti vedere Costanti (Pagina 135)

Solo come supplemento: • per VAR in blocchi

funzionali, funzioni o programma

• per VAR_GLOBAL nella sezione interfaccia e implementazione

3.5.3 Inizializzazione di variabili o tipi di dati L'assegnazione di valori iniziali alle variabili o ai tipi di dati all'interno della dichiarazione è facoltativa, ved. Sintassi della dichiarazione delle variabili (Pagina 128) oppure Sintassi dei tipi di dati definiti dall'utente (Pagina 115):

● Se nella dichiarazione delle variabili non è specificata nessuna inizializzazione, il compilatore assegna automaticamente alle variabili il valore di inizializzazione preimpostato nella dichiarazione del tipo di dati.

Per i campi (ARRAY) vale quanto segue: Gli elementi di campo ricevono il valore di inizializzazione del tipo di dati base.

● Se anche nella dichiarazione del tipo di dati non è specificata nessuna inizializzazione, il compilatore assegna alle variabili o ai tipi di dati il valore zero.

Eccezione:

– Per i tipi di dati relativi al tempo: il valore di inizializzazione del relativo tipo di dati,

– Per i tipi di dati di enumerazione: 1° valore dell'enumerazione.

– Per i campi (ARRAY): Gli elementi di campo ricevono il valore di inizializzazione del tipo di dati base.

– Per le strutture (STRUCT): I componenti della struttura ricevono il valore di inizializzazione del relativo tipo di dati.

La preimpostazione di una variabile o di un tipo di dati definito dall'utente con valori iniziali avviene con un'assegnazione di valori (:=) in base al tipo di dati specificato:

● Assegnare un'espressione di costante ai tipi di dati elementari (o ai tipi di dati derivati da tipi di dati elementari) in base alla figura Sintassi: espressione di costante.

● Assegnare un elenco di inizializzazione dei campi al campo (ARRAY) in base alla figura Sintassi: elenco di inizializzazione dei campi.



● Assegnare un elenco di inizializzazione della struttura ad una struttura (STRUCT) in base alla figura Sintassi: elenco di inizializzazione della struttura (utilizzando la struttura in altre dichiarazioni).

● Assegnare un elemento di enumerazione a un tipo di dati di enumerazione.

Figura 3-12 Sintassi: inizializzazione di variabili

Il valore di inizializzazione assegnato a una variabile viene calcolato a partire dall'espressione di costante al momento della conversione. Per la sintassi dell'espressione di costante vedere la figura Sintassi: Espressione di costante.

Tenere presente che si può inizializzare un elenco di variabili ( a1, a2, a3,.. : INT := .. ) con un valore comune. In questo caso le variabili non devono essere inizializzate singolarmente (a1 : INT := .. ; a2 : INT := .. ; ecc.).

Nota

Le espressioni di costanti utilizzate per l'inizializzazione vengono calcolate nel tipo di dati delle variabili dichiarate o nel tipo di dati dichiarato.



Figura 3-13 Sintassi: Espressione di costante

Figura 3-14 Sintassi: Elenco di inizializzazione del campo



Figura 3-15 Sintassi: Elenco di inizializzazione della struttura

Tabella 3- 23 Esempi di inizializzazione delle variabili

VAR

// Dichiarazione di una variabile ...

var1 : REAL := 100.0;

// ... o se esistono più variabili dello stesso tipo:

var2, var3, var4 : INT := 1;

var5 : REAL := 3 / 2;

var6 : INT := 5 * SHL(1, 4);

myC1 : C1 := GREEN;

array1 : ARRAY [0..4] OF INT := [1, 3, 8, 4, 0];

array2 : ARRAY [0..5] OF DINT := [6 (7)];

array3 : ARRAY [0..10] OF INT := [2 (2(3),3(1)),0];

// corrisponde a [2(3),3(1),2(3),3(1)),0]

// Inizializzazione come segue:

// Elementi di campo 0, 1 con 3;

// Elementi di campo 2, 3, 4 con 1;

// Elementi di campo 5, 6 con 3;


// Elemento di campo 10 con 0

myAxis : PosAxis := TO#NIL;

END_VAR



Tabella 3- 24 Esempi di inizializzazione dei tipi di dati

TYPE

// Inizializzazione di un tipo di dati derivato

type1 : REAL := 10.0;

// Inizializzazione di un tipo di dati di enumerazione

cmyk_colour : (cyan, magenta, yellow, black) := yellow;

// Inizializzazione di strutture

var_rgb_colour : STRUCT

red, green, blue : USINT := 255;// bianco

END_STRUCT;

new_colour : var_rgb_colour := (red := 0, blue := 0);// verde

myInt : INT := 9;

myArray : ARRAY [0..5] OF myInt := [1, 2, 3];

// Inizializzazione come segue:

// Elemento di campo 0 con 1;




END_TYPE

Non è possibile assegnare a variabili del tipo di dati di un oggetto tecnologico valori di inizializzazione. Vengono inizializzati dal compilatore con TO#NIL.

Consultare le informazioni riguardanti le circostanze in cui le variabili vengono inizializzate al capitolo "Punto temporale dell'inizializzazione delle variabili" (Pagina 237).

3.5.4 costanti Le costanti sono dati con un valore fisso che non può essere modificato in fase di runtime del programma. La dichiarazione delle costanti è analoga alla dichiarazione delle variabili:

● per le costanti locali nella sezione dichiarazione di una POE (vedere la figura Sintassi: blocco di costanti in una POE e sintassi: Dichiarazione di costante).

● per le costanti Unit nella sezione interfaccia o implementazione della sorgente ST (vedere la figura Sintassi: costanti Unit nella sezione interfaccia e implementazione e sintassi: Dichiarazione di costante). Le costanti Unit dichiarate nella sezione interfaccia possono essere importate in altre sorgenti ST (vedere Modello di variabili (Pagina 220)).

La sezione file sorgente definisce anche la portata della dichiarazione delle variabili.

Figura 3-16 Sintassi: blocco di costanti in una POE



Figura 3-17 Sintassi: costanti Unit nella sezione Interfaccia e implementazione

Figura 3-18 Sintassi: Dichiarazione costante

Per l'inizializzazione di una costante vedere "Inizializzazione delle variabili o dei tipi di dati (Pagina 131)". Il valore assegnato a una costante viene calcolato al momento della conversione dall'espressione di costante.

Tabella 3- 25 Esempi di costanti

VAR CONSTANT

PI : REAL := 3.1415;

intConst : INT := 10;

sintConst : SINT := 0;

dintConst : DINT := 10_000;

timeConst : TIME := TIME#1h;

strConst : STRING[40] := 'Example of a string';

Two_PI : REAL := 2 * PI;

END_VAR

Principi fondamentali di ST 3.6 Assegnazione del valore e espressioni


3.6 Assegnazione del valore e espressioni Ovviamente finora sono state create assegnazioni di valori con la sequenza di caratteri :=, come nell'esempio relativo a un'istruzione (vedere la tabella Esempi per le istruzioni in Istruzioni (Pagina 107)) oppure durante l'inizializzazione delle variabili nella sezione di dichiarazione di una sezione del file sorgente.

Questa, tuttavia, è solo una piccola parte delle possibilità disponibili per l'assegnazione di valori. Qui viene fornita una trattazione completa di questo argomento.

Vedere anche Indicazioni su come evitare gli errori ed eseguire una programmazione efficace (Pagina 315)

3.6.1 Assegnazione del valore

3.6.1.1 Sintassi dell'assegnazione del valore L'assegnazione di un valore consente di assegnare a una variabile il valore di un'espressione. Il valore esistente viene sovrascritto. Il requisito per la corretta assegnazione di un valore è la dichiarazione di una variabile nella sezione dichiarazione (vedere Sintassi della dichiarazione delle variabili (Pagina 128)).

Come mostra il diagramma della sintassi seguente, l'espressione viene analizzata sul lato destro del carattere di assegnazione :=. Il risultato viene memorizzato nella variabile il cui nome si trova sul lato sinistro del carattere di assegnazione (variabile di destinazione). La figura illustra anche la totalità delle variabili di destinazione consentite da punti di vista formali.



Figura 3-19 Sintassi: Assegnazione valore

Di seguito vengono riportati chiarimenti ed esempi relativi al lato sinistro dell'assegnazione del valore:

● Assegnazioni di valori con variabili di un tipo di dati elementare (Pagina 139)

● Assegnazioni di valori con variabili del tipo di dati derivato enumerazione (enumeratore) (Pagina 143)

● Assegnazioni di valori con variabili del tipo di dati derivato ARRAY (campo) (Pagina 143)

● Assegnazioni di valori con variabili del tipo di dati derivato STRUCT (struttura) (Pagina 144)

● Per le assegnazioni del valore con accesso assoluto agli indirizzi dell'immagine di processo, vedere: Accesso assoluto all'immagine di processo fissa del BackgroundTask (accesso assoluto all'immagine di processo) (Pagina 275).

Per informazioni sulla struttura del lato destro di un'assegnazione del valore, ossia di un'espressione, vedere Espressioni (Pagina 145).



3.6.1.2 Assegnazioni di valori con variabili di un tipo di dati elementare Un'espressione con un tipo elementare di dati (Pagina 110) può essere assegnata a una variabile quando una delle condizioni seguenti è soddisfatta:

● Espressione e variabile di destinazione hanno lo stesso tipo di dati.

Tenere conto della seguente nota sul tipo di dati STRING (Pagina 139)

● Il tipo di dati dell'espressione può essere commutato nel tipo di dati delle variabili di destinazione attraverso una conversione implicita; vedere Conversione dei tipi di dati elementari (Pagina 169) e Funzioni per la conversione di tipi di dati numerici e tipi di dati di bit nel manuale di guida alle funzioni Funzioni di base SIMOTION.

Esempi

elemVar := 3*3;

elemVar := elemVar1;

Vedere anche Assegnazioni del valore con variabili di un tipo di dati a bit (Pagina 141)

3.6.1.3 Assegnazioni di valori con variabili del tipo di dati elementare STRING

Assegnazioni fra variabili del tipo di dati STRING Le assegnazioni tra variabili del tipo di dati STRING (sequenze di caratteri) dichiarate con lunghezze diverse sono possibili senza limitazioni. Se la lunghezza dichiarata della variabile di destinazione è inferiore alla lunghezza attuale della stringa assegnata, la stringa viene troncata alla lunghezza della variabile di destinazione.

Eccezione: In caso di assegnazione di passaggio (trasferimento di parametri a un parametro di passaggio) vale quanto segue: La lunghezza dichiarata delle variabili assegnate (parametro attuale) deve essere superiore o uguale alla lunghezza dichiarata delle variabili di destinazione (parametro di passaggio formale). Vedere Trasferimento dei parametri di passaggio (Pagina 185).

Vedere anche Diagramma della sintassi del tipo di dati STRING (Pagina 110):

Esempi:

string20 := 'ABCDEFG';

string20 := string30;



Accesso agli elementi di una stringa I singoli elementi di una stringa possono essere richiamati come gli elementi di un campo [1..n]. Questi elementi vengono convertiti implicitamente nel tipo di dati elementare BYTE. In questo modo sono possibili assegnazioni fra elementi di stringa e variabili del tipo di dati BYTE.

Esempi:

byteVar := string20[5];

string20[10] := byteVar;

È necessario fare attenzione ai seguenti casi particolari:

1. Durante l'assegnazione di una variabile del tipo di dati BYTE a un elemento di stringa (ad es. stringVar[n:] := byteVar):

– L'elemento di stringa cui deve essere assegnato il valore si trova oltre la lunghezza dichiarata della stringa:

La stringa resta invariata, TSI#ERRNO viene impostato sul valore 1

– L'elemento di stringa cui il valore deve essere assegnato si trova oltre la lunghezza assegnata della stringa (n > LEN(stringVar)), ma all'interno della lunghezza dichiarata:

La lunghezza della stringa viene adattata, gli elementi della stringa compresi fra LEN(stringvar) e n vengono impostati su $00,

2. Durante l'assegnazione di un elemento di stringa a una variabile del tipo di dati BYTE (byteVar := stringVar[n:]):

– L'elemento di stringa che deve essere assegnato alle variabili si trova oltre la lunghezza assegnata alla stringa (n > LEN(stringVar)):

La variabile viene impostata sul valore16#00, TSI#ERRNO sul valore 2.

Elaborazione di stringhe Per l'elaborazione delle stringhe, come per la combinazione di stringhe e per la sostituzione o l'estrazione di caratteri, sono disponibili diverse funzioni di sistema, vedere manuale di guida alle funzioni Funzioni di base SIMOTION.

Conversione fra numeri e stringhe Per la conversione fra variabili dei tipi di dati numerici e stringhe sono disponibili diverse funzioni di sistema, vedere Conversione di tipi di dati elementari (Pagina 169) e manuale di guida alle funzioni Funzioni di base SIMOTION.



3.6.1.4 Assegnazioni del valore con variabili di un tipo di dati a bit

Accesso ai singoli bit di una variabile di un tipo di dati a bit È possibile accedere ai singoli bit di una variabile del tipo di dati BYTE, WORD o DWORD:

● Con funzioni standard (vedere manuale di guida alle funzioni Funzioni di base SIMOTION):

Con le funzioni _getBit, _setBit und _toggleBit è possibile leggere, scrivere o invertire un bit a piacere di una stringa di bit.

I numeri dei bit possono essere specificati tramite una variabile.

● Con accesso bit diretto:

Il bit delle variabili cui si desidera accedere può essere immesso come costante separato da un punto dietro alle variabili.

I numeri dei bit possono essere specificati tramite una costante.

Per poter utilizzare questa opzione deve essere attivata l'opzione compilatore "Consenti estensioni lingua" (vedere Impostazioni globali del compilatore (Pagina 59) e Impostazioni locali del compilatore (Pagina 61)).

Figura 3-20 Sintassi: Accesso bit diretto



Tabella 3- 26 Esempio di accesso bit diretto

// Solo con l'opzione compilatore "Consenti estensioni lingua"

FUNCTION f : VOID

VAR CONSTANT

BIT_7 : INT := 7;

END_VAR

VAR

dw : DWORD;

b : BOOL;

END_VAR

b := dw.BIT_7; // Accesso a bit 7

b := dw.3; // Accesso a bit 3

// b := dw.33; // Errore di compilazione;

// Bit 33 non consentito.

END_FUNCTION

ATTENZIONE L'accesso ai bit di una variabile I/O o di variabili di sistema può essere interrotto da altri task. La coerenza perciò non è garantita.

Elaborazione di variabili dei tipi di dati a bit È possibile:

1. Raggruppare più variabili dello stesso tipo di dati in un'unica variabile di un tipo di dati sovraordinato (ad es. 2 variabili del tipo di dati BYTE in 1 variabile del tipo di dati WORD). A questo scopo sono disponibili diverse funzioni di sistema, ad es. WORD_FROM_2BYTE.

2. Scomporre una variabile in più variabili di un tipo di dati subordinato (ad es. 1 variabile del tipo di dati DWORD in 4 variabili del tipo di dati BYTE). A questo scopo sono disponibili diversi blocchi funzionali di sistema, ad es. DWORD_TO_4BYTE.

3. Ruotare o spostare la posizione di un bit all'interno di una variabile. Qui sono disponibili le funzioni standard della stringa di bit ROL, ROR, SHL e SHR.

Queste funzioni di sistema e blocchi funzionali di sistema sono descritti nel manuale di guida alle funzioni Funzioni di base SIMOTION.

Operatori logici Le variabili dei tipi di dati a bit possono essere combinate con operatori logici, vedere Espressioni logiche ed espressioni a sequenza di bit (Pagina 154).



3.6.1.5 Assegnazioni di valori con variabili del tipo di dati derivato enumerazione (Enumerator) Ogni espressione e ogni variabile del tipo di dati derivato enumerazione (vedere anche: Tipo di dati derivato enumerazione - Enumeratore (Pagina 120)) può essere assegnato a un'altra variabile dello stesso tipo.

type1 := BLUE;

3.6.1.6 Assegnazioni di valori con variabili del tipo di dati derivato ARRAY (campo) Un campo è costituito da più dimensioni ed elementi di campo tutti dello stesso tipo (vedere anche: Tipo di dati derivato ARRAY - Campo (Pagina 118)).

Esistono varie possibilità per assegnare campi a una variabile; si possono assegnare singoli elementi o campi parziali:

● Un campo completo può essere assegnato a un altro campo se i tipi di dati dei componenti e i limiti di campo (indice di campo minimo e massimo) corrispondono. Assegnazioni valide sono:

array_1 := array_2;

● Un singolo elemento di campo viene richiamato con il nome di campo, seguito dal valore di indice tra parentesi angolari. Un indice deve essere un'espressione aritmetica del tipo di dati SINT, USINT, INT, UINT o DINT.

elem1 := array [i];

array_1 [2] := array_2 [5];

array [j] := 14;

● Un'assegnazione di valori per un campo parziale consentito si ottiene omettendo per ogni dimensione del campo una coppia di parentesi angolari a partire da destra. In questo modo si richiama un intervallo parziale il cui numero di dimensioni è uguale al numero degli indici rimanenti (vedere l'esempio di seguito).

Da ciò consegue che in una matrice è possibile fare riferimento in modo chiuso a righe e singoli componenti, ma non a colonne (chiuso significa da...a). Assegnazioni valide sono:

matrix1 [i] := matrix2 [k];

array1 := matrix2 [k];



3.6.1.7 Assegnazioni di valori con variabili del tipo di dati derivato STRUCT (struttura) Le variabili di un tipo di dati definito dall'utente che contengono le specifiche del tipo di dati STRUCT vengono definite variabili strutturate (vedere anche Tipo di dati derivato STRUCT - Struttura (Pagina 122)). Possono sostituire una struttura completa o una componente di questa struttura.

Dati validi per una variabile di struttura sono:

struct1 //Identificatore per una struttura struct1.elem1 //Identificatore per il componente della struttura struct1.array1 //Identificatore di un campo semplice

//all'interno di una struttura struct1.array1[5] //Identificatore di un componente di campo

//all'interno di una struttura

Per assegnare strutture a una variabile è possibile fare riferimento alle strutture complete o ai componenti delle strutture:

● Una struttura completa è un'altra struttura assegnabile solo quando i componenti della struttura concordano per quanto riguarda il tipo di dati e il nome.

Un'assegnazione valida è la seguente:

struct1 := struct2;

● A ogni componente della struttura è possibile assegnare una variabile o un'espressione di tipo affidabile o un altro componente della struttura.

Assegnazioni valide sono:

struct1.elem1 := Var1; struct1.elem1 := 20; struct1.elem1 := struct2.elem1; struct1.array1 := struct2.array1; struct1.array1[10] := 100;

Nota

Anche per accedere alle variabili di uscita di un blocco funzionale, ossia ai relativi risultati, si utilizzano variabili strutturate nel formato nome_istanza_FB.parametro_uscita, ad es. mioAmbito.ambiente. Per maggiori dettagli sui blocchi funzionali consultare le informazioni contenute in Definizione delle funzioni (Pagina 176) e Definizione dei blocchi funzionali (Pagina 177). Le variabili strutturate vengono utilizzate anche per accedere alle variabili TO e alle variabili del sistema base.



3.6.2 Espressioni Un'espressione è un valore che viene calcolato durante la conversione o il runtime del programma. È composta di operandi (ad es. costanti, variabili o valori della funzione) e operatori (ad es. *, /, +, -).

I tipi di dati degli operandi e degli operatori assegnati determinano il tipo dell'espressione.

In ST viene eseguita la distinzione tra:

● Espressioni aritmetiche (Pagina 148)

● Espressioni di confronto (Pagina 151)

● Espressioni logiche ed espressioni a sequenza di bit (Pagina 154)

3.6.2.1 Risultato di un'espressione Il risultato di un'espressione:

● può essere assegnato a una variabile,

● può essere utilizzato come condizione per un'istruzione di controllo,

● può essere utilizzato come parametro per il richiamo di una funzione o di un blocco funzionale.

Il tipo di dati del risultato di un'espressione aritmetica o di un'espressione a sequenza di bit è definito dai tipi di dati degli operandi. Viene considerato il più piccolo tipo di dati comune nel quale possono essere convertiti implicitamente entrambi gli operandi.

Un'ulteriore assegnazione dell'espressione ad una variabile (o parametri di una funzione oppure di un blocco funzionale) è possibile solo nei seguenti casi:

● L'espressione calcolata e la variabile da assegnare presentano lo stesso tipo di dati.

● Il tipo di dati dell'espressione calcolata può essere convertito in modo implicito nel tipo di dati delle variabili da assegnare.

Per questa possibile causa d'errore e la relativa soluzione vedere il manuale di guida alle funzioni Funzioni di base SIMOTION.

Nota

Le espressioni che contengono solo gli elementi indicati di seguito possono essere utilizzate per l'inizializzazione di variabili e per la specifica dell'indice nelle dichiarazioni di ARRAY (espressioni di inizializzazione – vedere la figura Sintassi: Espressione di costante in Inizializzazione di variabili o tipi di dati (Pagina 131)): • costanti • Operazioni aritmetiche di base • Operazioni logiche e operazioni di confronto • Funzioni delle stringhe di bit standard

Le espressioni di costanti utilizzate per l'inizializzazione vengono calcolate nel tipo di dati delle variabili dichiarate o nel tipo di dati dichiarato.



3.6.2.2 Sequenza di analisi di un'espressione La sequenza di analisi di un'espressione dipende da:

● priorità degli operatori assegnati,

● la sequenza da sinistra a destra,

● parentesi (per operatori con priorità uguale).

L'elaborazione delle espressioni avviene in base a regole specifiche:

● Gli operatori vengono elaborati in base alla rispettiva priorità (vedere tabella in Ordine degli operatori (Pagina 156)).

● Gli operatori con la stessa priorità vengono elaborati da sinistra a destra.

● Il segno meno (-) anteposto a un identificatore equivale alla moltiplicazione per -1.

● Gli operatori aritmetici non possono essere posizionati direttamente uno dopo l'altro. Pertanto, l'espressione a * -b non è valida, mentre a * (-b) è consentita.

● L'aggiunta delle parentesi annulla la priorità degli operatori, ossia le parentesi hanno la priorità maggiore.

● Le espressioni tra parentesi vengono considerate come singoli operatori e vengono valutate per prime.

● Il numero di parentesi di apertura deve corrispondere al numero di parentesi di chiusura.

● Le operazioni aritmetiche non possono essere eseguite su caratteri o dati logici. Pertanto, le espressioni come (n<=0) + (n<0) sono false.

Tabella 3- 27 Esempi per le espressioni

testVar // Operando

A AND (B) // Espressione logica

A AND (NOT B) // Espressione logica con negazione

(C) < (D) // Espressione di confronto

3+3*4/2 // Espressione aritmetica



3.6.3 Operandi

Definizione Gli operandi sono oggetti con i quali si possono costruire le espressioni. Gli operandi possono essere rappresentati tramite il diagramma della sintassi:

Figura 3-21 Sintassi: Operando

Tabella 3- 28 Esempi per operandi

intVar 5 %I4.0 PI NOT TRUE axis1.motionStateData.actualVelocity



3.6.4 Espressioni aritmetiche Un'espressione aritmetica è un'espressione costruita con operatori aritmetici. Tali espressioni consentono di elaborare tipi di dati numerici.

Figura 3-22 Sintassi: operatore aritmetico

Figura 3-23 Sintassi: operatore aritmetico di base

La seguente tabella indica per ogni operazione aritmetica:

● l'operatore aritmetico

● i tipi di dati ammessi degli operandi

● il tipo di dati del risultato.

Vengono quindi utilizzati i tipi di dati generali (Pagina 113).

Nota

Altre operazioni sono possibili con le funzioni numeriche standard, vedere Funzioni numeriche standard nel manuale di guida alle funzioni Funzioni di base SIMOTION.

Per ragioni di visibilità, si consiglia di racchiudere i numeri negativi tra parentesi anche nei casi in cui non è necessario.

Gli operatori aritmetici vengono trattati in base al loro ordine (Pagina 156).



Tabella 3- 29 Operatori aritmetici

Tipo di dati Operazione Operatore 1° operando 2° operando Risultato1)

Elevazione a potenza (vedere anche la funzione EXPT)

** ANY_REAL2) ANY_REAL ANY_REAL3)

Meno unario – ANY_NUM (nessuno) ANY_NUM ANY_NUM ANY_NUM ANY_NUM ANY_BIT4) ANY_BIT4) ANY_BIT

Moltiplicazione *

TIME ANY_NUM TIME ANY_NUM ANY_NUM5) ANY_NUM ANY_BIT4) ANY_BIT4) 5) ANY_BIT TIME ANY_NUM5) TIME

Divisione /

TIME TIME5 UDINT ANY_INT ANY_INT5) ANY_INT Divisione modulo MOD ANY_BIT4) ANY_BIT4) 5) ANY_BIT ANY_NUM ANY_NUM ANY_NUM ANY_BIT4) ANY_BIT4) ANY_BIT TIME TIME TIME6) TOD TIME TOD6)

Somma +

DT TIME DT7) ANY_NUM ANY_NUM ANY_NUM ANY_BIT4) ANY_BIT4) ANY_BIT TIME TIME TIME TOD TIME8) TOD DATE DATE TIME9) TOD TOD TIME9) DT TIME DT

Sottrazione –

DT DT TIME9)



1) Il tipo di dati del risultato (se non indicato esplicitamente) è il più piccolo tipo di dati comune nel quale possono essere convertiti implicitamente entrambi gli operandi.

2 Il 1° operando deve essere maggiore di zero. Eccezione dalla versione V4.1 del kernel SIMOTION: – Se il 2° operando è un numero intero il 1° operando può essere anche minore di zero. – Se il 2° operando è positivo il 1° operando può anche essere uguale a zero. Fino alla versione V4.0 del kernel SIMOTION vale quanto segue: Se il 1° operando è uguale a zero, è possibile venga visualizzato un messaggio di errore con ExecutionFaultTask.

3) Tipo di dati del 1° operando. 4) Oltre al tipo di dati BOOL. Il calcolo viene eseguito con il numero intero senza segno della stessa

ampiezza di bit. 5) Il 2° operando deve essere diverso da zero. 6) Addizione eventualmente con superamento. 7) Addizione con correzione del dato. 8) Limitazione di TIME su TOD prima del calcolo. 9) Queste operazioni elaborano il modulo per il valore massimo del tipo di dati TIME.

Nota

Se nelle operazioni con variabili del tipo di dati generale ANY_REAL vengono superati i limiti del campo di valori, il risultato contiene il modello di bit corrispondente secondo IEEE 754.

Per appurare se durante l'operazione il campo di valori è stato superato, è possibile controllare il risultato con la funzione _finite (vedere manuale di guida alle funzioni Funzioni di base SIMOTION).

3.6.4.1 Esempi per le espressioni aritmetiche

Esempi di espressioni aritmetiche con numeri Supponendo che i e j siano variabili a numero intero (ad es. del tipo di dati INT) con i valori 11 o -3, di seguito vengono riportate come esempio alcune espressioni a numeri interi e i rispettivi valori:

Espressione Valore i + j 8 i - j 14 i * j -33 i MOD j -2 i / j -3



Esempi di espressioni aritmetiche valide con indicazioni del tempo: Sono date le seguenti variabili:

Variabili Contenuto Tipo di dati t1 T#1D_1H_1M_1S_1MS TIME t2 T#2D_2H_2M_2S_2MS TIME d1 D#2004-01-11 DATE d2 D#2004-02-12 DATE tod1 TOD#11:11:11.11 TIME_OF_DAY tod2 TOD#12:12:12.12 TIME_OF_DAY dt1 DT#2004-01-11-11:11:11.11 DATE_AND_TIME dt2 DT#2004-02-12-12:12:12.12 DATE_AND_TIME

Alcune espressioni con queste variabili e i rispettivi valori sono riportati nell'esempio.

Espressione Valore t1 + t2 T#3D_3H_3M_3S_3MS dt1 + t1 DT#2004-01-12-12:12:12.111 t1 - t2 T#48D_16H_1M_46S_295MS t1 * 2 T#2D_2H_2M_2S_2MS t1 / 2 T#12H_30M_30S_500MS DATE_AND_TIME_TO_TIME_OF_DAY(dt1) TOD#11:11:11.110 DATE_AND_TIME_TO_DATE(dt1) D#2004-01-11

3.6.5 Espressioni di confronto

Definizione Un'espressione di confronto è un'espressione costituita con operatori di confronto (vedere la figura) del tipo di dati BOOL.

Figura 3-24 Sintassi: Operatori di confronto

Gli operatori di confronto confrontano il valore di 2 operandi (vedere la tabella) e forniscono come risultato un valore booleano.

1° operando operatore 2° operando -> valore booleano



Tabella 3- 30 Significato degli operatori di confronto

Operatore Significato > 1. operando è maggiore del 2° operando < 1. operando è minore del 2° operando >= 1. operando è maggiore o uguale al 2° operando <= 1. operando è minore o uguale al 2° operando = 1. operando è uguale al 2° operando <> 1. operando è diverso dal 2° operando

Il risultato dell'espressione di confronto è:

● 1 (TRUE) se il confronto è soddisfatto,

● 0 (FALSE) se il confronto non è soddisfatto.

La tabella seguente mostra le combinazioni di tipi di dati e operatori di confronto ammesse per entrambi gli operandi.

Tabella 3- 31 Espressioni di confronto: Combinazioni di tipi di dati e operatori di confronto ammesse

Tipo di dati

1. Operando 2. Operando

Operandi di confronto ammessi

ANY_NUM ANY_NUM1) <, >, <=, >=, =, <> ANY_BIT ANY_BIT <, >, <=, >=, =, <> DATE DATE <, >, <=, >=, =, <> TIME_OF_DAY (TOD) TIME_OF_DAY (TOD) <, >, <=, >=, =, <> DATE_AND_TIME (DT) DATE_AND_TIME (DT) <, >, <=, >=, =, <> TIME TIME <, >, <=, >=, =, <> STRING STRING2) <, >, <=, >=, =, <> Tipo di dati enumerazione Tipo di dati di enumerazione3) =, <> Campo (ARRAY) Campo (ARRAY)3) =, <> Struttura (STRUCT) Struttura (STRUCT)3) =, <>

1) Il confronto avviene nel più piccolo tipo di dati comune nel quale possono essere convertiti implicitamente entrambi gli operandi.

2) Variabili del tipo di dati STRING sono confrontabili indipendentemente dalla lunghezza dichiarata della stringa. Per il confronto fra due variabili del tipo di dati STRING con diverse lunghezze, la stringa di caratteri più breve viene espansa attraverso l'inserimento a destra di $00 al termine della stringa più lunga. Il confronto si svolge da sinistra verso destra e avviene sulla base del codice ASCII dei rispettivi caratteri. Esempio: ’ABC’ < ’AZ’ < ’Z’ < ’abc’ < ’az’ < ’z’.

3) Tipo di dati del 1° operando.



Le espressioni di confronto e le variabili o costanti del tipo di dati BOOL si possono combinare in espressioni logiche mediante gli operatori logici (vedere Espressioni logiche ed espressioni a sequenza di bit (Pagina 154)). In questo modo si possono realizzare query del tipo Se a < b e b < c, allora ….

ATTENZIONE In un'espressione gli operatori di confronto hanno la priorità sugli operatori logici (vedere Ordine degli operatori (Pagina 156)). Per questo gli operandi di un'espressione di confronto devono stare tra parentesi, se essi stessi sono espressioni logiche o espressioni a sequenza di bit.

Tenere presente una possibile causa d'errore nel confronto di grandezze REAL o LREAL (anche le variabili di sistema corrispondenti, come la posizione dell'asse).

Tabella 3- 32 Esempi di espressioni di confronto

IF A = 2 THEN

; //...

END_IF;

var_1 := B < C; // var_1 del tipo di dati BOOL

IF D < E OR var_2 THEN // var_2 del tipo di dati BOOL

; // ...

END_IF;

var_3 := 0 < F < 10 // var_3 del tipo di dati BOOL, valore TRUE

// Il calcolo avviene da sinistra a destra

// nel seguente formato: (0 < F) < 10

// Dapprima viene calcolato 0 < F.

// Il risultato è del tipo di dati BOOL (FALSE o TRUE)

// e viene confrontato con BYTE#10.

// Espressione equivalente:

var_3 : = BOOL_TO_BYTE (0 < F) < BYTE#10



3.6.6 Espressioni logiche e espressioni a sequenza di bit

Definizione Con gli operatori logici AND, &, XOR e OR è possibile collegare operandi ed espressioni del tipo di dati generico ANY_BIT (BOOL, BYTE, WORD oppure DWORD).

Con l'operatore logico NOT è possibile negare operandi ed espressioni del tipo di dati ANY_BIT.

La tabella fornisce informazioni sugli operatori disponibili:

Tabella 3- 33 Operatori logici

Operazione Operatore 1. Operando 2. Operando Risultato1 Negazione NOT ANY_BIT - ANY_BIT Congiunzione AND o & ANY_BIT ANY_BIT ANY_BIT Disgiunzione esclusiva

XOR ANY_BIT ANY_BIT ANY_BIT

Disgiunzione OR ANY_BIT ANY_BIT ANY_BIT 1 Il tipo di dati del risultato viene determinato dal tipo di dati più potente degli operandi.

L'espressione viene definita

● come espressione logica, se vengono utilizzati esclusivamente operandi di tipo BOOL

Gli operatori agiscono sugli operandi secondo la seguente tabella di verità.

Il risultato di un'espressione logica è 1 (TRUE) o 0 (FALSE).

● come espressione a sequenza di bit, se vengono utilizzati gli operandi di tipo BYTE, WORD o DWORD.

Gli operatori agiscono sui singoli bit degli operandi secondo la seguente tabella di verità.

Tabella 3- 34 Tabella di verità degli operatori logici

Operandi (tipo di dati BOOL)

Risultato (tipo di dati BOOL)

a b NOT a NOT b a AND b a & b

a XOR b a OR b

0 0 1 1 0 0 0 0 1 1 0 0 1 1 1 0 0 1 0 1 1 1 1 0 0 1 0 1



Esempi

Tabella 3- 35 Espressioni logiche

Espressione (n = 10) Valore (n>0) AND (n<20) TRUE (n>0) AND (n<5) FALSE (n>0) OR (n<5) TRUE (n>0) XOR (n<20) FALSE NOT ((n>0) AND n<20)) FALSE

Tabella 3- 36 Espressioni a sequenza di bit

Espressione Valore 2#01010101 AND 2#11110000 2#01010000 2#01010101 OR 2#11110000 2#11110101 2#01010101 XOR 2#11110000 2#10100101 NOT 2#01010101 2#10101010

Espressione nella query (value1 sia 2#01, value2 sia 2#11)

IF (value1 AND value2) = 2#01 THEN...

La condizione restituisce TRUE, poiché l'espressione a sequenza di bit restituisce 2#01.

Principi fondamentali di ST 3.7 Istruzioni di controllo


3.6.7 Ordine degli operatori In Espressioni (Pagina 145) sono state descritte alcune regole generali per la creazione di espressioni. Nella tabella è riportato l'ordine dei singoli operatori all'interno di un'espressione.

Operazione Simbolo Ordine Parentesi (Espressione) Valutazione della funzione Identificatore (elenco argomenti)

ad es. LN(a), EXPT (a,b) ecc. Complemento di negazione

– NOT

Elevazione a potenza ** Modulo moltiplicazione divisione

* / MOD

Addizione Sottrazione

+ –

Confronto <, >, <=, >= Uguaglianza Diseguaglianza

= <>

AND booleano &, AND OR ESCLUSIVO booleano

XOR

OR booleano OR

Superiore

Inferiore

3.7 Istruzioni di controllo È possibile programmare solo alcune sezioni del file sorgente in modo che tutte le istruzioni si trovino in sequenza l'una dopo l'altra fino alla fine della sezione. Di norma, a seconda delle condizioni, solo determinate istruzioni vengono eseguite (alternative) o ripetute (loop). Gli strumenti di programmazione utilizzati in questo caso sono le istruzioni di controllo all'interno di una sezione del file sorgente.

3.7.1 Istruzione IF L'istruzione IF è un'istruzione condizionata. Offre una o più opzioni e seleziona una (o nessuna) parte dell'istruzione per l'esecuzione.

L'esecuzione dell'istruzione condizionata genera la valutazione delle espressioni logiche indicate. Se il valore di un'espressione è TRUE, la condizione viene considerata soddisfatta; se il valore è FALSE la condizione non è soddisfatta.



Figura 3-25 Sintassi: Istruzione IF

Sequenza operativa L'istruzione IF viene elaborata in base alle seguenti regole:

1. Se il valore della prima espressione è TRUE, viene eseguita la parte di istruzione che segue THEN.

L'esecuzione del programma continua dopo END_IF.

2. Se il valore dell'espressione è FALSE, vengono valutate le espressioni delle diramazioni ELSIF. Se le diramazioni ELSIF contengono un'espressione TRUE, viene eseguita la parte di istruzione che segue THEN.


3. Se le diramazioni ELSIF non contengono l'espressione booleana TRUE, la sequenza di istruzioni viene eseguita con ELSE (o non c'è alcuna sequenza se la diramazione ELSE non è disponibile).


Può esistere un numero qualsiasi di istruzioni ELSIF.

La diramazione ELSIF e/o la diramazione ELSE può non essere presente. Questi casi vengono trattati come se tali diramazioni contenessero istruzioni vuote.

Nota

L'uso di una o più diramazioni ELSIF offre, rispetto a una sequenza di istruzioni IF, il vantaggio che in un'espressione valida le seguenti espressioni logiche non vengono più valutate. Il tempo di esecuzione di un programma si riduce oppure l'esecuzione di parti di programmi non consentite viene impedita.



Esempio L'esempio seguente chiarisce l'uso dell'istruzione IF.

Tabella 3- 37 Esempi di istruzione IF

IF A = B THEN

n:= 0;

END_IF;

IF temperature < 5.0 THEN

%Q0.0 := TRUE;

ELSIF temperature > 10.0 THEN

%Q0.2 := TRUE;

ELSE

%Q0.1 := TRUE;

END_IF;

3.7.2 Istruzione CASE L'istruzione CASE serve alla selezione di 1 su n di una parte di programma.

La selezione definisce, mediante un'espressione di selezione (selettore),

● un'espressione del tipo di dati generico ANY_INT

● variabile di un tipo di dati di enumerazione (enumeratore)

La selezione viene eseguita da un elenco di valori in cui ciascun valore o gruppo di valori è assegnato a una sezione del programma.



Figura 3-26 Sintassi: Istruzione CASE

Sequenza operativa L'istruzione CASE viene elaborata in base alle seguenti regole:

1. Viene calcolata l'espressione di selezione (selettore). Essa deve fornire un valore del tipo di dati generico ANY_INT (numero intero) o di un tipo di dati di enumerazione.

2. Successivamente viene verificato se il valore del selettore è contenuto nella lista dei valori. Ciascun valore di questo elenco rappresenta uno dei valori ammessi per l'espressione di selezione.

3. In caso di concordanza, viene eseguita la parte di programma assegnata all'elenco.

4. La diramazione ELSE è opzionale. Viene eseguita quando il processo di confronto non rileva alcuna concordanza.

5. Se la diramazione ELSE non è presente e il processo di confronto non rileva alcuna concordanza, l'esecuzione del programma riprende dopo END_CASE.



Elenco dei valori L'elenco dei valori contiene i valori ammessi per l'espressione di selezione.

Figura 3-27 Sintassi: Elenco dei valori

Nella formulazione dell'elenco dei valori tenere presente che

● ciascun elenco dei valori con una costante (Valore), un elenco di costanti (Valore1, Valore2, Valore3, ...) o con un intervallo di costanti (Valore1 .. Valore2),

● i valori contenuti nella lista dei valori devono essere numeri interi o costanti e elementi del tipo di dati di enumerazione del selettore.

Nota

Un valore deve comparire un'unica volta nelle liste dei valori di un'istruzione CASE.

Se un valore compare più volte, il compilatore fornisce un messaggio di allarme; viene eseguita la parte delle istruzioni per l'elenco dei valori nel quale tale valore compare per la prima volta.

Esempio L'esempio seguente chiarisce l'uso dell'istruzione CASE:

Tabella 3- 38 Esempi di istruzione CASE

CASE intVar OF

1 : a := 1;

2,3 : b := 1;

4..9 : c := 1; d:=2;

ELSE

e := 5;

END_CASE;



3.7.3 Istruzione FOR Un'istruzione FOR o anche un'istruzione di ripetizione esegue una sequenza di istruzioni in un loop in cui a una variabile (variabile di esecuzione) vengono assegnati valori continui. La variabile di esecuzione deve essere l'identificatore di una variabile locale di tipo SINT, INT o DINT.

La definizione di un loop con FOR include la determinazione di un valore iniziale e finale. Entrambi i valori devono essere dello stesso tipo della variabile di esecuzione.

Nota

Utilizzare l'istruzione FOR se è noto il numero di passaggi nella programmazione. Se non si conosce tale numero, è più adatta l'istruzione WHILE o REPEAT (vedere Istruzione WHILE (Pagina 163) e Istruzione REPEAT (Pagina 164)).

Figura 3-28 Sintassi: Istruzione FOR



Sequenza operativa L'istruzione FOR viene elaborata in base alle seguenti regole:

1. All'avvio del loop la variabile di esecuzione viene impostata sul valore iniziale e dopo l'esecuzione di ciascun loop viene aumentata (incremento positivo) o ridotta (incremento negativo) dell'incremento indicato finché non viene raggiunto il valore finale. Dopo la prima esecuzione del loop il valore iniziale viene considerato valore attuale.

2. Ad ogni esecuzione viene verificato se vengono soddisfatte le seguenti condizioni:

– Valore iniziale o valore attuale <= Valore finale (con incremento positivo) o

– Valore iniziale o valore attuale >= valore finale (con incremento negativo)

Se la condizione è soddisfatta, viene eseguita la sequenza di istruzioni.

Se la condizione non è soddisfatta, il loop e quindi la sequenza di istruzioni viene saltata e l'elaborazione del programma continua dopo END_FOR.

3. Se il loop FOR non viene eseguito per il passo 2, la variabile di esecuzione mantiene il valore attuale.

Regole Per l'istruzione FOR valgono le seguenti regole:

● L'indicazione di BY [incremento] può essere omessa. Se non viene specificato un incremento, viene considerato +1.

● Il valore iniziale, il valore finale e l'incremento sono espressioni (vedere Espressioni (Pagina 145)). La valutazione avviene una volta all'inizio dell'esecuzione dell'istruzione FOR.

● Se il valore iniziale e il valore finale sono del tipo di dati DINT, l'importo di (valore finale-valore iniziale) deve essere minore del campo di valori massimo di numeri interi della doppia larghezza, quindi minore di 2**31-1.

● Viene eseguita solo la prima istruzione di selezione per la quale viene soddisfatta l'espressione di selezione.

● La variabile di esecuzione contiene il valore che determina l'interruzione del loop, ossia viene aggiornata prima dell'interruzione del loop in base all'incremento.

● Una modifica di entrambi i valori di valore finale e incremento durante l'esecuzione del loop non è consentita.

Esempio L'esempio seguente chiarisce l'uso dell'istruzione FOR:

Tabella 3- 39 Esempio di istruzione FOR

FOR k := 1 TO 10 BY 2 DO

l := l + 1;

// ...

END_FOR;



3.7.4 Istruzione WHILE L'istruzione WHILE consente di ripetere l'esecuzione di una sequenza di istruzione sotto il controllo di una condizione di esecuzione. La condizione di esecuzione viene creata in base alle regole di un'espressione logica.

Nota

Utilizzare l'istruzione WHILE se non è noto il numero di cicli della programmazione. Se il numero dei cicli di programmazione è noto, è da utilizzarsi preferibilmente l'istruzione FOR (vedere Istruzione FOR (Pagina 161)).

Figura 3-29 Sintassi: Istruzione WHILE

La parte di istruzione DO seguente viene ripetuta se la condizione di esecuzione ha il valore TRUE.

Sequenza operativa L'istruzione WHILE viene elaborata in base alle seguenti regole:

1. Prima di ciascuna esecuzione della parte di istruzione viene valutata la condizione di elaborazione.

2. Se il valore è TRUE, la parte di istruzione viene eseguita.

3. Se il valore è FALSE, l'esecuzione dell'istruzione WHILE viene conclusa (ciò può verificarsi anche già alla prima valutazione), l'elaborazione del programma continua dopo END_WHILE.

Esempio L'esempio seguente chiarisce l'uso dell'istruzione WHILE:

Tabella 3- 40 Esempio di istruzione WHILE

WHILE Index <= 50 DO

Index:= Index + 2;

END_WHILE;



3.7.5 Istruzione REPEAT Un'istruzione REPEAT determina l'esecuzione ripetuta di una sequenza di istruzioni tra REPEAT e UNTIL fino al verificarsi di una condizione di interruzione. La condizione di interruzione viene creata in base alle regole di un'espressione logica.

Nota

Utilizzare l'istruzione REPEAT se non è noto il numero di passaggi nella programmazione. Se il numero dei cicli di programmazione è noto, è da utilizzarsi preferibilmente l'istruzione FOR (vedere Istruzione FOR (Pagina 161)).

Figura 3-30 Sintassi: Istruzione REPEAT

La condizione viene verificata di volta in volta dopo l'esecuzione della parte di istruzione. Questo significa che la parte di istruzione viene eseguita almeno una volta, anche se la condizione di interruzione viene soddisfatta fin dall'inizio.

L'istruzione REPEAT viene elaborata in base alle seguenti regole:

1. Dopo ciascuna esecuzione della parte di istruzione viene valutata la condizione di esecuzione.

2. Se il valore è FALSE, la parte di istruzione viene eseguita nuovamente.

3. Se compare il valore TRUE, viene terminata l'esecuzione dell'istruzione REPEAT; l'elaborazione del programma viene continuata dopo END_REPEAT.

Esempio L'esempio seguente chiarisce l'uso dell'istruzione REPEAT:

Tabella 3- 41 Esempio di istruzione REPEAT

Index := 1;

REPEAT

Index := Index + 2;

UNTIL Index > 50

END_REPEAT;



3.7.6 Istruzione EXIT Un'istruzione EXIT consente di uscire da un loop (loop di FOR, WHILE o REPEAT) in un punto qualsiasi, indipendentemente dal fatto che sia soddisfatta o meno la condizione di interruzione.

Questa istruzione consente di abbandonare immediatamente l'istruzione di ripetizione che circonda direttamente l'istruzione EXIT.

L'esecuzione del programma viene ripresa dopo la fine del loop di ripetizione (ad es. dopo END_FOR).

Esempio L'esempio seguente chiarisce l'uso dell'istruzione EXIT:

Tabella 3- 42 Esempio di istruzione EXIT

Index := 1;

FOR Index := 1 to 51 BY 2 DO

IF %I0.0 THEN

EXIT;

END_IF;

END_FOR;

(*

La seguente assegnazione di valori viene eseguita dopo l'esecuzione di

EXIT o dopo la conclusione regolare del loop FOR:

*)

Index_find := Index_2;

3.7.7 Istruzione RETURN Un'istruzione RETURN chiude la POE attuale in esecuzione (programma, funzione, blocco funzionale).

Dopo la conclusione di una funzione o di un blocco funzionale l'elaborazione del programma nella POE sovraordinata viene ripresa dopo la posizione in cui è stata richiamata la funzione o il blocco funzionale.



Esempio L'esempio seguente chiarisce l'uso dell'istruzione RETURN:

Tabella 3- 43 Esempio di istruzione RETURN

Index := 1;

FOR Index := 1 to 51 BY 2 DO

IF %I0.0 THEN

RETURN;

END_IF;

END_FOR;

(*

La seguente assegnazione di valori viene eseguita dopo la conclusione

regolare del loop FOR, tuttavia non dopo l'esecuzione di RETURN.

*)

Index_find:= Index_2;

3.7.8 Istruzione WAITFORCONDITION L'istruzione WAITFORCONDITION consente di attendere un evento programmabile o una condizione in un MotionTask. Il comando imposta l'esecuzione del MotionTask dal quale è stato richiamato finché la condizione non diventa vera. Questa condizione viene programmata in un'espressione (Pagina 197). Per ulteriori informazioni su WAITFORCONDITION e espressioni in combinazione consultare il Manuale di guida alle funzioni Funzioni di base SIMOTION Motion Control.



Figura 3-31 Sintassi: Istruzione WAITFORCONDITION

La definizionedell'espressione è un costrutto conforme con EXPRESSION; il suo valore stabilisce (event. in combinazione con Valutazione del fronte WITH), se la condizione è soddisfatta o meno.

La parte WITH valutazione del fronte è opzionale. Valutazione del fronte è un'espressione di tipo BOOL e stabilisce come viene valutato il valore della definizione dell'espressione:

● Valutazione del fronte = TRUE: Il fronte di salita della definizione dell'espressione viene valutato; vale a dire che la condizione è soddisfatta se il valore della definizione dell'espressione cambia da FALSE a TRUE.

● Valutazione del fronte = FALSE: Il valore statico della definizione dell'espressione viene valutato; vale a dire che la condizione è soddisfatta se il valore della definizione dell'espressione è TRUE.

Se non viene specificato WITH valutazione del fronte, viene valutata la preimpostazione FALSE, ossia il valore statico della definizione dell'espressione.

La sezione di istruzione deve contenere almeno un'istruzione (sono ammesse anche istruzioni vuote).



Esempio L'esempio seguente chiarisce l'uso dell'istruzione WAITFORCONDITION:

Tabella 3- 44 Esempio di istruzione WAITFORCONDITION

// ...

// Richiamo del comando con il nome dell'espressione

WAITFORCONDITION myExpression WITH TRUE DO

// qui almeno un'istruzione viene eseguita con priorità elevata, ad es.

%Q0.0 := TRUE;

END_WAITFORCONDITION;

// ...

Per un esempio completo vedere la descrizione relativa a Espressione (Pagina 197).

3.7.9 Istruzione GOTO L'istruzione GOTO produce un salto all'etichetta di salto indicata nel comando (vedere Istruzione ed etichette di salto (Pagina 313)).

Le istruzioni di salto vengono programmate con il comando GOTO tramite l'indicazione delle etichette di salto a cui si desidera passare. I salti sono ammessi solo all'interno di un'unità di organizzazione programma (POE).

Figura 3-32 Sintassi: Istruzione GOTO

Principi fondamentali di ST 3.8 Conversioni dei tipi di dati


Nota

L'istruzione GOTO deve essere utilizzata solo in casi particolari (ad es. elaborazione degli errori). In base alle regole della programmazione strutturata, tale istruzione non dovrebbe comunque essere utilizzata.

I salti sono ammessi solo all'interno di un'unità di organizzazione programma (POE).

I seguenti salti non sono consentiti: • Salti nelle strutture di controllo di livello inferiore (WHILE, FOR, ecc.) • Salti da una struttura WAITFORCONDITION • Salti all'interno di istruzioni CASE

Le etichette di salto possono essere dichiarate solo nell'unità di organizzazione programma (POE) in cui vengono utilizzate. In caso di dichiarazione possono essere utilizzate solo le etichette dichiarate.

3.8 Conversioni dei tipi di dati Nel presente capitolo si apprende come eseguire implicitamente ed esplicitamente la conversione fra tipi di dati elementari. È inoltre contenuta una panoramica su ulteriori possibilità di conversione.

3.8.1 Conversione dei tipi di dati elementari La tabella offre una panoramica delle possibilità di conversione fra tipi di dati numerici e a bit. Viene fatta distinzione tra:

● Conversione implicita: la conversione viene eseguita automaticamente dal compilatore utilizzando tipi di dati diversi in un'espressione o in un'assegnazione di valori.

● Conversione esplicita: La conversione viene eseguita dall'utente richiamando una funzione di conversione (vedere Manuale di guida alle funzioni Funzioni di base SIMOTION).



Tabella 3- 45 Conversione di tipi di dati numerici e tipi di dati a bit

Tipi di dati di destinazione Tipo di dati di origine BOOL BYTE WORD DWOR

D USINT UINT UDINT SINT INT DINT REAL LREAL STRIN

G

BOOL – Im/Ex Im/Ex Im/Ex Val Val Val Val Val Val Val Val – BYTE Ex – Im/Ex Im/Ex Ex Ex Ex Ex Ex Ex Val Val Elem WORD Ex Ex – Im/Ex Ex Ex Ex Ex Ex Ex Val Val – DWORD Ex Ex Ex – Ex Ex Ex Ex Ex Ex Ex/Val Val – USINT Val Ex Ex Ex – Im/Ex Im/Ex Ex Im/Ex Im/Ex Im/Ex Im/Ex – UINT Val Ex Ex Ex Ex – Im/Ex Ex Ex Im/Ex Im/Ex Im/Ex – UDINT Val Ex Ex Ex Ex Ex – Ex Ex Ex Ex Ex Ex SINT Val Ex Ex Ex Ex Ex Ex – Im/Ex Im/Ex Im/Ex Im/Ex – INT Val Ex Ex Ex Ex Ex Ex Ex – Im/Ex Im/Ex Im/Ex – DINT Val Ex Ex Ex Ex Ex Ex Ex Ex – Ex Im/Ex Ex REAL Val Val Val Ex/Val Ex Ex Ex Ex Ex Ex – Im/Ex Ex LREAL Val Val Val Val Ex Ex Ex Ex Ex Ex Ex – Ex STRING – Elem – – – – Ex – – Ex Ex Ex – Im: è possibile la conversione implicita dei dati Ex: Conversione esplicita del tipo di dati tramite funzione di conversione del tipo Tipo di dati origine_TO_Tipo di dati destinazione possibileVal: Conversione esplicita del tipo di dati tramite funzione di conversione del tipo Tipo di dati origine_VALUE_TO_Tipo di dati destinazione possibile Elem: Conversione implicita del tipo di dati con elemento del tipo di dati STRING

Per le funzioni di conversione per tipi di dati relativi a data o ora: Vedere Manuale di guida alle funzioni Funzioni di base SIMOTION.

3.8.1.1 Conversioni implicite dei tipi di dati Una conversione implicita è sempre possibile se tramite un aumento del campo di valori non viene determinata una perdita di valore, ad es. da REAL a LREAL o da INT a REAL. Il risultato è sempre definito.

La figura seguente mostra graficamente tutte le catene di conversione implicite del tipo. Un livello in una catena di conversione del tipo, letto da sinistra a destra o dall'alto al basso, rappresenta sempre un incremento del campo di valori.



Figura 3-33 Sequenze di conversione del tipo implicite (uno o più livelli da sinistra a destra oppure un

livello dall'alto verso il basso)

Sono possibili le seguenti conversioni implicite del tipo:

1. orizzontale (da sinistra a destra) su uno o più livelli (ad es. da USINT a UDINT)

2. verticale (dall'alto verso il basso) su un livello (ad es. da UINT a REAL)

Le conversioni implicite del tipo possono essere combinate nella successione indicata. (ad es. da INT a LREAL).

Tutte le altre conversioni del tipo non possono essere eseguite in modo implicito (ad es. da UDINT a REAL), ciò significa che è necessario utilizzare una funzione esplicita (vedere Manuale di guida alle funzioni Funzioni di base SIMOTION).

Nota

Nelle espressioni, il risultato viene sempre calcolato con il formato numerico maggiore dell'espressione.

L'assegnazione di un valore dell'espressione a una variabile è possibile solo se: • l'espressione calcolata e la variabile da assegnare presentano lo stesso tipo di dati • il tipo di dati dell'espressione calcolata può essere convertito in modo implicito nel tipo di

dati delle variabili da assegnare.

Per questa causa di errore e la relativa soluzione: Vedere Manuale di guida alle funzioni Funzioni di base SIMOTION.



Tabella 3- 46 Esempio di tipi di dati nelle espressioni e assegnazioni del valore

VAR

usint_var : USINT;

real_var : REAL;

byte_var : BYTE;

string_var : STRING[80] := 'example for string';

END_VAR

usint_var := 234 / 10; // Tipo di dati dell'espressione: USINT

// Risultato = 23

real_var := 234 / 10; // Tipo di dati dell'espressione: USINT

// Conversione implicita possibile

// Risultato = 23.0

usint_var := 234 / SINT#10; // Tipo di dati dell'espressione: INT

// Conversione implicita e

// assegnazione del valore impossibile

real_var := 234 / 10.0; // Tipo di dati dell'espressione: REAL

// Risultato = 23,4

usint_var := 234 / 10.0; // Tipo di dati dell'espressione: REAL

// Conversione implicita e

// assegnazione del valore impossibile

byte_var := string_var[5]; // Conversione implicita possibile

// Risultato = 16#70 ('p')

string_var[10] := byte_var; // Conversione implicita possibile

// Risultato = 'example fpr string'

Nota

Eventualmente, per i numeri indicare il tipo di dati in modo esplicito (ad es. UINT#127, se il tipo di dati del numero 127 deve essere UINT anzichè USINT).



3.8.1.2 Conversioni esplicite del tipo di dati Una conversione esplicita è sempre necessaria se vi è il rischio di perdita di informazioni, ad es. a causa della riduzione del campo di valori o della precisione, come nel caso della conversione da LREAL a REAL.

Le funzioni di conversione per i tipi di dati numerici e i tipi di dati a bit sono elencate nel Manuale di guida alle funzioni Funzioni di base SIMOTION.

Il compilatore segnala le conversioni che implicano una perdita.

ATTENZIONE Il risultato della conversione del tipo può provocare errori durante il runtime del programma; viene quindi attivata la risposta all'errore impostata nella configurazione del task (vedere Manuale di guida alle funzioni Funzioni di base SIMOTION).

Prestare particolare attenzione nella conversione da DWORD a REAL. La stringa di bit di DWORD viene trasferita come valore REAL non verificato. Tenere presente che la stringa di bit in DWORD corrisponde al modello di bit di un numero a virgola mobile normalizzato secondo IEEE. A questo scopo possono essere utilizzate le funzioni _finite e _isNaN.

In caso contrario viene emesso un errore (vedere sopra) non appena il valore REAL viene utilizzato per la prima volta in un calcolo (ad es. nel programma o durante l'osservazione nel browser dei simboli).

Nota

Se durante la conversione da LREAL a REAL vengono superati i limiti del campo di valori, vale quanto segue: • Underflow (il valore assoluto del numero LREAL è inferiore al numero REAL positivo più

piccolo) Il risultato è 0.0.

• Overflow (il valore assoluto del numero LREAL è maggiore del numero REAL positivo più grande): Viene attivata la risposta all'errore impostata durante la configurazione del task.



3.8.2 Conversioni integrative Tramite le funzioni di sistema ST e i blocchi funzionali di sistema ST sono possibili inoltre le seguenti conversioni:

● Raggruppamento di tipi di dati stringa di bit

Queste funzioni riuniscono diverse variabili di un tipo di dati Stringa di bit in un'unica variabile di un tipo di dati sovraordinato.

● Scomposizione di tipi di dati Stringa di bit

Questi blocchi funzione scompongono una variabile di un tipo di dati Stringa di bit in più variabili di un tipo di dati subordinato.

● Conversione tra qualsiasi tipo di dati e campi di byte

Vengono spesso utilizzate per creare formati di trasmissione definiti per lo scambio di dati tra più apparecchiature.

Per ulteriori informazioni (ad es. disposizione dei campi di byte, esempi pratici): Vedere Manuale di guida alle funzioni Funzioni di base SIMOTION.

● Conversione dei tipi di dati degli oggetti tecnologici

Trasforma le variabili di un tipo di dati TO gerarchico (driveAxis, posAxis, followingAxis) o del tipo generale ANYOBJECT in un tipo di dati TO compatibili.

Per esempi pratici e ulteriori informazioni: Vedere Manuale di guida alle funzioni Funzioni di base SIMOTION.


Funzioni, blocchi funzionali e programmi 4

Questo capitolo descrive come creare e richiamare le funzioni e i blocchi funzionali autodefiniti. Il sistema è provvisto di funzioni standard che forniscono soluzioni per la conversione del tipo, la trigonometria e le stringhe di bit. Per le modalità di utilizzo delle funzioni di sistema e delle funzioni degli oggetti tecnologici (funzioni TO), consultare il Manuale di guida alle funzioni Funzioni di base SIMOTION.

Una funzione (FC) è un blocco di codice senza dati statici. Tutte le variabili locali perdono il proprio valore quando si esce dalla funzione; al richiamo successivo vengono nuovamente inizializzate.

Un blocco funzionale (FB) è un blocco di codici con dati statici. Ogni blocco funzionale dispone di una memoria; è pertanto possibile accedere in qualsiasi momento ai relativi parametri di uscita da qualsiasi posizione del programma utente. Le variabili locali conservano il proprio valore anche dopo diversi richiami.

I programmi sono simili ai blocchi funzionali, ma non sono parametrizzabili. Possono essere tuttavia assegnati a livelli esecutivi o task (vedere Manuale di guida alle funzioni Funzioni di base SIMOTION). Le funzioni e i blocchi funzionali possono essere utilizzati più volte in quanto sono segmenti di file sorgente incapsulati e parametrizzabili:

Le funzioni, i blocchi funzionali e i programmi appartengono alle unità di organizzazione di programma (POE), vale a dire a segmenti eseguibili del file sorgente. Per una panoramica di tutti i segmenti del file sorgente, vedere Uso delle sezioni del file sorgente (Pagina 201).

Funzioni, blocchi funzionali e programmi 4.1 Creazione e richiamo di funzioni e blocchi funzionali


4.1 Creazione e richiamo di funzioni e blocchi funzionali Di seguito viene descritta la procedura di base per la creazione e il richiamo delle funzioni (FC) e dei blocchi funzionali (FB). Per un esempio completo che illustri la differenza tra le funzioni e i blocchi funzionali, vedere Confronto tra funzioni e blocchi funzionali (Pagina 192).

Per informazioni sulla sequenza da utilizzare nella definizione e nel richiamo delle del file sorgente, vedere Uso delle sezioni del file sorgente (Pagina 201).

Per informazioni sulla procedura di esportazione e di importazione di FC e FB, vedere Importazione ed esportazione tra sorgenti ST (Pagina 214).

4.1.1 Definizione delle funzioni Una funzione viene definita nella parte di dichiarazione della sezione di implementazione che precede la sezione del file sorgente (programma, blocco funzionale o funzione) in cui viene richiamata.

Per eseguire questa operazione, utilizzare la sintassi seguente:

Figura 4-1 Sintassi: Funzione (FC)

Dopo la parola chiave FUNCTION, indicare un identificatore come nome della funzione e il tipo di dati del valore di ritorno. Se la funzione non presenta alcun valore di ritorno, immettere VOID come tipo di dati.

A seguire vanno indicati (vedere l'esempio nel File sorgente con commenti (Pagina 193)):

● la sezione di dichiarazione opzionale

● la sezione di istruzione

● la parola chiave END_FUNCTION



4.1.2 Definizione di blocchi funzionali Un blocco funzionale viene definito nella parte di dichiarazione della sezione di implementazione che precede la sezione del file sorgente (programma, blocco funzionale o funzione) in cui viene richiamato.

Per eseguire questa operazione, utilizzare la sintassi seguente:

Figura 4-2 Sintassi: Blocco funzionale (FB)

Dopo la parola chiave FUNCTION_BLOCK, indicare un identificatore come nome del blocco funzionale.

A seguire vanno indicati (vedere l'esempio nel File sorgente con commenti (Pagina 193)):

● la sezione di dichiarazione opzionale

● la sezione di istruzione

● la parola chiave END_FUNCTION_BLOCK

4.1.3 Sezione di dichiarazione di FB e FC La sezione di dichiarazione è suddivisa in diversi blocchi di dichiarazione contraddistinti da una coppia specifica di parole chiave. Ciascun blocco contiene una lista di dichiarazione per i dati dello stesso tipo, ad es. le costanti, le variabili locali e i parametri. Ogni tipo di blocco può presentarsi una sola volta, mentre la sequenza dei blocchi è a scelta.

Per la sezione di dichiarazione di una FC e di un FB esistono quindi le seguenti possibilità (vedere anche l'esempio nel File sorgente con commenti (Pagina 193)):



Blocchi di dichiarazione consentiti

Tabella 4- 1 Blocchi di dichiarazione per funzione e blocco funzionale: opzioni

Dati Sintassi FB FC Costante VAR CONSTANT

Elenco delle dichiarazioni END_VAR

X X

Parametro di ingresso VAR_INPUT Elenco delle dichiarazioni END_VAR

X X

Parametro di passaggio VAR_IN_OUT Elenco delle dichiarazioni END_VAR

X X

Parametro di uscita VAR_OUTPUT Elenco delle dichiarazioni END_VAR

X –

Variabile locale (per FC e FB)

VAR Elenco delle dichiarazioni END_VAR

X (statiche)

X (temporanee)

Variabile locale (per FB)

VAR_TEMP Elenco delle dichiarazioni END_VAR

X (temporanee)

-

Elenco delle dichiarazioni: elenco degli identificatori dei tipi da dichiarare.

Blocchi di parametri I parametri appartengono ai dati locali e sono parametri formali di un blocco funzionale o di una funzione. Quando si richiama il blocco funzionale o la funzione, i parametri correnti sostituiscono quelli formali generando un meccanismo per lo scambio di informazioni tra le sezioni di file sorgente richiamate e quelle da richiamare.

● I parametri di ingresso formali assumono i valori di ingresso correnti (flusso di dati dall'esterno all'interno).

● I parametri di uscita formali (solo per FB) servono per il trasferimento dei valori di uscita (flusso di dati dall'interno all'esterno).

● I parametri di passaggio formali dispongono della funzione di un parametro di ingresso e di un parametro di uscita.

Le figure seguenti mostrano la sintassi per la dichiarazione di parametri di un FB o di una FC.



Figura 4-3 Sintassi: Blocco parametri FB

Figura 4-4 Sintassi: Blocco parametri FC



Nel blocco di parametri per i parametri di passaggio, oltre alle variabili è possibile dichiarare:

● istanze dei blocchi funzionali (Pagina 188),

● campi (ARRAY) con lunghezza dinamica (Pagina 182), a partire dalla versione V4.2 del kernel SIMOTION.

All'interno di un FB o di una FC è possibile utilizzare parametri dichiarati come le altre variabili, con la seguente eccezione: non si possono assegnare valori ai parametri di ingresso.

Dall'esterno di un FB o di una FC si può accedere:

● Ai parametri di ingresso e di uscita di un FB mediante variabili strutturate (Pagina 122). L'accesso ai parametri di ingresso è possibile solo se l'opzione compilatore (Pagina 58) "Consenti estensioni lingua" è attivata.

L'accesso ai parametri di uscita è generalmente possibile.

● Al valore di ritorno di una FC utilizzando la funzione in un'espressione e assegnando questa ad es. a una variabile. L'indicazione del nome della funzione richiama la funzione e fornisce contemporaneamente il risultato.

4.1.4 Sezione istruzioni di FB e FC La sezione istruzioni della funzione o del blocco funzionale contiene istruzioni eseguite tramite richiamo. Per la creazione di una sezione istruzioni non esiste alcuna differenza a livello di regole formali, per quanto riguarda il contenuto è tuttavia necessario fare riferimento alle avvertenze contenute nella tabella seguente.

Nota

Per suggerimenti sull'impiego efficiente dei parametri vedere Programmazione con ottimizzazione del runtime nel Manuale di guida alle funzioni Funzioni di base SIMOTION.



Tabella 4- 2 Uso dei parametri e delle variabili nella funzione e nel blocco funzionale

Parametri/variabili Utilizzo Parametro di ingresso Al richiamo di una FC o di un FB si assegnano ai parametri di ingresso

valori attuali. Questi valori vengono utilizzati all'interno della funzione o del blocco funzionale per l'elaborazione di dati, ad esempio per i calcoli, tuttavia non possono essere essi stessi modificati. Solo con l'opzione compilatore "Consenti estensioni lingua" attivata (vedere Impostazioni globali del compilatore (Pagina 59) oppure Impostazioni locali del compilatore (Pagina 61)): Ai parametri di ingresso di un FB è possibile accedere in lettura e in scrittura tramite variabili strutturate anche all'esterno del blocco funzionale (ad es. nella sezione file sorgente da richiamare).

Parametri di passaggio Al richiamo di una funzione o di un blocco funzionale si assegna una variabile a un parametro di passaggio. La funzione o il blocco funzionale accede direttamente a questa variabile e può modificarla. Le conversioni del tipo non sono invece ammesse. La variabile assegnata a un parametro di passaggio deve essere subito leggibile e scrivibile. Variabili di sistema (dell'apparecchio SIMOTION o di un oggetto tecnologico), le variabili I/O oppure gli accessi alle immagini di processo non possono quindi essere assegnati a un parametro di passaggio.

Parametri di uscita (solo per FB)

Al richiamo di un FB si assegna una variabile a un parametro di uscita con l'operatore =>. Il valore del parametro di uscita (risultato) viene trasmesso alla fine del blocco funzionale delle variabili. Ai parametri di uscita di un blocco funzionale è possibile inoltre accedere in lettura tramite variabili strutturate anche all'esterno del blocco funzionale (ad es. nella sezione file sorgente da richiamare). Una funzione non contiene formalmente alcun parametro di uscita, dato che al nome viene assegnato il valore di ritorno. Il nome stesso della funzione rappresenta in un certo modo il parametro di uscita.

Variabili locali Le variabili locali sono variabili dichiarate e utilizzate solo all'interno del blocco. Nella funzione tutte le variabili locali (VAR ... END_VAR) sono temporanee, ossia perdono il loro valore al termine della funzione. Al richiamo successivo della funzione vengono nuovamente inizializzate. Nel blocco funzionale si distingue fra variabili locali statiche e temporanee: • Le variabili statiche (VAR ... END_VAR) alla fine del blocco funzionale

conservano il proprio valore. • Le variabili temporanee (VAR_TEMP ... END_VAR) perdono alla fine

del blocco funzionale il proprio valore. Al richiamo successivo del blocco funzionale vengono nuovamente inizializzate.

Il valore delle variabili locali non può essere richiesto direttamente dal blocco da richiamare. Questa richiesta è possibile solo tramite un parametro di uscita.



4.1.5 ARRAY con lunghezza dinamica (a partire dal kernel V4.2)

Dichiarazione come parametro di passaggio A partire dalla versione 4.2 del kernel SIMOTION si possono dichiarare campi con lunghezza dinamica in funzioni e blocchi funzionali. Ciò è possibile esclusivamente nel rispettivo blocco di parametri per parametri di passaggio (Pagina 177) (VAR_IN_OUT / END_VAR).

Figura 4-5 Sintassi: Dichiarazione di un ARRAY con lunghezza dinamica

Utilizzo di un ARRAY con lunghezza dinamica Al richiamo della funzione o di un'istanza del blocco funzionale si possono trasferire campi di una lunghezza qualsiasi del tipo di dati dichiarato. Sullo stack dati locali (Pagina 237) oltre al riferimento al campo trasferito vengono salvati anche i relativi limite dell'indice.

All'interno della funzione o del blocco funzionale, con le funzioni _firstIndexOf (in := array-name) o _lastIndexOf (in := array-name) è possibile definire il limite dell'indice inferiore o superiore. La funzione _lengthIndexOf (in := array-name) definisce il numero di elementi dell'ARRAY. Vale quanto segue: _lengthIndexOf (x) := _lastIndexOf (x) - _firstIndexOf (x) + 1.

La capacità dello spazio di memoria occupata dall'ARRAY può essere definita con _sizeOf (in := array-name). Vale quanto segue: _sizeOf (in := array_of_type) := _lengthIndexOf (in := array_of_type) * _sizeOf (in := type).

La sintassi delle funzioni è descritta nel manuale di guida alle funzioni Funzioni di base SIMOTION.

Nota

Per un ARRAY con lunghezza dinamica vengono eseguite le funzioni di cui sopra al runtime.



Esempio

Tabella 4- 3 Esempio di utilizzo di un ARRAY con lunghezza dinamica

FUNCTION_BLOCK example_dyn_array

VAR_IN_OUT

flexarray : ARRAY [..] OF DINT;

END_VAR

VAR_TEMP

i : DINT := 0;

END_VAR

i := _firstIndexOf (in := flexarray);

WHILE i <= _lastIndexOf (in := flexArray) DO

flexArray[i] := i;

i := i + 1;

END_WHILE;

END_FUNCTION_BLOCK

PROGRAM test_dyn_array

VAR

array_1 : ARRAY [0 .. 29] OF DINT;

fb_example : example_dyn_array;

END_VAR

// ...

fb_example (flexarray := array_1);

// ...

END_PROGRAM



4.1.6 Richiamo di funzioni e di blocchi funzionali Di seguito si può avere una panoramica sul richiamo delle funzioni e dei blocchi funzionali.

4.1.6.1 Principio di trasferimento dei parametri Al richiamo della funzione e del blocco funzionale si verifica uno scambio di dati tra il blocco da richiamare e quello richiamato. I parametri da trasferire devono essere indicati nel richiamo come elenco dei parametri. I parametri vengono scritti fra parentesi e molti sono separati da virgole.

Figura 4-6 Principio del trasferimento dei parametri al richiamo

I parametri di ingresso e di passaggio vengono indicati solitamente sotto forma di assegnazione del valore. Questa assegnazione permette quindi di attribuire un valore (parametro attuale) ai parametri definiti nella sezione di dichiarazione del blocco richiamato (parametro formale).

L'assegnazione dei parametri di uscita avviene con l'operatore =>. Questa assegnazione permette quindi di attribuire una variabile (parametro corrente) ai parametri di uscita definiti nella sezione di dichiarazione del blocco richiamato (parametro formale).

4.1.6.2 Trasferimento di parametri di ingresso

Figura 4-7 Sintassi: Assegnazione di ingresso

Il trasferimento di dati (parametri attuali) ai parametri di ingresso formali di un blocco funzionale o di una funzione avviene mediante assegnazioni di ingresso. I parametri attuali possono essere indicati sotto forma di espressioni. I parametri di ingresso formali nelle istruzioni della funzione o del blocco funzionale possono essere utilizzati, ma non modificati.



È disponibile anche una procedura abbreviata di trasferimento dei parametri, che non può essere utilizzata per i blocchi funzionali autodefiniti. Questa forma abbreviata è necessaria soltanto per alcune funzioni, vedere Manuale di guida alle funzioni Funzioni di base SIMOTION.

In un blocco funzionale l'assegnazione dei parametri attuali è opzionale. Se non è indicata alcuna assegnazione di ingresso vengono conservati i valori dell'ultimo richiamo, dato che il blocco funzionale è una sezione di file sorgente dotata di memoria.

Con una funzione l'assegnazione del parametro attuale è opzionale, posto che la dichiarazione del parametro formale sia stata indicata con un'espressione di inizializzazione.

Vedere anche gli esempi in Richiamo delle funzioni (Pagina 187) o Richiamo di blocchi funzionali (richiamo di istanze) (Pagina 188).

È sempre possibile, anche all'esterno di un blocco funzionale, accedere in lettura e in scrittura al relativo parametro di ingresso. Vedi anche: Accesso al corrispondente parametro di ingresso all'esterno del blocco funzionale (Pagina 190).

4.1.6.3 Trasferimento dei parametri di passaggio

Figura 4-8 Sintassi: Assegnazione di passaggio

Il trasferimento di dati (parametri attuali) ai parametri di passaggio formali di una funzione o di un blocco funzionale avviene mediante assegnazioni di passaggio. È possibile assegnare solo una variabile dello stesso tipo al parametro di passaggio formale, le conversioni dei tipi di dati non sono possibili.

I parametri di passaggio formali possono essere utilizzati e modificati nelle istruzioni all'interno di una funzione o di un blocco funzionale. La funzione o il blocco funzionale accede direttamente alla variabile del parametro attuale e può modificarla immediatamente.

Vedere anche gli esempi in Richiamo delle funzioni (Pagina 187) o Richiamo di blocchi funzionali (richiamo di istanze) (Pagina 188).

Se si utilizza il tipo di dati STRING nelle istruzioni di passaggio, la lunghezza dichiarata del parametro attuale deve essere superiore o uguale alla lunghezza del parametro di passaggio formale (vedere l'esempio seguente).



Tabella 4- 4 Esempio di uso del tipo di dati STRING nelle istruzioni di passaggio

FUNCTION_BLOCK REF_STRING

VAR_IN_OUT

io : STRING[80]

END_VAR

; // Istruzioni

END_FUNCTION_BLOCK

FUNCTION_BLOCK test

VAR

my_fb : REF_STRING;

str1 : STRING[100]

str2 : STRING[50]

END_VAR

my_fb(io := str1); // Richiamo consentito

my_fb(io := str2); // Richiamo non consentito,

// Messaggio di errore del compilatore

END_FUNCTION_BLOCK

La variabile assegnata a un parametro di passaggio deve essere subito leggibile e scrivibile. Variabili di sistema (dell'apparecchio SIMOTION o di un oggetto tecnologico), le variabili di I/O oppure gli accessi alle immagini di processo non possono quindi essere assegnati a un parametro di passaggio.

Rispettare i diversi tempi di accesso ai parametri.

4.1.6.4 Trasferimento di parametri di uscita (solo per FB)

Figura 4-9 Sintassi: Assegnazione di uscita

I parametri di uscita formali di un blocco funzionale si assegnano attraverso un'assegnazione di uscita alle variabili (parametri di uscita), che alla fine del blocco funzionale assumono il valore del parametro di uscita formale.

I parametri di uscita formali possono essere utilizzati e modificati nelle istruzioni all'interno di un blocco funzionale.

Vedere anche gli esempi in Richiamo di blocchi funzionali (richiamo di istanze) (Pagina 188).



Con il trasferimento dei parametri le assegnazioni di uscita sono opzionali. È sempre possibile, anche all'esterno di un blocco funzionale, accedere in lettura al relativo parametro di uscita. Vedi anche: Accesso al corrispondente parametro di uscita all'esterno del blocco funzionale (Pagina 190)).

4.1.6.5 Tempi di accesso ai parametri I tipi di accesso e i relativi tempi di accesso ai parametri sono diversi:

● Per le istruzioni di ingresso i valori dei parametri correnti vengono copiati nei parametri formali. Quando si copiano strutture di dimensioni maggiori (ad es. array) e si richiamano frequentemente le funzioni o i blocchi funzionali, è possibile che le prestazioni vengano ridotte.

● Le assegnazioni di passaggio non copiano alcun valore, ma collegano soltanto gli indirizzi della memoria dei parametri formali con quelli dei parametri correnti. Il trasferimento delle variabili è più veloce di quanto avviene nelle assegnazioni degli ingressi (soprattutto in caso di quantità maggiori di dati). L'accesso alla variabile dal blocco funzionale può tuttavia essere più lento.

● Quando vengono utilizzate delle variabili Unit, nella funzione o nel blocco funzionale non vengono eseguiti processi di copiatura, dal momento che queste variabili sono valide nell'intera sorgente ST (vedere Modello di variabile (Pagina 220)).

Nota

L'utilizzo di parametri di passaggio invece dei parametri di ingresso è vantaggioso dal punto di vista della velocità solo se è necessario trasferire al blocco funzionale una grande mole di dati.

L'utilizzo prevalente delle variabili Unit invece dei parametri rende la struttura del programma poco chiara: Non sono più possibili l'orientamento dell'oggetto, la compressione dei dati, l'utilizzo ripetuto dei nomi delle variabili (compressione delle aree di validità) ecc.

4.1.6.6 Richiamo delle funzioni Una funzione viene richiamata come di seguito illustrato:

● Funzione con valore di ritorno (tipo di dati diverso da VOID):

La funzione si trova a destra di un'assegnazione del valore e può comparire anche come operando all'interno di un'espressione. Dopo il richiamo della funzione, il rispettivo valore di ritorno viene utilizzato nella posizione corrispondente per il calcolo dell'espressione.

Esempi:

y:=sin(x); y := sin(in := x); y := sqrt (1 - cos(x) * cos(x));



● Funzione senza valore di ritorno (tipo di dati VOID)

L'istruzione è costituita solo dal richiamo della funzione.

Il seguente esempio è valido con il presupposto che una funzione funct1 con il parametro di ingresso in1 e in2 e con il parametro di passaggio inout sia già stata definita.

Esempio:

funct1 (in1 := var11, in2 := var12, inout1 := var13);

Nota

Il risultato (valore di ritorno) della funzione viene assegnato al nome della funzione (ad eccezione del tipo di dati VOID).

4.1.6.7 Richiamo dei blocchi funzionali (dichiarazione e richiamo delle istanze)

Dichiarazione di un'istanza del blocco funzionale Prima di richiamare un blocco funzionale (FB) è necessario dichiarare un'istanza: dichiarare una variabile e immettere come tipo di dati il nome del blocco funzionale. La dichiarazione di istanza deve essere eseguita come segue:

● localmente (all'interno di VAR / END_VAR nella sezione di dichiarazione di un programma o di un blocco funzionale),

● globalmente (all'interno di VAR_GLOBAL/END_VAR nella sezione interfaccia o implementazione),

● come parametro di passaggio (all'interno di VAR_IN_OUT/ END_VAR nella sezione di dichiarazione di un blocco funzionale o di una funzione).

Figura 4-10 Sintassi: Dichiarazione di istanza



La dichiarazione di istanza è possibile anche come campo, ad es.:

FB_inst : ARRAY [1..2] OF FB_name.

Nota

Prestare attenzione ai diversi tempi di inizializzazione dei tipi di variabile differenti.

Richiamo di un'istanza del blocco funzionale Richiamare l'istanza del blocco funzionale nella sezione istruzioni di una POE (per la sintassi vedere la figura). I parametri FB sono le assegnazioni di ingresso e di passaggio separate da una virgola.

Figura 4-11 Sintassi del richiamo di un blocco funzionale

L'esempio della tabella seguente è valido a condizione che i blocchi funzionali Supply e Motor siano già stati definiti:

● FB Supply: Parametro di ingresso in1, in2; parametro di passaggio inout; parametro di uscita out

● Motore FB: Parametro di passaggio inout1, inout2; parametro di uscita out1, out2



Tabella 4- 5 Esempio di dichiarazione di istanza, richiamo del blocco funzionale e accesso ai parametri di uscita

VAR

Supply1, Supply2: Supply;

Motor1 : Motor;

END_VAR

// Trasferimento dei parametri (assegnazione di uscita) al richiamo dell'istanza di un

blocco funzionale

Supply1 (in1 := var11, in2 := expr12, inout := var13, out => var14) ;

Supply2 (in1 := var21, in2 := expr22, inout := var23, out => var24) ;

Motor1 (inout1 := var31, inout2 := var32, out1 => var33, out2 => var34);

// ...

// Accesso al corrispondente parametro di uscita all'esterno del blocco funzionale

var15 := Supply1.out;

var25 := Supply2.out;

var35 := Motor1.out1;

var36 := Motor1.out2;

var41 := Motor1.out1 * Motor1.out2 * (Supply1.out + Supply2.out);

4.1.6.8 Accesso al corrispondente parametro di uscita all'esterno del blocco funzionale Oltre all'assegnazione di uscita (Pagina 186), al richiamo di un blocco funzionale è sempre possibile accedere in lettura al relativo parametro di uscita.

Utilizzare a questo scopo variabili strutturate (Pagina 122) nel formato NomeIstanzaFB.ParametroDiUscita, ad es. Supply1.out. Vedere anche gli esempi in Richiamo di blocchi funzionali (richiamo di istanze) (Pagina 188).

Il nome dell'istanza del blocco funzionale non può essere utilizzato in un'assegnazione del valore.

4.1.6.9 Accesso al corrispondente parametro di ingresso all'esterno del blocco funzionale Oltre all'assegnazione di ingresso (Pagina 184), al richiamo di un blocco funzionale è possibile accedere in lettura e in scrittura al relativo parametro di ingresso.

Utilizzare a questo scopo Variabili strutturate (Pagina 122) nel formato NomeIstanza-FB.ParametroDiIngresso, ad es. Supply1.in1.

ATTENZIONE Per poter utilizzare questa opzione deve essere attivata l'opzione compilatore "Consenti estensioni lingua" (vedere Impostazioni globali del compilatore (Pagina 59) e Impostazioni locali del compilatore (Pagina 61)).

Il nome dell'istanza del blocco funzionale non può essere utilizzato in un'assegnazione del valore.



Tabella 4- 6 Esempio per l'assegnazione al parametro di ingresso

// Solo con l'opzione compilatore "Consenti estensioni lingua" attivata

VAR

var_fb : _WORD_TO_2BYTE;

var_word : WORD;

END_VAR

var_fb.wordin := var_word;

// ..

var_fb();

4.1.6.10 Fonti di errore nel richiamo di un blocco funzionale Nel richiamare un'istanza di un blocco funzionale, prestare attenzione a quanto segue:

● Assegnare ai parametri di passaggio solo le variabili presenti direttamente in memoria.

Sono consentiti esclusivamente i seguenti parametri correnti:

– le variabili globali (variabili Unit e variabili utente globali degli apparecchi),

– Variabili locali

– le variabili del tipo di dati degli oggetti tecnologici (istanze TO).

Tra i parametri non consentiti vi sono in particolare:

– le variabili di sistema (variabili TO),

– i nomi degli oggetti tecnologici da ES,

– Variabili I/O

– gli accessi alle immagini di processo assoluti e simbolici

● Non utilizzare alcuna funzione (FC) come parametro di passaggio.

Il valore di ritorno, ossia il richiamo della funzione, non può essere utilizzato come parametro corrente in un'assegnazione di passaggio. Per questo motivo è necessario salvare il risultato della funzione in una variabile locale e utilizzare quindi questa variabile come parametro corrente nell'assegnazione di passaggio.

● Non utilizzare alcuna costante come parametro di passaggio.

Come parametro corrente di un'assegnazione di passaggio possono essere utilizzate solo le variabili poiché il valore viene riscritto.

● Non è possibile inizializzare i parametri di passaggio.

Funzioni, blocchi funzionali e programmi 4.2 Confronto tra funzioni e blocchi funzionali


4.2 Confronto tra funzioni e blocchi funzionali Le seguenti sezioni illustrano in breve le differenze tra i blocchi funzionali (FB) e le funzioni (FC) autodefinite tramite un esempio completo.

4.2.1 Descrizione dell'esempio L'esempio seguente spiega le differenze tra i blocchi funzionali e le funzioni. Per semplificare le operazioni, ogni tipo di parametro viene utilizzato solo una volta ed è possibile definire tutti i parametri desiderati. Per informazioni sui concetti utilizzati vedere le sezioni dettagliate in Definizione funzioni (Pagina 176) e Definizione blocchi funzionali (Pagina 177).

Nella sezione implementazione della parte di dichiarazione, creare un blocco funzionale o una funzione per il calcolo del perimetro e dell'area del cerchio per la grandezza di ingresso Radius (raggio):

● Per il raggio viene definito un parametro di ingresso.

● Per la circonferenza del cerchio viene definito un parametro di ingresso, vale a dire durante il richiamo del blocco funzionale o della funzione il valore della variabile trasferita viene direttamente assegnato.

● Per la superficie del cerchio sono disponibili con il blocco funzionale e con la funzione diverse possibilità:

– Con il blocco funzionale viene definito un parametro di uscita.

– Con la funzione viene utilizzato il valore di ritorno della funzione; il tipo di dati del valore di ritorno viene definito di conseguenza.

● Ogni richiamo del blocco funzionale o della funzione deve essere registrato da un contatore (variabile locale). Nelle informazioni relative all'esempio, come si vedrà, si indica che tale valore viene ricontato solo nel blocco funzionale.

● Nella sezione di programma il blocco funzionale o la funzione vengono richiamati e i parametri attuali vengono assegnati ai parametri formali indicati successivamente:

– Con il blocco funzionale: Parametri di ingresso, di passaggio e di uscita

– Con la funzione: Parametri di ingresso e di passaggio.

Dopo il richiamo del blocco funzionale o della funzione, i valori per la circonferenza e per la superficie sono disponibili:

– Con il blocco funzionale: nei parametri attuali del parametro di ingresso e di uscita.

Al parametro di uscita è possibile anche accedere in lettura all'esterno del blocco funzionale.

– Con la funzione: nel valore di ritorno della funzione come anche nel parametro attuale del parametro di passaggio.



4.2.2 File sorgente con commenti

Tabella 4- 7 Esempio delle differenze tra blocco funzionale e funzione

Blocco funzionale (FB) Funzione (FC) INTERFACE

PROGRAM CircleCalc1;

END_INTERFACE

IMPLEMENTATION

FUNCTION_BLOCK Circle1

// Dichiarazione costante

VAR CONSTANT

PI : LREAL := 3.1415 ;

END_VAR

// Parametri di ingresso

VAR_INPUT

Radius : LREAL ;

END_VAR

// Parametri di passaggio

VAR_IN_OUT

circumference : LREAL ;

END_VAR

// Parametri di uscita

VAR_OUTPUT

Area : LREAL ;

END_VAR

// Variabili locali, statiche

VAR

Counter : DINT ; (* la variabile

contiene il rispettivo valore

superati i limiti di richiamo *)

END_VAR

// Contatore di richiamo

Counter := Counter + 1 ;

Circumference := 2 * PI * Radius ;

Area := PI * Radius**2 ;

END_FUNCTION_BLOCK

PROGRAM CircleCalc1

VAR

myCircle1 : Circle1 ;

myArea1, myArea2 : LREAL ;

myCircf : LREAL ;

END_VAR ;

myCircle1(Radius := 3

, Circumference := myCircf

, Area => myArea1) ;

myArea2 := myCircle1.Area ;

// myCircf ha il valore 18.849

// myArea1 ha il valore 28.274

// myArea2 ha il valore 28.274

END_PROGRAM

END_IMPLEMENTATION

INTERFACE

PROGRAM CircleCalc2;

END_INTERFACE

IMPLEMENTATION

FUNCTION Circle2 : LREAL

// Dichiarazione costante

VAR CONSTANT

PI : LREAL := 3.1415 ;

END_VAR

// Parametri di ingresso

VAR_INPUT

Radius : LREAL ;

END_VAR

// Parametri di passaggio

VAR_IN_OUT

circumference : LREAL ;

END_VAR

// Parametri di uscita

// non possibile

// Variabili locali, temporanee

VAR

Counter : DINT ;

(* la variabile viene inizializzata

a ciascun richiamo con 0 *)

END_VAR

// Contatore di richiamo

Counter := Counter + 1 ;

Circumference := 2 * PI * Radius ;

Circle2 := PI * Radius**2 ;

END_FUNCTION

PROGRAM CircleCalc2

VAR

myArea : LREAL ;

myCircf : LREAL ;

END_VAR ;

myArea := Circle2(Radius := 3

, Circumference := myCircf);

// myCircf ha il valore 18.849

// myArea ha il valore 28.274

END_PROGRAM END_IMPLEMENTATION



Tabella 4- 8 Informazioni relative all'esempio precedente delle differenze tra blocco funzionale e funzione

Blocco funzionale (FB) Funzione (FC) Commenti

Parole riservate per la definizione: FUNCTION_BLOCK e END_FUNCTION_BLOCK

Parole riservate per la definizione: FUNCTION e END_FUNCTION

Nessun valore di ritorno consentito. Dopo il nome è necessario indicare il tipo di dati del valore di ritorno (tipo di dati VOID, in mancanza del valore di ritorno).

I parametri di ingresso consentono la trasmissione dei valori al blocco funzionale.

I parametri di ingresso consentono la trasmissione dei valori alla funzione.

I parametri di passaggio consentono di accedere in lettura e in scrittura alla variabile trasferita all'interno del blocco funzionale.

I parametri di passaggio consentono di accedere in lettura e in scrittura alla variabile trasferita all'interno della funzione.

I parametri di uscita consentono il ritorno dei valori da un blocco funzionale.

Nessun parametro di uscita consentito.

Le variabili locali sono statiche, conservano cioè il proprio valore fino al richiamo successivo del blocco funzionale. La variabile locale Counter viene incrementata; al termine del blocco funzionale il suo valore viene conservato. Pertanto, la variabile viene incrementata a ogni richiamo. Per osservare tale comportamento, procedere come segue: nel blocco funzionale, assegnare il valore della variabile locale a una variabile globale. Monitorare il valore della variabile globale dopo diversi richiami del blocco funzionale.

Le variabili locali sono temporanee, ossia perdono il proprio valore quando si esce dalla funzione. La variabile locale Counterviene incrementata; il suo valore va tuttavia perduto quando si esce dalla funzione. Al richiamo successivo della funzione, la variabile viene nuovamente inizializzata (nell'esempio a 0). Per osservare tale comportamento, procedere come segue: Nella funzione, assegnare il valore della variabile locale a una variabile globale. Il valore delle variabili globali rimane invariato dopo diversi richiami della funzione.

Nella sezione istruzioni vengono assegnati i risultati (valori di ritorno) ai parametri di uscita e di passaggio.

Nella sezione istruzioni viene assegnato il risultato (valore di ritorno) al nome della funzione (ad eccezione del tipo di dati VOID).

Nella parte di dichiarazione del blocco da richiamare viene dichiarata un'istanza del blocco funzionale: Dichiarare una variabile e indicare come tipo di dati il nome del blocco funzionale. Utilizzare il nome dell'istanza dichiarato con questa procedura per richiamare e accedere ai relativi parametri di uscita. Il nome del blocco funzionale non deve essere utilizzato nella sezione istruzioni.

• Al richiamo dell'istanza del blocco funzionale viene assegnata una variabile ai parametri di passaggio.

• I parametri di uscita possono essere assegnati al richiamo di una variabile.

• Anche all'esterno del blocco funzionale è possibile accede in lettura al relativo parametro di uscita. Utilizzare a questo scopo le variabili strutturate nel seguente formato: NomeIstanzaFB.ParametroDiUscita.

• Al richiamo dell'istanza del blocco funzionale viene assegnata una variabile ai parametri di passaggio.

• Per conservare il valore di ritorno di una funzione, procedere come segue: – Assegnare la funzione a una variabile. – Utilizzare la funzione in un'espressione nella pagina

di destra di un'assegnazione del valore.

Funzioni, blocchi funzionali e programmi 4.3 Programmi


Blocco funzionale (FB) Funzione (FC) Commenti

Il programma da richiamare non può accedere ad altre variabili quali i parametri di passaggio e di uscita del blocco funzionale. Eccezione: Con l'opzione compilatore "Consenti estensioni lingua" attivata (vedere Impostazioni globali del compilatore (Pagina 59) oppure Impostazioni locali del compilatore (Pagina 61)), il programma da richiamare può anche accedere ai parametri di ingresso di un blocco funzionale. Utilizzare a questo scopo le variabili strutturate nel seguente formato: NomeIstanzaFB.ParametroDiIngresso.

Il programma da richiamare non può accedere ad altre variabili come il valore di ritorno.

4.3 Programmi I programmi sono una sequenza di istruzioni tra le parole chiave PROGRAM e END_PROGRAM.

Figura 4-12 Sintassi: Programma

I programmi vengono dichiarati nella sezione implementazione (Pagina 204) di una sorgente ST e sono confrontabili ai blocchi funzionali. Ad esempio, anche in questo caso è possibile creare variabili locali statiche (VAR...END_VAR) o temporanee (VAR_TEMP...END_VAR). Non possiedono tuttavia alcun parametro formale e perciò non possono essere richiamati con i parametri. Esempi di programma sono riportati nelle sezioni File sorgente con commenti (Pagina 193) e Testo sorgente del programma esemplificativo (Pagina 83).

4.3.1 Assegnazione di un programma nel sistema esecutivo I programmi vengono assegnati per impostazione predefinita nel sistema esecutivo di un task. Il comportamento dei programmi durante l'esecuzione, ad es. l'inizializzazione delle variabili, è determinato dal relativo task. Per ulteriori informazioni sul sistema esecutivo e sui task vedere il manuale di guida alle funzioni Funzioni di base SIMOTION. Per questo è necessario indicare il programma nella sezione interfaccia (Pagina 202) della sorgente ST come unità di organizzazione del programma da esportare.

Funzioni, blocchi funzionali e programmi 4.3 Programmi


4.3.2 Richiamo di un programma nel programma ("program in program") Se lo si desidera è possibile richiamare facoltativamente un programma anche all'interno di un altro programma o di un blocco funzionale. Per farlo è necessario che siano attivate le seguenti opzioni del compilatore (vedere Impostazioni globali del compilatore (Pagina 59) e Impostazioni locali del compilatore (Pagina 61)):

1. "Consenti estensioni lingua" per la sorgente di programma del programma o del blocco funzionale richiamante e

2. "Crea dati di istanza del programma solo una volta" per la sorgente di programma del programma da richiamare.

Il richiamo viene eseguito come una funzione senza parametro e valore di ritorno; vedere il seguente esempio.

ATTENZIONE L'opzione compilatore "Crea dati di istanza del programma solo una volta" ha i seguenti effetti: • Le variabili statiche dei programmi (dati di istanza del programma) vengono

memorizzate in un'altra area di memoria (Pagina 232). In questo caso cambia anche il comportamento di inizializzazione (Pagina 244).

• Tutti i programmi richiamati con lo stesso nome utilizzano gli stessi dati di istanza del programma.

Tabella 4- 9 Esempio di richiamo di un programma in un programma

PROGRAM my_prog

; // ...

END_PROGRAM

PROGRAM main_prog

; // ...

my_prog();

; // ...

END_PROGRAM

Nota

Tramite il richiamo di programmi all'interno di un programma è possibile programmare completamente l'assegnazione dei programmi ai task. Nel sistema esecutivo è sufficiente assegnare ai task interessati un programma richiamante.

Funzioni, blocchi funzionali e programmi 4.4 Espressioni


4.4 Espressioni L'espressione rappresenta un caso particolare di una dichiarazione della funzione:

● Il tipo di dati del valore di ritorno è impostato come BOOL e non viene indicato in modo esplicito.

Viene utilizzato insieme all'istruzione WAITFORCONDITION (Pagina 166).

Un'espressione può essere dichiarata esclusivamente nella sezione implementazione della sorgente ST.

Figura 4-13 Sintassi: Espressione

Facoltativamente è possibile dichiarare nella sezione di dichiarazione:

● variabili locali (temporanee)

● costanti locali

● tipi di dati definiti dall'utente (UDT)

● parametri di ingresso e di passaggio (a partire dalla versione V4.1 del kernel SIMOTION)

La sezione istruzioni consente di accedere a:

● costanti e variabili locali dell'espressione

● parametri di ingresso e di passaggio (purché la relativa dichiarazione sia ammessa)

● variabili Unit

● variabili globali dell'apparecchio, variabili di I/O e immagine di processo

Nella sezione istruzioni dell'espressione è necessario assegnare un'espressione del tipo di dati BOOL alla definizione dell'espressione (vedere figura).

Nota

La sezione istruzioni non può contenere richiami di funzioni o loop.



Esempio Nell'esempio che segue si presuppone che il programma feeder venga eseguito in uno dei MotionTask. Per questo MotionTask viene selezionata l'opzione Attivazione dopo StartupTask. L'assegnazione dei programmi ai task si effettua in SIMOTION SCOUT (vedere descrizione delle funzioni Funzioni di base SIMOTION Motion Control).

Tabella 4- 10 Esempio di utilizzo di una EXPRESSION e dell'istruzione WAITFORCONDITION

INTERFACE

USEPACKAGE cam;

PROGRAM feeder; // in MotionTask_1

END_INTERFACE

IMPLEMENTATION

// Condizione per l'istruzione WAITFORCONDITION

EXPRESSION automaticExpr

automaticExpr := IOfeedCam; // Ingresso digitale

END_EXPRESSION

PROGRAM feeder

VAR

retVal : DINT ;

END_VAR ;

retVal := _enableAxis (axis := realAxis,

enableMode := ALL,

servoCommandToActualMode := INACTIVE,

nextCommand := WHEN_COMMAND_DONE,

commandId := _getCommandId() );

// Attendere che la condizione iniziale sia soddisfatta

WAITFORCONDITION automaticExpr WITH TRUE DO

// Esecuzione ad alta priorità di tutte le istruzioni

// fino al comando END_WAITFORCONDITION

retVal := _pos (axis := realAxis,

positioningMode := RELATIVE,

position := 500,

velocityType := DIRECT,

velocity := 300,

velocityProfile := TRAPEZOIDAL,

mergeMode := IMMEDIATELY,

nextCommand := WHEN_MOTION_DONE,

commandId:= _getCommandId() );


retVal := _disableAxis (axis := realAxis,

disableMode := ALL,

servoCommandToActualMode := INACTIVE,

nextCommand := WHEN_COMMAND_DONE,


END_PROGRAM

END_IMPLEMENTATION



Altri esempi sono riportati nel Manuale di guida alle funzioni Funzioni di base SIMOTION Motion Control. In particolare viene descritto come utilizzare una EXPRESSION con parametri a partire dalla versione V4.1 del kernel SIMOTION nonché, ad esempio, come programmare un controllo a tempo in un'istruzione WAITFORCONDITION.




Implementazione di ST in SIMOTION 5

Questo capitolo descrive l'interazione tra i programmi ST e SIMOTION SCOUT.

5.1 Sezioni del file sorgente Il Struttura dei file sorgente ST (Pagina 105) fornisce una panoramica sul significato delle sezioni del file sorgente. In questo capitolo vengono invece illustrati i dettagli relativi alla sintassi e all'uso delle sezioni per l'importazione e l'esportazione dei dati tra più file sorgente ST.

5.1.1 Uso delle sezioni del file sorgente Per compilare il file sorgente ST è necessario rispettare determinate strutture e regole di sintassi delle sezioni utilizzate. Di seguito vengono fornite alcune regole generali; per informazioni dettagliate sulle sezioni dei file sorgente, vedere i paragrafi successivi:

● Per la creazione dei file sorgente, rispettare sempre la sequenza dei segmenti del file sorgente. Affinché possa essere riconosciuta, una sezione richiamante deve sempre precedere la sezione che esegue il richiamo.

Le variabili, per esempio, devono essere dichiarate prima dell'uso, mentre le funzioni devono essere definite prima del richiamo.

● Il testo sorgente per le sezioni del file sorgente più frequenti (programma, funzione o blocco funzionale) è composto dalle seguenti parti:

– inizio della sezione con parola e identificatore riservati

– sezione dichiarazione (opzionale)

– Sezione istruzioni

– fine della sezione con parola riservata

● Gli identificatori per le sezioni del file sorgente, indicati di seguito con name o name_list, seguono la sintassi generale dell'identificatore (vedere Identificatori in ST (Pagina 93)).

Nota

Un modello comprendente tutte le sezioni di file sorgente possibili è contenuto nella guida in linea.

Implementazione di ST in SIMOTION 5.1 Sezioni del file sorgente


5.1.1.1 Sezione interfaccia La sezione interfaccia contiene istruzioni relative all'importazione e all'esportazione di dati (tipi di dati, variabili, blocchi funzionali, funzioni e programmi). È possibile caricare anche i pacchetti tecnologici e le librerie.

La sintassi della sezione interfaccia è la seguente:



Tabella 5- 1 sintassi della sezione interfaccia

Sintassi INTERFACE // Istruzioni Interface (opzionale) END_INTERFACE Non è stato possibile indicare un identificatore individuale della sezione. Tra le parole riservate INTERFACE e END_INTERFACE si trovano le istruzioni opzionali Interface nella seguente sequenza: 1. Indicazione del pacchetto tecnologico utilizzato. La sintassi è la seguente:

USEPACKAGE tp-name [AS namespace];

Per ulteriori informazioni vedere il Manuale di guida alle funzioni Funzioni di base SIMOTION. 2. Indicazione delle librerie utilizzate.

La sintassi è la seguente:

USELIB library-name-list [AS namespace];

Per ulteriori informazioni sull'argomento vedere "Uso di tipi di dati, funzioni e blocchi funzionali nelle librerie (Pagina 284)".

3. È possibile fare riferimento ad altre Unit per utilizzarne i componenti esportati. La sintassi è la seguente

USES unit_name-list;

Per ulteriori informazioni sull'argomento vedere "Istruzione USES in una Unit da importare (Pagina 217)".

4. Dichiarazioni e indicazioni per l'esportazione – Definizioni del tipo di dati (Pagina 211):

Tipi di dati definiti dall'utente validi nell'intera sorgente ST e da esportare (UDT) – Dichiarazioni delle variabili (Pagina 211):

Variabili e costanti Unit valide nell'intera sorgente ST e da esportare.

Parole chiave consentite: vedere la tabella in "Dichiarazione delle variabili (Pagina 211)". – Indicazione relativa alle unità di organizzazione del programma da esportare (POE).

La sintassi è la seguente: FUNCTION fc_name; FUNCTION_BLOCK fb_name; PROGRAM program_name;

Con opzione compilatore (Pagina 58) "Consenti dichiarazioni anticipative" attivata vengono interpretate anche come prototipi POE per la dichiarazione anticipativa (Pagina 310).

– Prototipi POE per la dichiarazione anticipativa (Pagina 310).

Indicazione dei prototipi per unità di organizzazione del programma con dichiarazione anticipativa (efficace solo con opzione compilatore (Pagina 58)"Consenti dichiarazioni anticipative") attivata.

Vengono interpretate anche come POE da esportare. Tutti i pacchetti tecnologici, le librerie, le unità importate, le dichiarazioni dei tipi di dati, le dichiarazioni delle variabili e le unità di organizzazione del programma elencati nella sezione interfaccia vengono esportati. Per ulteriori informazioni sull'esportazione vedere "Sezione interfaccia di una Unit da esportare (Pagina 214)".



Sequenza La sezione interfaccia è la 1° sezione di una sorgente ST1. La sequenza delle istruzioni Interface da 1 a 4 è vincolante. All'interno della n. 4 la sequenza è libera. I singoli blocchi di dichiarazione per le definizioni dei tipi di dati (compresi prototipi POE) e per le dichiarazioni delle variabili possono comparire più volte. Attenzione: Gli identificatori devono essere dichiarati prima di essere utilizzati. Solo con opzione compilatore "Consenti dichiarazioni anticipative" attivata: Per la dichiarazione di istanza di un blocco funzionale è sufficiente che il prototipo del blocco funzionale venga dichiarato preventivamente.

Frequenza Una volta per ogni sorgente ST. Parte obbligatoria Sì 1 Se lo si desidera, si può anteporre alla sezione interfaccia l'istruzione Unit; vedere "Definizione della Unit (Pagina 214)".

5.1.1.2 Sezione implementazione La sezione implementazione contiene le sezioni eseguibili e, di conseguenza, anche la parte principale della sorgente ST.

La sintassi della sezione implementazione è la seguente:



Tabella 5- 2 Sintassi della sezione implementazione

Sintassi IMPLEMENTATION // Istruzioni Implementation (opzionale) END_IMPLEMENTATION Non è stato possibile indicare un identificatore individuale della sezione. Tra le parole riservate IMPLEMENTATION e END_IMPLEMENTATION si trovano le istruzioni Implementation (la parte principale del file sorgente ST) nella seguente sequenza: 1. È possibile fare riferimento ad altre Unit per utilizzarne i componenti esportati. La sintassi è la

seguente:

USES unit_name-list;

Per ulteriori informazioni sull'argomento vedere "Istruzione USES in una Unit da importare (Pagina 217)".

2. Dichiarazioni – Definizioni del tipo di dati (Pagina 211):

Tipi di dati definiti dall'utente validi nell'intera sorgente ST (UDT) – Dichiarazioni delle variabili (Pagina 211):

Variabili e costanti Unit validi nell'intera sorgente ST.

Parole chiave consentite: vedere la tabella in "Dichiarazione delle variabili (Pagina 211)". – Prototipi POE per la dichiarazione anticipativa (Pagina 310).

Indicazione dei prototipi per unità di organizzazione del programma con dichiarazione anticipativa (efficace solo con opzione compilatore (Pagina 58)"Consenti dichiarazioni anticipative") attivata.

3. Unità di organizzazione del programma (POE) (Pagina 205)

Sequenza Segue sempre la sezione interfaccia. La sequenza delle suddette istruzioni Implementation è vincolante; all'interno dei num. 2 e 3 la sequenza è libera: Attenzione: Gli identificatori devono essere dichiarati prima di essere utilizzati. Solo con opzione compilatore (Pagina 58) "Consenti dichiarazioni anticipative" attivata: Per la dichiarazione di istanza di un blocco funzionale è sufficiente che il prototipo del blocco funzionale venga dichiarato preventivamente.

Frequenza Una volta per ogni sorgente ST. Parte obbligatoria Sì

5.1.1.3 Unità di organizzazione del programma (POE) Le unità di organizzazione del programma (POE) sono le sezioni eseguibili del file sorgente:

● Funzioni (FC) (Pagina 206)

● Blocchi funzionali (FB) (Pagina 207)

● Programmi (Pagina 208)

● Espressioni (Pagina 209)

Di solito nel file sorgente le POE richiamate devono precedere le POE che richiamo, in modo da essere note a queste ultime.



Eccezione: Solo con opzione compilatore (Pagina 58) "Consenti dichiarazioni anticipative" attivata. La sequenza è libera. Per l'indicazione di un prototipo per la dichiarazione anticipativa (Pagina 310) nella sezione interfaccia (Pagina 202) o sezione implementazione (Pagina 204) vale quanto segue:

● Obbligatoriamente richiesto per blocchi funzionali per dichiarazione di istanza

● Opzionale per il richiamo di funzioni e programmi

5.1.1.4 Funzioni (FC) Le funzioni (FC) appartengono alle unità di organizzazione del programma (POE). Esse sono sezioni del file sorgente richiamabili e parametrizzabili dai programmi e dai blocchi funzionali con dati temporanei. Tutte le variabili interne perdono il proprio valore quando si esce dalla funzione; al richiamo successivo vengono nuovamente inizializzate.

La sintassi delle funzioni è la seguente:

Tabella 5- 3 Sintassi delle funzioni (FC)

Sintassi FUNCTION name : function_data_type // Sezione dichiarazione // Sezione istruzioni END_FUNCTION name indica l'identificatore della funzione, function_data_type per il tipo di dati del valore di ritorno. Parole chiave consentite per la dichiarazione delle variabili nella sezione dichiarazione (Pagina 210): vedere la tabella in "Dichiarazione delle variabili (Pagina 211)". Prestare attenzione alle funzioni con function_data_type <> VOID: Nella sezione istruzioni (Pagina 210), all'identificatore della funzione deve essere assegnata un'espressione del tipo di dati function_data_type!

Sequenza Le funzioni possono essere definite solo nella sezione implementazione (Pagina 204). Di solito le funzioni devono precedere l'unità di organizzazione del programma da cui vengono richiamate. Eccezione: Solo con opzione compilatore (Pagina 58) "Consenti dichiarazioni anticipative" attivata. La sequenza è libera. L'indicazione di un prototipo per la dichiarazione anticipativa (Pagina 310) nella sezione interfaccia (Pagina 202) o sezione implementazione (Pagina 204) è possibile in via opzionale. La sezione dichiarazione (Pagina 210) deve precedere la sezione istruzioni (Pagina 210).

Frequenza Illimitata per sorgente ST. Parte obbligatoria No

Per ulteriori informazioni sulle funzioni (FC) vedere Creazione e richiamo di funzioni e di blocchi funzionali (Pagina 176).



5.1.1.5 Blocchi funzionali (FB) I blocchi funzionali (FB) appartengono alle unità di organizzazione del programma (POE). Sono sezioni del file sorgente richiamabili e parametrizzabili dai programmi con dati statici (il valore delle variabili interne viene conservato anche in presenza di più richiami). Ogni blocco funzionale dispone di una memoria; è pertanto possibile accedere in qualsiasi momento ai relativi parametri di uscita da qualsiasi posizione del programma utente.

La sintassi dei blocchi funzionali è la seguente:

Tabella 5- 4 Sintassi dei blocchi funzionali

Sintassi FUNCTION_BLOCK name // Sezione dichiarazione // Sezione istruzioni END_FUNCTION_BLOCK name indica l'identificatore del blocco funzionale. Parole chiave consentite per la dichiarazione delle variabili nella sezione dichiarazione: vedere la tabella in "Dichiarazione delle variabili (Pagina 211)".

Particolarità Prima di richiamare un blocco funzionale (FB) è necessario dichiarare un'istanza: dichiarare una variabile e immettere come tipo di dati l'identificatore del blocco funzionale. Questa dichiarazione di istanza viene eseguita localmente (all'interno di VAR / END_VAR nelle sezioni dichiarazione di un programma o di un blocco funzionale). La dichiarazione di istanza si può effettuare anche globalmente (all'interno di VAR_GLOBAL/END_VAR nella sezione interfaccia o implementazione). Di solito questa operazione è consentita solo con i blocchi funzionali che mettono a disposizione sorgenti di programma e librerie importate, ma non con i blocchi funzionali definiti nella stessa sorgente ST. Solo con opzione compilatore (Pagina 58) "Consenti dichiarazioni anticipative" attivata è possibile dichiarare istanze globali di blocchi funzionali definiti nella stessa sorgente ST. L'indicazione di un prototipo per la dichiarazione anticipativa (Pagina 310) nella sezione interfaccia o implementazione è obbligatoriamente richiesta. Nelle funzioni non possono essere dichiarate istanze di un blocco funzionale.

Sequenza I blocchi funzionali possono essere definiti solo nella sezione implementazione (Pagina 204). Rispettare la sequenza: I blocchi funzionali devono precedere la POE dalla quale un'istanza viene dichiarata come variabile locale. Eccezione: Solo con opzione compilatore (Pagina 58) "Consenti dichiarazioni anticipative" attivata. La sequenza è libera. L'indicazione di un prototipo per la dichiarazione anticipativa (Pagina 310) nella sezione interfaccia (Pagina 202) o sezione implementazione (Pagina 204) è richiesta obbligatoriamente. La sezione dichiarazione (Pagina 210) deve precedere la sezione istruzioni (Pagina 210).


Per ulteriori informazioni sui blocchi funzionali (FB) vedere Creazione e richiamo di funzioni e di blocchi funzionali (Pagina 176).



5.1.1.6 Programmi I programmi appartengono alle unità di organizzazione programma (POE). Questi vengono richiamati sull'apparecchio di destinazione in base all'assegnazione del task corrispondente (vedere Configurazione del sistema esecutivo nel Manuale di guida alle funzioni Funzioni di base SIMOTION) e possono richiamare funzioni e blocchi funzionali.

La sintassi dei programmi è la seguente:

Tabella 5- 5 Sintassi dei programmi

Sintassi PROGRAM name // Sezione dichiarazione // Sezione istruzioni END_PROGRAM name indica il nome del programma. Parole chiave consentite per la dichiarazione delle variabili nella sezione dichiarazione: vedere la tabella in "Dichiarazione delle variabili (Pagina 211)".

Sequenza I programmi possono essere definiti solo nella sezione implementazione (Pagina 204). A questo scopo i programmi si trovano dopo le espressioni, le funzioni, blocchi funzionali. In questo modo il programma conosce queste sezioni del file sorgente e può utilizzarle. Eccezione: Solo con opzione compilatore (Pagina 58) "Consenti dichiarazioni anticipative" attivata. La sequenza è libera. Quando viene richiamato un programma all'interno di un altro programma l'indicazione di un prototipo per la dichiarazione anticipativa (Pagina 310) nella sezione interfaccia (Pagina 202) o sezione implementazione (Pagina 204) è possibile in via opzionale. La sezione dichiarazione (Pagina 210) deve precedere la sezione istruzioni (Pagina 210).


Per ulteriori informazioni sui programmi vedere Programmi (Pagina 195).



5.1.1.7 Espressioni Le espressioni sono un caso particolare di dichiarazione della funzione con il tipo di dati definito BOOL del valore di ritorno. Viene valutata l'espressione all'interno delle parole riservate EXPRESSION <Identificatore di espressione> … END_EXPRESSION che viene assegnata al nome di funzione.

Il costrutto WAITFORCONDITION consente di attendere direttamente un evento programmabile o una condizione in un MotionTask. Il comando interrompe il task da cui viene richiamato per il tempo in cui la condizione (espressione) diventa vera.

La sintassi delle espressioni è la seguente:

Tabella 5- 6 Sintassi delle espressioni

Sintassi EXPRESSION name // Sezione dichiarazione // Sezione istruzioni END_EXPRESSION name indica l'identificatore dell'espressione. Parole chiave consentite per la dichiarazione delle variabili nella sezione dichiarazione: vedere la tabella in "Dichiarazione delle variabili (Pagina 211)". Attenzione: Nella sezione istruzioni (Pagina 210), all'identificatore di espressione deve essere assegnata un'espressione del tipo BOOL!

Sequenza Le espressioni possono essere dichiarate solo nella sezione implementazione (Pagina 204) di una sorgente ST. Di solito esse precedono il programma in cui vengono richiamate da una struttura di controllo WAITFORCONDITION. Eccezione: Solo con opzione compilatore (Pagina 58) "Consenti dichiarazioni anticipative" attivata. La sequenza è libera. L'indicazione di un prototipo per la dichiarazione anticipativa (Pagina 310) nella sezione interfaccia (Pagina 202) o sezione implementazione (Pagina 204) non è possibile. La sezione dichiarazione (Pagina 210) deve precedere la sezione istruzioni (Pagina 210).


Per ulteriori informazioni sulle espressioni vedere Espressioni (Pagina 197). In relazione all'istruzione WAITFORCONDITION, vedere il Manuale di guida alle funzioni Funzioni di base SIMOTION.



5.1.1.8 Sezione dichiarazione La sezione dichiarazione di un'unità di organizzazione del programma (POE) contiene la definizione del tipo di dati e la dichiarazione delle variabili della POE.

La sezione dichiarazione ha la seguente struttura:

Tabella 5- 7 Struttura della sezione dichiarazione

Struttura // Definizione del tipo di dati // Dichiarazione delle variabili

Sequenza La sezione dichiarazione non ha alcuna parola chiave esplicita all'inizio o alla fine. Inizia dopo la parola chiave della rispettiva unità di organizzazione del programma (POE) e termina con la prima istruzione eseguibile della sezione istruzioni. Contiene, in ordine libero: • Definizioni del tipo di dati (Pagina 211):

i tipi di dati definiti dall'utente (UDT) validi localmente nella POE • Dichiarazioni delle variabili (Pagina 211):

Le variabili e le costanti valide localmente nella POE.

Le parole chiave consentite a seconda della POE: vedere la tabella in "Dichiarazione delle variabili (Pagina 211)".

Attenzione: Gli identificatori devono essere dichiarati prima di essere utilizzati. Frequenza Una volta per ogni POE Parte obbligatoria No

5.1.1.9 Sezione istruzioni La sezione istruzioni di una POE è composta dalle singole istruzioni (eseguibili).

La sezione istruzioni ha la seguente struttura:

Tabella 5- 8 Struttura della sezione istruzioni

Struttura // Istruzioni

Sequenza La sezione istruzioni non ha alcuna parola chiave esplicita all'inizio o alla fine. Inizia dopo la sezione dichiarazione e termina con la parola chiave della POE.

Frequenza Una volta per ogni POE Parte obbligatoria No

Per ulteriori informazioni sulle istruzioni vedere

● Assegnazione del valore ed espressioni (Pagina 137)

● Istruzioni di controllo (Pagina 156)

● Richiamo di funzioni e di blocchi funzionali (Pagina 184)



5.1.1.10 Definizione del tipo di dati Definendo il tipo di dati si determinano i tipi di dati definiti dall'utente (UDT). Questi dati possono essere utilizzati per la dichiarazione delle variabili. Gli UDT possono essere definiti nella sezione interfaccia, nella sezione implementazione nonché nella sezione dichiarazione delle funzioni, dei blocchi funzionali e dei programmi.

La sintassi della definizione del tipo di dati è la seguente:

Tabella 5- 9 Sintassi della definizione del tipo di dati

Sintassi TYPE name : data_type_specification; // ... END_TYPE name indica i nomi dei singoli tipi di dati utilizzati nella dichiarazione delle variabili. data_type_specification indica un tipo di dati o una struttura specifici. Tra TYPE e END_TYPE può trovarsi un numero illimitato di tipi di dati individuali.

Sequenza Si possono definire gli UDT: • nella sezione interfaccia:

Gli UDT sono noti all'interno della sorgente ST e vengono esportati

Possono essere utilizzati nella sezione interfaccia e implementazione per la dichiarazione delle variabili Unit e in tutte le POE per la dichiarazione delle variabili locali.

Inoltre possono essere utilizzate in tutte le Unit che importano questa sorgente ST (in SIMOTION ST con l'istruzione USES).

• nella sezione implementazione:

Gli UDT sono noti all'interno della sorgente ST.

Possono essere utilizzati nella sezione implementazione per la dichiarazione delle variabili Unit e in tutte le POE per la dichiarazione delle variabili locali.

• nella sezione dichiarazione di una POE (funzione, blocco funzionale, programma, espressione

Gli UDT sono noti soltanto localmente all'interno della POE.

Possono essere utilizzate solo all'interno della POE per la dichiarazione delle variabili locali. È necessario definire gli UDT prima di poterli utilizzare in una dichiarazione delle variabili.

Frequenza Il blocco di dichiarazione TYPE / END_VAR può comparire più volte all'interno di una sezione del file sorgente; in un blocco di dichiarazione è possibile un numero a piacere di UDT.

Parte obbligatoria No

Per ulteriori informazioni sugli UDT vedere Tipi di dati definiti dall'utente (Pagina 114).

5.1.1.11 Dichiarazione delle variabili Una sezione dichiarazione contiene le dichiarazioni delle variabili e può essere presente nelle funzioni, nei blocchi funzionali e nei programmi (POE), oltre che nella sezione interfaccia e nella sezione implementazione.

La sintassi della dichiarazione delle variabili è la seguente:



Tabella 5- 10 Sintassi della dichiarazione delle variabili

Sintassi variable_type name_list : data_type; // ... END_VAR variable_type indica la parola chiave del tipo di variabile che viene dichiarata. Le parole chiave consentite dipendono dalla sezione del file sorgente. • nella sezione interfaccia o nella sezione implementazione di una sorgente ST:

VAR_GLOBAL: Variabile Unit non ritentiva

VAR_GLOBAL CONSTANT: costante Unit

VAR_GLOBAL RETAIN: Variabile Unit ritentiva • nella sezione dichiarazione di una funzione:

VAR: Variabile locale

VAR CONSTANT: Costante locale

VAR_INPUT: Parametri di ingresso

VAR_IN_OUT: Parametri di passaggio • nella sezione dichiarazione di un blocco funzionale:



VAR_TEMP: Variabile temporanea

VAR_INPUT: Parametri di ingresso

VAR_OUTPUT: Parametri di uscita

VAR_IN_OUT: Parametri di passaggio • nella sezione dichiarazione di un programma:



VAR_TEMP: Variabile temporanea • nella sezione dichiarazione di una espressione:



VAR_INPUT: Parametro di ingresso (a partire dalla versione 4.1 del kernel SIMOTION)

VAR_IN_OUT: Parametro di passaggio (a partire dalla versione 4.1 del kernel SIMOTION) name_list è l'elenco di identificatori del tipo di dati (data_type) da dichiarare.



Sequenza La dichiarazione delle variabili può avvenire: • nella sezione interfaccia della sorgente ST:

Parole chiave consentite: vedere il campo Sintassi della tabella.

Le variabili Unit sono note all'interno della sorgente ST e vengono esportate

Possono essere utilizzate in tutte le POE della sorgente ST.

Inoltre possono essere utilizzate in tutte le Unit che importano questa sorgente ST (in SIMOTION ST con l'istruzione USES).

• nella sezione implementazione della sorgente ST:

Parole chiave consentite: vedere il campo Sintassi della tabella.

Le variabili Unit sono note all'interno della sorgente ST.

Possono essere utilizzate in tutte le POE della sorgente ST. • nella sezione dichiarazione di una POE (funzione, blocco funzionale, programma,

espressione)

Le parole chiave consentite a seconda del tipo di POE: vedere il campo Sintassi della tabella.

Le variabili sono note soltanto localmente all'interno della POE.

Possono essere utilizzate solo all'interno della POE per la dichiarazione delle variabili locali.

Eccezioni: – È possibile accedere ai parametri di uscita di un blocco funzionale anche dall'esterno di un

blocco funzionale. – Ai parametri di ingresso di un blocco funzionale è possibile accedere dall'esterno del

blocco funzionale stesso, a condizione che l'opzione compilatore "Consenti estensioni lingua" sia attivata. Vedere Impostazioni globali del compilatore (Pagina 59) e Impostazioni locali del compilatore (Pagina 61).

È necessario definire le variabili prima di poterle utilizzare. Frequenza La frequenza con cui il blocco di dichiarazione variable_type / END_VAR di un determinato tipo di

variabile può comparire dipende dalla sezione del file sorgente interessata. • Nella sezione interfaccia e implementazione della sorgente ST:

I blocchi di dichiarazione possono comparire più volte. • Nella sezione dichiarazione di una POE (funzione, blocco funzionale, programma,

espressione):

Ogni blocco di dichiarazione (a eccezione di VAR CONSTANT / END_VAR) può comparire una sola volta all'interno della sezione dichiarazione.

Blocchi di dichiarazione e parole chiave consentiti in relazione alla sezione del file sorgente interessata: vedere il campo Sintassi della tabella. All'interno di un blocco di dichiarazione è possibile un numero a piacere di dichiarazioni delle variabili.

Parte obbligatoria No

Per ulteriori informazioni sulle dichiarazioni delle variabili vedere Dichiarazione delle variabili (Pagina 128).



5.1.2 Importazione ed esportazione tra sorgenti ST ST mette a disposizione il concetto di Unit con cui si può accedere alle variabili, ai tipi di dati, alle funzioni (FC), ai blocchi funzionali (FB) e ai programmi globali di altri file sorgente. In questo modo si possono raggruppare e rendere disponibili dei sottoprogrammi riutilizzabili.

5.1.2.1 Definizione della Unit Come Unit viene definita qui di seguito una sorgente di programma (ad es. sorgente ST, sorgente MCC). Come definizione viene utilizzato il nome della sorgente di programma definito in SIMOTION SCOUT.

In una sorgente ST è possibile impostare facoltativamente l'istruzione Unit come prima istruzione (anteposta alla sezione interfaccia). La sintassi è la seguente:

UNIT name;

name corrisponde al nome della sorgente ST come definito in SIMOTION SCOUT, vedere Inserimento sorgente ST (Pagina 21) oppure Modifica delle proprietà di una sorgente ST (Pagina 25).

Se il nome indicato è diverso dal nome della sorgente ST, l'istruzione viene ignorata.

5.1.2.2 Sezione interfaccia di una Unit da esportare Nella sezione interfaccia di una Unit da esportare possono essere immessi i seguenti costrutti. In questo paragrafo la sintassi dei costrutti è solo accennata; per informazioni dettagliate vedere "Sezione interfaccia (Pagina 202)".

● Le dichiarazioni del tipo di dati da esportare

TYPE

Tipi di dati definiti dall'utente con relativa dichiarazione completa.

● le dichiarazioni della variabile da esportare

VAR_GLOBAL, VAR_GLOBAL RETAIN o VAR_GLOBAL CONSTANT

Variabili UNIT non ritentive e ritentive e costanti Unit con relativa dichiarazione completa.

● POE da esportare (funzioni, blocchi funzionali e programmi)

Indicare l'unità di organizzazione del programma da esportare (funzioni, blocchi funzionali o programmi) con la parola chiave corrispondente (opzionale all'interno del costrutto TYPE / END_TYPE). Ogni voce deve terminare con un punto e virgola.

– FUNCTION_BLOCK fb_name;

– FUNCTION fc_name;

– PROGRAM program_name ;

Con opzione compilatore (Pagina 58) "Consenti dichiarazioni anticipative " attivata vengono interpretate anche come prototipi POE per la dichiarazione anticipativa (Pagina 310).



La sequenza delle indicazioni è libera; la POE stessa è programmabile nella sezione implementazione (Pagina 204) della sorgente ST.

Nota

Nella sezione interfaccia sono possibili ulteriori indicazioni elencate davanti ai tipi di dati, alle variabili e alle POE esportate: 1. Indicazione del pacchetto tecnologico utilizzato (USEPACKAGE …). 2. Indicazione delle librerie utilizzate (USELIB …). 3. È possibile fare riferimento ad altre Unit per utilizzarne i componenti esportati (USES …).

Questi pacchetti tecnologici, librerie e Unit importati vengono anche esportati. Per l'ereditarietà vedere "Istruzione USES in una Unit da importare (Pagina 217)".

Nella sezione interfaccia di una Unit (sorgente ST) rispettare la sequenza di indicazioni nella "Sezione interfaccia (Pagina 202)". Se la sequenza non viene rispettata, la compilazione della sorgente ST comporta necessariamente degli errori.

I programmi da assegnare a un task nel sistema esecutivo devono essere eseguiti nella sezione interfaccia (vedere Configurazione del sistema esecutivo nel Manuale di guida alle funzioni Funzioni di base SIMOTION). Se i programmi non vengono esportati nella sezione interfaccia di una sorgente ST, il compilatore emette un messaggio di avviso.

Le funzioni, i blocchi funzionali e i programmi utilizzati solo all'interno della sorgente ST non devono essere eseguiti nella sezione interfaccia.



5.1.2.3 Esempio di Unit da esportare Di seguito è riportato un esempio relativo a una Unit da esportare (myUnit_A). Essa viene importata dalla myUnit_B (vedere Esempio di una Unit da importare (Pagina 219)).

Tabella 5- 11 Esempio di Unit da esportare

UNIT myUnit_A; // Opzionale, nome della sorgente ST

INTERFACE

// ... Qui è possibile anche l'istruzione USES

TYPE // Dichiarazione relativa ai tipi di dati da esportare

color : (RED, GREEN, BLUE);

END_TYPE

VAR_GLOBAL

cycle : INT := 1; // Dichiarazione relativa alle variabili Unit

// da esportare

END_VAR

FUNCTION myFC; // Istruzione di esportazione di una funzione

FUNCTION_BLOCK myFB; // Istruzione di esportazione di un blocco funzionale

PROGRAM myProgram_A; // Istruzione di esportazione di un programma

// (per il collegamento al sistema esecutivo)

END_INTERFACE

IMPLEMENTATION

Function myFC : LREAL // Funzione esplicitata

; // ... (istruzioni)

END_FUNCTION

Function_BLOCK myFB // Blocco funzionale esplicitato


END_FUNCTION_BLOCK

PROGRAM myProgram_A // Programma esplicitato


END_PROGRAM

END_IMPLEMENTATION



5.1.2.4 Istruzione USES in una Unit da importare In una Unit da importare viene inserita la seguente istruzione nella sezione interfaccia o nella sezione implementazione:

USES unit_name-list

unit_name-list è un'enumerazione delle Unit, separate da virgole, che devono essere importate.

Esempio:

USES unit_1, unit_2, unit_3;

Ciò consente di accedere ai seguenti elementi inseriti o dichiarati nella sezione interfaccia delle Unit importate (ad es. sorgente ST, sorgente MCC):

● Tipi di dati definiti dall'utente (UDT)

● Variabili e costanti Unit

● Programmi, funzioni e blocchi funzionali

● Pacchetti tecnologici, librerie e Unit importate

Gli elementi importati possono essere utilizzati come se esistessero nella Unit attuale.

Nota

La parola chiave USES deve essere presente una sola volta nella sezione interfaccia o nella sezione implementazione di una Unit. Molte Unit da importare sono designate dalla parola chiave USES nell'elenco separato da virgole.

L'istruzione USES può trovarsi nella sezione interfaccia o nella sezione implementazione di una Unit. Ciò ha molteplici effetti:



Tabella 5- 12 Effetti dipendenti dalla sezione della sorgente ST in cui si trova l'istruzione USES.

Effetto Istruzione USES nella sezione interfaccia

Istruzione USES nella sezione implementazione

Ereditarietà La Unit attuale esporta di nuovo la Unit importata; la Unit importata viene ereditata da tutte le Unit successive che hanno accesso alla Unit attuale. Esempio: 1. La Unit B importa la Unit A nella sezione

Interfaccia. 2. La Unit C importa a sua volta la Unit B. 3. Quindi anche la Unit C importa

automaticamente la Unit A. A → B → C ⇒ A → C Grazie a questo trasferimento non è necessario importare in modo esplicito la Unit A nella Unit C.

Il trasferimento è interrotto. Esempio: 1. La Unit B importa la Unit A nella sezione

Implementazione. 2. La Unit C importa a sua volta la Unit B. 3. In questo caso la Unit C non accede

automaticamente alla Unit A. La Unit C deve importare la Unit A in modo esplicito quando vuole accedere alla Unit A stessa.

Dichiarazione delle variabili

La dichiarazione di una variabile Unit di un tipo di dati importato è possibile nella: • Sezione interfaccia • Sezione implementazione

La dichiarazione di una variabile Unit di un tipo di dati importato è possibile solo nella sezione implementazione.

Nota

Per suggerimenti sull'uso delle variabili Unit vedere il Manuale di guida alle funzioni Funzioni di base SIMOTION.



5.1.2.5 Esempio di una Unit da importare Di seguito è riportato un esempio relativo a una Unit da importare (myUnit_B). Essa importa la Unit myUnit_A dalla Esempio di Unit da esportare (Pagina 216).

Tabella 5- 13 Esempio di Unit da importare

UNIT myUnit_B; // Opzionale, nome della sorgente ST

INTERFACE

// ... Event. istruzione USES

PROGRAM myProgram_B;

// Indicazione sul programma da esportare, FB, FC,

// Tipo di dati e variabili Unit

END_INTERFACE

IMPLEMENTATION

USES myUnit_A; // Indicazione della Unit importata

VAR_GLOBAL

myInstance : myFB; // Dichiarazione di un'istanza

// del blocco funzionale importato

mycolor : color; // Dichiarazione di una variabile

// del tipo di dati importato

END_VAR

PROGRAM myProgram_B

mycolor := GREEN; // Assegnazione del valore alla variabile del

// tipo di dati importato

cycle := cycle + 1; // Assegnazione del valore alla

// variabile importata

END_PROGRAM

END_IMPLEMENTATION

Implementazione di ST in SIMOTION 5.2 Variabili in SIMOTION


5.2 Variabili in SIMOTION Di seguito si può avere una panoramica sulle variabili che sono disponibili nel linguaggio ST.

5.2.1 Modello di variabile Le tabelle seguenti mostrano tutti i tipi di variabili disponibili per la programmazione.

● Variabili di sistema dell'apparecchio SIMOTION e degli oggetti tecnologici

● Variabili utente globali (variabili I/O, variabili globali dell'apparecchio, variabili Unit)

● Variabili utente locali (variabili all'interno di un programma, di una funzione o di un blocco funzionale)

Variabili di sistema Tipo di variabile Significato Variabili di sistema dell'apparecchio SIMOTION Variabili di sistema degli oggetti tecnologici

Ciascun apparecchio SIMOTION e ciascun oggetto tecnologico possiede variabili di sistema specifiche. Si può accedere a queste variabili: • da tutti i programmi all'interno dell'apparecchio SIMOTION • da apparecchi HMI È possibile verificare le variabili di sistema nel browser dei simboli.



Variabili utente globali Tipo di variabile Significato Variabili I/O È possibile assegnare nomi di variabili simboliche agli indirizzi I/O dell'apparecchio

SIMOTION o alle periferiche. Questa operazione consente i seguenti accessi diretti e accessi alle immagini di processo sulla periferica: • da tutti i programmi all'interno dell'apparecchio SIMOTION • da apparecchi HMI Queste variabili si creano nel browser dei simboli dopo aver selezionato l'elemento I/O nella navigazione di progetto. Le variabili I/O possono essere monitorate nel browser dei simboli.

Variabili globali d'apparecchio

Variabili definite dall'utente cui tutti i programmi dell'apparecchio SIMOTION e degli apparecchi HMI possono accedere. Queste variabili vengono create nel browser dei simboli dopo aver selezionato l'elemento VARIABILI GLOBALI DEGLI APPARECCHI nella navigazione di progetto. Le variabili globali possono essere dichiarate ritentive. Esse rimangono archiviate anche dopo lo spegnimento dell'apparecchio SIMOTION. È possibile verificare le variabili globali d'apparecchio nel browser dei simboli.

Variabili Unit Variabili definite dall'utente cui possono accedere tutti i programmi, i blocchi funzionali e le funzioni all'interno di una Unit (ad es. sorgente ST, sorgente MCC, sorgente KOP/FUP). Per dichiarare queste variabili nella Unit: • nella sezione interfaccia:

Queste variabili vengono esportate e possono essere importate in altre Unit (ad es. sorgenti ST, sorgenti MCC, sorgenti KOP/FUP). Inoltre sono solitamente disponibili sugli apparecchi HMI.

• nella sezione implementazione:

Queste variabili sono accessibili solo all'interno della Unit interessata. Le variabili UNIT possono essere dichiarate ritentive. Esse rimangono archiviate anche dopo lo spegnimento dell'apparecchio SIMOTION. È possibile verificare le variabili UNIT nel browser dei simboli.



Variabili utente locali Tipo di variabile Significato Variabili definite dall'utente cui è possibile accedere solo all'interno del programma (o

funzione, blocco funzionale) nel quale sono state definite. Variabile di un programma (variabile di programma)

La variabile viene dichiarata in un programma. È possibile accedervi solo all'interno di questo programma. Si distingue tra variabili statiche e temporanee. • Le variabili statiche vengono inizializzate in base allo spazio di memoria in cui vengono

memorizzate. Definire questo spazio di memoria tramite un'opzione compilatore. Di solito le variabili statiche vengono inizializzate in relazione al task al quale viene assegnato il programma (vedere il manuale di guida alle funzioni Funzioni di base SIMOTION).

È possibile verificare le variabili statiche nel Browser dei simboli. • Le variabili temporanee vengono inizializzate a ogni richiamo del programma in un task.

Le variabili temporanee non possono essere monitorate nel Browser dei simboli. Variabile di una funzione (Variabile FC)

La variabile viene dichiarata in una funzione (FC). È possibile accedervi solo all'interno di questa FC. Le variabili FC sono temporanee; vengono inizializzate ad ogni richiamo di funzione. Non possono essere monitorate nel Browser dei simboli.

Variabile di un blocco funzionale (variabile FB)

La variabile viene dichiarata sorgente in un blocco funzionale (FB). È possibile accedervi solo all'interno di questo FB. Si distingue tra variabili statiche e temporanee. • Le variabili statiche al termine del blocco funzionale conservano il proprio valore.

Vengono inizializzate solo se viene inizializzata l'istanza del blocco funzionale; ciò dipende dal tipo di variabile con la quale è stata dichiarata l'istanza del blocco funzionale.

È possibile verificare le variabili statiche nel Browser dei simboli. • Le variabili temporanee al termine del blocco funzionale perdono il proprio valore. Al

richiamo successivo del blocco funzionale vengono nuovamente inizializzate.

Le variabili temporanee non possono essere monitorate nel Browser dei simboli.

Per ulteriori informazioni, fare riferimento:

● Nei relativi Libretti di descrizione parametri sono disponibili in sintesi le informazioni relative a tutte le variabili di sistema dei pacchetti tecnologici SIMOTION e degli apparecchi SIMOTION.

● Nei Manuali di guida alle funzioni Oggetti tecnologici SIMOTION Motion Control sono disponibili informazioni sull'uso delle variabili di sistema degli oggetti tecnologici.



● Nel manuale di guida alle funzioni Funzioni di base SIMOTION sono disponibili informazioni su come accedere alle variabili di sistema e ai dati di configurazione.

● La presente documentazione fornisce informazioni

– sull'accesso agli indirizzi della periferica con le variabili di I/O (vedere Accesso diretto e immagine di processo dei task ciclici (Pagina 256)),

– sull'accesso all'immagine di processo (vedere Accesso all'immagine di processo fissa dei BackgroundTask (Pagina 267)),

– sulla creazione e l'utilizzo di variabili globali dell'apparecchio (vedere Utilizzo di variabili globali dell'apparecchio (Pagina 231)),

– sull'utilizzo di variabili Unit e variabili locali (variabili statiche e temporanee).

Nota

Tenere presente che il download della sorgente ST nel sistema di destinazione e i task da eseguire influiscono sull'inizializzazione delle variabili e, di conseguenza, sul contenuto corrispondente, vedere Istante di inizializzazione delle variabili (Pagina 237).

5.2.1.1 Variabili Unit Le variabili Unit sono valide in tutta la sorgente ST; ciò significa che è possibile accedere a queste variabili da qualsiasi sezione del file sorgente.

Le variabili Unit vengono dichiarate con la sezione interfaccia e/o implementazione di una sorgente ST, la posizione della dichiarazione determina la validità delle variabili Unit:

● Se le variabili Unit vengono dichiarate nella sezione interfaccia, vengono create variabili che possono essere utilizzate anche in altre sorgenti di programma (ad es. sorgenti ST, sorgenti MCC). Per ulteriori informazioni sull'importazione e sull'esportazione tra sorgenti di programma vedere Importazione ed esportazione tra sorgenti ST (Pagina 214).

Solitamente queste variabili Unit sono disponibili anche sugli apparecchi HMI. La dimensione totale delle variabili Unit che possono essere esportate sugli apparecchi HMI è limitata a 64 kByte per Unit.

● Se si dichiarano le variabili unit nella sezione implementazione, vengono create delle variabili che possono essere utilizzate da tutte le unità di organizzazione del programma (POE) delle sorgenti attuali.

La preimpostazione per l'esportazione HMI delle variabili Unit può essere modificata con un pragma all'interno di ciascun blocco di dichiarazione, vedere Variabili e apparecchi HMI (Pagina 248) e Gestione del compilatore tramite attributi (Pagina 304).

Le variabili Unit possono essere definite con comportamenti diversi ad es. in caso di caduta di tensione:



● Variabili Unit non ritentive (parola chiave VAR_GLOBAL): questo valore va perso in caso di caduta di tensione.

● Variabili Unit ritentive (parola chiave VAR_GLOBAL RETAIN): questo valore viene mantenuto in caso di caduta di tensione.

● Costanti Unit (parola chiave VAR_GLOBAL CONSTANT): questo valore resta invariato (vedere costanti (Pagina 135)).

Per suggerimenti sull'uso efficiente delle variabili Unit vedere il manuale di guida alle funzioni Funzioni di base SIMOTION.

5.2.1.2 Variabili Unit non ritentive Le variabili unit non ritentive perdono il loro valore in caso di interruzione di corrente.

Figura 5-1 Sintassi: Variabili Unit

Questo blocco di dichiarazione può comparire più volte all'interno di una sezione interfaccia o implementazione. Nella dichiarazione delle variabili vengono indicati il nome della variabile e il tipo di dati (vedere Panoramica di tutte le dichiarazioni delle variabili (Pagina 130) e Inizializzazione delle variabili o dei tipi di dati (Pagina 131)).

Per la portata della dichiarazione e dell'esportazione HMI vedere Variabili Unit (Pagina 223).

Nota

Per inizializzare le variabili Unit non ritentive: • Vedere Inizializzazione delle variabili globali non ritentive (Pagina 240). • È possibile impostare il comportamento in fase di download (menu Strumenti >

Impostazioni, scheda Download, casella di controllo Inizializzazione dei dati di programma non ritentivi e delle variabili globali dell'apparecchio non ritentive.

• Il tipo di identificazione della versione e del comportamento di inizializzazione in fase di download dipende dalla versione del kernel SIMOTION. Vedere a questo scopo Identificazione della versione delle variabili globali e relativa inizializzazione in fase di download (Pagina 247).



Tabella 5- 14 Esempi di variabili Unit non ritentive

INTERFACE

VAR_GLOBAL // Queste variabili possono essere esportate.

rotation1 : INT;

field1 : ARRAY [1..10] OF REAL;

flag1 : BOOL;

motor1 : motor; // Dichiarazione di istanza

END_VAR

END_INTERFACE

IMPLEMENTATION

VAR_GLOBAL // Queste variabili non possono essere esportate

// .

rotation2 : INT;

field2 : ARRAY [1..10] OF REAL;

flag2 : BOOL;

motor2 : motor; // Dichiarazione di istanza

END_VAR

END_IMPLEMENTATION

5.2.1.3 Variabili Unit ritentive Le variabili Unit ritentive permettono la memorizzazione permanente dei valori delle variabili anche in caso di caduta di tensione.

Figura 5-2 Sintassi: blocco delle variabili ritentivo

Questo blocco di dichiarazione può comparire più volte all'interno di una sezione interfaccia o implementazione. Nella dichiarazione delle variabili vengono indicati il nome della variabile e il tipo di dati (vedere Panoramica di tutte le dichiarazioni delle variabili (Pagina 130) e Inizializzazione delle variabili o dei tipi di dati (Pagina 131)).



Per la portata della dichiarazione e dell'esportazione HMI vedere Variabili Unit (Pagina 223).

Nota • Per inizializzare le variabili Unit ritentive:

– Vedere Inizializzazione delle variabili globali ritentive (Pagina 238). – È possibile impostare il comportamento in fase di download (menu Strumenti >

Impostazioni, scheda Download, casella di controllo Inizializzazione dei dati di programma ritentivi e delle variabili globali dell'apparecchio ritentive.

– Il tipo di identificazione della versione e del comportamento di inizializzazione in fase di download dipende dalla versione del kernel SIMOTION. Vedere a questo scopo Identificazione della versione delle variabili globali e relativa inizializzazione in fase di download (Pagina 247).

• La memoria disponibile per le variabili ritentive dipende dall'apparecchio (vedere le strutture d'insieme nel manuale di progettazione SIMOTION SCOUT). Per sfruttare al meglio questo spazio di memoria limitato, è necessario occuparlo con un singolo file sorgente ST e ordinare le variabili in base alle dimensioni del tipo di dati in ordine decrescente.

• Verificare in SIMOTION SCOUT lo spazio disponibile nella memoria ritentiva. Nella modalità online, richiamare la Diagnostica apparecchi dell'apparecchio SIMOTION da controllare (vedere la guida in linea). Nella scheda Carico risorse del sistema, alla voce Dati ritentivi, viene visualizzata la memoria disponibile.

Tabella 5- 15 Esempi di variabili ritentive

VAR_GLOBAL RETAIN

Campo di misura : ARRAY[1..10] OF REAL;

Ciclo : INT;

Interruttori : BOOL;

END_VAR

5.2.1.4 Variabili locali (variabili statiche e temporanee) Le variabili locali sono valide solo nella sezione del file sorgente (ad es. programma, FC o FB) in cui sono state dichiarate. In particolare, si distinguono:

● Variabili statiche (Pagina 229):

Mantengono il proprio valore in tutte le fasi dell'esecuzione della sezione del file sorgente (memoria del blocco).

● Variabili temporanee (Pagina 230):

Vengono inizializzate al successivo richiamo della sezione del file sorgente.

Vedere anche: Inizializzazione delle variabili locali (Pagina 243).

Nota

Al di fuori della sezione del file sorgente in cui sono state dichiarate, le variabili locali non sono accessibili.



La seguente tabella contiene una panoramica delle dichiarazioni delle variabili statiche e temporanee. Indica in quale sezione del file sorgente e con quali parole chiave è possibile dichiarare queste variabili.

Tabella 5- 16 Parole chiave per la dichiarazione di variabili statiche e temporanee in funzione della sezione del file sorgente.

Parole chiave per la dichiarazione Sezione file sorgente

Variabili statiche Variabili temporanee Funzione – VAR / END_VAR

oppure VAR_INPUT / END_VAR

oppure VAR_IN_OUT / END_VAR2

Espressione – VAR / END_VAR oppure

VAR_INPUT / END_VAR oppure

VAR_IN_OUT / END_VAR2 Blocco funzionale VAR / END_VAR1

oppure VAR_INPUT / END_VAR1

oppure VAR_OUTPUT / END_VAR1

VAR_TEMP / END_VAR oppure

VAR_IN_OUT / END_VAR2

Programma VAR / END_VAR3 VAR_TEMP / END_VAR 1 L'inizializzazione delle variabili dipende dall'inizializzazione dell'istanza dichiarata. Vedere Inizializzazione delle istanze dei blocchi funzionali (FB) (Pagina 245). 2 Il riferimento (indicatore) della variabile da trasferire è temporaneo 3 L'inizializzazione delle variabili dipende dallo spazio di memoria in cui queste vengono create. Vedere Inizializzazione variabili statiche dei programmi (Pagina 244).

Nota

Tenere presente che il download della sorgente ST nel sistema di destinazione e i task da eseguire influiscono sull'inizializzazione delle variabili e, di conseguenza, sul contenuto corrispondente, vedere Istante di inizializzazione delle variabili (Pagina 237).



Tabella 5- 17 Esempi di variabili statiche e temporanee

IMPLEMENTATION

FUNCTION testFkt

VAR // Dichiarazione di variabili temporanee

flag : BOOL;

END_VAR

END_FUNCTION

FUNCTION_BLOCK testFbst;

VAR // Dichiarazione di variabili statiche

rotation1 : INT;

END_VAR

VAR_TEMP // Dichiarazione di variabili temporanee

help1, help2 : REAL;

END_VAR

END_FUNCTION_BLOCK

PROGRAM testPrg;

VAR // Dichiarazione di variabili statiche

rotation2 : INT;

END_VAR

VAR_TEMP // Dichiarazione di variabili temporanee

help1, help2 : REAL;

END_VAR

END_PROGRAM

END_IMPLEMENTATION



5.2.1.5 Variabili statiche Le variabili statiche conservano l'ultimo valore memorizzato dopo la chiusura della sezione del file sorgente. Questo valore viene riutilizzato durante il richiamo successivo.

Le variabili statiche sono presenti nelle seguenti sezioni del file sorgente:

● Programmi

● Blocchi funzionali

Esse vengono dichiarate nel blocco delle variabili statiche.

Figura 5-3 Sintassi: Blocco di variabili statico

Nel blocco delle variabili statiche si possono eseguire le seguenti operazioni in base alla sintassi dell'immagine:

● Dichiarazione delle variabili (nome e tipo di dati), facoltativamente con inizializzazione

● Dichiarazione dell'accesso simbolico all'immagine di processo del BackgroundTask

● Dichiarazione delle istanze dei blocchi funzionali

Per l'inizializzazione delle variabili statiche:

● Nei programmi: in relazione al comportamento durante l'esecuzione del task al quale è assegnato il programma (vedere il manuale di guida alle funzioni Funzioni di base SIMOTION).

Vedere anche Inizializzazione variabili statiche dei programmi (Pagina 244).

● Nel blocchi funzionali: in relazione all'inizializzazione dell'istanza dichiarata.

Vedere anche Inizializzazione delle istanze dei blocchi funzionali (FB) (Pagina 245).



5.2.1.6 Variabili temporanee Le variabili temporanee vengono inizializzate ad ogni richiamo della sezione del file sorgente. Il valore di queste variabili si conserva solo durante l'esecuzione della sezione del file sorgente.

Le variabili temporanee sono presenti nelle seguenti sezioni del file sorgente:

● Programmi

● Blocchi funzionali

● Funzioni

● Espressione

Nei blocchi funzionali e nei programmi le variabili temporanee vengono dichiarate nel blocco delle variabili temporanee FB e di programma (vedere la figura seguente):

Figura 5-4 Sintassi: blocco di variabili temporanee in un blocco funzionale o in un programma

Nelle funzioni e nelle espressioni le variabili temporanee vengono dichiarate nel blocco delle variabili temporanee FC (vedere la figura seguente):

Figura 5-5 Sintassi: blocco di variabili temporanee in una funzione



5.2.2 Uso di variabili utente globali dell'apparecchio Le variabili globali degli apparecchi sono variabili definite dall'utente, alle quali è possibile accedere da tutte le sorgenti di programma (ad es. sorgenti ST, sorgenti MCC) di un apparecchio SIMOTION.

Le variabili globali dell'apparecchio si creano nella scheda del browser dei simboli della visualizzazione dei dettagli; a questo scopo occorre sempre trovarsi in modalità offline.

Ecco una descrizione sintetica del modo di procedere:

1. Nella navigazione di progetto di SIMOTION SCOUT, selezionare l'elemento VARIABILI GLOBALI D'APPARECCHIO nella diramazione dell'apparecchio SIMOTION.

2. Nella visualizzazione dei dettagli, aprire la scheda Browser dei simboli e scorrere la scheda fino alla fine della tabella delle variabili (riga vuota).

3. Inserire nell'ultima riga (riga vuota) della tabella o selezionare i seguenti elementi:

– Nome delle variabili

– Tipo di dati delle variabili (accessibili solo tipi di dati elementari)

4. Facoltativamente è possibile impostare anche:

– Attivazione della casella di controllo Retain (in tal modo la variabile viene definita come ritentiva; il valore viene conservato anche in mancanza di corrente).

– Lunghezza del campo (dimensione array.)

– Valore iniziale (in caso di array per ogni elemento)

– Formato di visualizzazione (in caso di array per ogni elemento)

Ora si può accedere a questa variabile con il browser dei simboli o con ciascun programma dell'apparecchio SIMOTION.

Nelle sorgenti ST è possibile utilizzare una variabile globale dell'apparecchio come qualsiasi altra variabile.

Nota

Se sono state dichiarate variabili Unit o variabili locali con lo stesso nome (ad es. var-name), specificare la variabile globale dell'apparecchio con _device.var-name.

Un'alternativa alle variabili globali dell'apparecchio è la dichiarazione di variabili Unit in una propria Unit che viene importata in altre Unit. Ciò presenta i seguenti vantaggi: 1. Possono essere utilizzate strutture delle variabili. 2. L'inizializzazione delle variabili durante il passaggio da STOP a RUN è possibile (tramite

programma in StartupTask). 3. Per le variabili Unit globali appena create è possibile anche un download nella modalità

RUN.

Vedere il Manuale di guida alle funzioni Funzioni di base SIMOTION.



5.2.3 Aree di memoria dei tipi di variabili I diversi tipi di variabili vengono memorizzati in aree di memoria differenti, che vengono inizializzate in momenti diversi. la tabella mostra:

● le aree di memoria disponibili per i tipi di variabili dichiarate nelle sorgenti ST (eventualmente in relazione alla versione del SIMOTION kernel),

● il momento di inizializzazione della relativa area di memoria.

Una spiegazione con un esempio è riportata nella sezione Esempio per settori di memoria (Pagina 234).

Tabella 5- 18 Le aree di memoria occupate da diversi tipi di variabili e la relativa inizializzazione

Settore di memoria Tipi di variabili assegnate Inizializzazione3 Memoria ritentiva Variabili Unit ritentive Durante il download in base alle impostazioni

per il download Memoria utente della Unit

• Variabili Unit non ritentive • Istanze dei blocchi funzionali dichiarate con

VAR_GLOBAL, incluse le variabili statiche ad esse associate (VAR, VAR_INPUT, VAR_OUTPUT)

Inoltre con l'opzione del compilatore (Pagina 58) "Crea dati di istanza del programma solo una volta": • Variabili locali del programma della Unit

dichiarate con VAR • Istanze dei blocchi funzionali dichiarate con

VAR all'interno del programma della Unit, incluse le variabili statiche corrispondenti (VAR, VAR_INPUT, VAR_OUTPUT)

• All'inserimento dell'apparecchio. • Durante il download in base alle

impostazioni per il download. • Nel passaggio allo stato operativo RUN:

– A partire dalla versione V4.2 del SIMOTION kernel:

Tramite impostazione sull'apparecchio SIMOTION, casella di controllo Inizializzazione delle variabili globali e dei dati di programma non ritentivi con transizione STOP-RUN:.

– A partire dalla versione V4.1 del SIMOTION kernel:

Se per ciascun blocco di dichiarazione è indicato il pragma successivo:

{ BlockInit_OnDeviceRun := ALWAYS; }

Vedere anche Gestione del compilatore tramite attributi (Pagina 304).

Memoria utente dei task

Con l'opzione del compilatore (Pagina 58) "Crea dati di istanza del programma solo una volta" (standard) disattivata: • Variabili locali dei programmi associati

dichiarate con VAR • Istanze dei blocchi funzionali dichiarate con

VAR all'interno dei programmi associati, incluse le variabili statiche ad esse associate (VAR, VAR_INPUT, VAR_OUTPUT)

In base al comportamento dei task durante l'esecuzione: • Task sequenziali:

Ad ogni avvio dei task • Task ciclici:

Nel passaggio allo stato operativo RUN.



Settore di memoria Tipi di variabili assegnate Inizializzazione3

• il riferimento (indicatore) del programma richiamato nel task

• Le variabili locali del programma richiamato nel task, dichiarate con VAR_TEMP

Ad ogni richiamo del programma nel task

• Riferimento (indicatore) delle istanze dei blocchi funzionali richiamate

• Variabili locali dei blocchi funzionali dichiarate con VAR_TEMP

• I parametri di passaggio dei blocchi funzionali dichiarati con VAR_IN_OUT1

Ad ogni richiamo dell'istanza del blocco funzionale.

Stack dati locali dei task2

• Variabili delle funzioni richiamate dichiarate con VAR, VAR_INPUT o VAR_IN_OUT1

• Valore di ritorno delle funzioni richiamate

Ad ogni richiamo della funzione

1 Riferimenti (indicatori) alle variabili trasferite. 2 Vedere anche Memoria necessaria per le variabili nello stack dati locali (Pagina 237). 3 Per una descrizione completa del comportamento di inizializzazione dei singoli tipi di variabili vedere Istante di inizializzazione delle variabili (Pagina 237).



5.2.3.1 Esempio per settori di memoria

Tabella 5- 19 Esempio per settori di memoria dei tipi di variabili - parte 1

INTERFACE

// Le istruzioni nella sezione interfaccia stabiliscono

// quali contenuti sorgente vengono esportati.

FUNCTION FC1;

FUNCTION_BLOCK FB1;

PROGRAM p1;

// Le variabili Unit della sezione interfaccia sono visibili sugli

// apparecchi HMI.

VAR_GLOBAL // Le variabili Unit non ritentive

// si trovano nella memoria utente della UNIT

u1_if : INT;

END_VAR

VAR_GLOBAL CONSTANT // Le costanti Unit si trovano

// nella memoria utente della UNIT

END_VAR

VAR_GLOBAL RETAIN // Le variabili Unit ritentive si trovano

// nella memoria ritentiva (protetta da un guasto alla rete)

END_VAR

END_INTERFACE

IMPLEMENTATION

// La sezione implementazione contiene in diverse

// unità organizzative di programma (POE) le sezioni di codice eseguibili

// Una POE può essere un programma, una FC oppure un FB.

// Le variabili Unit della sezione implementazione possono essere utilizzate solo

// all'interno della sorgente.

VAR_GLOBAL // Le variabili Unit non ritentive si trovano


u1_glob : INT;

END_VAR

VAR_GLOBAL CONSTANT // Le costanti Unit si trovano


END_VAR

VAR_GLOBAL RETAIN // Le variabili Unit ritentive si trovano

// nella memoria ritentiva (protetta da un guasto alla rete)

END_VAR

//----------------------------------------------------------------------




// Proseguimento esecuzione

//----------------------------------------------------------------------

FUNCTION_BLOCK FB1 // La dichiarazione di un'istanza

// di un blocco funzionale stabilisce dove si trovano i relativi dati:

// - come VAR_GLOBAL in una Unit:

// nella memoria utente della Unit

// - come VAR in un programma:

// per impostazione predefinita nella memoria utente del task

// - come VAR in un blocco funzionale:

// nella memoria utente della Unit o del task,

// in relazione alla dichiarazione di istanza dell'FB sovraordinato

// Al richiamo dell'istanza, un indicatore dei dati di istanza viene creato

// sullo stack del task richiamante

VAR_INPUT // Parametri di ingresso

// si trovano nella memoria utente,

// vengono scritti al richiamo dell'istanza

fb_in : INT;

END_VAR

VAR_OUTPUT // Parametri di uscita

// si trovano nella memoria utente

fb_out : INT;

END_VAR

VAR_IN_OUT // Parametri di passaggio.

// I riferimenti si trovano nella memoria utente,

// vengono scritti al richiamo dell'istanza

fb_in_out : INT;

END_VAR

VAR // Le variabili statiche

// si trovano nella memoria utente

// possono essere utilizzate localmente nell'FB

fb_var1 : INT;

END_VAR

VAR_TEMP // Le variabili temporanee

// si trovano sullo stack del task richiamante,

// vengono inizializzate a ogni richiamo

fb_temp1 : INT;

END_VAR

// Il codice si trova nella memoria applicativa della Unit.

fb_var1 := fb_var1 + 1;

fb_out := fb_var1;

fb_temp1 := fb_in_out;

fb_in_out := fb_temp1 + fb_in;

END_FUNCTION_BLOCK

//----------------------------------------------------------------------




// Proseguimento esecuzione

//----------------------------------------------------------------------

FUNCTION FC1 : INT // I dati della funzione si trovano nello

// stack del task richiamante; vengono inizializzati a ogni richiamo

// della funzione.

// Il valore di ritorno si trova sullo stack del task richiamante.

VAR_INPUT // Parametri di ingresso

// si trovano sullo stack del task richiamante,

// vengono scritti al richiamo della funzione

fc_in : INT;

END_VAR

VAR // Le variabili temporanee

// si trovano sullo stack del task richiamante

fc_var : INT;

END_VAR

// Il codice si trova nella memoria utente della Unit.

fc_var := 567;

fc1 := fc_in + fc_var;

END_FUNCTION

PROGRAM p1

VAR // Le variabili si trovano per impostazione predefinita

// nella memoria utente del task

p_var : INT;

p_varFB : FB1;

END_VAR

VAR_TEMP // Le variabili temporanee

// si trovano sullo stack del task,

// vengono inizializzati a ogni esecuzione del task

p_temp : INT;

END_VAR

// Il codice si trova nella memoria utente della Unit.

p_temp := p_var;

p_varFB (fb_in_out := p_temp);

u1_glob := 4711;

END_PROGRAM

END_IMPLEMENTATION



5.2.3.2 Memoria necessaria per le variabili nello stack dati locali Le variabili che vengono memorizzate nello stack dati locali di un task sono elencate in Aree di memoria dei tipi di variabili (Pagina 232). Le dimensioni dello stack per ogni task vengono impostate nella scheda Configurazione task. A tale scopo vedere Descrizione per ogni task utente nel Manuale di guida alle funzioni Funzioni base.

Per i requisiti di memoria sullo stack dei dati locali, attenersi alle seguenti informazioni:

● Le variabili locali temporanee richiedono solo uno spazio sullo stack corrispondente alle proprie dimensioni.

● Le variabili globali e le variabili statiche locali non richiedono risorse dello stack.

Solo quando vengono utilizzate come parametro di ingresso di una funzione, le variabili globali richiedono dimensioni di dati semplici sullo stack.

● Anche se la funzione viene richiamata più volte in un task, lo stack viene sollecitato un'unica volta.

● Le variabili di tipo BOOL necessitano di 1 byte sullo stack.

Per informazioni sui requisiti di memoria di un'unità di organizzazione programma (POE) sullo stack dei dati locali, utilizzare la funzione Struttura del programma (Pagina 296).

5.2.4 Istante di inizializzazione delle variabili Il momento dell'inizializzazione delle variabili viene determinato:

● tramite l'area di memoria al quale è assegnata la variabile,

● tramite determinate operazioni (ad es. con il download della sorgente nel sistema di destinazione)

● tramite il comportamento del task (sequenziale, ciclico) al quale è il programma è stato assegnato.

Tutti i tipi di variabili e l'istante di inizializzazione corrispondente sono illustrati nelle seguenti tabelle. Informazioni base sui task sono disponibili nel Manuale di guida alle funzioni Funzioni di base SIMOTION.



Il comportamento relativo all'inizializzazione delle variabili durante il download può essere impostato: selezionare la preimpostazione del menu Strumenti > Impostazioni e la scheda Download, oppure definire l'impostazione durante il download attuale.

Nota

I valori delle variabili Unit o delle variabili globali dell'apparecchio possono essere caricati dall'apparecchio SIMOTION in SIMOTION SCOUT (upload) e salvati nel formato XML. 1. Salvare con la funzione _saveUnitDataSet i segmenti dati delle variabili Unit desiderati o

delle variabili globali dell'apparecchio come blocco dati. 2. In SIMOTION SCOUT applicare la funzione Salva variabili.

Con la funzione inversa Ripristina variabili questi blocchi di dati e queste variabili possono essere ricaricati/e nell'apparecchio SIMOTION (download).

Per ulteriori informazioni consultare il Manuale di progettazione di SIMOTION SCOUT.

Questa procedura consente di mantenere i dati anche se sono stati inizializzati o sono divenuti inservibili a causa di un download del progetto (ad es. durante il cambio della versione di SIMOTION SCOUT).

5.2.4.1 Inizializzazione delle variabili globali ritentive In caso di caduta di tensione, le variabili ritentive conservano l'ultimo valore assegnato. Tutti gli altri dati vengono nuovamente inizializzati al riavvio.

Le variabili globali ritentive vengono inizializzate:

● se viene a mancare il supporto o in caso di bufferizzazione dei dati ritentivi.

● in caso di update del firmware.

● in caso di cancellazione totale (MRES).

● con la funzione Riavvio (Del. SRAM) per SIMOTION P320 o P350.

● se si utilizza la funzione _resetUnitData, possibile selettivamente per vari segmenti dei dati ritentivi.

● con il download conformemente alla descrizione seguente.



Comportamento in caso di download

Tabella 5- 22 Inizializzazione delle variabili globali ritentive con il download

Tipo di variabile Istante di inizializzazione delle variabili Variabili globali dell'apparecchio ritentive

Il comportamento in fase di download dipende dall'impostazione Inizializzazione dei dati di programma ritentivi e delle variabili globali dell'apparecchio ritentive1: • Sì2: Le variabili globali ritentive dell'apparecchio vengono inizializzate. • No3: Le variabili globali dell'apparecchio ritentive vengono installate solo se la loro

identificazione di versione è stata modificata. Vedere: Identificazione della versione delle variabili globali e relativa inizializzazione in fase di download (Pagina 247).

Variabili Unit ritentive Il comportamento in fase di download dipende dall'impostazione Inizializzazione dei dati di programma ritentivi e delle variabili globali dell'apparecchio ritentive1: • Sì2: Vengono inizializzate tutte le variabili Unit ritentive (di tutte le unit). • No3: Un blocco dati ( = blocco di dichiarazione)4 delle variabili Unit ritentive nella sezione

interfaccia o implementazione viene inizializzata5 soltanto se la sua identificazione di versione è stata modificata.

Vedere: Identificazione della versione delle variabili globali e relativa inizializzazione in fase di download (Pagina 247).

1 Preimpostazione nel menu Strumenti > Impostazioni, scheda Download, oppure impostazione attuale durante il download. 2 La casella di controllo corrispondente è attiva. 3 La casella di controllo corrispondente non è attiva. 4 Con il linguaggio di programmazione SIMOTION ST: un blocco dati delle variabili Unit ritentive corrisponde ad un blocco di dichiarazione VAR_GLOBAL RETAIN / END_VAR nella sezione interfaccia o implementazione. Con i linguaggi di programmazione SIMOTION MCC e SIMOTION KOP/FUP: un blocco dati di variabili Unit ritentive viene conseguentemente creato con le variabili dichiarate con VAR_GLOBAL RETAIN nella sezione interfaccia o implementazione della tabella di dichiarazione: Le righe pragma dividono all'interno di una sezione della tabella di dichiarazione le variabili in vari blocchi dati. 5 L'inizializzazione di un blocco dati modificato avviene anche durante il download nello stato RUN purché sia soddisfatto il seguente presupposto: Con il linguaggio di programmazione SIMOTION ST Indicare nel rispettivo blocco di dichiarazione all'interno di un pragma il seguente attributo: { BlockInit_OnChange := TRUE; }. Con i linguaggi di programmazione SIMOTION MCC o SIMOTION KOP/FUP: nella tabella di dichiarazione è inserita una riga pragma per la quale è attiva la seguente casella di controllo: Inizializzazione VAR_GLOBAL RETAIN in caso di modifica. Tutte le variabili dichiarate con VAR_GLOBAL RETAIN fino alla seguente riga pragma o alla fine della tabella costituiscono un corrispondente blocco dati. Per i presupposti generali per un download nello stato RUN, vedere Manuale di guida alle funzioni Funzioni di base SIMOTION.



5.2.4.2 Inizializzazione delle variabili globali non ritentive Le variabili globali non ritentive perdono il loro valore in caso di caduta di tensione. Queste variabili vengono inizializzate:

● in fase di inizializzazione delle variabili globali (Pagina 238), ad es. in caso di update del firmware o in caso di cancellazione totale (MRES).

● all'attivazione.

● se si utilizza la funzione _resetUnitData,possibile selettivamente per vari segmenti dei dati non ritentivi.

● durante il download in base alla descrizione nella seguente tabella

● Durante la transizione dallo stato operativo STOP allo stato operativo RUN in base alla descrizione alla fine della sezione.



Comportamento in fase di download

Tabella 5- 23 Inizializzazione delle variabili globali non ritentive con il download

Tipo di variabile Istante di inizializzazione delle variabili Variabili globali dell'apparecchio non ritentive

Il comportamento in fase di download dipende dall'impostazione Inizializzazione dei dati di programma non ritentivi e delle variabili globali dell'apparecchio non ritentive1: • Sì2: Vengono inizializzate tutte le variabili globali dell'apparecchio non ritentive. • No3: Le variabili globali dell'apparecchio non ritentive vengono installate solo se la loro

identificazione di versione è stata modificata. Vedere: Identificazione della versione delle variabili globali e relativa inizializzazione in fase di download (Pagina 247).

Variabili Unit non ritentive

Il comportamento in fase di download dipende dall'impostazione Inizializzazione dei dati di programma non ritentivi e delle variabili globali dell'apparecchio non ritentive1: • Sì2: Vengono inizializzate tutte le variabili Unit non ritentive (di tutte le unit). • No3: Un blocco dati ( = blocco di dichiarazione)4 delle variabili Unit non ritentive nella sezione

interfaccia o implementazione viene inizializzata5 soltanto se la sua identificazione di versione è stata modificata.

Vedere: Identificazione della versione delle variabili globali e relativa inizializzazione in fase di download (Pagina 247).

1 Preimpostazione nel menu Strumenti > Impostazioni, scheda Download, oppure impostazione attuale durante il download. 2 La casella di controllo corrispondente è attiva. 3 La casella di controllo corrispondente non è attiva. 4 Con il linguaggio di programmazione SIMOTION ST: un blocco dati delle variabili Unit non ritentive corrisponde ad un blocco di dichiarazione VAR_GLOBAL / END_VAR nella sezione interfaccia o implementazione. Con i linguaggi di programmazione SIMOTION MCC o SIMOTION KOP/FUP: un blocco dati di variabili Unit non ritentive viene conseguentemente creato con le variabili dichiarate con VAR_GLOBAL nella sezione interfaccia o implementazione della tabella di dichiarazione: Le righe pragma dividono all'interno di una sezione della tabella di dichiarazione le variabili in vari blocchi dati. 5 L'inizializzazione di un blocco dati modificato avviene anche durante il download nello stato RUN purché sia soddisfatto il seguente presupposto: Con il linguaggio di programmazione SIMOTION ST Indicare nel rispettivo blocco di dichiarazione all'interno di un pragma il seguente attributo: { BlockInit_OnChange := TRUE; }. Con i linguaggi di programmazione SIMOTION MCC o SIMOTION KOP/FUP: nella tabella di dichiarazione è inserita una riga pragma per la quale è attiva la seguente casella di controllo: Inizializzazione VAR_GLOBAL in caso di modifica. Tutte le variabili dichiarate con VAR_GLOBAL fino alla seguente riga pragma o alla fine della tabella costituiscono un corrispondente blocco dati. Per i presupposti generali per un download nello stato RUN, vedere Manuale di guida alle funzioni Funzioni di base SIMOTION.



Comportamento con transizione STOP-RUN Di solito i valori delle variabili globali non ritentive durante la transizione dallo stato operativo STOP allo stato operativo RUN vengono mantenuti.

È comunque possibile impostare l'inizializzazione delle variabili globali non ritentive durante la transizione STOP-RUN:

● A partire dalla versione V4.2 del SIMOTION kernel tramite impostazione sull'apparecchio SIMOTION (Pagina 309), casella di controllo Inizializzazione delle variabili globali e dei dati di programma non ritentivi con transizione STOP-RUN.

Questa impostazione può essere sovrascritta con variabili Unit non ritentive tramite un pragma o una riga pragma nei rispettivi blocchi dati delle sorgenti di programma.

● Dalla versione V4.1 del SIMOTION kernel mediante un pragma o una riga pragma nei corrispondenti blocchi dati delle sorgenti di programma (solo per variabili Unit non ritentive):

– Con linguaggio di programmazione SIMOTION ST:

nel corrispondente blocco di dichiarazione VAR_GLOBAL / END_VAR è indicato all'interno di un pragma il seguenteattributo: { BlockInit_OnDeviceRun := ALWAYS; }

– con i linguaggi di programmazione SIMOTION MCC o SIMOTION KOP/FUP:

nella tabella di dichiarazione è inserita una riga pragma con la seguente impostazione: "Inizializzazione con di transizione STOP-RUN = Sempre". Tutte le variabili dichiarate con VAR_GLOBAL formano un blocco dati fino alla seguente riga pragma o alla fine della tabella, inizializzato con la transizione STOP-RUN.

Nota

Per apparecchi SIMOTION fino a V4.0 del SIMOTION kernel le variabili globali non ritentive non vengono mai inizializzate con transizione STOP-RUN.



5.2.4.3 Inizializzazione delle variabili locali Le variabili locali vengono inizializzate:

● durante l'inizializzazione delle variabili Unit ritentive (Pagina 238)

● durante l'inizializzazione delle variabili Unit non ritentive (Pagina 240)

● e inoltre, conformemente alla descrizione seguente:

Tabella 5- 24 Inizializzazione delle variabili locali

Tipo di variabile Istante di inizializzazione delle variabili Variabili locali dei programmi

Le variabili locali dei programmi vengono inizializzate in diversi modi: • Le variabili statiche (VAR) vengono inizializzate in base al settore di memoria in cui vengono

memorizzate.

Vedere: Inizializzazione variabili statiche dei programmi (Pagina 244). • Le variabili temporanee (VAR_TEMP) vengono inizializzate durante ogni richiamo del

programma nel task.

Variabili locali dei blocchi funzionali (FB)

Le variabili locali dei blocchi funzionali vengono inizializzate in diversi modi: • Le variabili statiche (VAR, VAR_IN, VAR_OUT) vengono inizializzate solo quando viene

inizializzata l'istanza dell'FB.

Vedere: Inizializzazione delle istanze dei blocchi funzionali (FB) (Pagina 245). • Le variabili temporanee (VAR_TEMP) vengono inizializzate durante ogni richiamo dell'istanza

dell'FB.

Variabili locali delle funzioni (FC)

Le variabili locali delle funzioni sono temporanee e vengono inizializzate durante ogni richiamo della funzione.

Nota




5.2.4.4 Inizializzazione variabili statiche dei programmi Le seguenti esecuzioni riguardano le seguenti variabili statiche:

● Variabili locali del programma di una Unit dichiarate con VAR,

● Istanze dei blocchi funzionali dichiarate con VAR all'interno del programma di una Unit, incluse le variabili statiche corrispondenti (VAR, VAR_INPUT, VAR_OUTPUT)

Il comportamento di inizializzazione viene determinato dall'area di memoria in cui le variabili statiche vengono create. Tale comportamento viene determinato dall'opzione compilatore (Pagina 58) "Crea dati di istanza del programma solo una volta".

● Con l'opzione del compilatore "Crea dati di istanza del programma solo una volta" (standard) non attivata:

Le variabili statiche vengono create nella memoria utente di ciascun task cui il programma è assegnato.

L'inizializzazione delle variabili dipende dal comportamento durante l'esecuzione del task al quale è assegnato il programma (vedere Manuale di guida alle funzioni Funzioni di base SIMOTION):

– Task sequenziali (MotionTasks, UserInterruptTasks, SystemInterruptTasks, StartupTask, ShutdownTask): Le variabili statiche vengono inizializzate ad ogni avvio del task.

– Task ciclici (BackgroundTask, SynchronousTasks, TimerInterruptTasks): Le variabili statiche vengono inizializzate solo con transizione dallo stato operativo STOP allo stato operativo RUN.



● Con l'opzione compilatore "Crea dati di istanza del programma solo una volta" attivata:

Questa impostazione è necessaria, ad esempio, se all'interno di un programma deve essere richiamato un altro programma.

Le variabili statiche di tutti i programmi della sorgente di programma (Unit) in questione vengono memorizzate una sola volta nella memoria utente della Unit.

Queste vengono perciò inizializzate insieme alle variabili Unit non ritentive; vedere Inizializzazione delle variabili globali non ritentive (Pagina 240).

Di solito con transizione dallo stato operativo STOP allo stato operativo RUN non vengono inizializzate. È comunque possibile impostare che esse vengano inizializzate con transizione STOP-RUN:

– A partire dalla versione V4.2 del SIMOTION Kernel tramite impostazione sull'apparecchio SIMOTION (Pagina 309), casella di controllo Inizializzazione delle variabili globali e dei dati di programma non ritentivi con transizione STOP-RUN.

Questa impostazione può essere sovrascritta con un pragma o una riga pragma nel blocco dati della corrispondente unità di organizzazione del programma (POE).

– Dalla versione V4.1 del SIMOTION Kernel mediante un pragma o una riga pragma nel blocco dati della corrispondente unità di organizzazione del programma (POE):

con linguaggio di programmazione SIMOTION ST: nel blocco di dichiarazione VAR / END_VAR è indicato all'interno di un pragma il seguenteattributo: { BlockInit_OnDeviceRun := ALWAYS; }

Con i linguaggi di programmazioneSIMOTION MCC o SIMOTION KOP/FUP: la tabella di dichiarazione inizia con una riga pragma con la seguente impostazione: "Inizializzazione con di transizione STOP-RUN = Sempre". Tutte le variabili dichiarate con VAR nella tabella vengono inizializzate con transizione STOP-RUN.

5.2.4.5 Inizializzazione delle istanze dei blocchi funzionali (FB) L'inizializzazione di un'istanza di un blocco funzionale (Pagina 188) viene determinata dal punto in cui è stata dichiarata:

● dichiarazione globale (all'interno di VAR_GLOBAL / END_VAR nella sezione interfaccia o implementazione):

Inizializzazione come variabile Unit non ritentiva, vedere Inizializzazione delle variabili globali non ritentive (Pagina 240).

● Dichiarazione locale in un programma (all'interno di VAR / END_VAR):

Inizializzazione come variabile statica dei programmi, vedere Inizializzazione variabili statiche dei programmi (Pagina 244).

● Dichiarazione locale in un blocco funzionale (all'interno di VAR / END_VAR):

Inizializzazione come un'istanza di questo blocco funzionale.

● Dichiarazione come parametro di passaggio in un blocco funzionale o in una funzione (all'interno di VAR_IN_OUT / END_VAR):

Durante l'inizializzazione del POE viene inizializzato solo il riferimento (indicatore), mentre l'istanza del blocco funzionale rimane invariata.



Nota


5.2.4.6 Inizializzazione delle variabili di sistema degli oggetti tecnologici Le variabili di sistema di un oggetto tecnologico sono generalmente non ritentive. In relazione all'oggetto tecnologico vengono memorizzate poche variabili di sistema nell'area di memoria ritentiva (ad es. taratura encoder valore assoluto).

Il comportamento di inizializzazione corrisponde (tranne che per il download) a quello delle variabili globali ritentive e non ritentive. Vedere Inizializzazione delle variabili globali ritentive (Pagina 238) e Inizializzazione delle variabili globali non ritentive (Pagina 240).

Il comportamento in caso di download viene rappresentato come segue per:

● Variabili di sistema non ritentive

● Variabili di sistema ritentive

Tabella 5- 25 Inizializzazione delle variabili di sistema degli oggetti tecnologici in fase di download

Tipo di variabile Istante di inizializzazione delle variabili Variabili di sistema non ritentive

Comportamento in fase di download, in funzione dell'impostazione Inizializzazione di tutti i dati non ritentivi degli oggetti tecnologici1: • Sì2: Vengono inizializzati tutti gli oggetti tecnologici.

– Vengono ricreati tutti gli oggetti tecnologici e vengono inizializzate tutte le variabili di sistema non ritentive.

– Vengono cancellati tutti gli allarmi tecnologici. • No3: Vengono inizializzati solo gli oggetti tecnologici modificati in SIMOTION SCOUT.

– Gli oggetti tecnologici in questione vengono ricreati e vengono inizializzate tutte le variabili di sistema non ritentive.

– Vengono cancellati tutti gli allarmi presenti negli oggetti tecnologici in questione. – Se in un oggetto tecnologico che non deve essere inizializzato è presente un allarme che

non può essere tacitato con Power On, il download viene interrotto.

Variabili di sistema ritentive

Solo se un oggetto tecnologico è stato modificato nel SIMOTION SCOUT, le variabili di sistema ritentive ad esso relative vengono inizializzate. Le variabili di sistema ritentive di tutti gli altri oggetti tecnologici vengono mantenute (ad es. taratura encoder valore assoluto)

1 Preimpostazione nel menu Strumenti > Impostazioni, scheda Download, oppure impostazione attuale durante il download. 2 La casella di controllo corrispondente è attiva. 3 La casella di controllo corrispondente non è attiva.



5.2.4.7 Identificazione della versione delle variabili globali e relativa inizializzazione in fase di download.

Tabella 5- 26 Identificazione della versione delle variabili globali e relativa inizializzazione in fase di download.

Segmento dati Descrizione dell'identificazione di versione. Variabili globali d'apparecchio

Variabili globali dell'apparecchio ritentive

Variabili globali dell'apparecchio non ritentive

• Identificazione versione propria per ogni segmento dati delle variabili globali dell'apparecchio

• L'identificazione della versione di un segmento dati varia con: – L'aggiunta o l'eliminazione di una variabile all'interno del segmento dati – La modifica dell'identificatore o del tipo di dati di una variabile all'interno del

segmento dati • Nessuna modifica di tale identificazione della versione con:

– Modifiche in altri segmenti dati – Modifica dei valori di inizializzazione1

• Per il download2 vale: Solo se l'identificazione di versione di un segmento dati è stata modificata, questo segmento dati viene inizializzato

Variabili Unit di una unit Variabili Unit ritentive nella sezione interfaccia Variabili Unit ritentive nella sezione implementazione Variabili Unit non ritentive nella sezione interfaccia

Variabili Unit non ritentive nella sezione implementazione

• Più blocchi dati ( = blocchi di dichiarazione)3 possibili in ogni segmento dati • Identificazione versione propria per ciascun blocco dati • L'identificazione della versione di un blocco dati varia con:

– L'aggiunta o l'eliminazione di una variabile nel blocco di dichiarazione interessato – Modifica della sequenza della variabili nel blocco di dichiarazione corrispondente – La modifica dell'identificatore o del tipo di dati di una variabile nel blocco di

dichiarazione interessato – La modifica di una definizione del tipo di dati (da una Unit propria o importata 4)

utilizzata nel blocco di dichiarazione interessato – L'aggiunta o l'eliminazione di blocchi di dichiarazione all'interno dello stesso

segmento dati prima del blocco di dichiarazione interessato • Nessuna modifica di tale identificazione della versione con:

– L'aggiunta o l'eliminazione di blocchi di dichiarazione in altri segmenti dati – L'aggiunta o l'eliminazione di blocchi di dichiarazione all'interno dello stesso

segmento dati dopo il blocco di dichiarazione interessato – Modifiche in altri blocchi di dichiarazioni – Modifica dei valori di inizializzazione1 – Modifiche delle definizioni del tipo di dati non utilizzate nel blocco delle definizioni

interessato – Modifica delle funzioni

• Per il download2 vale: Solo se l'identificazione di versione di un blocco dati è stata modificata, questo blocco dati viene inizializzato5

• Le funzioni per il salvataggio e l'inizializzazione dei dati tengono in considerazione l'identificazione della versione dei blocchi dati



Segmento dati Descrizione dell'identificazione di versione. 1 I valori di inizializzazione modificati diventano efficaci soltanto dopo che è stato inizializzato il relativo blocco o segmento dati. 2 Con l'impostazione Inizializzazione dei dati di programma ritentivi e delle variabili globali dell'apparecchio ritentive = No e Inizializzazione dei dati di programma non ritentivi e delle variabili globali dell'apparecchio non ritentive = No. Con altre impostazioni: Vedere le sezioni "Inizializzazione delle variabili globali ritentive (Pagina 238)" o "Inizializzazione delle variabili globali non ritentive (Pagina 240)". 3 Con il linguaggio di programmazione SIMOTION ST: un blocco dati corrisponde ad un blocco di dichiarazione VAR_GLOBAL / END_VAR o VAR_GLOBAL RETAIN / END_VAR nella sezione interfaccia o implementazione. Con i linguaggi di programmazione SIMOTION MCC o SIMOTION KOP/FUP: un blocco dati di variabili Unit non ritentive viene creato con le variabili dichiarate con VAR_GLOBAL o VAR_GLOBAL RETAIN nella sezione interfaccia o implementazione della tabella di dichiarazione: Le righe pragma dividono all'interno di una sezione della tabella di dichiarazione le variabili in vari blocchi dati. 4 L'importazione di Unit dipende dal linguaggio di programmazione; vedere la sezione corrispondente (Pagina 217). 5 L'inizializzazione di un blocco dati modificato avviene anche durante il download nello stato RUN purché sia soddisfatto il seguente presupposto: Con il linguaggio di programmazione SIMOTION ST Indicare nel rispettivo blocco di dichiarazione all'interno di un pragma (Pagina 299) il seguente attributo (Pagina 304): { BlockInit_OnChange := TRUE; }. Con i linguaggi di programmazione SIMOTION MCC o SIMOTION KOP/FUP: nella tabella di dichiarazione è inserita una riga pragma per la quale è attiva la seguente casella di controllo: Inizializzazione VAR_GLOBAL in caso di modifica. Tutte le variabili dichiarate con VAR_GLOBAL fino alla seguente riga pragma o alla fine della tabella costituiscono un corrispondente blocco dati. Per i presupposti generali per un download nello stato RUN, vedere Manuale di guida alle funzioni Funzioni di base SIMOTION.

5.2.5 Variabili e apparecchi HMI Le seguenti variabili vengono esportate sugli apparecchi HMI e sono disponibili su di essi:

● Variabili di sistema dell'apparecchio SIMOTION

● Variabili di sistema degli oggetti tecnologici

● Variabili I/O

● Variabili globali d'apparecchio

● Variabili Unit ritentive e non ritentive della sezione interfaccia (preimpostazione).

Modificare la preimpostazione nel modo seguente:

– Nel linguaggio di programmazione SIMOTION ST:

per ogni blocco di dichiarazione con il seguente pragma: { HMI_Export := FALSE; }.


– Nei linguaggi di programmazioneSIMOTION MCC e SIMOTION KOP/FUP:

per le dichiarazioni di variabili, che seguono la riga pragma, disattivare in questa riga pragma i parametri VAR_GLOBAL per gli apparecchi HMI o VAR_GLOBAL RETAIN per gli apparecchi HMI.

Le variabili Unit di un tale blocco dati non vengono esportate sugli apparecchi HMI. Al download viene inoltre omessa per gli apparecchi la verifica di coerenza HMI.



Le seguenti variabili non vengono esportate su apparecchi HMI e non sono quindi su di essi disponibili:

● Variabili Unit ritentive e non ritentive della sezione implementazione (preimpostazione)

Modificare la preimpostazione nel modo seguente:

– Nel linguaggio di programmazione SIMOTION ST:

per ogni blocco di dichiarazione con il seguente pragma: { HMI_Export := TRUE; }


– Nei linguaggi di programmazioneSIMOTION MCC e SIMOTION KOP/FUP:

per le dichiarazioni di variabili, che seguono la riga pragma, attivare in questa riga pragma i parametri VAR_GLOBAL per gli apparecchi HMI o VAR_GLOBAL RETAIN per gli apparecchi HMI.

Le variabili Unit di un tale blocco dati vengono esportate sugli apparecchi HMI. Al download gli apparecchi vengono perciò sottoposti alla verifica di coerenza HMI.

● Variabili locali di una POE

ATTENZIONE La dimensione totale delle variabili Unit che possono essere esportate sugli apparecchi HMI è limitata a 64 kByte per Unit.

L'effetto del pragma { HMI_Export := FALSE; } /{ HMI_Export := TRUE; } (o delle impostazioni VAR_GLOBAL per gli apparecchi HMI o VAR_GLOBAL RETAIN per gli apparecchi HMI in una riga pragma) dipende dalla versione del SIMOTION kernel: • A partire dalla versione V4.1 del SIMOTION kernel:

Il pragma ha effetto sull'esportazione del blocco di dichiarazione corrispondente agli apparecchi HMI e alla struttura dell'area indirizzi HMI: – L'area indirizzi HMI viene occupata solo dalle variabili dei blocchi di dichiarazione

esportate agli apparecchi HMI. – All'interno dell'area indirizzi HMI le variabili sono ordinate in base alla rispettiva

sequenza di dichiarazione. • fino alla versione V4.0 del SIMOTION kernel:

Il pragma ha effetto solo sull'esportazione del blocco di dichiarazione corrispondente agli apparecchi HMI. L'area di memoria HMI viene occupata anche dalle variabili Unit della sezione interfaccia con blocchi di dichiarazione non esportati agli apparecchi HMI. Le variabili all'interno dell'area indirizzi HMI vengono ordinate nella seguente sequenza: – Variabili Unit ritentive della sezione interfaccia (esportate e non esportate) – Variabili Unit ritentive della sezione implementazione (solo esportate) – Variabili Unit non ritentive della sezione interfaccia (esportate e non esportate) – Variabili Unit non ritentive della sezione implementazione (solo esportate) All'interno di questi segmenti le variabili sono ordinate in base alla rispettiva sequenza di dichiarazione.



Esempio di linguaggio di programmazione SIMOTION ST

Tabella 5- 27 Esempio di controllo dell'esportazione HMI con il pragma corrispondente

INTERFACE

VAR_GLOBAL

// Esportazione HMI

x1 : DINT;

END_VAR

VAR_GLOBAL

{ HMI_Export := FALSE; }

// Nessuna esportazione HMI

x2 : DINT;

END_VAR

// ...

END_INTERFACE

IMPLEMENTATION

VAR_GLOBAL

// Nessuna esportazione HMI

y1 : DINT;

END_VAR

VAR_GLOBAL

{ HMI_Export := TRUE; }

// Esportazione HMI

y2 : DINT;

END_VAR

// ...

END_IMPLEMENTATION

Implementazione di ST in SIMOTION 5.3 Accesso agli ingressi e alle uscite (immagine di processo, variabili I/O)


5.3 Accesso agli ingressi e alle uscite (immagine di processo, variabili I/O)

5.3.1 Panoramica dell'accesso a ingressi e uscite SIMOTION offre diverse opzioni per accedere agli ingressi e alle uscite dell'apparecchio SIMOTION e alla periferia centralizzata e decentrata:

● tramite accesso diretto con le variabili I/O

Con l'accesso diretto si accede direttamente all'indirizzo I/O corrispondente.

Si definisce una variabile I/O (nome e indirizzo I/O) senza assegnarle un task. È utilizzabile l'intera area indirizzi dell'apparecchio SIMOTION.

Utilizzare l'accesso diretto preferibilmente con la programmazione sequenziale (in MotionTasks); qui è particolarmente importante l'accesso al valore corrente di ingressi e uscite in un determinato istante.

Per maggiori informazioni vedere: Accesso diretto e immagine di processo dei task ciclici (Pagina 256).

● tramite l'immagine di processo dei task ciclici con le variabili I/O

L'immagine di processo dei task ciclici è un settore della memoria RAM dell'apparecchio SIMOTION in cui è riprodotta l'intera area di indirizzamento dell'apparecchio SIMOTION. L'immagine speculare di ciascun indirizzo I/O è assegnata a un task ciclico e viene aggiornata con lo stesso. È coerente durante l'intero ciclo del task. Questa immagine di processo viene utilizzata preferibilmente nella programmazione del task assegnato (programmazione ciclica).

Si definisce una variabile I/O (nome e indirizzo I/O) e le si assegna un task. È utilizzabile l'intera area indirizzi dell'apparecchio SIMOTION.

È comunque possibile effettuare l'accesso diretto a questa variabile I/O: specificare l'accesso diretto con _direct.var-name.

Per maggiori informazioni vedere: Accesso diretto e immagine di processo dei task ciclici (Pagina 256).

● tramite l'immagine di processo fissa del BackgroundTask

L'immagine di processo di BackgroundTask è un settore della memoria nella RAM dell'apparecchio SIMOTION in cui è riprodotto un sottoinsieme dell'area di indirizzamento I/O dell'apparecchio SIMOTION. Questa immagine speculare viene aggiornata con BackgroundTask ed è coerente durante tutto il ciclo relativo. Questa immagine di processo viene impiegata di preferenza nel caso di programmazione di BackgroundTask (programmazione ciclica).

È utilizzabile l'intervallo indirizzi 0 .. 63. Sono esclusi gli indirizzi I/O a cui si accede con l'immagine di processo dei task ciclici.

Per maggiori informazioni vedere: Accesso all'immagine di processo dei BackgroundTask (Pagina 267).



Per un confronto tra le proprietà più importanti vedere "Proprietà importanti dell'accesso diretto e dell'immagine di processo (Pagina 252)".

È possibile utilizzare le variabili I/O come qualsiasi altra variabile, vedere "Accesso alle variabili I/O (Pagina 279)".

Nota

l'accesso mediante l'immagine di processo ha migliori prestazioni dell'accesso diretto.

5.3.2 Proprietà importanti dell'accesso diretto e dell'immagine di processo

Tabella 5- 28 Proprietà importanti dell'accesso diretto e dell'immagine di processo

Accesso diretto Accesso all'immagine di processo dei task ciclici

Accesso all'immagine di processo fissa dei BackgroundTask

Area indirizzi ammessa

Area indirizzi complessiva dell'apparecchio SIMOTION. Eccezione: le variabili di I/O che comprendono più byte non possono contenere gli indirizzi 63 e 64 contigui ( PIW63 o PQD62 non sono consentiti).

0 .. 63. Eccezione fino alla versione V4.1 del SIMOTION Kernel o impostazione "Immagine di processo separata": indirizzi utilizzati nell'immagine di processo dei task ciclici.

Progettazione degli indirizzi

Necessaria. Gli indirizzi utilizzati devono esistere nella periferia ed essere opportunamente progettati.

Non necessaria. Possono essere utilizzati anche indirizzi non esistenti nella periferia o non progettati.

Task assegnati Nessuno. Task ciclici selezionabili: • SynchronousTasks, • TimerInterruptTasks, • BackgroundTask.

BackgroundTask.

Settore di memoria delle immagini di processo

- A seconda della versione del SIMOTION Kernel: • Fino alla versione V.4.1:

Settore di memoria sempre separate. • A partire dalla versione V4.2:

Settore di memoria comune selezionabile.





Aggiornamento • Nella periferia onboard degli apparecchi SIMOTION C230-2, C240 e C240 PN:

L'aggiornamento avviene in un unico clock di 125 µs.

• Nella periferia tramite PROFIBUS DP o PROFINET sincroni al clock, tramite DRIVE-CLiQ nonché nella periferia onboard degli apparecchi SIMOTION D:

L'aggiornamento avviene nel clock del regolatore di posizione1.

• Nella periferia tramite PROFIBUS DP o PROFINET non sincroni al clock e tramite P-Bus:

L'aggiornamento avviene nel clock dell'interpolatore1.

Gli ingressi vengono letti all'inizio del clock. Le uscite vengono scritte alla fine del clock.

L'aggiornamento avviene con il task assegnato: • Gli ingressi vengono letti

prima dell'avvio del task assegnato e trasferiti nell'immagine di processo degli ingressi.

• L'immagine di processo delle uscite viene scritta sulle uscite dopo la chiusura del task assegnato.

L'aggiornamento avviene con BackgroundTask: • Gli ingressi vengono letti

prima dell'avvio di BackgroundTask e trasferiti nell'immagine di processo degli ingressi.

• L'immagine di processo delle uscite viene scritta dopo la chiusura di BackgroundTask.

– durante l'intero ciclo del task assegnato. Eccezione: accesso diretto all'uscita.

Coerenza

La coerenza è garantita solo per i tipi di dati elementari. Se vengono utilizzati degli array, l'utente deve verificare autonomamente la coerenza dei dati.

durante l'intero ciclo del BackgroundTask. Eccezione: accesso diretto all'uscita.

Utilizzo Prevalentemente nei MotionTask

Prevalentemente nel task assegnato

Prevalentemente nel BackgroundTask

Dichiarazione come variabile

Necessaria, globale per l'apparecchio come variabile I/O nel browser dei simboli. Ciascun byte di un'area indirizzi può essere assegnato a un'unica variabile I/O. Sintassi dell'indirizzo I/O: ad es. PIW1022, PQ63.3.

possibile, non necessaria: • globale per l'apparecchio

come variabile I/O nel browser dei simboli,

• Come variabile Unit, • Come variabile statica

locale in un programma.





Download di una variabile I/O nuova o modificata

Possibile solo nello stato operativo STOP. -

Utilizzo dell'indirizzo assoluto

Non possibile. Possibile, con la seguente sintassi: ad es. %IW62, %Q63.3.

Disposizione byte durante la creazione dell'immagine di processo

- Come fornita dalla periferia. A seconda della versione del SIMOTION Kernel e dell'impostazione del settore di memoria delle immagini di processo: • Fino alla versione V.4.1 o

impostazione "Immagine di processo separata":

Sempre Big Endian. • A partire dalla versione

V.4.2 e impostazione "Immagine di processo comune":

Come fornita dalla periferia.

Disposizione byte durante l'accesso

A seconda della periferia Sempre Big Endian

Descrivibilità degli ingressi

No. A seconda della versione del SIMOTION Kernel: • Fino alla versione V.4.1:

No. • A partire dalla versione

V4.2:

Sì.

Sì.

Protezione in scrittura per uscite

possibile; è selezionabile lo stato Sola lettura.

Non possibile. Non possibile.

Dichiarazione di array Possibile. Non possibile. Maggiori informazioni Accesso diretto e immagine di processo dei task ciclici

(Pagina 256). Accesso all'immagine di processo dei BackgroundTask (Pagina 267).





Errore in fase di formazione dell'immagine di processo, reazione selezionabile: • Stop CPU3 • Valore sostitutivo • Ultimo valore

Errore in fase di formazione dell'immagine di processo, reazione: Stop CPU3. Eccezione: se sullo stesso indirizzo è stato creato un accesso diretto, vale il comportamento impostato.

Comportamento in caso di errore

Errore di accesso al programma utente, reazione selezionabile: • Stop CPU2 • Valore sostitutivo • Ultimo valore Vedere Descrizione delle funzioni Funzioni di base SIMOTION.

Vedere Descrizione delle funzioni Funzioni di base SIMOTION.

Accessi

• Nello stato operativo RUN

Possibile senza limitazioni. Possibile senza limitazioni. Possibile senza limitazioni.

• Durante lo StartupTask

Consentito con limitazioni: • Gli ingressi possono essere

letti. • Le uscite vengono scritte

solo al termine dello StartupTask.

Consentito con limitazioni: • Gli ingressi vengono letti

all'inizio dello StartupTask. • Le uscite vengono scritte


Consentito con limitazioni: • Gli ingressi vengono letti

all'inizio dello StartupTask. • Le uscite vengono scritte


• Durante lo ShutdownTask

Possibile senza limitazioni. Consentito con limitazioni: • Gli ingressi mantengono lo

stato dell'ultimo aggiornamento

• Le uscite non vengono più scritte.

Consentito con limitazioni: • Gli ingressi mantengono lo

stato dell'ultimo aggiornamento

• Le uscite non vengono più scritte.

1 Per i seguenti apparecchi SIMOTION l'attualizzazione avviene nel clock Servo_fast o nel clock IPO_fast, se tali clock sono configurati: D445-2 DP/PN, D455-2 DP/PN (dalla versione V4.2) e D435-2 DP/PN (dalla versione V4.3).

2 Richiamo di ExecutionFaultTask. 3 Richiamo di PeripheralFaultTask



5.3.3 Accesso diretto e immagine di processo dei task ciclici

Caratteristica L'accesso diretto agli ingressi e alle uscite e l'accesso all'immagine di processo dei task ciclici avviene sempre tramite variabili I/O. È utilizzabile l'intera area indirizzi dell'apparecchio SIMOTION (Pagina 259).

Per un confronto tra le proprietà più importanti anche rispetto all'immagine di processo fissa del BackgroundTask (Pagina 267) vedere "Proprietà importanti dell'accesso diretto e dell'immagine di processo (Pagina 252)".

Nota

Prestare attenzione alle regole degli indirizzi I/O per l'accesso diretto e l'immagine di processo dei task ciclici (Pagina 260).

In particolare ogni indirizzo, utilizzato in una variabile I/O, deve essere presente nella periferia e deve essere progettato; ogni byte dell'area di indirizzo deve essere assegnato al massimo ad una variabile I/O (ad eccezione di accessi con tipo di dati BOOL).

Uno stato dettagliato delle variabili I/O (Pagina 265) può essere letto dalla versione V4.2 del SIMOTION kernel.

Accesso diretto Con l'accesso diretto si accede direttamente all'indirizzo I/O corrispondente. Utilizzare l'accesso diretto preferibilmente con la programmazione sequenziale (in MotionTasks). Qui è particolarmente importante l'accesso al valore corrente di ingressi e uscite in un determinato istante.

Per l'accesso diretto, definire una variabile I/O (Pagina 261) senza assegnarle un task.

Immagine di processo del task ciclico L'immagine di processo dei task ciclici è un settore della memoria RAM dell'apparecchio SIMOTION in cui è riprodotta l'intera area di indirizzamento dell'apparecchio SIMOTION. L'immagine speculare di ciascun indirizzo I/O è assegnata a un task ciclico e viene aggiornata con lo stesso. È coerente durante l'intero ciclo del task. Questa immagine di processo viene utilizzata preferibilmente nella programmazione del task assegnato (programmazione ciclica). Per questa operazione è particolarmente importante la coerenza durante l'intero ciclo del task.

Per l'immagine di processo dei task ciclici, definire una variabile I/O (Pagina 261) e assegnarle un task.



È comunque possibile effettuare l'accesso diretto a questa variabile I/O: specificare l'accesso diretto con _direct.var-name.

Nota

l'accesso mediante l'immagine di processo ha migliori prestazioni dell'accesso diretto.

Proprietà supplementari a partire dalla versione V4.2 del SIMOTION kernel A partire dalla versione V4.2 del SIMOTION kernel, l'accesso diretto agli ingressi e alle uscite nonché l'immagine di processo dei task ciclici dispongono di proprietà supplementari;

● Nell'immagine di processo dei task ciclici è possibile regolare un settore della memoria comune con un'immagine di processo fissa del BackgroundTask (standard per apparecchi creati da nuovo).

● Nell'immagine di processo dei task ciclici le variabili I/O per gli ingressi sono descrivibili, ovvero possono essere assegnati loro dei valori.

● Uno stato dettagliato delle variabili /O può essere letto.

Settore di memoria con immagine di processo fissa del BackgroundTask ● A partire dalla versione V4.2 del SIMOTION kernel, tramite un'impostazione

sull'apparecchio (Pagina 309) "Immagine di processo comune" è possibile scegliere che il settore di memoria per l'immagine di processo fissa del BackgroundTask diventi un sottoinsieme del settore di memoria per l'immagine di processo dei task ciclici.

● Fino alla versione V4.1 del SIMOTION kernel o con impostazione sull'apparecchio "Immagine di processo separata" (a partire dalla versione V4.2 del SIMOTION kernel), l'immagine di processo fissa del BackgroundTask e l'immagine di processo dei task ciclici occupano settori di memoria diversi.

ATTENZIONE Solo per l'utilizzo aggiuntivo dell'immagine di processo fissa del BackgroundTask: Osservare gli effetti delle impostazioni "Immagine di processo comune" o "Immagine di processo separata" sull'immagine di processo fissa del BackgroundTask (Pagina 267).



Tabella 5- 29 Influsso delle impostazioni "Immagine di processo comune" o "Immagine di processo separata" sull'immagine di processo dei task ciclici

Immagine di processo comune Immagine di processo separata Disponibilità Disponibile soltanto a partire dalla

versione V4.2 del SIMOTION kernel: • Impostazione selezionabile. • Standard per apparecchi di nuova

creazione.

Fino alla versione V4.1 del SIMOTION kernel vale: • Proprietà di sistema, non

configurabile. A partire dalla versione V4.2 del SIMOTION kernel vale quanto segue: • Impostazione selezionabile. • Standard con l'upgrade

dell'apparecchio.

Download di una variabile I/O nuova o modificata

Possibile solo nello stato operativo STOP.

Possibile solo nello stato operativo STOP.

Disposizione byte durante la creazione dell'immagine di processo e durante l'accesso

Corrispondente alla periferia collegata.

Effetti sull'immagine di processo fissa del BackgroundTask

Vedere tabella corrispondente in "Accesso all'immagine di processo fissa del BackgroundTask (Pagina 267)".

Maggiori informazioni Immagine di processo comune (Pagina 269).

Immagine di processo separata (Pagina 272).



5.3.3.1 Area indirizzi degli apparecchi SIMOTION Di seguito è riportata l'area indirizzi degli apparecchi SIMOTION in base alla versione del SIMOTION Kernel indicata. Per l'accesso diretto e per 'immagine di processo dei task ciclici si può utilizzare l'intera area indirizzi.

Tabella 5- 30 Area indirizzi degli apparecchi SIMOTION in base alla versione del SIMOTION Kernel

Area indirizzi con versione del SIMOTION Kernel Apparecchio SIMOTION V3.2 V4.0 V4.1 4.2 V4.3

C230-2 0 .. 2047 3 0 .. 2047 3 0 .. 2047 3 – – C240 – 0 .. 4095 3 0 .. 4095 3 0 .. 4095 3 0 .. 4095 3

C240 PN 1 – – 0 .. 4095 4 0 .. 4095 4 0 .. 4095 4 D410 DP – – 0 .. 8191 3 0 .. 8191 3 0 .. 8191 3 D410 PN – – 0 .. 8191 4 0 .. 8191 4 0 .. 8191 4 D410-2 – – – – 0 .. 8191 3 4 D425 0 .. 4095 3 0 .. 16383 3 4 0 .. 16383 3 4 0 .. 16383 3 4 0 .. 16383 3 4

D425-2 – – – – 0 .. 16383 3 4 D435 0 .. 4095 3 0 .. 16383 3 4 0 .. 16383 3 4 0 .. 16383 3 4 0 .. 16383 3 4

D435-2 – – – – 0 .. 16383 3 4 D445 0 .. 4095 3 0 .. 16383 3 4 0 .. 16383 3 4 0 .. 16383 3 4 0 .. 16383 3 4

D445-1 1 – – 0 .. 16383 3 4 0 .. 16383 3 4 0 .. 16383 3 4 D445-2 – – – 0 .. 16383 3 4 0 .. 16383 3 4 D455-2 – – – 0 .. 16383 3 4 0 .. 16383 3 4 P320 2 – – 0 .. 4095 4 0 .. 4095 4 0 .. 4095 4 P350 0 .. 2047 3 0 .. 4095 3 0 .. 4095 3 0 .. 4095 3 0 .. 4095 3

1 dalla versione V4.1 SP2 HF4. 2 disponibile dalla versione V4.1 SP5. 3 Per la periferia decentrata tramite PROFIBUS DP, durante il trasferimento le dimensioni dei dati sono limitate a 1024

byte per ogni segmento PROFIBUS DP. 4 Per la periferia decentrata tramite PROFINET, durante il trasferimento le dimensioni dei dati sono limitate a 4096 byte

per ogni segmento PROFINET.



5.3.3.2 Regole degli indirizzi I/O per l'accesso diretto e l'immagine di processo dei task ciclici

ATTENZIONE Per gli indirizzi delle variabili I/O per l'diretto e l'immagine di processo dei task ciclici (Pagina 256) è necessario rispettare le regole riportate di seguito. Il rispetto delle regole viene controllato durante la verifica della coerenza del progetto SIMOTION (ad es. durante il download). 1. Gli indirizzi utilizzati per le variabili I/O devono esistere nella periferia ed essere

opportunamente progettati in Config HW. 2. Le variabili I/O che contengono più bit non possono contenere contemporaneamente gli

indirizzi 63 e 64. I seguenti indirizzi I/O non sono ammessi: – Ingressi: PIW63, PID61, PID62, PID63 – Uscite: PQW63, PQD61, PQD62, PQD63

3. Tutti gli indirizzi di una variabile I/O che comprende più byte devono trovarsi all'interno di un'area indirizzi progettata in Config HW.

4. Un indirizzo I/O (ingresso o uscita) può essere usato solo da un'unica variabile I/O del tipo di dati BYTE, WORD o DWORD o da un array di questo tipo di dati. Gli accessi a singoli bit con variabili I/O del tipo di dati BOOL sono possibili.

5. Se più processi (ad es. variabile I/O, oggetto tecnologico, telegramma PROFIdrive) accedono a un indirizzo I/O, vale quanto segue: – A un indirizzo I/O di un'uscita (tipo di dati BYTE, WORD o DWORD) può accedere in

scrittura un solo processo. L'accesso in lettura con una variabile I/O a un'uscita utilizzata in scrittura da un altro processo è possibile.

– Tutti i processi devono accedere a questo indirizzo I/O con lo stesso tipo di dati (BYTE, WORD, DWORD o ARRAY di questi tipi di dati). Gli accessi a singoli bit sono possibili indipendentemente da ciò. Prestare ad esempio attenzione se con una variabile I/O si intende leggere il telegramma PROFIdrive trasmesso da o verso un azionamento: la lunghezza delle variabili I/O deve corrispondere alla lunghezza del telegramma.

– L'accesso in scrittura ai diversi bit di un indirizzo può avvenire da diversi processi; un accesso in scrittura con i tipi di dati BYTE, WORD o DWORD non sarà allora possibile.

Nota

Queste regole non valgono in caso di accessi all'immagine di processo fissa del BackgroundTask (Pagina 267). Questi accessi non vengono tenuti in considerazione durante la verifica della coerenza del progetto (ad es. durante il download).



5.3.3.3 Creazione della variabile I/O per l'accesso diretto all'immagine di processo dei task ciclici

Le variabili I/O per Accesso diretto o immagine di processo dei task ciclici si creano nella lista degli indirizzi della visualizzazione dei dettagli.

A tale scopo, ci si deve trovare nella modalità offline:


1. Selezionare nella visualizzazione dei dettagli la scheda "Lista degli indirizzi" e selezionare l'apparecchio SIMOTION.

oppure

Nella navigazione di progetto di SIMOTION SCOUT fare doppio clic sull'elemento "LISTA INDIRIZZI" nella diramazione dell'apparecchio SIMOTION.

2. Selezionare la riga davanti alla quale si vuole inserire la variabile I/O e selezionare nel menu contestuale Inserisci nuova riga

oppure

Scorrere fino in fondo la tabella delle variabili (riga vuota).

3. Inserire nella riga vuota della tabella o selezionare:

– nome delle variabili I/O.

– Indirizzo I/O

Selezionare le voci "IN" o "OUT", se si desidera assegnare in modo simbolico la variabile I/O (ingresso o uscita) (dalla versione V4.2 del SIMOTION kernel. L'assegnazione simbolica deve essere attivata, menu Progetto > Utilizza assegnazione simbolica.).

Oppure immettere un indirizzo fisso secondo la "Sintassi per l'immissione degli indirizzi I/O (Pagina 264)".

– opzionale per le uscite:

selezionare la casella di controllo Sola lettura per accedere all'uscita solo in lettura.

Si può allora leggere un'uscita già descritta da un altro processo (ad es. uscita di una camma, telegramma PROFIdrive).

Una variabile di uscita di sola lettura non può essere assegnata a un task ciclico.

– Tipo di dati delle variabili secondo "Tipi di dati possibili delle variabili I/O (Pagina 265)".



4. Facoltativamente è possibile impostare o selezionare quanto segue (non per il tipo di dati BOOL):

– Lunghezza campo (dimensione array)

– Immagine di processo oppure accesso diretto:

L'assegnazione è possibile solo se la casella di controllo Sola lettura è deselezionata.

Per l'immagine di processo selezionare il task ciclico al quale si desidera assegnare la variabile I/O. Per poter selezionare un task è necessario che sia attivato nel sistema esecutivo.

Per l'accesso diretto selezionare il campo vuoto.

– Strategia per il comportamento in caso di errore (vedere Manuale di guida alle funzioni Funzioni di base SIMOTION).

– Formato visualizzazione (in caso di array per ogni elemento), se si esegue il monitoraggio della variabile nella lista degli indirizzi.

– Valore sostitutivo (in caso di array per ogni elemento).

5. Solo se è stato selezionato come indiritto I/O "IN" oppure "OUT" (assegnazione simbolica).

– Fare clic nella colonna Assegnazione sul pulsante […].

Si apre una finestra in cui vengono visualizzate le possibili destinazioni di assegnazione dell'apparecchio SIMOTION ed eventualmente di SINAMICS Integrated. Vengono visualizzate soltanto le destinazioni di assegnazione che coincidono per direzione di dati (ingresso o uscita) e tipo di dati.

– Selezionare la destinazione di assegnazione.

Nella colonna Stato assegnazione viene visualizzato se l'assegnazione è andata a buon fine.

Per l'assegnazione simbolica vedere Manuale di guida alle funzioni Funzioni di base SIMOTION.

Ora si può accedere a questa variabile con la lista degli indirizzi o con ciascun programma dell'apparecchio SIMOTION.



Informazioni su come operare con la lista indirizzi sono descritte dettagliatamente nella Guida in linea.

ATTENZIONE Per quanto riguarda l'immagine di processo dei task ciclici, tenere presente quanto segue: • Una variabile può essere assegnata ad un unico task. • Ciascun byte di un ingresso o di un'uscita può essere assegnato a un'unica variabile

I/O.

Tenere presente per il tipo ti dati BOOL • Non è possibile definire l'immagine di processo per i task ciclici e una strategia in caso

di errore. Vale il comportamento definito per l'intero byte tramite una variabile I/O (preimpostazione: Accesso diretto e Stop CPU).

• L'accesso ai singoli bit di una variabile I/O è possibile con l'ausilio delle funzioni di accesso ai bit.

Fare attenzione durante le modifiche all'interno delle variabili I/O (ad es. inserimento ed eliminazione di variabili I/O, modifiche di nomi, modifiche di indirizzi): • L'indirizzamento interno di altre variabili I/O può modificarsi in determinate circostanze;

tutte le variabili I/O diventano di conseguenza incoerenti. • Tutte le sorgenti di programma e gli accessi contenuti in variabili I/O devono essere

all'occorrenza ricompilati.

Nota

Le variabili I/O possono essere create solo in modalità offline. La creazione avviene in SIMOTION SCOUT e le variabili vengono utilizzate nelle proprie sorgenti di programma (ad es. sorgenti ST, sorgenti MCC, sorgenti KOP/FUP).

Le uscite consentono l'accesso in lettura e scrittura; gli ingressi solo in lettura.

Prima di poter monitorare e gestire variabili I/O nuove o aggiornate, è necessario caricare il progetto nel sistema di destinazione.

È possibile utilizzare una variabile I/O come qualsiasi altra variabile, vedere "Accesso alle variabili I/O (Pagina 279)".



5.3.3.4 Sintassi per l'immissione degli indirizzi I/O Utilizzare la seguente sintassi per l'immissione dell'indirizzo I/O durante la definizione di una variabile I/O per l'accesso diretto o l'immagine di processo dei task ciclici (Pagina 256). In questa sintassi non viene specificato solo l'indirizzo, ma anche il tipo di dati dell'accesso e il tipo di accesso stesso (ingresso/uscita).

Tabella 5- 31 Sintassi per l'immissione degli indirizzi I/O per l'accesso diretto o l'immagine di processo dei task ciclici

Sintassi per Area indirizzi ammessa Tipo di dati

Ingresso Uscita Accesso diretto Immagine di processo ad es. accesso diretto D435 V4.1

BOOL PIn.x PQn.x n: x:

0 .. MaxInd 0 .. 7

-1 n: x:

0 .. 16383 0 .. 7

BYTE PIBn PQBn n: 0 .. MaxInd n: 0 .. MaxInd n: 0 .. 16383 WORD PIWn PQWn n: 0 .. 62

64 .. MaxInd - 1 n: 0 .. 62

64 .. MaxInd - 1 n: 0 .. 62

64 .. 16382 DWORD PIDn PQDn n: 0 .. 60

64 .. MaxInd - 3 n: 0 .. 60

64 .. MaxInd - 3 n: 0 .. 60

64 .. 16380 n= indirizzo logico x= numero bit MaxInd = Indirizzo I/O massimo dell'apparecchio SIMOTION in base alla versione del kernel SIMOTION, vedere l'area

indirizzi degli apparecchi SIMOTION in "Accesso diretto e immagine di processo dei task ciclici (Pagina 256)".

1 Per il tipo di dati BOOL non è possibile definire l'immagine di processo per task ciclici. Vale il comportamento definito per l'intero byte tramite una variabile I/O (preimpostazione: Accesso diretto).

Esempi Ingresso all'indirizzo logico 1022, tipo di dati WORD: PIW1022.

Uscita all'indirizzo logico 63, Bit 3, tipo di dati BOOL: PQ63.3.

Nota

Prestare attenzione alle regole degli indirizzi I/O per l'accesso diretto e l'immagine di processo dei task ciclici (Pagina 260).



5.3.3.5 Tipi di dati possibili delle variabili I/O È possibile assegnare i seguenti tipi di dati alle variabili I/O per l'accesso diretto e l'immagine di processo dei task ciclici (Pagina 256). La larghezza del tipo di dati deve corrispondere a quella del tipo di dati dell'indirizzo I/O.

Assegnando alle variabili I/O un tipo di dati numerico è possibile accedere a questa variabile come numero intero.

Tabella 5- 32 Tipi di dati possibili delle variabili I/O per l'accesso diretto e l'immagine di processo dei task ciclici

Tipo di dati dell'indirizzo I/O Tipi di dati possibili delle variabili I/O BOOL (PIn.x, PQn.x) BOOL BYTE (PIBn, PQBn) BYTE, SINT, USINT WORD (PIWn, PQWn) WORD, INT, UINT DWORD (PIDn, PQDn) DWORD, DINT, UDINT

Per il tipo di dati dell'indirizzo I/O vedere anche "Sintassi per l'immissione degli indirizzi I/O (Pagina 264)".

5.3.3.6 Stato dettagliato delle variabili I/O (a partire dal kernel V.4.2) A partire dalla versione V4.2 del SIMOTION kernel è possibile interrogare lo stato di una variabile I/O con _quality.var-name. Esso viene fornito come operazione logica OR dei seguenti valori di stato nel tipo dati DWORD e può essere ad es. assegnato ad una variabile corrispondente. Il valore 16#0000_0000 segnala che la periferia collegata lavora correttamente.

Per ogni variabile I/O all'interno di un'area indirizzi (slot o subslot) progettata in Config HW viene fornito lo stesso valore.

Tabella 5- 33 Significato dei valori di stato delle variabili I/O

Valore (DWORD)

Bit x = 1 Significato

16#0000_0000 - Non si è verificato alcun errore 16#0000_0001 0 Richiesta di manutenzione (Maintenance Required)

L'unità collegata segnala una richiesta di manutenzione. Entro un intervallo di tempo prevedibile è necessaria una verifica dei componenti (ad es. la cartuccia della stampante deve essere sostituita entro un arco di tempo di più giorni).

16#0000_0002 1 Necessità di manutenzione (Maintenance Demanded) L'unità collegata segnala una necessità di manutenzione. Entro un breve intervallo di tempo è necessaria una verifica dei componenti (ad es. la cartuccia della stampante deve essere sostituita immediatamente).

16#0000_0004 2 Avviso in corso (Avviso di azionamento, Avviso TM17, …) L'unità collegata ha segnalato un avviso. È stato inserito nel buffer di diagnostica. La causa precisa è indicata nella documentazione della corrispondente unità.

16#0000_0008 3 Guasto in corso (,Allarme diagnostico, Guasto di azionamento, Guasto TM17, …) L'unità collegata segnala un errore. È stato inserito nel buffer di diagnostica. La causa precisa è indicata nella documentazione della corrispondente unità.



Valore (DWORD)


16#0000_0010 4 La propria parametrizzazione non corrisponde alla controparte Nel confronto tra la propria parametrizzazione e la parametrizzazione dell'unità collegata è stata rilevata una differenza. La funzionalità desiderata non può più essere garantita. Rimedio: salvare il progetto e compilare le modifiche, caricare entrambe le pagine nuovamente.

16#0000_0020 5 L'applicazione e la controparte non sono sincroni al clock (errore nella funzionalità vitale dinamica) Determinati telegrammi (telegramma asse, sincronismo, camma, tastatore di misura) vengono sincronizzati mediante la sostituzione di funzionalità vitali cicliche. La verifica delle funzionalità vitali cicliche fornisce errori. I dati nel telegramma non sono quindi validi. Rimedio: Attendere la sincronizzazione, verificare la parametrizzazione (ad es. il Master-Application-Cycle impostato in Config HW sull'apparecchio corrisponde al clock servo), salvare il progetto e compilare le modifiche, caricare entrambe le pagine nuovamente.

16#0000_0040 6 La periferia non può essere utilizzata in tutti i clock in modo sincrono Clock di applicazione rapido (Servo_fast) e clock di applicazione lento (Servo) procedono complementari in modo asincrono. La periferia può essere utilizzata in modo sincrono soltanto in clock appartenenti al clock bus. Un accesso da altri clock avviene in modo asincrono e in modo incoerente. Rimedio: Richiamare la funzione _synchroniseDpInterfaces()

16#0000_0080 7 La periferia non può essere utilizzata in modo sincrono Il controllo SIMOTION è sync-slave rispetto ad un bus. Il collegamento del bus procede in modo sincrono al sync-master, ma in modo asincrono rispetto ai clock di applicazione del controllo SIMOTION. Un accesso alla periferia avviene in modo asincrono e in modo incoerente! Rimedio: Richiamare la funzione _synchroniseDpInterfaces()

16#0000_0100 8 Il collegamento del bus (sync-slave) non è sincrono al clock rispetto al sync-master Il controllo SIMOTION è sync-slave rispetto ad un bus e non ha ancora sincronizzato il proprio collegamento bus rispetto al sync-master. La periferia sincrona al clock su questo bus non può essere ancora utilizzata. Rimedio: Attivare/collegare sync-master.

16#0000_0200 9 Stazione DP disattivata L'unità partner è stata disattivata. Rimedio: Attivare l'unità partner (funzione _activateDpSlave()).

16#0000_0400 10 Il partner degli ingressi (ad es. I-Device, I-Slave) è in STOP L'unità collegata si trova nello stato operativo STOP e per questo non invia dati nuovi. Rimedio: commutare l'unità collegata a RUN.

16#0000_0800 11 PROFINET: Guasto riconosciuto mediante sottomodulo (ad es. errore canale) Il collegamento all'apparecchio collegato è corretto. L'errore deve essere cercato nell'apparecchio collegato. Ricerca errori: buffer di diagnostica, diagnostica apparecchio con Config HW.

16#0000_1000 12 PROFINET: Guasto riconosciuto mediante modulo (ad es. sottomodulo guasto, estratto, ...)Il collegamento all'apparecchio collegato è corretto. L'errore deve essere cercato nell'apparecchio collegato. Ricerca errori: buffer di diagnostica, diagnostica apparecchio con Config HW.



Valore (DWORD)


16#0000_2000 13 PROFINET: Guasto riconosciuto mediante apparecchio (ad es. apparecchio in STOP, modulo estratto, ...) Il collegamento all'apparecchio collegato è corretto. L'errore deve essere cercato nell'apparecchio collegato. Ricerca errori: buffer di diagnostica, diagnostica apparecchio con Config HW.

16#0000_4000 14 PROFINET: Guasto riconosciuto mediante controller (ad es. non collegato, ...) Non vi sono collegamenti ad un partner su Profinet. Causa possibile: partner disattivato, cavo estratto, errata parametrizzazione del collegamento Ricerca errori: al meglio con editor topologico Profinet in Config HW

16#0000_8000 15 Slot/subslot non collegato (allarme di estrazione) Il collegamento all'apparecchio collegato è corretto. L'errore deve essere cercato nell'apparecchio collegato (ad es. modulo/sottomodulo estratto). Ricerca errori: buffer di diagnostica, diagnostica apparecchio con Config HW

16#0001_0000 16 Apparecchio non collegato (guasto alla stazione) Non vi sono collegamenti ad un partner. Causa possibile: partner disattivato, cavo estratto.

16#0002_0000 17 Comportamento del valore sostitutivo durante l'accesso Non vi è alcun collegamento alla controparte (segnale sommato da bit 9 ... 16), ovvero non vi sono dati di accesso validi o i dati di uscita non giungono ai morsetti. Durante l'accesso diretto a questo indirizzo o durante l'aggiornamento dell'immagine di processo ha effetto il comportamento del valore sostitutivo impostato (valore sostitutivo, ultimo valore).

16#4000_0000 30 Solo indirizzo diagnostico Per questo indirizzo non vengono progettati dati I/O ciclici. È tuttavia possibile richiedere informazioni diagnostiche del sottomodulo.

16#8000_0000 31 Spazio libero per indirizzi Per questo indirizzo logico non è progettato alcun hardware.

5.3.4 Accesso all'immagine di processo dei BackgroundTask L'immagine di processo fissa del BackgroundTask è un settore della memoria nella RAM dell'apparecchio SIMOTION in cui è riprodotto un sottoinsieme dell'area indirizzi I/O dell'apparecchio SIMOTION. L'immagine viene utilizzata di preferenza in fase di programmazione di BackgroundTask (programmazione ciclica), poiché è coerente per il relativo ciclo completo.

L'immagine di processo fissa del BackgroundTask ha una dimensione di 64 byte per tutti gli apparecchi SIMOTION (area indirizzi 0 ... 63).

Nota

Con l'immagine di processo fissa del BackgroundTask è possibile accedere ad indirizzi non presenti nella periferia o non progettati in Config HW. Essi vengono trattati come normali indirizzi di memoria.



Settore di memoria ● A partire dalla versione V4.2 del SIMOTION kernel, tramite un'impostazione

sull'apparecchio (Pagina 309) "Immagine di processo comune" è possibile scegliere che il settore di memoria per l'immagine di processo fissa del BackgroundTask diventi un sottoinsieme del settore di memoria per l'immagine di processo dei task ciclici.

Gli indirizzi I/O possono essere letti e descritti sia con l'immagine di processo fissa del BackgroundTask sia come immagine di processo dei task ciclici.

● Fino alla versione V4.1 del SIMOTION kernel o con impostazione sull'apparecchio "Immagine di processo separata" (a partire dalla versione V4.2 del SIMOTION kernel), l'immagine di processo fissa del BackgroundTask e l'immagine di processo dei task ciclici occupano settori di memoria diversi.

Gli indirizzi I/O a cui si accede con l'immagine di processo dei task ciclici non possono essere letti o descritti con l'immagine di processo fissa del BackgroundTask. Essi vengono trattati come normali indirizzi di memoria.

Tabella 5- 34 Influsso delle impostazioni "Immagine di processo comune" o "Immagine di processo separata" sull'immagine di processo fissa del BackgroundTask

Immagine di processo comune Immagine di processo separata Disponibilità Disponibile soltanto a partire dalla

versione V4.2 del SIMOTION kernel: • Impostazione selezionabile. • Standard per apparecchi di nuova

creazione.

Fino alla versione V4.1 del SIMOTION kernel vale: • Proprietà di sistema, non

configurabile. A partire dalla versione V4.2 del SIMOTION kernel vale quanto segue: • Impostazione selezionabile. • Standard con l'upgrade

dell'apparecchio.

Settore di memoria Sottoinsieme del settore di memoria per l'immagine di processo dei task ciclici

Settore di memoria separato all'immagine di processo dei task ciclici.

Utilizzo degli indirizzi I/O a cui si accede con l'immagine di processo dei task ciclici

Possibile. L'aggiornamento avviene con task ciclici configurati.

Non possibile. Gli indirizzi vengono trattati come normali indirizzi di memoria

Disposizione byte durante la creazione dell'immagine di processo

Come fornita dalla periferia. Sempre Big Endian.

Disposizione byte durante l'accesso all'immagine di processo

Sempre Big Endian. Sempre Big Endian.

Accesso alla periferia che funziona nella disposizione byte Little Endian

Stesso risultato come per l'accesso diretto o l'immagine di processo dei task cicilici (ad eccezione del tipo dati WORD o DWORD).

A seconda delle variabili I/O create per l'accesso diretto i risultati sono diversi.



Immagine di processo comune Immagine di processo separata Effetti sull'immagine di processo dei task ciclici

Vedere la corrispondente tabella in "Accesso diretto e immagine di processo dei task ciclici (Pagina 256)".

Maggiori informazioni Immagine di processo comune (Pagina 269).

Immagine di processo separata (Pagina 272).

Informazioni sulla disposizione dei byte Little Endian e Big Endian: vedere il Manuale di guida alle funzioni Funzioni di base SIMOTION.

Per un confronto tra le proprietà più importanti rispetto all'accesso diretto e all'immagine di processo dei task ciclici (Pagina 256) vedere "Proprietà importanti dell'accesso diretto e dell'immagine di processo (Pagina 252)".

Nota

Le regole degli indirizzi I/O per l'accesso diretto e l'immagine di processo dei task ciclici (Pagina 260)non valgono. Gli accessi all'immagine di processo fissa del BackgroundTask non vengono tenuti in considerazione durante la verifica della coerenza del progetto (ad es. durante il download).

Gli indirizzi non presenti nella periferia o non progettati in Config HW vengono trattati come normali indirizzi di memoria.

All'immagine di processo fissa del BackgroundTask è possibile accedere:

● tramite un accesso assoluto all'immagine di processo (Pagina 275): l'identificatore dell'accesso assoluto all'immagine di processo contiene l'indirizzo I/O e il tipo di dati.

● tramite accesso simbolico all'immagine di processo (Pagina 276): dichiarare una variabile che rimandi all'accesso assoluto all'immagine di processo corrispondente:

– una variabile Unit,

– una variabile statica locale in un programma.

● tramite una variabile I/O (Pagina 278): Nel browser dei simboli viene definita una variabile I/O globale dell'apparecchio valida che rimanda all'accesso assoluto all'immagine di processo corrispondente.

5.3.4.1 Immagine di processo comune (a partire dal kernel V4.2) A partire dalla versione V.4.2 del SIMOTION kernel sull'apparecchio SIMOTION può essere selezionata l'impostazione (Pagina 309) "Immagine di processo comune". Questo significa che gli indirizzi 0 .. 63 dell'immagine di processo dei task ciclici e l'immagine di processo fissa del BackgroundTask occupano lo stesso settore di memoria.

Questa è la preimpostazione per gli apparecchi SIMOTION a partire dalla versione V.4.2 appena creati nel progetto.



Proprietà dell'immagine di processo comune 1. Il settore di memoria per l'immagine di processo fissa del BackgroundTask (Pagina 267)

è un sottoinsieme del settore di memoria per l'immagine di processo dei task ciclici (Pagina 256).

2. Gli indirizzi I/O a cui si accede con l'immagine di processo dei task ciclici continuano ad essere utilizzati anche per l'immagine di processo fissa del BackgroundTask. L'aggiornamento avviene anche con task ciclici configurati.

3. Nella creazione dell'immagine di processo fissa del BackgroundTask vale:

la disposizione byte è la stessa fornita dalla periferia:

– Big Endian, ad es. con periferia tramite PROFIBUS DP, PROFINET, P-Bus, DRIVE-CLiQ

– Little Endian, ad es. con la periferia Onboard degli apparecchi SIMOTION C240, C240 PN.

Una variabile I/O creata eventualmente per il relativo indirizzo, per l'accesso diretto o l'immagine di processo dei task ciclici non ha alcuna influenza sulla disposizione byte.

4. Si accede all'immagine di processo fissa del BackgroundTask sempre con una disposizione byte Big Endian.

5. Queste ultime due proprietà (n. 3 e 4) hanno un effetto sull'accesso agli ingressi e alle uscite che funzionano con la disposizione byte Little Endian (ad es. periferia Onbaord degli apparecchi SIMOTION C240, C240 PN).

Se si accede con l'immagine di processo fissa del BackgroundTask, indipendentemente dalla creazione di relativi indirizzi I/O per l'accesso diretto o l'immagine di processo di task ciclici, si ha il seguente comportamento:

– l'accesso ai singoli byte tramite la variabile I/O o l'immagine di processo fissa del BackgroundTask forniscono sempre lo stesso risultato.

– Solo con l'accesso diretto con il tipo dati WORD i byte vengono scambiati con immagine di processo fissa del BackgroundTask.

Vedere anche l'esempio seguente.




Esempio di immagine di processo comune: accesso a una periferia che funziona nella diposizione byte Little Endian

Gli ingressi digitali dell'apparecchio SIMOTION C240 funzionano con la disposizione byte Little Endian e occupano solitamente gli indirizzi 66 (bit 0 ..7) e 67 (bit 0.. 3). In Config HW l'indirizzo iniziale viene modificato su 60, in modo da rientrare nell'area dell'immagine di processo fissa del BackgroundTask. Si accede ora agli indirizzi 60 e 61 con diverse variabili I/O e con l'immagine di processo del BackgroundTask.

Si osservano i seguenti tre casi, che distinguono se e quali variabili I/O vengono create per l'accesso diretto o l'immagine di processo dei task ciclici:

1. Caso A:

per gli indirizzi 60 e 61 non sono state create variabili I/O.

2. Caso B:

per gli indirizzi 60 e 61 sono state create due variabili I/O con tipo dati BYTE: io_byte_60 (PIB60) e io_byte_61 (PIB61).

3. Caso C:

per l'indirizzo 60 è stata creata una variabile I/O con tipo dati WORD che contiene anche l'indirizzo 61: io_word_60 (PIW60).

Inoltre in ciascuno dei tre casi sono state create due variabili I/O che consentono l'accesso al bit°3: io_bit_60_3 (PI60.3) e io_bit_61_3 (PI61.3).

Nella seguente tabella vengono elencati quali valori si ottengono nei seguenti accessi:

● accessi diretti o accessi all'immagine di processi dei task ciclici:

– accesso ai singoli byte o alla parola con la relativa variabile I/O.

– Accesso ad ogni singolo byte con la funzione _getInOutByte (solo accesso diretto).

– accesso al rispettivo bit 3 con la corrispondente variabile I/O.

● Accesso all'immagine di processo fissa del BackgroundTask:

– accesso ai singoli byte con identificatore assoluto.

– Accesso alla parola con identificatore assoluto.

– Accesso al relativo bit°3 con identificatore assoluto.



Tabella 5- 35 Impostazione "Immagine di processo comune" (a partire dal kernel V4.2): Diversi accessi alle immagini di processo di un ingresso che funziona con disposizione byte Little Endian

Accesso con Caso A 1 Caso B 1 Caso C 1 Accesso diretto o accesso all'immagine di processo dei task ciclici

io_byte_60 (PIB60) - 16#08 -

io_byte_61 (PIB61) - 16#00 - io_word_60 (PIW60) - - 16#0008 _getInOutByte (IN, 60) 16#08 16#08 16#08 _getInOutByte (IN, 61) 16#00 16#00 16#00 io_bit_60_3 (PI60.3) TRUE TRUE TRUE io_bit_61_3 (PI61.3) FALSE FALSE FALSE

%IB60 16#08 16#08 16#08 %IB61 16#00 16#00 16#00 %IW60 16#0800 2 16#0800 2 16#0800 2 %I60.3 TRUE TRUE TRUE

Accesso all'immagine di processo fissa del BackgroundTask

%I61.3 FALSE FALSE FALSE

1 I casi A, B o C distinguono se e quali variabili I/O vengono create per l'accesso diretto o l'immagine di processo dei task ciclici, vedere spiegazione nel testo.

2 Entrambi i byte nella parola vengono scambiati poiché un valore memorizzato in una disposizione byte Little Endian viene letto con Big Endian.

5.3.4.2 Immagine di processo separata (a partire dal kernel V4.1) Fino alla versione 4.1 del SIMOTION kernel l'immagine di processo dei task ciclici e l'immagine di processo fissa del BackgroundTask vengono memorizzate in diversi settori di memoria (immagine di processo separata).

A partire dalla versione V.4.2 del SIMOTION kernel sull'apparecchio SIMOTION può essere selezionata l'impostazione (Pagina 309) "Immagine di processo separata". Questa impostazione assicura la compatibilità con le precedenti versioni kernel.

Questa è la preimpostazione per apparecchi SIMOTION che ricevono un upgrade alla versione V.4.2.

Proprietà dell'immagine di processo separata 1. L'immagine di processo fissa del BackgroundTask (Pagina 267) e l'immagine di processo

dei task ciclici (Pagina 256) vengono memorizzate in diversi settori di memoria.

2. Pertanto gli indirizzi I/O a cui si accede con l'immagine di processo dei task ciclici non possono essere letti o descritti con l'immagine di processo fissa del BackgroundTask. Essi vengono trattati come normali indirizzi di memoria.

3. Le variabili I/O per l'accesso diretto influenzano l'immagine di processo fissa del BackgroundTask:

– L'immagine di processo fissa del BackgroundTask viene creata sempre per i relativi indirizzi nella disposizione byte Big Endian.



4. Si accede all'immagine di processo fissa del BackgroundTask sempre con una disposizione byte Big Endian.

5. Queste ultime due proprietà (n. 3 e 4) hanno un effetto sull'accesso agli ingressi e alle uscite che funzionano con la disposizione byte Little Endian (ad es. periferia Onbaord degli apparecchi SIMOTION C230-2, C240, C240 PN).

Se per i relativi indirizzi viene creata una variabile I/O per l'accesso diretto con il tipo dati WORD e si accede con l'immagine di processo fissa del BackgroundTask, si ha il seguente comportamento:

– L'accesso con il tipo di dati WORD tramite la variabile I/O e tramite l'immagine di processo fissa dei BackgroundTask fornisce lo stesso risultato.

– L'accesso ai singoli byte con la funzione _getInOutByte (vedere il Manuale di guida alle funzioni Funzioni di base SIMOTION) fornisce i byte nella disposizione Little Endian.

– L'accesso ai singoli byte o bit con l'immagine di processo fissa del BackgroundTask fornisce i byte e i bit stessi nella disposizione Big Endian.

Vedere anche l'esempio seguente.


Esempio di immagine di processo separata: accesso a una periferia che funziona nella diposizione byte Little Endian

Gli ingressi digitali dell'apparecchio SIMOTION C240 funzionano con la disposizione byte Little Endian e occupano solitamente gli indirizzi 66 (bit 0 ..7) e 67 (bit 0.. 3). In Config HW l'indirizzo iniziale viene modificato su 60, in modo da rientrare nell'area dell'immagine di processo fissa del BackgroundTask. Si accede ora agli indirizzi 60 e 61 con diverse variabili I/O e con l'immagine di processo del BackgroundTask.

Si osservano i seguenti tre casi, che distinguono se e quali variabili I/O vengono create per l'accesso diretto:

1. Caso A:

per gli indirizzi 60 e 61 non sono state create variabili I/O.

2. Caso B:

per gli indirizzi 60 e 61 sono state create due variabili I/O con tipo dati BYTE: io_byte_60 (PIB60) e io_byte_61 (PIB61).

3. Caso C:

per l'indirizzo 60 è stata creata una variabile I/O con tipo dati WORD che contiene anche l'indirizzo 61: io_word_60 (PIW60).

Inoltre in ciascuno dei tre casi sono state create due variabili I/O che consentono l'accesso al bit°3: io_bit_60_3 (PI60.3) e io_bit_61_3 (PI61.3).

Nella seguente tabella vengono elencati quali valori si ottengono nei seguenti accessi:



● Accessi diretti:

– accesso ai singoli byte o alla parola con la relativa variabile I/O.

– Accesso ad ogni singolo byte con la funzione _getInOutByte (Pagina 256).

– accesso al rispettivo bit 3 con la corrispondente variabile I/O.

● Accessi all'immagine di processo fissa del BackgroundTask:

– accesso ai singoli byte con identificatore assoluto.

– Accesso alla parola con identificatore assoluto.

– Accesso al relativo bit°3 con identificatore assoluto.

Tabella 5- 36 Impostazione "Immagine di processo separata" o kernel fino alla versione 4.1: Diversi accessi alle immagini di processo di un ingresso che funziona con disposizione byte Little Endian

Accesso con Caso A 1 Caso B 1 Caso C 1 Accesso diretto io_byte_60 (PIB60) - 16#08 -

io_byte_61 (PIB61) - 16#00 - io_word_60 (PIW60) - - 16#0008 _getInOutByte (IN, 60) 16#08 16#08 16#08 _getInOutByte (IN, 61) 16#00 16#00 16#00 io_bit_60_3 (PI60.3) TRUE TRUE TRUE io_bit_61_3 (PI61.3) FALSE FALSE FALSE

%IB60 16#08 16#08 16#00 3 %IB61 16#00 16#00 16#08 3 %IW60 16#0800 2 16#0800 2 16#0800 %I60.3 TRUE TRUE FALSE 3

Accesso all'immagine di processo fissa del BackgroundTask

%I61.3 FALSE FALSE TRUE 3

1 I casi A, B o C distinguono se e quali variabili I/O vengono create per l'accesso diretto, vedere spiegazione nel testo.

2 Entrambi i byte nella parola vengono scambiati poiché un valore memorizzato in una disposizione Little Endian viene letto con Big Endian.

3 I due byte adiacenti vengono scambiati poiché la relativa parola viene memorizzata nella disposizione Big Endian.



5.3.4.3 Accesso assoluto all'immagine di processo fissa del BackgroundTask (Accesso assoluto all'immagine di processo)

Si accede in modo assoluto all'immagine di processo fissa del BackgroundTask (Pagina 267) utilizzando direttamente l'identificatore degli indirizzi (con tipo di dati implicito). La sintassi dell'identificatore (Pagina 275) è descritta nella seguente sezione.

È possibile utilizzare l'identificatore per l'accesso assoluto all'immagine di processo come una normale variabile (Pagina 275).

Nota

Le uscite consentono l'accesso in lettura e scrittura; gli ingressi solo in lettura.

5.3.4.4 Sintassi per l'identificatore dell'accesso assoluto all'immagine di processo Utilizzare la seguente sintassi per l'accesso assoluto all'immagine di processo fissa del BackgroundTask (Pagina 275). In questa sintassi non viene specificato solo l'indirizzo, ma anche il tipo di dati dell'accesso e il tipo di accesso stesso (ingresso/uscita).

Questi identificatori vengono utilizzati anche:

● nella dichiarazione di un accesso simbolico all'immagine di processo fissa del BackgroundTask (Pagina 276).

● nella creazione di una variabile I/O per l'accesso all'immagine di processo fissa del BackgroundTask (Pagina 278).

Tabella 5- 37 Sintassi per l'identificatore dell'accesso assoluto all'immagine di processo

Sintassi per Tipo di dati

Ingresso Uscita

Area indirizzi ammessa

BOOL %In.x oppure %IXn.x 1

%Qn.x oppure %QXn.x 1

n: x :

0 .. 63 2 0 .. 7

BYTE %IBn %QBn n: 0 .. 63 2 WORD %IWn %QWn n: 0 .. 63 2 DWORD %IDn %QDn n: 0 .. 63 2 n= indirizzo logico x= numero bit 1 La sintassi %IXn.x e/o %QXn.x non è ammessa nella definizione delle variabili I/O. 2 Ad eccezione degli indirizzi utilizzati nell'immagine di processo dei task ciclici.



Esempi Ingresso all'indirizzo logico 62, tipo di dati WORD: %IW62.

Uscita all'indirizzo logico 63, Bit 3, tipo di dati BOOL: %Q63.3.

ATTENZIONE Fino alla versione 4.1 del kernel SIMOTION o con impostazione sull'apparecchio "Immagine di processo separata" (a partire dalla versione 4.2 del kernel SIMOTION) vale: • Gli indirizzi a cui si accede con l'immagine di processo dei task ciclici non possono

essere letti o descritti con l'immagine di processo fissa del BackgroundTask.

Questa limitazione non è valida a partire dalla versione V.4.2 del kernel SIMOTION e con impostazione sull'apparecchio "Immagine di processo comune".

Nota

Le regole degli indirizzi I/O per l'accesso diretto e l'immagine di processo dei task ciclici (Pagina 260)non valgono. Gli accessi all'immagine di processo fissa del BackgroundTask non vengono tenuti in considerazione durante la verifica della coerenza del progetto (ad es. durante il download).

Gli indirizzi non presenti nella periferia o non progettati in Config HW vengono trattati come normali indirizzi di memoria.

Seguono alcuni esempi di assegnazione di variabili dello stesso tipo:

Tabella 5- 38 Esempi di accesso assoluto alla memoria della CPU

status1 := %I1.1; // Tipo di dati BOOL

status2 := %IB10; // Tipo di dati BYTE

status3 := %IW20; // Tipo di dati WORD

status4 := %ID20; // Tipo di dati DWORD

%Q1.1 := status1; // Tipo di dati BOOL

%QB20 := status2; // Tipo di dati BYTE

%QW20 := status3; // Tipo di dati WORD

%QD20 := status4; // Tipo di dati DWORD

5.3.4.5 Accesso simbolico all'immagine di processo fissa del BackgroundTask (Accesso simbolico all'immagine di processo)

Si può accedere all'immagine di processo fissa del BackgroundTask (Pagina 267) anche in modo simbolico e non è necessario indicare sempre l'accesso assoluto.

È possibile dichiarare un accesso simbolico:

● come variabile statica di un programma (nella struttura VAR/END_VAR nella sezione dichiarazione),

● come variabile Unit (nella struttura VAR_GLOBAL / END_VAR nella sezione interfaccia o implementazione della sorgente ST).



La sintassi per la dichiarazione di un nome simbolico per l'accesso all'immagine di processo è illustrata nella figura:

Figura 5-6 Dichiarazione di un accesso simbolico all'immagine di processo

Per l'accesso assoluto all'immagine di processo vedere "Sintassi per l'identificatore dell'accesso assoluto all'immagine di processo (Pagina 275)".

La larghezza del numero intero o del tipo di dati bit dichiarato deve corrispondere a quella dell'accesso assoluto all'immagine di processo, vedere "Tipi di dati possibili dell'accesso simbolico all'immagine di processo (Pagina 277)". Dopo la dichiarazione di un tipo di dati numerico, si può richiamare il contenuto dell'immagine di processo come numero intero.

Vedere anche Esempio di dichiarazione (Pagina 278).

5.3.4.6 Tipi di dati possibili dell'accesso simbolico all'immagine di processo Nei casi seguenti è possibile assegnare all'immagine di processo fissa del BackgroundTask (Pagina 267) un tipo di dati diverso da quello dell'accesso assoluto all'immagine di processo. La larghezza del tipo di dati deve corrispondere a quella del tipo di dati dell'accesso assoluto all'immagine di processo.

● nella dichiarazione di un accesso simbolico all'immagine di processo (Pagina 276).

● nella creazione di una variabile I/O (Pagina 278).

Assegnando all'accesso simbolico all'immagine di processo o alle variabili I/O un tipo di dati numerico è possibile accedere a questa variabile come numero intero.

Tabella 5- 39 Tipi di dati possibili dell'accesso simbolico all'immagine di processo

Tipo di dati dell'accesso assoluto all'immagine di processo

Tipi di dati possibili dell'accesso simbolico all'immagine di processo

BOOL (%In.x, %IXn.x, %Qn.x. %QXn.x) BOOL BYTE (%IBn, %QBn) BYTE, SINT, USINT WORD (%IWn, %QWn) WORD, INT, UINT DWORD (%IDn, %PQDn) DWORD, DINT, UDINT

Per il tipo di dati dell'accesso assoluto all'immagine di processo vedere anche "Sintassi per l'identificatore dell'accesso assoluto all'immagine di processo (Pagina 275)".



5.3.4.7 Esempio di accesso simbolico all'immagine di processo Ad esempio si desidera accedere all'area di memoria della CPU (accesso assoluto all'immagine di processo (Pagina 275)) %IB10, ma con la possibilità di reagire in modo flessibile alle modifiche del programma utilizzato. Dichiarare quindi una variabile myInput con quest'area di memoria della CPU come segue:

VAR

myInput AT %IB10 : BYTE;

END_VAR

Se si desidera utilizzare un valore a numero intero dell'area di memoria, dichiarare la variabile myInput come segue:

VAR

myInput AT %IB10 : SINT;

END_VAR

Se in un secondo tempo si desidera utilizzare nel programma un'area di memoria della CPU diversa da %IB10, modificare l'accesso assoluto all'immagine di processo solo nella dichiarazione della variabile.

5.3.4.8 Creazione di una variabile I/O per l'accesso a una immagine di processo fissa di BackgroundTask

Le variabili I/O per accesso all'immagine di processo fissa del BackgroundTask si creano nel browser della visualizzazione dettagliata; a tal fine occorre passare in modalità offline.


1. Nella navigazione di progetto di SIMOTION SCOUT, selezionare l'elemento "I/O" nella diramazione dell'apparecchio SIMOTION.

2. Nella visualizzazione dei dettagli, aprire la scheda Browser dei simboli e scorrere la scheda fino alla fine della tabella delle variabili (riga vuota).

3. Inserire nell'ultima riga (riga vuota) della tabella o selezionare i seguenti elementi:

– Nome delle variabili.

– In Indirizzo I/O l'accesso assoluto all'immagine di processo secondo "Sintassi per l'identificatore dell'accesso assoluto all'immagine di processo (Pagina 275)" (eccezione: la sintassi %IXn.x opp. %QXn.x per il tipo di dati BOOL non è ammessa).

– Tipo di dati delle variabili I/O secondo "Tipi di dati possibili dell'accesso simbolico all'immagine di processo (Pagina 277)".

4. È possibile scegliere il formato di visualizzazione per il monitoraggio della variabile nel browser dei simboli.



Ora si può accedere a questa variabile con il browser dei simboli o con ciascun programma dell'apparecchio SIMOTION.

Nota

Le variabili I/O possono essere create solo in modalità offline. Le variabili I/O vengono create in SIMOTION SCOUT e utilizzate nelle sorgenti di programma.

Tenere presente che le uscite possono essere lette e scritte, ma gli ingressi possono solo essere letti.

Prima di poter monitorare e gestire variabili I/O nuove o aggiornate, è necessario caricare il progetto nel sistema di destinazione.

È possibile utilizzare una variabile I/O come qualsiasi altra variabile, vedere "Accesso alle variabili I/O (Pagina 279)".

5.3.5 Accesso alle variabili I/O È stata creata una variabile I/O per le seguenti operazioni:

● Accesso diretto o immagine di processo dei task ciclici (Pagina 256).

● Accesso all'immagine di processo fissa del BackgroundTask (Pagina 267).

È possibile utilizzare questa variabile I/O come qualsiasi altra variabile.

ATTENZIONE La coerenza è garantita solo per i tipi di dati elementari.

Se vengono utilizzati degli array, l'utente deve verificare autonomamente la coerenza dei dati.

Nota

Se sono state dichiarate variabili Unit o variabili locali con lo stesso nome (ad es. var-name), specificare la variabile I/O con _device.var-name (spazio del nome predefinito, vedere tabella "Spazi nome predefiniti" in "Spazi nome").

È possibile l'accesso diretto a una variabile I/O creata come immagine di processo di un task ciclico: specificare l'accesso diretto con _direct.var-name o _device._direct.var-name.

Per modificare il comportamento predefinito in caso di errori durante l'accesso alle variabili, utilizzare le funzioni _getSafeValue e _setSafeValue (vedere Manuale di guida alle funzioni Funzioni di base SIMOTION).

In caso di errori durante l'accesso alle variabili I/O, vedere Manuale di guida alle funzioni Funzioni di base SIMOTION.

Implementazione di ST in SIMOTION 5.4 Uso delle librerie


5.4 Uso delle librerie Le librerie mettono a disposizione i tipi di dati definiti dall'utente, le funzioni e i blocchi funzionali che possono essere utilizzati da tutti gli apparecchi SIMOTION.

Le librerie possono essere scritte in tutti i linguaggi di programmazione; possono essere utilizzate in tutte le sorgenti di programma (ad es. sorgenti ST, sorgenti MCC).

Per ulteriori dettagli sull'inserimento e la gestione delle librerie, consultare la guida in linea.

ATTENZIONE Per i nomi delle librerie valgono le stesse regole applicate per i nomi delle sorgenti di programma, vedere Inserimento sorgente ST (Pagina 21). In particolare la lunghezza dei nomi consentita dipende dalla versione del kernel SIMOTION: • A partire dalla versione V4.1 del kernel SIMOTION: max. 128 caratteri. • fino alla versione V4.0 del kernel SIMOTION: max. 8 caratteri.

Con le versioni fino alla V4.0 del kernel SIMOTION si rileva in determinate circostanze un superamento della lunghezza consentita del nome della libreria non appena si avvia una verifica della coerenza o il download del progetto.

In via opzionale una libreria può anche mettere a disposizione programmi richiamabili da altri programmi o blocchi funzionali. Per il richiamo di un "program in program" (Pagina 196) prestare attenzione ai requisiti necessari. I dati statistici del programma richiamato vengono memorizzati una volta soltanto nella memoria utente dell'apparecchio sul quale viene richiamato il programma della libreria. Ad ogni richiamo del programma sullo stesso apparecchio vengono utilizzati gli stessi dati di istanza. L'assegnazione di un programma della libreria al sistema esecutivo non è possibile.



5.4.1 Compilazione delle librerie Le librerie supportano l'uso di tutti i comandi ST, ad eccezione di quelli indicati nella tabella. Non sono inoltre consentiti alcuni accessi alle variabili, anch'essi indicati nella tabella.

Tabella 5- 40 Comandi ST e accessi a variabili non consentiti nelle librerie

Comandi non consentiti: • Funzione _getTaskId (vedere Manuale di guida alle funzioni Funzioni di base SIMOTION) • Funzione _getAlarmId (vedere Manuale di guida alle funzioni Funzioni di base SIMOTION) • Funzione _checkEqualTask (vedere Manuale di guida alle funzioni Funzioni di base SIMOTION) • Se la libreria viene compilata in modo indipendente dall'apparecchio (vale a dire senza riferimento

a un apparecchio SIMOTION e a una versione del SIMOTION kernel): – Funzioni di sistema degli apparecchi SIMOTION (vedere il Libretto di descrizione parametri

degli apparecchi SIMOTION) – funzioni di sistema dipendenti dalla versione

Accessi alle variabili non consentiti: • Variabili Unit (ritentive e non ritentive) • Variabili globali dell'apparecchio (ritentive e non ritentive) • Variabili I/O • Istanze degli oggetti tecnologici e relative variabili di sistema • Variabili dei nomi task e dei messaggi progettati (spazi nome _task e _alarm, vedere Spazi nome

(Pagina 288), tabella Spazi nomi predefiniti) • Se la libreria viene compilata in modo indipendente dall'apparecchio (vale a dire senza riferimento

a un apparecchio SIMOTION e a una versione del SIMOTION kernel): – Variabili di sistema degli apparecchi SIMOTION (vedere il Libretto di descrizione parametri

degli apparecchi SIMOTION) – Dati di configurazione degli oggetti tecnologici (vedere il Libretto di descrizione parametri dei

dati di configurazione del relativo pacchetto tecnologico SIMOTION)

Nota

Nelle librerie non è disponibile la funzione di debug Stato programma.

Compilazione della singola libreria



Per compilare una libreria singola, procedere come segue:

1. Selezionare la libreria nella navigazione di progetto.

2. Selezionare il menu Modifica > Proprietà dell'oggetto.

3. Selezionare la scheda TP/TO.

4. Selezionare gli apparecchi SIMOTION (con la versione del SIMOTION kernel) e i pacchetti tecnologici per i quali deve essere compilata la libreria; vedere il manuale di guida alle funzioni Funzioni di base SIMOTION.

5. Selezionare il menu contestuale Applica e compila.

La libreria viene compilata rispetto a tutti gli apparecchi SIMOTION selezionati, le versioni del SIMOTION kernel e i pacchetti tecnologici (o indipendentemente dall'apparecchio).

ATTENZIONE Se la libreria di compilare ne importa un'altra, tenere presente quanto segue: 1. Per la libreria importata vanno selezionati almeno gli stessi apparecchi e le stesse

versioni del SIMOTION kernel rispetto alla libreria in cui avviene l'importazione. In alternativa, la libreria importata può essere compilata in modo indipendente dagli apparecchi, se ci sono le relative premesse; vedere il manuale di guida alle funzioni Funzioni di base SIMOTION.

2. In rapporto a tutti gli apparecchi configurati, le versioni del kernel e i pacchetti tecnologici, la libreria importata deve già essere singolarmente compilata. Di norma non è sufficiente compilare la libreria nell'ambito di una compilazione di tutto il progetto.

Compilazione di una libreria nell'ambito di una compilazione di tutto il progetto Compilando l'intero progetto SIMOTION (ad es. con il comando di menu Progetto > Salva e ricompila tutto o con un'importazione XML) vengono compilate anche li librerie utilizzate.

ATTENZIONE Tenere presente per una compilazione di tutto il progetto: 1. Le relazioni tra le librerie sono riconosciute automaticamente, con conseguente scelta

della sequenza di compilazione. 2. Un libreria viene compilata solo per gli apparecchi SIMOTION (comprese le versioni del

SIMOTION kernel) che sono configurati nel progetto e la libreria utilizza. 3. Gli altri apparecchi SIMOTION e le altre versioni di kernel impostati per la libreria

vengono ignorati.



5.4.2 Protezione del know-how per le librerie È possibile proteggere le librerie o le loro sorgenti dall'accesso non autorizzato di terzi. Le librerie protette o le sorgenti possono essere aperte o esportate come file di testo in chiaro solo inserendo la password.

È possibile:

● Dotare di una protezione know-how le singole sorgenti di una libreria:

Solo le sorgenti sono protette dagli accessi non autorizzati.

L'impostazione degli apparecchi SIMOTION, incluse le versioni del SIMOTION Kernel e i pacchetti tecnologici, per la quale viene compilata la libreria, può ancora essere modificata e adattata dall'utente. Vedere Manuale di guida alle funzioni Funzioni di base SIMOTION.

L'utente può pertanto utilizzare la libreria per altri apparecchi SIMOTION e altre versioni del Kernel.

● Dotare di una protezione know-how la libreria:

In questo caso sono protette dagli accessi non autorizzati:

– tutte le sorgenti della libreria

– l'impostazione degli apparecchi SIMOTION, incluse le versioni del SIMOTION Kernel e i pacchetti tecnologici, per i quali deve essere compilata la libreria,

L'utente in questo caso non può utilizzare la libreria per altri apparecchi SIMOTION e altre versioni del Kernel.

Utilizzare questa impostazione solo se è davvero questo lo scopo dell'operazione.

Per maggiori informazioni sulla protezione know-how consultare la Guida in linea SIMOTION.

Nota

Per l'esportazione nel formato XML le librerie o le sorgenti vengono codificate. Durante l'importazione dei file XML codificati viene mantenuta la protezione know-how, inclusi login e password.



5.4.3 Uso di tipi di dati, funzioni e blocchi funzionali delle librerie Prima di utilizzare i tipi di dati, le funzioni o i blocchi funzionali delle librerie è necessario dichiararli alla sorgente ST. A questo scopo si utilizza il seguente costrutto nella sezione interfaccia della sorgente ST:

USELIB library-name [AS namespace];

library-name è il nome della libreria come viene visualizzato nella navigazione di progetto.

Numerose librerie possono essere indicate sotto forma di elenco separato da virgole, ad esempio:

USELIB library-name_1 [AS namespace_1],

library-name_2 [AS namespace_2],

library-name_3 [AS namespace_1] , ...

Aggiungendo opzionalmente AS namespace si può definire uno spazio del nome (Pagina 288).

● Si può accedere a tipi di dati, alle funzioni e ai blocchi funzionali della libreria che hanno lo stesso nome di quelli di una sorgente ST dell'apparecchio SIMOTION (nella cartella PROGRAMMI).

● Si possono inoltre eliminare i nomi doppi di tipi di dati, funzioni e blocchi funzionali presenti nelle librerie.

Uno spazio del nome può essere assegnato a diverse librerie.

Tabella 5- 41 Esempio di uso degli spazi del nome nelle librerie

INTERFACE

USELIB Bib_1 AS NS_1, Bib_2 AS NS_2;

PROGRAM Main_Program;

END_INTERFACE

IMPLEMENTATION

FUNCTION Function1 : VOID

VAR

ComID : CommandIdType;

END_VAR

ComId := _getCommandId();

END_FUNCTION

PROGRAM Main_program

function1(); // Funzione da questa sorgente

NS_1.Var1:=1;

NS_2.Var1:=2;

NS_1.function1(); // Funzione dalla libreria Bib1

NS_2.function1(); // Funzione dalla libreria Bib2

END_PROGRAM

END_IMPLEMENTATION

Implementazione di ST in SIMOTION 5.5 Uso di identificatori uguali, spazi del nome


5.5 Uso di identificatori uguali, spazi del nome

5.5.1 Uso di identificatori uguali È consentito l'uso di variabili Unit e di variabili locali (variabili di programma, variabili FB, variabili FC con lo stesso nome). Durante la compilazione di una sorgente di programma, il compilatore cerca gli identificatori che iniziano con l'unità di organizzazione programma (POE) corrente. L'area di validità più piccola ha sempre la priorità rispetto all'area più grande.

Ciò consente di utilizzare lo stesso identificatore in diverse sezioni del file sorgente se vengono rispettate le regole seguenti. Se un identificatore di una Unit o di una POE nasconde un identificatore sovraordinato, il compilatore emette un avviso.

ATTENZIONE In determinati casi il compilatore non è in grado di emettere un avviso, ad es. se il relativo pacchetto tecnologico non è importato.

Identificatori di un'unità di organizzazione del programma (POE) Tutti i seguenti identificatori di una POE devono essere univoci:

● Variabili locali della POE.

● Tipi di dati locali della POE.

Inoltre non devono essere identici ai seguenti identificatori:

● Identificatori riservati.

● Identificatori della POE stessa.

Se i seguenti identificatori vengono nascosti, il compilatore emette un avviso:

● Variabili Unit, tipi di dati e POE della stessa Unit o di Unit importate.

● Funzioni di sistema standard, blocchi funzionali di sistema standard e tipi di dati associati.

● Funzioni di sistema e tipi di dati di sistema dell'apparecchio SIMOTION.

● Unità di organizzazione del programma (POE) e tipi di dati di librerie importate.

– Il problema è risolvibile specificando uno spazio del nome definito dall'utente.

● Funzioni di sistema e tipi di dati di sistema di pacchetti tecnologici importati.


● Variabili dell'apparecchio SIMOTION (variabili di sistema, variabili I/O, variabili globali dell'apparecchio).

– Il problema è risolvibile specificando uno spazio del nome predefinito _device.

● Pacchetti tecnologici configurati sull'apparecchio SIMOTION

– Il problema è risolvibile specificando uno spazio del nome predefinito _to.



Identificatori di una Unit Gli identificatori esportati di tutte le Unit (variabili Unit, tipi di dati e POE) devono essere univoci a livello di apparecchio.

All'interno di una Unit tutti i seguenti identificatori devono essere univoci:

● Variabili Unit (dichiarate nella sezione interfaccia o implementazione).

● Tipi di dati (dichiarati nella sezione interfaccia o implementazione).

● Unità organizzative di programma (POE).



● Variabili Unit, tipi di dati e POE di Unit importate.



● Unità di organizzazione del programma (POE) e tipi di dati di librerie importate.


● Funzioni di sistema e tipi di dati di sistema di pacchetti tecnologici importati.


Se i seguenti identificatori vengono nascosti, il compilatore emette un avviso:

● Variabili dell'apparecchio SIMOTION (variabili di sistema, variabili I/O, variabili globali dell'apparecchio).

– Il problema è risolvibile specificando uno spazio del nome predefinito _device.

● Pacchetti tecnologici configurati sull'apparecchio SIMOTION.

– Il problema è risolvibile specificando uno spazio del nome predefinito _to.

Identificatori sull'apparecchio SIMOTION (ad es. variabili I/O, variabili globali dell'apparecchio) Tutti i seguenti identificatori sull'apparecchio SIMOTION devono essere univoci:

● Variabili I/O


● Variabili di sistema dell'apparecchio SIMOTION







Esempio L'esempio seguente illustra questa situazione: se si utilizza la stessa definizione delle variabili Unit (area di validità più grande) e delle variabili FC (area di validità più piccola), le uniche variabili valide in questa sezione del file sorgente sono quelle dichiarate nella funzione. Le variabili Unit sono valide solo nelle POE in cui non sono state dichiarate variabili locali con lo stesso nome. Vedere a questo scopo l'esempio.

Tabella 5- 42 Esempio di identificatori validi

TYPE

type_a : (enum1, enum2, enum3);

END_TYPE

VAR_GLOBAL

var_a, var_b : DINT; // Variabili Unit

END_VAR

FUNCTION fc_1 : VOID

VAR

var_a : type_a; // La dichiarazione nasconde la variabile

Unit

var_c : DINT; // Variabile locale

END_VAR

// Istruzioni consentite

var_a := enum2; // Accesso alla variabile locale

var_b := 100; // Accesso alla variabile Unit

var_c := -1; // Accesso alla variabile locale

// Istruzione non consentita

// var_a := 200;

END_FUNCTION

FUNCTION fc_2 : VOID

VAR

var_b : type_a; // La dichiarazione nasconde la variabile UNIT

var_c : type_a; // Variabile locale

END_VAR

// Istruzioni consentite

var_a := -100; // Accesso alla variabile Unit

var_b := enum3; // Accesso alla variabile locale

var_c := enum1; // Accesso alla variabile locale

// Istruzione non consentita

// var_b := 200;

END_FUNCTION



5.5.2 Spazi del nome Per accedere ai tipi di dati, alle variabili, alle funzioni e ai blocchi funzionali definiti al di fuori di una sorgente di programma (libreria, pacchetto tecnologico, apparecchio SIMOTION), si può utilizzare comunque il nome assegnato.

Durante la compilazione di una sorgente di programma, il compilatore cerca gli identificatori che iniziano con l'unità di organizzazione programma (POE) corrente. I tipi di dati, le variabili, le funzioni o i blocchi funzionali dichiarati in una sorgente di programma si sovrappongono quindi agli identificatori con lo stesso nome definiti al di fuori della sorgente; vedere Uso di identificatori uguali (Pagina 285). Per raggiungere comunque questi identificatori, in certi casi è possibile utilizzare gli spazi del nome.

Spazio del nome definito dall'utente Nelle istruzioni d'importazione per le librerie e i pacchetti tecnologici è possibile definire spazi del nome per poter raggiungere i tipi di dati, le funzioni o i blocchi funzionali di tali librerie e pacchetti tecnologici.

USELIB library-name_1 [AS lib_namespace_1],

library-name_2 [AS lib_namespace_2],

library-name_3 [AS lib_namespace_1], ...

USEPACKAGE tp-name_1 [AS tp_namespace_1],

tp-name_2 [AS tp_namespace_2],

tp-name_3 [AS tp_namespace_1], ...

In questo modo si possono eliminare anche i nomi doppi all'interno di librerie diverse.

Per utilizzare una funzione, un blocco funzionale o un tipo di dati di una libreria o di un pacchetto tecnologico impostare la denominazione dello spazio dei nomi con un punto di separazione davanti al nome corrispondente, ad es. namespace.fc-name, namespace.fb-name, namespace.type-name.



Esempio

L'esempio seguente illustra come scegliere il pacchetto tecnologico Cam, come assegnare ad esso lo spazio del nome Cam1 e come utilizzare lo spazio del nome:

Tabella 5- 43 Esempio di selezione di un pacchetto tecnologico e uso di uno spazio del nome

INTERFACE

USEPACKAGE Cam AS Cam1;

USES ST_2;

FUNCTION function1;

END_INTERFACE

IMPLEMENTATION

FUNCTION function1 : VOID

VAR_INPUT

p_Axis : posAxis;

END_VAR

VAR

retVal : DINT;

END_VAR

retVal:= Cam1._enableAxis (

axis := p_Axis,

nextCommand := Cam1.WHEN_COMMAND_DONE,


END_FUNCTION

END_IMPLEMENTATION

ATTENZIONE Se per una libreria importata o un pacchetto tecnologico è definito uno spazio del nome, lo stesso deve essere sempre specificato se si utilizza una funzione, un blocco funzionale o un tipo di dati di tale libreria o del pacchetto tecnologico. Vedere nell'esempio di cui sopra: Cam1._enableAxis, Cam1.WHEN_COMMAND_DONE.



Spazio del nome predefinito Per le variabili specifiche dell'apparecchio e del progetto e per le variabili del TaskId e dell'AlarmId esistono spazi dei nomi predefiniti. Anteporre eventualmente la denominazione al nome della variabile separandola da quest'ultimo con un punto, ad es. _device.var-name oppure _task.task-name.

Tabella 5- 44 Spazi nome predefiniti

Spazio del nome

Descrizione

_alarm Per gli AlarmId: La variabile _alarm.name contiene l'AlarmId del messaggio con l'identificatore name (vedere il Manuale di guida alle funzioni Funzioni di base SIMOTION).

_device Per le variabili specifiche per l'apparecchio (variabili globali per l'apparecchio, variabili I/O, variabili di sistema dell'apparecchio SIMOTION).

_direct Per l'accesso diretto alle variabili I/O, vedere Accesso diretto e immagine di processo dei task ciclici (Pagina 256). Spazio del nome locale per _device. L'annidamento _device._direct.name è consentito.

_project Per i nomi degli apparecchi SIMOTION nel progetto; solo per l'utilizzo con oggetti tecnologici su altri apparecchi. In caso di nomi univoci in tutto il progetto anche per questi e le relative variabili.

_task Per i TaskId: La variabile _task.name contiene il TaskId del task con l'identificatore name (vedere il Manuale di guida alle funzioni Funzioni di base SIMOTION).

_quality A partire dalla versione V4.2 del kernel SIMOTION: Per lo stato dettagliato delle variabili I/O (Pagina 265). Viene fornito un valore con tipo dati DWORD. Spazio del nome locale per _device. L'annidamento _device._quality.name è consentito.

_to Per gli oggetti tecnologici configurati sull'apparecchio SIMOTION e per le relative variabili di sistema e dati di configurazione. Non per le funzioni di sistema e per i tipi di dati degli oggetti tecnologici. In questo caso si utilizza eventualmente lo spazio dei nomi definito dall'utente per l'oggetto tecnologico importato.



Figura 5-7 Spazi dei nomi e gerarchia degli identificatori

Implementazione di ST in SIMOTION 5.6 Dati di riferimento


5.6 Dati di riferimento Utilizzando i dati di riferimento si può avere una panoramica su:

● identificatori utilizzati con indicazione della dichiarazione e dell'uso (elenco riferimenti incrociati (Pagina 292)).

● chiamate delle funzioni e relativo annidamento (struttura del programma (Pagina 296))

● requisiti di memoria di diversi settori dati delle sorgenti di programma (attributi di codice (Pagina 298))

5.6.1 Elenco dei riferimenti incrociati Nell'elenco dei riferimenti incrociati sono contenuti tutti identificatori delle sorgenti di programma (ad es. sorgenti ST, sorgenti MCC).

● i tipi di dati dichiarati come variabili o come unità di organizzazione programma (programma, funzione, blocco funzionale),

● gli identificatori utilizzati nelle dichiarazioni come tipi di dati precedentemente definiti,

● gli identificatori utilizzati come variabili nella sezione istruzioni di una unità di organizzazione programma.

L'elenco dei riferimenti incrociati può essere costituito in modo selettivo per:

● una singola sorgente di programma (ad es. sorgente ST, sorgente MCC e sorgente KOP/FUP)

● tutte le sorgenti di programma di un apparecchio SIMOTION

● tutte le sorgenti di programma e le librerie del progetto

● le librerie (tutte le librerie o una sola)

5.6.1.1 Creazione elenco dei riferimenti incrociati Per creare l'elenco di riferimenti incrociati:

1. Selezionare nella navigazione di progetto l'elemento corrispondente per il quale si vuole creare l'elenco di riferimenti incrociati.

2. Selezionare il menu Modifica > Dati di riferimento > Genera.

L'elenco dei riferimenti incrociati viene visualizzato in una scheda della visualizzazione dei dettagli.



Nota

L'elenco dei riferimenti incrociati generato viene salvato automaticamente e può essere visualizzato in modo selettivo selezionando l'elemento corrispondente nella navigazione di progetto. Selezionare a questo scopo il menu Modifica > Dati di riferimento > Visualizza > Riferimenti incrociati..

Quando si crea un nuovo elenco dei riferimenti incrociati, questo viene aggiornato solo in modo selettivo (a seconda dell'elemento selezionato nella navigazione di progetto). Gli altri dati esistenti di riferimenti incrociati vengono mantenuti ed eventualmente visualizzati.

5.6.1.2 Contenuto dell'elenco dei riferimenti incrociati L'elenco dei riferimenti incrociati contiene tutti gli identificatori assegnati all'elemento selezionato della navigazione di progetto, nonché i relativi utilizzi in forma di tabella:

L'utilizzo dell'elenco dei riferimenti incrociati è descritto nel paragrafo "Uso dell'elenco dei riferimenti incrociati (Pagina 295)".

Tabella 5- 45 Significato delle colonne e delle voci selezionate nell'elenco dei riferimenti incrociati

Colonna Voce nella colonna Significato Nome Nome dell'identificatore Tipo Tipo dell'identificatore Nome • Tipo di dati di una variabile (ad es. REAL, INT)

• Tipo di POE (ad es. PROGRAM, FUNCTION).

DERIVED Tipo di dati derivato DERIVED ANY_OBJECT Tipo di dati TO ARRAY … Tipo di dati ARRAY ENUM … Tipo di dati enumerazione (enumeratore) STRUCT … Tipo di dati STRUCT Dichiarazione Posizione della dichiarazione Nome (Unit) Dichiarazione nella sorgente di programma Nome Nome (LIB) Dichiarazione nella libreriaNome Nome (TO) Variabile di sistema dell'oggetto tecnologico Nome Nome (TP) Dichiarazione nella libreria standard indicata:

• Pacchetto tecnologico Nome • std_fct = libreria IEC • device = libreria specifica dell'apparecchio

Nome (DV) Dichiarazione sull'apparecchio SIMOTION Nome (ad es. variabile I/O o variabile globale dell'apparecchio)

_project Dichiarazione nel progetto (ad es. oggetto tecnologico) _device Variabile interna nell'apparecchio SIMOTION (ad es. informazioni avvio task) _task Task nel sistema esecutivo



Colonna Voce nella colonna Significato Utilizzo Utilizzo dell'identificatore CALL Richiamo come sottoprogramma ENUM Nome Come elemento per la dichiarazione del tipo di dati enumerazione Nome. I/O Dichiarazione come variabile I/O R Accesso in lettura R (TYPE) Come tipo di dati in una dichiarazione R/W Accesso in lettura e scrittura STRUCT Nome Come componente per la dichiarazione della struttura Nome. TYPE Dichiarazione come tipo di dati o POE Tipo di variabile (ad es. VAR,

VAR_GLOBAL) Dichiarazione come variabile del tipo indicato

W Accesso in scrittura Indicazione del percorso Indicazione del percorso dell'apparecchio SIMOTION o della sorgente di

programma Nome Apparecchio SIMOTION Nome Nome1 / Nome2 • Sorgente di programma Nome2 all'apparecchio SIMOTION Nome1

• Sorgente di programma Nome2 nella libreria Nome1

Nome / taskbind.hid Sistema esecutivo dell'apparecchio SIMOTION Nome Campo Area all'interno dell'apparecchio SIMOTION o della sorgente di programma IMPLEMENTATION Sezione di implementazione della sorgente di programma INTERFACE Sezione di interfaccia della sorgente di programma Tipo POE Nome(ad es.

FUNCTION Nome, PROGRAM Nome)

Unità organizzativa programma (POE) Nome all'interno della sorgente di programma (anche MCC-Chart, programma KOP/FUP)

Indirizzo I/O Variabile I/O TASK Nome Assegnazione al task Nome _device Variabile globale di apparecchiatura Lingua Linguaggio di programmazione della sorgente di programma Riga/Blocco Numero di riga della sorgente di programma (ad es. sorgente ST)

Per sorgenti MCC o MCC-Chart vengono visualizzati anche: • Numero: numerazione progressiva del comando (numero blocco) o • DT: tabella di dichiarazione



Nota Funzioni di diagnostica controllo dei passi singoli e traccia luminosa nella programmazione MCC

Per queste funzioni di diagnostica vengono create o impiegate variabili e funzioni aggiuntive:• per la funzione di diagnostica del controllo dei passi singoli vengono impiegate le variabili

TSI#dwuser_1 e TSI#dwuser_2 delle informazioni avvio task). • Per la funzione di diagnostica della traccia luminosa vengono create automaticamente

dal compilatore diverse funzioni e variabili interne, i cui identificatori cominciano con un carattere di sottolineatura. Inoltre viene impiegata la variabile TSI#currentTaskId delle informazioni avvio task.

Con la funzione di diagnostica attivata, queste variabili e funzioni vengono impiegate per il controllo della funzione di diagnostica. Queste variabili e funzioni non devono essere impiegate nel programma utente.

5.6.1.3 Uso dell'elenco dei riferimenti incrociati Nell'elenco dei riferimenti incrociati è possibile effettuare le seguenti operazioni:

● Ordinamento alfabetico nelle colonne:

– È sufficiente fare clic sull'intestazione della rispettiva colonna.

● Ricerca di un identificatore o di una voce:

– Fare clic sul pulsante "Trova" e inserire l'espressione da cercare.

● Filtraggio (Pagina 296) delle voci e degli indicatori visualizzati.

● Copiare il contenuto negli appunti per poterlo utilizzare, ad esempio, in un programma di calcolo delle tabelle:

– Contrassegnare le righe e le colonne corrispondenti.

– Premere la combinazione di tasti CTRL+C.

● Stampare il contenuto (menu Progetto°> Stampa).

● Aprire la sorgente del programma con ricerca del punto di riferimento e posizionare il cursore sulla riga corrispondente della sorgente ST (oppure comando MCC o elemento KOP/FUP):

– a questo scopo fare doppio clic sulla riga corrispondente dell'elenco dei riferimenti incrociati.

oppure

– Posizionare il cursore nella riga corrispondente dell'elenco dei riferimenti incrociati e fare clic sul pulsante "Vai all'applicazione".

Per maggiori informazioni sull'uso dell'elenco dei riferimenti incrociati consultare la Guida in linea.



5.6.1.4 Filtraggio dell'elenco di riferimenti incrociati È possibile filtrare le voci nell'elenco dei riferimenti incrociati per limitare la visualizzazione solo a quelle rilevanti:

1. Fare clic sul pulsante "Impostazioni di filtraggio".

Viene visualizzata la finestra "Impostazioni di filtraggio per riferimenti incrociati".

2. Attivare la casella di controllo "Filtro attivo".

3. Se si intende visualizzare anche variabili e funzioni di sistema:

– Disattivare la casella di controllo "Visualizza solo variabili definite dall'utente".

4. Impostare il criterio di filtraggio desiderato per le colonne corrispondenti:

– Selezionare la voce corrispondente dall'elenco oppure immettere il criterio.

– Se si desidera cercare una sequenza di caratteri all'interno di una voce: Disattivare la casella di controllo "Solo parole intere".


L'elenco dei riferimenti incrociati viene visualizzato in base alle impostazioni selezionate per il filtraggio.

Nota

Dopo la creazione dell'elenco di riferimenti incrociati un filtro risulta attivato per impostazione predefinita.

5.6.2 Struttura del programma Nella struttura del programma compaiono tutte le chiamate delle funzioni e il relativo annidamento di un elemento selezionato.

Dopo che l'elenco dei riferimenti incrociati è stato creato correttamente, è possibile visualizzare la struttura del programma in modo che contenga selettivamente:




● librerie (tutte le librerie, una singola libreria, singole sorgenti di programma all'interno di una libreria)




1. Selezionare nella navigazione di progetto l'elemento corrispondente per il quale si vuole visualizzare la struttura di programma.

2. Selezionare il menu Modifica > Dati di riferimento > Visualizza > Struttura di programma.

Al posto della scheda Riferimenti incrociati, nella visualizzazione dei dettagli compare solo la scheda Struttura del programma.

5.6.2.1 Contenuto della struttura di programma In una struttura ad albero vengono visualizzati:

● come radice rispettivamente

– le unità di organizzazione programma (programmi, funzioni, blocchi funzionali) dichiarate nella sorgente di programma o

– i task impiegati nel sistema esecutivo

● al di sotto i sottoprogrammi a cui si fa riferimento in questa unità di organizzazione e/o in questo task del programma.

Per la struttura delle voci vedere la tabella:



Tabella 5- 46 Elementi della visualizzazione per la struttura del programma

Elemento Descrizione Radice (POE dichiarata o task utilizzato)

Lista separata da virgola • Identificatore dell'unità organizzativa di programma (POE) o del task • Identificatore della sorgente di programma in cui l'unità organizzativa

(POE) o il task è stata dichiarata/o, con il suffisso [UNIT] • Memoria stack minima e massima necessaria (memoria necessaria della

POE e o del task sullo stack dei dati locali) in byte [Min, Max] • Memoria stack complessiva minima e massima necessaria (memoria

necessaria della POE e/o del task sullo stack dei dati locali, incluse tutte le POE richiamate) in byte [Min, Max]

POE referenziate Lista separata da virgola: • Identificatore delle POE richiamate • opzionale: Identificatore della sorgente di programma o del pacchetto

tecnologico in cui è stata dichiarata la POE:

Aggiunta (UNIT): Sorgente del programma definita dall'utente

Aggiunta (LIB): Libreria

Aggiunta (TP): Funzione di sistema dal pacchetto tecnologico • Solo nei blocchi funzionali: Identificatore dell'istanza • Solo nei blocchi funzionali: Identificatore della sorgente di programma in

cui è stata dichiarata l'istanza:

Aggiunta (UNIT): Sorgente del programma definita dall'utente

Aggiunta (LIB): Libreria • Riga della sorgente (generata) in cui viene richiamata la POE; più righe

vengono separate da "I".

5.6.3 Attributi di codice Con gli attributi di codice si ottengono informazioni sui requisiti di memoria di diversi settori dati delle sorgenti di programma.

Dopo che l'elenco dei riferimenti incrociati è stato creato correttamente, è possibile visualizzare gli attributi di codice in modo che contengano selettivamente:




● librerie (tutte le librerie, una singola libreria, singole sorgenti di programma all'interno di una libreria)

Implementazione di ST in SIMOTION 5.7 Controllo del preprocessore e del compilatore tramite pragma



1. Selezionare nella navigazione di progetto l'elemento corrispondente per il quale si vogliono visualizzare gli attributi di codice.

2. Selezionare il menu Modifica > Dati di riferimento > Visualizza > Attributi di codice.

Nella visualizzazione dei dettagli, al posto della scheda Riferimenti incrociati compare adesso la scheda Attributi di codice.

5.6.3.1 Contenuto degli attributi di codice In una tabella vengono visualizzati, per tutte le sorgenti di programma selezionate:

● l'identificatore della sorgente di programma,

● la memoria necessaria in byte per le seguenti aree di dati della sorgente di programma:

– Dati dinamici: tutte le variabili Unit (ritentive e non ritentive, nelle sezioni interfaccia ed implementazione),

– Dati Retain: variabili Unit ritentive nella sezione interfaccia e nella sezione implementazione,

– Dati interfaccia: variabili Unit (ritentive e non ritentive) nella sezione interfaccia,

● la grandezza codice per l'ultima compilazione in byte,

● il numero delle sorgenti sincronizzate:

Viene visualizzato il numero massimo delle sorgenti collegate (incluse le librerie di sistema), indipendentemente dal fatto se successivamente verranno caricate nel sistema di destinazione.

5.7 Controllo del preprocessore e del compilatore tramite pragma Si usa un pragma per inserire in una sorgente ST del testo (ad es. istruzioni) che influenza la compilazione della sorgente stessa.

I pragma sono racchiusi fra parentesi graffe { e } e possono contenere (vedere immagine):

● Istruzioni del preprocessore per il comando dello stesso, vedere Comando del preprocessore (Pagina 300).

I pragma contenuti in una sorgente ST con istruzioni del preprocessore vengono analizzati da quest'ultimo e interpretati come istruzioni di controllo.

● Attributi delle opzioni del compilatore per il comando dello stesso (vedere Gestione del compilatore tramite attributi (Pagina 304).

I pragma contenuti in una sorgente ST con attributi per le opzioni del compilatore vengono analizzati da quest'ultimo e interpretati come istruzioni di controllo.



Figura 5-8 Sintassi dei pragma

ATTENZIONE Rispettare accuratamente la sintassi di un pragma (ad es. grafia maiuscola e minuscola degli attributi).

I pragma non riconosciuti dal sistema vengono ignorati e non viene emesso alcun avviso.

5.7.1 Comando del preprocessore Il preprocessore prepara una sorgente ST per la compilazione. Ad es. è possibile definire sequenze di caratteri come testi sostitutivi per l'identificatore oppure visualizzare o nascondere sezioni del programma sorgente per la compilazione.

Di norma il preprocessore è disattivato. È possibile attivarlo come segue:

● Globalmente per tutte le sorgenti di programma e i linguaggi di programmazione all'interno del progetto, vedere "Impostazioni globali del compilatore (Pagina 59)".

● Localmente per una sorgente di programma, vedere "Impostazioni globali del compilatore (Pagina 61)".

Durante la compilazione di una sorgente di programma l'utente viene informato del lavoro del preprocessore. Affinché questo sia possibile è necessario attivare la visualizzazione di avvisi della classe 7, vedere Significato delle classi di avviso (Pagina 67). L'ambito dei messaggi di avviso e delle informazioni emesse viene definito:

● Nelle impostazioni globali o locali del compilatore.

● Con l'attributo _U7_PoeBld_CompilerOption := warning:n:off o warning:n:on all'interno di una sorgente ST, vedere "Gestione del compilatore tramite attributi (Pagina 304)".

Le informazioni sul lavoro del preprocessore sono contenute nei messaggi del compilatore visualizzate nella scheda "Compila / verifica output" della visualizzazione dei dettagli.



Nota

È anche possibile visualizzare il testo della sorgente ST modificato dal preprocessore: 1. Aprire la sorgente ST. 2. Selezionare il menu Sorgente ST > Esegui preprocessore.

Il testo sorgente modificato viene visualizzato nella scheda "Compila / verifica output" della visualizzazione dei dettagli.

5.7.1.1 Istruzione del preprocessore Il preprocessore viene comandato in pragma mediante le istruzioni. Sono disponibili le istruzioni riportate nel seguente diagramma della sintassi. Le istruzioni hanno effetto sulle seguenti righe della sorgente ST.

Possono essere utilizzate nella sorgente ST di un apparecchio SIMOTION o di una libreria

Le definizioni per il preprocessore possono essere impostate anche nella finestra di dialogo della sorgente ST (vedere Impostazione delle definizioni del preprocessore (Pagina 70)). È possibile controllare il preprocessore anche nelle sorgenti STQ con protezione del know-how (vedere Protezione del know-how per le sorgenti ST (Pagina 69).

Figura 5-9 Sintassi di un'istruzione del preprocessore



Tabella 5- 47 Istruzioni del preprocessore

Istruzione Significato #define Di seguito l'identificatore indicato verrà sostituito con il testo indicato.

Caratteri consentiti: vedere ultima riga della tabella. #undef Le norme per la sostituzione dell'identificatore vengono eliminate. #ifdef Per la formazione delle varianti (compilazione condizionata)

Se l'identificatore indicato è definito, le seguenti righe di programma (fino al successivo pragma contenente #else oppure #endif) vengono compilate dal compilatore.

#ifndef Per la formazione delle varianti (compilazione condizionata) Se l'identificatore indicato non è definito, le seguenti righe di programma (fino al successivo pragma contenente #else oppure #endif) vengono compilate dal compilatore.

#else Per la formazione delle varianti (compilazione condizionata) Diramazione alternativa a #ifdef oppure a #ifndef. Le seguenti righe di programma (fino al pragma successivo contenente #endif) vengono compilate dal compilatore se la richiesta precedente non è stata soddisfatta con #ifdef oppure #ifndef.

#endif chiude la diramazione alternativa a #ifdef oppure a #ifndef. Caratteri consentiti: • Per gli identificatori: In base alle regole per gli identificatori (Pagina 93). • Per il testo: stringa di caratteri qualsiasi tranne \ (backlash), ' (virgoletta singola - single quote),

" (virgoletta doppia - double quote). Le parole chiave USES, USELIB e USEPACKAGE non sono ammesse.

Nota

Ogni istruzione del preprocessore deve iniziare in una nuova riga e terminare con un'interruzione di riga. Le parentesi graffe che racchiudono il pragma { e } devono perciò trovarsi su due righe diverse della sorgente ST.

Con i pragma con istruzioni #define prestare attenzione a quanto segue: • I pragma presenti nella sezione interfaccia di una sorgente ST con istruzioni #define

vengono esportati. Gli identificatori definiti possono essere importati in altre sorgenti ST dello stesso apparecchio SIMOTION o della stessa libreria con l'istruzione USES.

• Gli identificatori definiti nei pragma delle librerie non possono essere importati nelle sorgenti ST di un apparecchio SIMOTION.

• Impossibile modificare la definizione degli identificatori riservati.

Le definizioni per il preprocessore possono essere effettuate anche nella finestra di dialogo Proprietà della sorgente ST. In presenza di definizioni diverse di identificatori simili, le istruzioni #define hanno la priorità all'interno della sorgente ST.



5.7.1.2 Esempio di istruzioni per il preprocessore

Tabella 5- 48 Esempio di istruzioni per il preprocessore

Sorgente ST

con istruzioni del preprocessore

Output del preprocessore

INTERFACE

FUNCTION_BLOCK fb1;

VAR_GLOBAL

g_var : INT;

END_VAR

// Definizioni del preprocessore

{

#define my_define g_var

#define my_call f(my_define)

}

// my_define -> g_var

// my_call -> f(g_var)

END_INTERFACE

IMPLEMENTATION

FUNCTION f : INT

VAR_INPUT

i : INT;

END_VAR

f := i;

END_FUNCTION

FUNCTION_BLOCK fb1

VAR_INPUT

i_var : INT;

END_VAR

VAR_OUTPUT

o_var : INT;

END_VAR

my_define := i_var;

// Cancellazione della definizione del

preprocessore

// Per my_define

{

#undef my_define

}

o_var := my_call + 1;

{

#ifdef my_define

}

my_define := i_var;

{

#endif

}

END_FUNCTION_BLOCK

END_IMPLEMENTATION

INTERFACE

FUNCTION_BLOCK fb1;

VAR_GLOBAL

g_var : INT;

END_VAR

{

}

END_INTERFACE

IMPLEMENTATION

FUNCTION f : INT

VAR_INPUT

i : INT;

END_VAR

f := i;

END_FUNCTION

FUNCTION_BLOCK fb1

VAR_INPUT

i_var : INT;

END_VAR

VAR_OUTPUT

o_var : INT;

END_VAR

g_var := i_var;

{

}

o_var := f(g_var) + 1;

{

}

END_FUNCTION_BLOCK

END_IMPLEMENTATION



5.7.2 Gestione del compilatore tramite attributi Per comandare il compilatore è possibile utilizzare gli attributi all'interno di un pragma.

Figura 5-10 Sintassi di un attributo per le opzioni del compilatore

Tabella 5- 49 Attributi ammessi per le opzioni del compilatore

Definizione attributo Valore attributo Significato L'attributo influenza l'emissione di avvisi ed informazioni del compilatore all'interno di una sorgente ST ed è attivo su tutte le seguenti righe della sorgente ST. warning:n:err Output dell'avviso o dell'informazione specificati come errore

tramite il numero n. Valori consentiti per n: n = 16000 ff: Numero di un avviso o un'informazione.

warning:n:off Nessuna visualizzazione degli avvisi o delle informazioni specificati con il numero n. Valori consentiti per n: n = 0..7 : Classe di avviso, vedere Significato delle classi di avviso (Pagina 67). n = 16000 ff: Numero di un avviso o un'informazione.

_U7_PoeBld_CompilerOption

warning:n:on Visualizzazione degli allarmi specificati con il numero n Valori consentiti per n: n = 0..7 : Classe di avviso, vedere Significato delle classi di avviso (Pagina 67). n = 16000 ff: Numero di un avviso o un'informazione.

L'attributo modifica l'impostazione standard relativa a quali variabili Unit sono disponibili sugli apparecchi HMI. Deve trovarsi subito dopo la parola chiave del blocco di dichiarazione seguente: • VAR_GLOBAL • VAR_GLOBAL RETAIN Ha effetto solo sul blocco di dichiarazione delle variabili Unit dichiarate. Per una descrizione completa dell'esportazione HMI, in particolare dell'effetto dell'attributo in base alla versione del SIMOTION kernel vedere Variabili e apparecchi HMI (Pagina 248). FALSE Nella sezione interfaccia di una sorgente ST. Le variabili Unit

dichiarate nel blocco di dichiarazione interessato non sono disponibili sugli apparecchi HMI.

HMI_Export

TRUE Nella sezione implementazione di una sorgente ST. Le variabili Unit dichiarate nel blocco di dichiarazione interessato sono disponibili sugli apparecchi HMI.



Definizione attributo Valore attributo Significato L'attributo cambia l'impostazione standard relativa alla possibilità effettuare un download in modalità RUN durante la modifica dell'identificazione della versione del relativo blocco di dichiarazione. Deve trovarsi subito dopo la parola chiave del blocco di dichiarazione seguente: • VAR_GLOBAL (nella sezione interfaccia e implementazione) • VAR_GLOBAL RETAIN (nella sezione interfaccia e implementazione) • VAR (solo nei programmi con una Unit, se l'opzione del compilatore "Crea dati di

istanza del programma solo una volta" è attiva). Ha effetto solo sul blocco di dichiarazione delle variabili dichiarate. Vedere anche Identificazione della versione delle variabili globali e relativa inizializzazione in fase di download (Pagina 247). FALSE Download in modalità RUN non possibile durante la modifica

dell'identificazione della versione del blocco di dichiarazione (preimpostazione).

BlockInit_OnChange

TRUE Download in modalità RUN possibile nonostante la modifica dell'identificazione della versione del blocco di dichiarazione. In questo modo le variabili del blocco di dichiarazione vengono inizializzate.

Efficace solo a partire dalla versione V4.1 del SIMOTION kernel. L'attributo cambia l'impostazione standard relativa all'inizializzazione delle variabili del relativo blocco di dichiarazione nel passaggio allo stato operativo RUN. Deve trovarsi subito dopo la parola chiave del blocco di dichiarazione seguente: • VAR_GLOBAL (nella sezione interfaccia e implementazione) • VAR (solo nei programmi con una Unit, se l'opzione del compilatore "Crea dati di

istanza del programma solo una volta" è attiva). Ha effetto solo sul blocco di dichiarazione delle variabili dichiarate. Vedere anche Aree di memoria dei tipi di variabili (Pagina 232). DISABLE Le variabili dichiarate nel blocco di dichiarazione interessato non

vengono inizializzate nel passaggio dallo stato operativo STOP allo stato operativo RUN.

ALWAYS Le variabili dichiarate nel blocco di dichiarazione interessato vengono inizializzate nel passaggio dallo stato operativo STOP allo stato operativo RUN.

BlockInit_OnDeviceRun

Preimpostazione: Fino alla versione V4.1 del SIMOTION kernel: DISABLE. A partire dalla versione V4.2 del SIMOTION kernel: In base all'impostazione nell'apparecchio

ATTENZIONE Rispettare la grafia maiuscola e minuscola degli attributi



Nota

L'inserimento, la cancellazione o la modifica degli attributi HMI_Export, BlockInit_OnChange o BlockInit_OnDeviceRun di un blocco di dichiarazione non cambiano la relativa identificazione della versione.

Tabella 5- 50 Esempio di attributo per le opzioni del compilatore

INTERFACE

VAR_GLOBAL

{ HMI_Export := FALSE;

BlockInit_OnChange := TRUE; }

// Nessuna importazione HMI, possibilità di download in modalità

RUN

x : DINT;

END_VAR

FUNCTION_BLOCK fb1;

END_INTERFACE

IMPLEMENTATION

VAR_GLOBAL

{ HMI_Export := TRUE;

BlockInit_OnDeviceRun := ALWAYS; }

// Esportazione HMI, inizializzazione nel passaggio da STOP a RUN

y : DINT;

END_VAR

FUNCTION_BLOCK fb1

VAR_INPUT

i_var : INT;

END_VAR

VAR_OUTPUT

o_var : INT;

END_VAR

{ _U7_PoeBld_CompilerOption := warning:2:on; }

o_var := REAL_TO_INT(1.0); // Avviso 16004

{ _U7_PoeBld_CompilerOption := warning:2:off; }

o_var := REAL_TO_INT(1.0); // Nessuna avviso 16004

{ _U7_PoeBld_CompilerOption := warning:16004:on; }


{ _U7_PoeBld_CompilerOption := warning:16004:off; }

o_var := REAL_TO_INT(1.0); // Nessuna avviso 16004

{ _U7_PoeBld_CompilerOption := warning:2:off;

_U7_PoeBld_CompilerOption := warning:16004:on; }


END_FUNCTION_BLOCK

END_IMPLEMENTATION

Implementazione di ST in SIMOTION 5.8 Apparecchi SIMOTION


5.8 Apparecchi SIMOTION

5.8.1 Regole per gli identificatori di apparecchi SIMOTION

Informazioni generali sugli identificatori di apparecchi Non è necessario che gli identificatori degli apparecchi SIMOTION nella navigazione di progetto siano conformi alle Regole per gli identificatori (Pagina 93) generali.

Per l'identificatore di un apparecchio SIMOTION sono consentiti tutti i caratteri visualizzabili del set di caratteri ASCII esteso (Codice ASCII da $20 a $7E, da $80 a $FF), ad eccezione dei seguenti caratteri speciali:

● " (doppie virgolette alte, codice ASCII $22),

● & (caratteri Et, "e" commerciale, codice ASCII $26),

● * (asterisco, codice ASCII $2A),

● : (due punti, codice ASCII $3A),

● < (segno minore di, codice ASCII $3C),

● < (segno maggiore di, codice ASCII $3E),

● ? (punto interrogativo, codice ASCII $3F),

● \ (Barra inversa, codice ASCII $5C),

● | (Linea verticale, codice ASCII $7C).

Gli identificatori per gli apparecchi SIMOTION possono essere definiti solo nelle configurazioni SIMOTION SCOUT o HW, nei linguaggi di programmazione possono essere utilizzati in maniera esclusiva.

Esempi di identificatori di apparecchi validi

● C240.2

● D455-2-DP (1)

● D445-2.PN-1

Gli identificatori di apparecchi che non si attengono alle regole generale per identificatori possono essere impiegati per gli apparecchi SIMOTION di tutte le versioni (o tutte le versioni del SIMOTION Kernel).

ATTENZIONE I progetti contenenti identificatori di apparecchi che non si soddisfano le Regole per gli identificatori (Pagina 93) generali, non possono essere salvati nel vecchio formato di progetto (fino alla versione V4.2 inclusa).



Identificatori di apparecchi per PROFINET IO (Name of Station) Gli identificatori di apparecchi, che vengono impiegati come nomi di apparecchi nel caso di PROFINET IO (NameOfStation), devono corrispondere alle seguenti convenzioni DNS:

● Lunghezza consentita: da 1 a 127 caratteri.

● Struttura in punti "." consentita in più etichette; lunghezza di un'etichetta da 1 a 63 caratteri.

● Caratteri consentiti all'interno di un'etichetta:

– Lettere dalla "A" alla "Z" e dalla "a" alla "z".

– Cifre da "0" a "9" (non all'inizio dell'etichetta).

– Carattere speciale trattino "-" (non all'inizio e alla fine dell'etichetta).

– Altri caratteri speciali (ad es. dieresi, spazio vuoto, parentesi, sottolineatura) non sono consentiti.

● Per i nomi di apparecchi non sono consentiti i seguenti identificatori:

– Identificatori che iniziano con "port-xyz-" (x, y, z = 0 … 9),

– Identificatori nella forma n.n.n.n (n = 0 … 999).

Impiego di identificatori di apparecchi in SIMOTION SCOUT Identificatori per apparecchi SIMOTION che non soddisfano le regole generali per identificatori, nel caso di uso in SIMOTION SCOUT (ad es. nei linguaggi di programmazione) devono essere inclusi all'interno di doppie virgolette alte (", ASCII-Code $22).

Esempio:

● "D455-2 DP (1)".axis_1. motionStateData.actualVelocity

Accesso alla variabile di sistema motionStateData.actualVelocity dell'oggetto tecnologico axis_1 nell'apparecchio D455-2 DP (1).

Nota

Anche gli identificatori di apparecchi che si attengono alle Regole per gli identificatori (Pagina 93) generali, possono essere inclusi all'interno delle doppie virgolette alte.

Esempio: per l'accesso alla variabile di sistema motionStateData.motionState dell'oggetto tecnologico axis_2 nell'apparecchio D435_2 sono consentite le seguenti modalità di scrittura:• D435_2.axis_2.motionStateData.motionState • "D435_2".axis_2.motionStateData.motionState



5.8.2 Esecuzione delle impostazioni sull'apparecchio (dal kernel V4.2) Dalla versione V4.2 del SIMOTION Kernel è possibile eseguire tra l'altro le seguenti impostazioni sull'apparecchio SIMOTION:

● Settore di memoria per l'immagine di processo dei task ciclici e l'immagine di processo fissa dei BackgroundTask:

– Settori di memoria separati per entrambe le immagini di processo - Immagine di processo separata (Pagina 272)

– Immagine di processo comune (Pagina 269)

● Inizializzazione delle variabili globali non ritentive e dei dati di programma con transizione STOP-RUN

● Esecuzione della sincronizzazione automatica dell'ora con apparecchi di azionamento SINAMICS

● OPC-XML consentono variabili globali dell'apparecchio o variabili I/O

Le informazioni sui simboli di queste variabili sono a disposizione nell'apparecchio SIMOTION. Ciò è ad es. necessario per la funzione Watch di IT DIAG.

● Limitare il campo per l'assegnazione automatica di indirizzi in caso di progettazione di telegrammi (dalla versione V4.3 del SIMOTION Kernel).

Con casella di controllo attiva, l'area indirizzi indicata viene bloccata in caso di progettazione di telegrammi automatica. L'indicazione del campo di blocco non è attiva se il telegramma è già progettato.

Per una descrizione dettagliata consultare la Guida in linea.

Procedura Per eseguire le impostazioni sull'apparecchio:

1. Selezionare il relativo apparecchio SIMOTION nella navigazione di progetto.

2. Selezionare il menu Modifica > Proprietà oggetto.

3. Selezionare la scheda Impostazioni.

4. Effettuare le impostazioni desiderate.


Implementazione di ST in SIMOTION 5.9 Dichiarazioni anticipative


5.9 Dichiarazioni anticipative Solitamente per la creazione dei file sorgente occorre rispettare la sequenza dei segmenti del file sorgente. Affinché possa essere riconosciuta, una sezione richiamante deve sempre precedere la sezione che esegue il richiamo.

Le variabili, per esempio, devono essere dichiarate prima dell'uso, mentre le funzioni devono essere definite prima del richiamo e i blocchi funzionali prima della dichiarazione di istanza.

Dichiarazione anticipativa per unità organizzative di programma (POE) Con l'opzione del compilatore (Pagina 58) "Consenti dichiarazioni anticipative" attivata in un file sorgente sono possibili i seguenti utilizzi di unità organizzative di programma (POE) prima della definizione completa della rispettiva POE:

● dichiarazione di istanza di un blocco funzionale (Pagina 188),

● richiamo di una funzione (Pagina 187),

● richiamo di un programma all'interno di un altro programma (Pagina 196), se sono soddisfatti gli ulteriori requisiti.

Se questa opzione del compilatore è attivata, le seguenti istruzioni all'interno del costrutto TYPE / END_TYPE nella sezione interfaccia (Pagina 202) o sezione implementazione (Pagina 204) di una sorgente ST vengono implementate come prototipi:

● FUNCTION_BLOCK fb-name;

● FUNCTION fc-name;

● PROGRAM prog-name;

Figura 5-11 Sintassi: Prototipi POE

Dopo la dichiarazione del prototipo di un blocco funzionale, è possibile dichiarare un'istanza del blocco funzionale; l'implementazione del blocco funzionale avviene solo successivamente nella sorgente ST.



In occasione del richiamo di una funzione o di un programma prima della relativa implementazione, la dichiarazione del prototipo è opzionale; il richiamo può avvenire anche senza dichiarazione del prototipo. Per il richiamo di un programma all'interno di un altro programma, rispettare i requisiti seguenti.

Nota

Se i prototipi POE all'interno della sezione interfaccia sono dichiarati, le corrispondenti POE vengono esportate.

Anche le istruzioni di esportazione per POE all'interno della sezione interfaccia (ad es. FUNCTION_BLOCK fb-name;) vengono interpretate come prototipi.

In caso di opzione compilatore (Pagina 58) "Consenti dichiarazioni anticipative" non attivata i prototipi POE vengono ignorati. Solo i prototipi nella sezione interfaccia vengono interpretati come istruzioni di esportazione per la POE corrispondente.

Esempio

Tabella 5- 51 Programma di esempio con dichiarazione anticipativa

(*

Solo con opzione compilatore "Consenti dichiarazione anticipativa"

attivata.

*)

(*

In seguito al richiamo di un programma nel programma è necessaria anche

l'attivazione delle opzioni compilatore seguenti:

"Consenti estensioni lingua" e

"Crea dati di istanza del programma solo una volta".

*)

INTERFACE

PROGRAM prog_main;

END_INTERFACE

IMPLEMENTATION

TYPE // Prototipi POE

FUNCTION_BLOCK fb_1; // Necessario per dichiarazione di istanza

FUNCTION fc_1; // Opzionale

PROGRAM prog_1; // Opzionale

END_TYPE

// Dichiarazione di istanza prima dell'implementazione

VAR_GLOBAL

var_fb_1 : fb_1;

END_VAR



PROGRAM prog_main

VAR

var_1, var_2 : DINT;

var_3, var_4 : INT;

END_VAR

var_fb_1 (x_in := var_3, x_out => var_4);

// Richiamo prima dell'implementazione

var_2 := fc_1 (var_1);

prog_1();

END_PROGRAM

// Implementazioni

FUNCTION_BLOCK fb_1

VAR_INPUT

x_in : INT;

END_VAR

VAR_OUTPUT

x_out : INT;

END_VAR

x_out := x_in;

END_FUNCTION_BLOCK

FUNCTION fc_1: DINT

VAR_INPUT

x_in : DINT;

END_VAR

fc_1 := x_in;

END_FUNCTION

PROGRAM prog_1

VAR

var_int1, var_int2 : INT;

END_VAR

var_int1 := var_int2;

END_PROGRAM

END_IMPLEMENTATION

Implementazione di ST in SIMOTION 5.10 Istruzioni di salto ed etichette di salto


5.10 Istruzioni di salto ed etichette di salto Oltre alle istruzioni di controllo (vedere Istruzioni di controllo (Pagina 156)), è disponibile anche un'istruzione di salto.

Le istruzioni di salto vengono programmate con il comando GOTO tramite l'indicazione delle etichette di salto a cui si desidera passare. I salti sono ammessi solo all'interno di un'unità di organizzazione programma (POE).

Le etichette di salto vengono immesse (separate da due punti) prima dell'istruzione con cui si desidera continuare l'esecuzione del programma.

Se necessario, è possibile dichiarare le etichette di salto nell'unità di organizzazione programma (tramite la struttura LABEL/END_LABEL nella POE). Nella sezione istruzioni possono essere utilizzate solo le etichette di salto dichiarate.

Sintassi di istruzioni ed etichette di salto

Tabella 5- 52 Esempio di sintassi per istruzioni di salto

FUNCTION func : VOID

VAR

x, y, z : BOOL;

END_VAR

LABEL

lab_1, lab_2; // Dichiarazione delle etichette di salto

END_LABEL

x := y;

lab_1 : y := z; // Etichette di salto con istruzione

IF x = y THEN

GOTO lab_2; // Istruzione di salto

END_IF;

GOTO lab_1; // Istruzione di salto

lab_2 : ; // Etichetta di salto con istruzione vuota

END_FUNCTION

Nota

L'istruzione GOTO deve essere utilizzata solo in casi particolari (ad es. elaborazione degli errori). In base alle regole della programmazione strutturata, tale istruzione non dovrebbe comunque essere utilizzata.

I salti sono ammessi solo all'interno di un'unità di organizzazione programma (POE).

I seguenti salti non sono consentiti: • Salti nelle strutture di controllo di livello inferiore (WHILE, FOR, ecc.) • Salti da una struttura WAITFORCONDITION • Salti all'interno di istruzioni CASE

Le etichette di salto possono essere dichiarate solo nell'unità di organizzazione programma (POE) in cui vengono utilizzate. In caso di dichiarazione possono essere utilizzate solo le etichette dichiarate.

Implementazione di ST in SIMOTION 5.10 Istruzioni di salto ed etichette di salto



Fonti di errore e test del programma 6

Questo capitolo descrive le possibili fonti di errore durante la programmazione e illustra la procedura di programmazione corretta. Il capitolo illustra inoltre le varie possibilità per l'esecuzione del test del programma. Per tutti i possibili messaggi di errore durante la compilazione, ossia gli errori compilatore, vedere Messaggi di errore del compilatore e relativa eliminazione (Pagina 421). Per ogni errore esiste un rimedio, ossia una reazione appropriata.

6.1 Indicazioni su come evitare gli errori ed eseguire una programmazione efficace

Nel Manuale di guida alle funzioni Funzioni di base SIMOTION sono riportati alcuni degli errori più frequenti che impediscono la compilazione o l'esecuzione corretta di un programma. Sono disponibili ad es. indicazioni per:

● Tipi di dati nell'assegnazione di espressioni aritmetiche

● Avvio di funzioni nei task ciclici

● Tempi di attesa nei task ciclici

● Errori nel download

● Mancata attivazione della CPU

● CPU passa allo stato STOP

● Dimensioni dello stack dei dati locali

● ecc.

Inoltre sono presenti alcune indicazioni relative alla programmazione efficiente, in particolare per

● Programmazione orientata al runtime

● Programmazione ottimizzata per la modifica

Fonti di errore e test del programma 6.2 Test del programma


6.2 Test del programma Gli errori di sintassi vengono rilevati e visualizzati da ST nel processo di compilazione. Gli errori di runtime che si verificano durante l'esecuzione del programma vengono visualizzati attraverso allarmi di sistema oppure conducono allo stato operativo STOP. Gli errori logici di programmazione possono essere rilevati con le funzioni di test di ST, ad es. il browser dei simboli, lo stato programma e Trace

Per mantenere i risultati delle funzioni di test illustrati di seguito, si consiglia di fare riferimento al programma esemplificativo descritto nel Creazione di un programma esemplificativo (Pagina 79).

6.2.1 Modi operativi per il test del programma

6.2.1.1 Modi operativi degli apparecchi SIMOTION Per il test del programma sono disponibili diversi modi operativi degli apparecchi SIMOTION.

Tabella 6- 1 Modi operativi di un apparecchio SIMOTION

Modo operativo Significato Modalità di processo Lo svolgimento del programma nell'apparecchio SIMOTION è ottimizzato per la massima

performance di sistema. Sono disponibili le seguenti funzioni di diagnostica, che tuttavia possono essere utilizzate solo limitatamente a causa dell'ottimizzazione per le massime prestazioni del sistema: • Supervisione delle variabili nel browser dei simboli o in una tabella Watch • Stato programma (solo con limitazioni):

– Supervisione limitata delle variabili (ad es. variabili in loop, valori di ritorno di funzioni di sistema).

– È possibile monitorare al massimo 1 sorgente di programma (ad es. sorgente ST, sorgente MCC, sorgente KOP/FUP)1.

• Tool Trace (solo limitato) con funzioni di misura per azionamenti e generatore di funzioni, vedere Guida in linea: – Max. 1 Trace su ogni apparecchio SIMOTION.



Modo operativo Significato Modalità test Le funzioni di diagnostica della modalità di processo sono disponibili senza limitazioni:

• Supervisione delle variabili nel browser dei simboli o in una tabella Watch • Stato programma:

– Possibilità di supervisione di tutte le variabili. – A partire dalla versione V4.0 del SIMOTION kernel:

È possibile monitorare più sorgenti di programma (ad es. sorgenti ST, sorgenti MCC, sorgenti KOP/FUP)1 per task.

– Con la versione V3.2 del SIMOTION kernel:

È possibile monitorare al massimo 1 sorgente di programma (ad es. sorgente ST, sorgente MCC, sorgente KOP/FUP) 1 per task.

• Tool Trace con funzioni di misura per azionamenti e generatore di funzioni, vedere Guida in linea: – Max. 4 Trace su ogni apparecchio SIMOTION.

Inoltre è disponibile la seguente funzione di diagnostica: • Traccia luminosa per l'osservazione dello svolgimento del programma in diramazioni di

programma cicliche (solo per linguaggio di programmazione MCC e a partire dalla versione V4.2 del SIMOTION kernel).

Nota Aumentando l'utilizzo delle funzioni di diagnostica aumenta il tempo di esecuzione e il carico di memoria.

Modalità debug Oltre alle funzioni di diagnostica della modalità test è possibile utilizzare le seguenti funzioni: • Punti di arresto

All'interno di una sorgente di programma è possibile impostare dei punti di arresto (Pagina 338). Al raggiungimento di un punto di arresto attivato i task selezionati si arrestano.

• Controllo di MotionTasks

Nella scheda "Task Manager" della diagnostica dell'apparecchio è possibile applicare ai MotionTask i comandi di controllo dei task; vedere il Manuale di guida alle Funzioni di base SIMOTION.

Nel progetto è possibile inserire al massimo 1 apparecchio SIMOTION nella modalità debug. SIMOTION SCOUT è in modalità online, vale a dire collegato al sistema di destinazione. Si prega di tener presente la seguente sezione: Informazioni importanti sulla sorveglianza della funzionalità vitale (Pagina 319).

1 1 MCC-Chart o 1 programma KOP/FUP ciascuno in una sorgente di programma.



Selezione del modo operativo Per selezionare il modo operativo di un apparecchio SIMOTION, procedere nel modo seguente:

1. Assicurarsi che sussista un collegamento con il sistema di destinazione (modalità online).

2. Selezionare l'apparecchio SIMOTION nella navigazione di progetto.

3. Selezionare "Modo operativo" nel menu contestuale.

4. Scegliere il modo operativo desiderato (vedere la tabella riportata sopra).

Se l'impostazione selezionata è "Modalità debug":

– Accettare le avvertenze di sicurezza.

– Parametrizzare la sorveglianza della funzionalità vitale.

Si prega di tener presente la seguente sezione: Informazioni importanti sulla sorveglianza della funzionalità vitale (Pagina 319).


L'apparecchio SIMOTION cambia il modo operativo selezionato (tranne nella modalità debug, vedere sezioni seguenti).

Particolarità nella modalità debug La modalità debug può essere selezionata solo per un apparecchio SIMOTION

Se è stata selezionata la modalità debug, solo SIMOTION SCOUT passa alla modalità debug, l'apparecchio SIMOTION si trova in modalità test.

● La modalità debug attivata di SIMOTION SCOUT viene mostrata dalla navigazione di progetto tramite un simbolo davanti all'apparecchio SIMOTION.

● Viene visualizzata la barra degli strumenti Punti di arresto.

La modalità debug dell'apparecchio SIMOTION viene attivata solo se è attivato almeno un punto di arresto impostato. Se tutti i punti di arresto sono disattivati, la modalità debug dell'apparecchio SIMOTION viene eliminata.

La modalità di debug attiva dell'apparecchio SIMOTION viene visualizzata nella barra di stato.



6.2.1.2 Informazioni importanti sulla sorveglianza della funzionalità vitale

AVVERTENZA Attenersi strettamente alle norme di sicurezza vigenti.

Utilizzare la modalità debug solo o un pannello di comando quando la sorveglianza della funzionalità vitale è attiva con un tempo di sorveglianza breve! In caso di problemi di comunicazione tra il PC di comando e l'apparecchio SIMOTION possono originarsi movimenti non controllabili dell'asse.

La funzione è esclusivamente abilitata a scopi di messa in servizio, diagnostica e assistenza. La funzione va utilizzata solo da personale specializzato e autorizzato. Gli interruttori di sicurezza del controllo sovraordinato non sono attivi.

Occorre perciò prestare attenzione in caso di esecuzione hardware del circuito di emergenza. Le relative misure necessarie devono essere assunte dall'utente.

Nei casi seguenti l'apparecchio SIMOTION e SIMOTION SCOUT scambiano regolarmente funzionalità vitali per garantire un collegamento regolare:

● in modalità debug con punti di arresto attivati.

● Con il comando di un asse o di un azionamento tramite pannello di comando (priorità di comando nel PC).

Se lo scambio della funzionalità vitale viene interrotto per un periodo superiore al tempo di sorveglianza impostato, vengono attivate le seguenti reazioni:

● In modalità debug con punti di arresto attivati:

– l'apparecchio SIMOTION entra nello stato operativo STOP.

– Le uscite vengono disattivate (ODIS).

● Con il comando di un asse o di un azionamento tramite pannello di comando (priorità di comando nel PC):

– L'asse viene arrestato.

– Le abilitazioni vengono annullate.

Accettazione delle avvertenze di sicurezza Dopo la selezione della modalità debug o di un pannello di comando occorre accettare le avvertenze di sicurezza. Inoltre è possibile parametrizzare la sorveglianza della funzionalità vitale.


1. Fare clic sul pulsante Impostazioni.

Viene visualizzata la finestra "Parametri sorveglianza della funzionalità vitale".

2. Leggere le avvertenze di sicurezza come descritto di seguito e parametrizzare la sorveglianza della funzionalità vitale.



Parametrizzazione della sorveglianza della funzionalità vitale Nella finestra "Parametri sorveglianza della funzionalità vitale", procedere come segue:

1. Leggere l'avvertenza!

2. Fare clic sul pulsante Avvertenze di sicurezza, per aprire la finestra con le avvertenze di sicurezza dettagliate.

3. Non modificare le impostazioni predefinite per la sorveglianza della funzionalità vitale.

Effettuare eventuali modifiche soltanto in casi eccezionali e nel rispetto delle avvertenze di pericolo.

4. Confermare con Accetta di aver letto le avvertenze di sicurezza e di aver parametrizzato correttamente la sorveglianza della funzionalità vitale.

ATTENZIONE La sorveglianza della funzionalità vitale si attiva tra l'altro nei seguenti casi: • premendo la barra spaziatrice. • Passaggio ad un'altra applicazione Windows. • Carico di comunicazione troppo elevato tra apparecchio SIMOTION e SIMOTION

SCOUT (ad es. attraverso il caricamento di dati del Task Trace).

Vengono visualizzate le reazioni seguenti: • In modalità debug con punti di arresto attivati:

– L'apparecchio SIMOTION entra nello stato operativo STOP. – Le uscite vengono disattivate (ODIS).

• Con il comando di un asse o di un azionamento tramite pannello di comando (priorità di comando nel PC): – L'asse o l'azionamento viene arrestato. – Le abilitazioni vengono annullate.

AVVERTENZA Questa funzione non è garantita in tutti gli stati operativi. Occorre perciò prestare attenzione in caso di esecuzione hardware del circuito di emergenza. Le relative misure necessarie devono essere assunte dall'utente.



6.2.1.3 Parametri sorveglianza della funzionalità vitale

Tabella 6- 2 Descrizione dei parametri della sorveglianza della funzionalità vitale

Campo Descrizione Sorveglianza della funzionalità vitale

L'apparecchio SIMOTION e SIMOTION SCOUT scambiano regolarmente funzionalità vitali per garantire un collegamento regolare. Se lo scambio della funzionalità vitale viene interrotto per un periodo superiore al tempo di sorveglianza impostato, vengono attivate le seguenti reazioni: • In modalità debug con punti di arresto attivati:

– L'apparecchio SIMOTION entra nello stato operativo STOP.

– Le uscite vengono disattivate (ODIS). • Con il comando di un asse o di un azionamento tramite

pannello di comando (priorità di comando nel PC): – L'asse viene arrestato. – Le abilitazioni vengono annullate.

Sono possibili le seguenti parametrizzazioni: • Casella di controllo Attiva:

Con la casella di controllo attiva la sorveglianza della funzionalità vitale è attiva.

La disattivazione della sorveglianza della funzionalità vitale non è sempre possibile.

• Tempo di sorvegl.:

Immettere il tempo di sorveglianza. Cautela Lasciare, se possibile, invariate le impostazioni predefinite per la sorveglianza della funzionalità vitale. Effettuare eventuali modifiche soltanto in casi eccezionali e nel rispetto delle avvertenze di pericolo.

Avvertenza di sicurezza Osservare assolutamente l'avvertenza! Fare clic sul pulsante per ottenere ulteriori avvertenze di sicurezza. Vedere: Informazioni importanti sulla sorveglianza della funzionalità vitale (Pagina 319).



6.2.2 Modifica delle sorgenti di programma in modalità online

Modifica online in modalità processo o test Se SIMOTION SCOUT è collegato con il sistema di destinazione che si trova nel modo operativo "Modalità di processo" o "Modalità test", le sorgenti di programma (ad es. sorgenti ST, sorgenti MCC con MCC-Chart) possono essere sostanzialmente modificate, compilate e caricate nel sistema di destinazione nello stato operativo STOP. Per il download nello stato operativo RUN vedere la sezione corrispondente nel Manuale di guida alle funzioni "Funzioni di base SIMOTION".

Le funzioni di test "Stato programma", "Osservazione dell'esecuzione del programma" (solo MCC) e traccia luminosa (solo MCC) si possono attivare per una sorgente di programma o un'unità di organizzazione del programma (POE) solo se sono soddisfatte le condizioni seguenti:

1. Questa sorgente o una qualsiasi POE di questa sorgente (ad es. MCC-Chart) non contiene modifiche non salvate.

2. La sorgente di programma (Unit) in SCOUT è coerente con il sistema di destinazione.

Nota

Con funzione test "Stato programma" attivata la modifica della corrispondente sorgente di programma o di una relativa POE è bloccata.

In caso di modifica di una sorgente MCC o di un MCC-Chart, per i quali sono attive le funzioni di test "Osservazione dell'esecuzione del programma" o traccia luminosa, le funzioni di test vengono interrotte.

Modifica online nella modalità debug Se SIMOTION SCOUT si trova nella modalità operativa debug, la modifica è possibile a condizione che l'apparecchio SIMOTION non si trovi nella modalità debug, quindi non vi siano punti di arresto attivati.

I punti di arresto si possono attivare, passando così l'apparecchio SIMOTION nella modalità debug, solo se la corrispondente sorgente di programma e tutte le relative POE sono salvate, compilate in modo aggiornato e coerenti con il sistema di destinazione.

Se si tenta di modificare una sorgente di programma o la POE con l'apparecchio SIMOTION in modalità debug, viene richiesto di disattivare tutti i punti di arresto e di togliere così l'apparecchio SIMOTION dalla modalità debug.

ATTENZIONE Se i punti di arresto sono attivati e l'apparecchio SIMOTION si trova nella modalità debug:

l'immissione di uno spazio vuoto fa sì che l'apparecchio SIMOTION passi nello stato operativo STOP e tutte le uscite vengano disattivate (ODIS).



6.2.3 Browser dei simboli

6.2.3.1 Proprietà del browser dei simboli Nel browser dei simboli è possibile visualizzare il nome, il tipo di dati e i valori delle variabili ed eventualmente modificarne i valori. In particolare si può: Vedere le seguenti variabili:

● Variabili Unit e variabili statiche di un programma o del blocco funzionale

● Variabili di sistema di un apparecchio SIMOTION o di un oggetto tecnologico

● Variabili I/O o variabili globali dell'apparecchio.

Per queste variabili è necessario:

● visualizzare una snapshot dei valori delle variabili,

● monitorare la modifica dei valori delle variabili in corso,

● modificare (controllare) i valori delle variabili.

Il browser dei simboli può visualizzare/modificare i valori delle variabili di un programma solo se il progetto è stato caricato nel sistema di destinazione e se esiste un collegamento con il sistema di destinazione.

6.2.3.2 Uso del browser dei simboli

Presupposti ● Verificare l'esistenza di un collegamento con il sistema di destinazione e il caricamento

del progetto nel sistema di destinazione. Per caricare il progetto con il programma di esempio, vedere "Esecuzione del programma di esempio (Pagina 86)".

● È possibile eseguire il programma utente, ma non è necessario. Se il programma non viene eseguito, vengono visualizzati soltanto i valori iniziali delle variabili.

La procedura dipende dall'area di memoria in cui le variabili da monitorare sono memorizzate.

Procedura Procedere come segue:

1. Selezionare nella navigazione di progetto l'elemento corrispondente secondo la seguente tabella.

2. Fare clic nella visualizzazione dei dettagli sulla scheda Browser dei simboli.

Nel browser dei simboli visualizzare le variabili corrispondenti.

3. Selezionare per ciascuna variabile nella colonna "Formato di visualizzazione", come questa variabile deve essere visualizzata.



Tabella 6- 3 Elementi nella navigazione di progetto e variabili da osservare nel browser dei simboli

Variabili da osservare nel browser dei simboli Elemento da contrassegnare nella navigazione di progetto

Variabili nella memoria utente di Unit o nella memoria ritentiva, vedere Settori di memoria dei tipi di variabile (Pagina 232): • Variabili Unit residue e non residue della sezione Interface di una sorgente di

programma (Unit), • Variabili Unit residue e non residue della sezione di implementazione di una

sorgente di programma (Unit), • Variabili statiche dei blocchi funzionali le cui istanze sono dichiarate come

variabili Unit. • Inoltre, se la sorgente di programma (Unit) è stata compilata con l'opzione

Compilatore (Pagina 58) "Crea dati di istanza del programma solo una volta": – Variabili statiche del programma. – Variabili statiche dei blocchi funzionali le cui istanze sono dichiarate come

variabili statiche dei programmi.

Sorgente di programma (Unit)

Variabili nella memoria utente del task, vedere Settori di memoria dei tipi di variabile (Pagina 232): Se la sorgente di programma (Unit) è stata compilata senza l'opzione Compilatore (Pagina 58) "Crea dati di istanza del programma solo una volta" (standard), si trovano le seguenti variabili nella memoria utente del task al quale è stato assegnato il programma: • Variabili statiche del programma. • Variabili statiche dei blocchi funzionali le cui istanze sono dichiarate come

variabili statiche dei programmi.

SISTEMA ESECUTIVO

Variabili di sistema di un apparecchio SIMOTION Apparecchio SIMOTION Variabili di sistema di un oggetto tecnologico Istanza dell'oggetto tecnologico Variabili globali d'apparecchio VARIABILI GLOBALI

D'APPARECCHIO Variabili I/O (nella scheda Lista indirizzi della visualizzazione dei dettagli). La scheda Lista indirizzi della visualizzazione dei dettagli si apre con un doppio clic sull'elemento LISTA INDIRIZZI nella navigazione di progetto.

LISTA INDIRIZZI

Nota

Le variabili temporanee possono essere monitorate (insieme alle variabili Unit e alle variabili statiche) con Stato programma (vedere Proprietà di stato programma (Pagina 332)).



Nota Funzione di diagnostica traccia luminosa per programmazione MCC

Per la funzione di diagnostica della traccia luminosa vengono create automaticamente dal compilatore diverse variabili interne, i cui identificatori cominciano con un carattere di sottolineatura. Questa variabili sono visibili nel browser dei simboli.

Con la funzione di diagnostica inserita queste variabili vengono impiegate per il controllo della funzione di diagnostica. Queste variabili non devono essere impiegate nel programma utente.

Figura 6-1 Monitoraggio di variabili nel browser dei simboli



Stato e controllo delle variabili Nella colonna Valore di stato viene visualizzato e aggiornato periodicamente il valore corrente delle variabili.

È possibile modificare il valore di una o più variabili. Per le variabili da modificare, procedere come segue:

1. Immettere un valore nella colonna Valore di comando.

2. Attivare la casella di controllo vicino a questa colonna

3. Fare clic sul pulsante Comando.

I valori inseriti vengono scritti nelle variabili selezionate.

AVVERTENZA I valori immessi sono immediatamente assegnati alle variabili. Ciò può provocare situazioni pericolose nell'impianto, ad es. movimenti dell'asse imprevedibili.

ATTENZIONE Se si modificano i valori di più variabili, prestare attenzione a ciò che segue:

I valori vengono scritti in modo sequenziale nelle variabili. Possono passare diversi millisecondi prima che venga scritto il successivo valore. La modifica delle variabili avviene dall'alto verso il basso nel browser dei simboli. La coerenza perciò non è garantita.

Uso del browser dei simboli Informazioni sulle funzioni del browser dei simboli su come operare con lo stesso sono descritte dettagliatamente nella Guida in linea.

Visualizzazione dei numeri a virgola mobile non validi I numeri a virgola mobile non validi vengono visualizzati come segue nel browser dei simboli (indipendentemente dall'apparecchio SIMOTION):

Tabella 6- 4 Visualizzazione dei numeri a virgola mobile non validi

Visualizzazione Significato 1.#QNAN -1.#QNAN

Stringa di bit non valida secondo IEEE 754, (NaN – Not a Number). Non c'è distinzione tra NaN di segnalazione (NaNs) e quiet NAN (NaNq).

1.#INF -1.#INF

Stringa di bit per + infinito (+ infinity) secondo IEEE 754 Stringa di bit per – infinito (– infinity) secondo IEEE 754

-1.#IND Stringa di bit per indeterminato (indeterminate)



6.2.4 Monitoraggio delle variabili nella tabella Watch

6.2.4.1 Variabili nella tabella Watch Con il browser dei simboli sono visibili solo le variabili di un oggetto all'interno del progetto. Con Stato programma si visualizzano solo le variabili di una sorgente ST all'interno di un'area di osservazione liberamente selezionabile.

Le tabelle Watch invece consentono di monitorare come gruppo variabili selezionate di origine diversa (ad es. sorgenti di programma, oggetti tecnologici, azionamenti SINAMICS, anche di diversi apparecchi).

In modalità offline si può visualizzare il tipo di dati delle variabili, mentre la modalità online permette invece di visualizzare e controllare il valore delle variabili.

6.2.4.2 Uso della tabella Watch Le variabili di diverse sorgenti di programma, oggetti tecnologici, apparecchi SIMOTION ecc. (anche apparecchi diversi) possono essere riunite in una tabella Watch, monitorate complessivamente ed eventualmente modificate.

Creazione della tabella Watch Questa è la procedura per la creazione di una tabella Watch e per l'assegnazione delle variabili:

1. Nella navigazione di progetto, selezionare la cartella MONITORAGGIO.

2. Scegliere Inserisci > Tabella Watch per creare e assegnare il nome a una tabella Watch. Una tabella Watch con questo nome viene salvata nella cartella MONITORAGGIO.

3. Nella navigazione di progetto, fare clic sull'oggetto da cui si desiderano spostare le variabili nella tabella Watch.

4. Selezionare la riga della variabile corrispondente nel browser dei simboli facendo clic sul relativo numero nella colonna sinistra.

5. Nel menu contestuale selezionare la voce Acquisisci nella tabella Watch e la tabella Watch corrispondente, per es. Tabella Watch_1.

6. Fare clic sulla tabella Watch, nella scheda Tabella Watch della visualizzazione dei dettagli, per verificare che la variabile selezionata sia inserita nella tabella Watch.

7. Ripetere i passaggi da 3 a 6 per monitorare le variabili di diversi oggetti.



Stato e controllo delle variabili Quando ci si collega al sistema di destinazione è possibile monitorare i contenuti delle variabili.

Nella colonna Valore di stato viene visualizzato e aggiornato periodicamente il valore corrente delle variabili.

È possibile modificare il valore di una o più variabili. Per le variabili da modificare, procedere come segue:

1. Immettere un valore nella colonna Valore di comando.

2. Attivare la casella di controllo in questa colonna

3. Fare clic sul pulsante Comando immed..

I valori inseriti vengono scritti nelle variabili selezionate.

AVVERTENZA I valori immessi sono immediatamente assegnati alle variabili. Ciò può provocare situazioni pericolose nell'impianto, ad es. movimenti dell'asse imprevedibili.

ATTENZIONE Controllare se i valori hanno più variabili:

I valori vengono scritti in modo sequenziale nelle variabili. Possono passare diversi millisecondi prima che venga scritto il successivo valore. La modifica delle variabili avviene dall'alto verso il basso nella tabella Watch. La coerenza perciò non è garantita.

Uso della tabella Watch Informazioni sulle funzioni del browser dei simboli su come operare con lo stesso sono descritte dettagliatamente nella Guida in linea.

Visualizzazione dei numeri a virgola mobile non validi I numeri a virgola mobile non validi vengono visualizzati come segue nella tabella Watch (indipendentemente dall'apparecchio SIMOTION):

Tabella 6- 5 Visualizzazione dei numeri a virgola mobile non validi

Visualizzazione Significato 1.#QNAN -1.#QNAN

Stringa di bit non valida secondo IEEE 754 (NaN – Not a Number). Non c'è distinzione tra NaN di segnalazione (NaNs) e quiet NAN (NaNq).

1.#INF -1.#INF

Stringa di bit per + infinito (+ infinity) secondo IEEE 754 Stringa di bit per – infinito (– infinity) secondo IEEE 754

-1.#IND Stringa di bit per indeterminato (indeterminate)



6.2.5 Stato variabile Con "Stato variabile" in una sorgente di programma o in un'unità di organizzazione del programma aperta (ad es. sorgente ST, MCC-Chart, programma KOP) è possibile osservare il valore attuale di una singola variabile, selezionata con il puntatore del mouse.

Presupposti ● Verificare l'esistenza di un collegamento con il sistema di destinazione e il caricamento

del progetto nel sistema di destinazione. Per il caricamento di un progetto vedere "Esecuzione del programma esemplificativo (Pagina 86)".

● La sorgente di programma nella quale si trova l'unità di organizzazione del programma (POE), di cui si desidera osservare le variabili, è coerente con il sistema di destinazione.

● La relativa sorgente (ad es. sorgente ST, MCC-Chart, programma KOP) è aperta.

● Solo con il linguaggio di programmazione MCC: la maschera dei parametri del comando in cui viene usata la variabile da osservare è aperta.

● È possibile eseguire il programma utente, ma non è necessario. Se il programma non viene eseguito, vengono visualizzati soltanto i valori iniziali delle variabili.

Procedura Per osservare una singola variante con Stato variabile procedere come segue:

1. Spostare il puntatore del mouse sull'identificatore di una variabile

– Con linguaggio di programmazione ST: nella sorgente ST aperta

– Con linguaggio di programmazione ST: all'interno di un campo di immissione nella maschera dei parametri aperta

– Con il linguaggio di programmazione KOP/FUP: all'interno di una rete del programma KOP/FUP

2. Soffermarsi per un breve intervallo sull'identificatore con il puntatore del mouse.

Il valore attuale delle variabili viene mostrato nella descrizione comandi. Se il puntatore del mouse si sofferma più a lungo sull'identificatore il valore viene costantemente aggiornato.

Nota

Con "Stato variabile" il valore attuale delle variabili viene mostrato indipendentemente dalla posizione di utilizzo selezionata.

Con la funzione "Stato variabile" è possibile osservare tutte le variabili che si possono monitorare anche nel browser dei simboli (Pagina 323) o nella lista indirizzi. Si tratta di:

● Variabili di sistema di apparecchi SIMOTION

● Variabili di sistema degli oggetti tecnologici


● Variabili Unit residue e non residue della sezione Interface di una sorgente di programma (Unit)



● Variabili Unit residue e non residue della sezione di implementazione di una sorgente di programma (Unit)

● Variabili statiche dei programmi

● Variabili statiche dei blocchi funzionali le cui istanze sono dichiarate come variabili Unit

● Variabili statiche dei blocchi funzionali le cui istanze sono dichiarate come variabili statiche dei programmi

● Variabili I/O

6.2.6 Esecuzione del programma

6.2.6.1 Esecuzione del programma: Visualizzazione di punto di codice e percorso di richiamo È possibile visualizzare il punto di codice (ad es. la riga di una sorgente ST) che esegue attualmente un MotionTask e il relativo percorso di richiamo.


1. Fare clic nella barra delle funzioni Esecuzione programma sul pulsante Visualizza esecuzione programma.

Viene visualizzata la finestra "Callstack di esecuzione del programma (Pagina 331)".

2. Selezionare i MotionTask desiderati.

3. Fare clic sul pulsante Aggiorna.

Nella finestra vengono visualizzati:

● Il punto di codice attualmente in fase di esecuzione (ad es. la riga della sorgente ST) con l'indicazione della sorgente di programma e della POE;

● In modo ricorsivo, i punti di codice di altre POE che richiamano il punto di codice eseguito.

Per le sorgenti di programma di SIMOTION RT vengono visualizzati i seguenti nomi:

Tabella 6- 6 Sorgenti di programma di SIMOTION RT

Nome Significato taskbind.hid Sistema esecutivo stdfunc.pck Libreria IEC device.pck Libreria specifica dell'apparecchio tp-name.pck Libreria del pacchetto tecnologico tp-name,

ad es. cam.pck per la libreria del pacchetto tecnologico CAM.



6.2.6.2 Parametro Esecuzione del programma Per tutti i task configurati è possibile visualizzare:

● Il punto di codice di programma eseguito attualmente (ad es. la riga di una sorgente ST)

● Il percorso di richiamo di questo punto di codice

Tabella 6- 7 Descrizione del parametro Esecuzione del programma

Campo Descrizione CPU selezionata L'apparecchio SIMOTION selezionato viene visualizzato. Aggiorna Facendo clic sul pulsante vengono letti i punti di codice attuali

dell'apparecchio SIMOTION, che vengono visualizzati nella finestra aperta.

Task richiamante Selezionare il task per cui si desidera rilevare il punto di codice eseguito attualmente. Sono disponibili per la selezione tutti i task configurati del sistema esecutivo.

Punto di codice attuale Il punto del codice di programma attualmente eseguito (ad es. una riga della sorgente ST) viene visualizzato (con nome della sorgente di programma, numero di riga, nome della POE).

viene richiamato da I punti di codice che richiamano all'interno del task selezionato il punto di codice attualmente eseguito vengono visualizzati in modo ricorsivo (con nome della sorgente di programma, numero di riga, nome della POE, event. nome dell'istanza di un blocco funzionale).

Per i nomi delle sorgenti di programma di SIMOTION RT vedere la tabella nella sezione "Esecuzione del programma (Pagina 330)".

6.2.6.3 Barra degli strumenti Esecuzione del programma Con questa barra delle funzioni è possibile visualizzare il punto di codice (ad es. la riga di una sorgente ST) che esegue attualmente un MotionTask e il relativo percorso di richiamo.

Tabella 6- 8 Barra delle funzioni Esecuzione del programma

Simbolo Significato

Esecuzione del programma Fare clic su questo simbolo per aprire la finestra "Callstack esecuzione del programma". In questa finestra è possibile visualizzare il punto di codice già attivo con il relativo percorso di richiamo Vedere: Esecuzione del programma: visualizzazione di punto di codice e percorso di richiamo (Pagina 330)



6.2.7 Stato programma

6.2.7.1 Proprietà dello stato programma Stato programma consente un monitoraggio preciso del ciclo dei valori delle variabili durante l'elaborazione del programma.

È possibile selezionare un'area di monitoraggio nella sorgente ST e in essa monitorare, oltre alle variabili locali globali e statiche, anche le variabili locali temporanee (ad es. all'interno di una funzione).

Vengono visualizzati i valori delle seguenti variabili:

● variabili con tipo di dati semplice (INT, REAL, ecc.),

● singoli elementi di una struttura, purché venga eseguita un'assegnazione,

● singoli elementi di un campo (array), purché venga eseguita un'assegnazione,

● variabili con tipi di dati di enumerazione.

Durante il ciclo dell'area di osservazione selezionata nella sorgente ST, sull'apparecchio SIMOTION vengono immessi nel buffer per le variabili da osservare i valori relativi. A conclusione del ciclo dell'area di osservazione selezionata, il contenuto del buffer è reso disponibile per la visualizzazione in SIMOTION SCOUT. SIMOTION SCOUT richiama i valori approntati a intervalli regolari e li visualizza nel formato selezionato per le impostazioni dell'editor ST (Pagina 29) come "Formato per visualizzazione di stato".

Per le funzioni e i blocchi funzionali è possibile selezionare un punto di una sorgente ST in cui viene effettuato il richiamo della funzione o dell'istanza di un blocco funzionale (percorso di richiamo). In tal modo è possibile visualizzare i valori delle variabili in modo mirato per il richiamo.

Nota

Poiché la capacità del buffer è limitata ed è necessario ridurre al minimo gli errori di runtime, le seguenti variabili non possono essere visualizzate: • campi completi • strutture complete

i singoli elementi di array o di strutture sono visualizzati solo se viene eseguita un'assegnazione nella sorgente ST.



Tabella 6- 9 Differenze tra modalità processo e modalità test per lo Stato programma

Modalità di processo Modalità test Ottimizzazione dell'esecuzione del programma

Per prestazioni del sistema massime, possibile solo una diagnostica limitata.

Per una completa possibilità di diagnostica

Numero massimo di sorgenti di programma osservabili (ad es. sorgenti ST, sorgenti MCC, sorgenti KOP/FUP)

al massimo 1 sorgente di programma1 • a partire dalla versione V4.0 del SIMOTION kernel:

più sorgenti di programma1 per task • con la versione V3.2 del SIMOTION

kernel:

al massimo 1 sorgente di programma 1 per task

Loop (ad es. WHILE, REPEAT, FOR)

La registrazione viene interrotta al primo salto di ritorno del loop. Con i loop completamente selezionati, i valori vengono visualizzati durante la prima esecuzione di un loop

La registrazione durante i salti di ritorno avviene correttamente. Con i loop completamente selezionati, i valori vengono visualizzati durante l'ultima esecuzione di un loop

Funzioni di sistema che contengono internamente dei loop (ad es. funzioni per l'elaborazione di stringhe)

La registrazione viene interrotta durante l'esecuzione della funzione di sistema. In certe circostanze i valori non vengono visualizzati correttamente.

La registrazione durante il richiamo della funzione di sistema avviene correttamente. I valori vengono visualizzati correttamente

1 1 MCC-Chart o 1 programma KOP/FUP ciascuno in una sorgente di programma.

ATTENZIONE Stato programma necessita di risorse aggiuntive della CPU.

Prestare attenzione a quanto segue se si desiderano monitorare contemporaneamente più programmi con stato programma: • La modalità test deve essere attivata (vedere Modi operativi degli apparecchi

SIMOTION (Pagina 316)) • Fino alla versione V4.0 del SIMOTION kernel i programmi devono essere assegnati a

diversi task.



6.2.7.2 Uso di Stato programma Prima di poter utilizzare Stato programma, è necessario comunicare al sistema che l'esecuzione deve avvenire in una modalità particolare:

1. Verificare che nella compilazione della sorgente ST venga generato il codice di debug aggiuntivo:

– Nella navigazione di progetto, selezionare la sorgente ST e scegliere il menu Modifica > Proprietà oggetto.

– Selezionare la scheda Compilatore, per modificare le Impostazioni locali del compilatore (Pagina 61).

– Verificare che la casella di controllo Consenti stato programma sia selezionata e premere OK per confermare.

L'opzione Compilatore è modificabile anche nelle Impostazioni globali del compilatore (Pagina 59).

2. Aprire la sorgente ST ed eseguire nuovamente la compilazione con Sorgente ST > Applica e compila.

3. Caricare e avviare normalmente il programma.

4. Fare clic nella barra degli strumenti Editor ST (Pagina 50) sul pulsante per Stato programma, per avviare questa modalità di test.

La finestra dell'editor ST viene visualizzata suddivisa verticalmente:

● Nella parte sinistra della finestra è visualizzata la sorgente ST. Qui è possibile selezionare un'area.

● Nella parte destra della finestra vengono mostrate le variabili dell'area selezionata e i relativi valori.



Figura 6-2 Parte di un programma ST in modalità di test Stato programma

Per eseguire il test con Stato programma, procedere come segue:

1. Nella parte sinistra della finestra selezionare la sezione della sorgente ST su cui si desidera eseguire il test.

2. Se è stata selezionata la sezione di una POE richiamata in più punti di una sorgente di programma o in più task:

Immettere il percorso di richiamo per Stato programma (Pagina 336).

Nella parte destra della finestra vengono mostrate le variabili dell'area selezionata e i relativi valori. La visualizzazione dei valori delle variabili viene aggiornata ciclicamente. Con variabili con tipo di dati bit la visualizzazione avviene nel formato selezionato per le impostazioni dell'editor ST (Pagina 29) come "Formato per visualizzazione di stato":

● i valori modificati nell'esecuzione corrente sono visualizzati in rosso;

● i valori rimasti invariati sono visualizzati in nero;

● le variabili senza valori, ad es. le variabili in una diramazione IF non eseguita, sono contrassegnate da punti interrogativi e visualizzate in verde.



Se la visualizzazione dei valori delle variabili cambia troppo rapidamente, procedere come segue:

● Fare clic nella barra degli strumenti Editor ST (Pagina 50) sul pulsante Sospendi osservazione delle variabili di programma per interrompere la visualizzazione.

● Fare clic nella barra degli strumenti Editor ST (Pagina 50) sul pulsante Prosegui osservazione delle variabili di programma per riprendere la visualizzazione.

È possibile forzare l'aggiornamento dei valori visualizzati:

● Fare clic nella barra degli strumenti Editor ST (Pagina 50) sul pulsante Aggiorna.

Viene effettuata una lettura a partire dal buffer dell'apparecchio SIMOTION anche se non si è ancora completato il ciclo dell'area di osservazione selezionata e i valori sono incompleti. Ciò può essere utile, ad es., se il programma attende a un'istruzione WAITFORCONDITION.

La supervisione delle variabili del programma deve essere attivata.

6.2.7.3 Percorso di richiamo per Stato programma È possibile specificare il percorso di richiamo durante il monitoraggio dei valori di variabili di funzioni e blocchi funzionali. In tal modo è possibile visualizzare i valori delle variabili in modo mirato per il richiamo.

Nei seguenti casi la finestra Percorso di richiamo si apre automaticamente:

● È stata selezionata una sezione di una funzione:

La funzione viene richiamata in diversi punti delle sorgenti del programma (ad es. sorgenti ST) dell'apparecchio SIMOTION

● È stata selezionata una sezione di un blocco funzionale:

Nel blocco funzionale esistono più istanze oppure l'istanza viene richiamata in diversi punti delle sorgenti del programma (ad es. sorgenti ST) dell'apparecchio SIMOTION

● È stata selezionata una sezione di un programma:

Il programma è associato a più task.



Per selezionare il percorso di richiamo procedere nel seguente modo: Nella finestra Percorso di richiamo stato programma viene visualizzata la sezione della POE selezionata (punto di codice) (con il nome della sorgente ST, il numero della riga, il nome della POE).

1. Se il punto di codice viene richiamato in più task:

– Selezionare il task.

2. Selezionare il punto di codice da richiamare (nel POE da richiamare).

Sono disponibili a scelta:

– i punti di codice da richiamare all'interno del task selezionato (con il nome della sorgente del programma, il numero di riga, il nome della POE)

Se i punti di codice da richiamare selezionati vengono a loro volta richiamati da diversi punti di codice, vengono visualizzate altra righe nelle quali è possibile procedere in modo analogo.

– tutte:

Vengono selezionati tutti i punti di codice visualizzati. Inoltre vengono selezionati tutti i punti di codice (fino al livello gerarchico più alto) di cui vengono richiamati i punti di codice visualizzati.

6.2.7.4 Parametro percorso di richiamo stato programma

Tabella 6- 10 Descrizione del parametro percorso di richiamo stato programma

Campo Descrizione Task che effettua il richiamo Selezionare il task.

Per la selezione sono disponibili tutti i task in cui il punto di codice contrassegnato viene richiamato.

Punto di codice attuale Viene visualizzata la sezione contrassegnata della POE (punto di codice) (con il nome della sorgente ST, il numero della riga, il nome della POE)

viene richiamato da Selezionare il punto di codice da richiamare. Si può scegliere tra: • i punti di codice da richiamare all'interno del task selezionato

(con il nome della sorgente del programma, il numero di riga, il nome della POE)

Se i punti di codice da richiamare selezionati vengono a loro volta richiamati da diversi punti di codice, vengono visualizzate altra righe nelle quali è possibile procedere in modo analogo.

• tutte:

Vengono selezionati tutti i punti di codice visualizzati. Inoltre vengono selezionati tutti i punti di codice (fino al livello gerarchico più alto) di cui vengono richiamati i punti di codice visualizzati.



6.2.8 Punti di arresto

6.2.8.1 Procedura generale per l'impostazione dei punti di arresto È possibile impostare i punti di arresto all'interno di una POE di una sorgente di programma (ad es. sorgente ST, MCC-Chart, programma KOP/FUP). Raggiungendo un punto di arresto attivato viene arrestato il task nel quale viene richiamata la POE con il punto di arresto. Se il punto di arresto che ha provocato l'interruzione del task si trova in un programma o in un blocco funzione, i valori delle variabili statiche di questa POE vengono visualizzati nella scheda "Stato variabili" della visualizzazione dettagliata. Le variabili temporanee (anche i parametri di transito nel caso di blocchi funzione) non vengono visualizzate. Le variabili statiche di altre POE o le variabili Unit possono essere monitorate nel browser dei simboli.

Presupposto: ● La sorgente del programma con la POE (ad es. sorgente ST, MCC-Chart, programma

KOP/FUP) è aperta.

Procedura Procedere come segue:

1. Selezionare per il relativo apparecchio SIMOTION il modo operativo "Modalità Debug", vedere Impostazione della modalità debug (Pagina 339).

2. Specificare i task da arrestare, vedere Definizione del gruppo di task di debug (Pagina 341).

3. Impostare i punti di arresto (vedere Impostazione dei punti di arresto (Pagina 344)).

4. Stabilire il percorso di richiamo; vedere Definizione del percorso di richiamo per un singolo punto di arresto (Pagina 348).

5. Attivare i punti di arresto; vedere Attivazione dei punti di arresto (Pagina 355).



6.2.8.2 Impostazione della modalità debug

AVVERTENZA Attenersi strettamente alle norme di sicurezza vigenti.

Utilizzare la modalità debug solo quando la sorveglianza della funzione vitale (Pagina 319) è attiva con un tempo di sorveglianza breve! In caso di problemi di comunicazione tra il PC di comando e l'apparecchio SIMOTION possono originarsi movimenti non controllabili dell'asse.

La funzione è esclusivamente abilitata a scopi di messa in servizio, diagnostica e assistenza. La funzione va utilizzata solo da personale specializzato e autorizzato. Gli interruttori di sicurezza del controllo sovraordinato non sono attivi!

Occorre perciò prestare attenzione in caso di esecuzione hardware del circuito di emergenza. Le relative misure necessarie devono essere assunte dall'utente.

Presupposto 1. Deve sussistere un collegamento con il sistema di destinazione (modalità online)

2. La modalità debug non è selezionata per alcun apparecchio SIMOTION.

Procedura Per attivare la modalità debug, procedere nel modo seguente:

1. Selezionare l'apparecchio SIMOTION nella navigazione di progetto.

2. Nel menu contestuale, selezionare Modo operativo.

3. Selezionare il modo operativo (Pagina 316) Modalità debug.

4. Accettare le avvertenze di sicurezza.

5. Parametrizzare la sorveglianza della funzionalità vitale.

Osservare le avvertenze contenute nella sezione: Informazioni importanti sulla sorveglianza della funzionalità vitale (Pagina 319).


SIMOTION SCOUT passa alla modalità debug per questo apparecchio; l'apparecchio SIMOTION stesso rimane nel modo operativo "modalità test" finché non viene attivato almeno un punto di arresto:

La modalità debug attivata di SIMOTION SCOUT viene mostrata dalla navigazione di progetto tramite un simbolo davanti all'apparecchio SIMOTION.

Viene visualizzata la Barra degli strumenti Punti di arresto (Pagina 347).

Finché non vi sono punti di arresto attivati, nella modalità debug è possibile editare sorgenti di programmi (Pagina 322).



La modalità debug dell'apparecchio SIMOTION viene attivata solo se è attivato almeno un punto di arresto impostato. Se tutti i punti di arresto sono disattivati, la modalità debug dell'apparecchio SIMOTION viene eliminata. La modalità di debug attiva dell'apparecchio SIMOTION viene visualizzata nella barra di stato.

ATTENZIONE Premendo la barra spaziatrice o passando ad un'altra applicazione Windows, se l'apparecchio SIMOTION si trova in modalità debug (punti di arresto attivati) si ottiene il seguente effetto: • L'apparecchio SIMOTION entra nello stato operativo STOP. • Le uscite vengono disattivate (ODIS).

AVVERTENZA Questa funzione non è garantita in tutti gli stati operativi. Occorre perciò prestare attenzione in caso di esecuzione hardware del circuito di emergenza. Le relative misure necessarie devono essere assunte dall'utente.



6.2.8.3 Definire il gruppo di task debug Al raggiungimento di un punto di arresto attivo vengono arrestati tutti i task che sono assegnati al gruppo di task di debug.

Presupposto 1. Deve sussistere un collegamento con il sistema di destinazione (modalità online).

2. SIMOTION SCOUT si trova nella Modalità debug per il relativo apparecchio SIMOTION, vedere Impostazione della modalità debug (Pagina 339).

Procedura Per assegnare un task al gruppo di task di debug:

1. Selezionare il relativo apparecchio SIMOTION nella navigazione di progetto.

2. Nel menu contestuale, selezionare Gruppo di task di debug.

Si apre la finestra Gruppo di task di debug.

3. Selezionare i task che devono essere arrestati al raggiungimento di un punto di arresto:

– Se si desidera arrestare soltanto singoli task (nello stato operativo RUN): Attivare l'opzione Gruppo di task di debug.

Assegnare tutti i task che devono essere arrestati al raggiungimento del punto di arresto alla lista Task da arrestare.

– Se si desidera arrestare tutti i task utente (mediante lo stato operativo ARRESTO): Attivare l'opzione Tutti i task.

In tal caso, specificare anche se le uscite e gli oggetti tecnologici devono essere riabilitati dopo aver proseguito l'elaborazione del programma.

ATTENZIONE Osservare il comportamento differente al raggiungimento di un punto di arresto attivato; vedere la tabella che segue.



Tabella 6- 11 Comportamento al raggiungimento del punto di arresto in funzione dei task da interrompere nel gruppo di task di debug

Task da arrestare Caratteristica

Singoli task selezionati (gruppo di task di debug)

Tutti i task

Comportamento al raggiungimento del punto di arresto Stato operativo RUN HALT Task arrestati Solo i task nel gruppo di task debug Tutti i task Uscite Attiva Disattivato (ODIS attivato) Tecnologia Regolazione attiva Nessuna regolazione (ODIS attivato) Misurazione del runtime dei

task Attivo per tutti i task Disattivato per tutti i task

Sorveglianza temporale dei task

Disattivato per i task nel gruppo di task di debug

Disattivato per tutti i task

Orologio in tempo reale Continua a funzionare Continua a funzionare Comportamento al proseguimento dell'elaborazione di programma Stato operativo RUN RUN Task avviati Tutti i task nel gruppo di task debug Tutti i task Uscite Attiva Tecnologia Regolazione attiva

Il comportamento delle uscite e degli oggetti tecnologici dipende dalla casella di controllo Con ’Prosegui’ le uscite vengono attivate (ODIS disattivato). • Attivo: ODIS viene disattivato. Tutte le

uscite e gli oggetti tecnologici vengono inizializzati.

• Non attivo: ODIS resta attivato. Tutte le uscite e gli oggetti tecnologici vengono inizializzati solo per una transizione STOP-RUN.

Nota

È possibile modificare il gruppo di task debug soltanto se non è stato attivato alcun punto di arresto.

Le impostazioni del gruppo di task di debug vengono mantenute anche al termine del modo operativo "Modalità debug".



Ulteriore procedura: 1. Impostare i punti di arresto (vedere Impostazione dei punti di arresto (Pagina 344)).

2. Stabilire il percorso di richiamo (vedere Definizione del percorso di richiamo per un singolo punto di arresto (Pagina 348)).

3. Attivare i punti di arresto (vedere Attivazione dei punti di arresto (Pagina 355)).

6.2.8.4 Parametri del gruppo di task di debug Questa finestra consente di definire il gruppo di task di debug. Al raggiungimento di un punto di arresto attivo vengono arrestati tutti i task che sono assegnati al gruppo di task di debug.

Il presupposto è che l'apparecchio SIMOTION in questione si trovi in modalità debug. Vedere Modi operativi degli apparecchi SIMOTION (Pagina 316).

Tabella 6- 12 Descrizione del parametro Impostazioni di debug

Campo Descrizione Gruppo di task di debug Selezionare questa opzione se si desidera arrestare solo singoli

task. Dopo il raggiungimento di un punto di arresto attivo, l'apparecchio SIMOTION resta nello stato operativo RUN. Le uscite e gli oggetti tecnologici restano attivati. Assegnare tutti i task che devono essere arrestati al raggiungimento del punto di arresto alla lista Task da arrestare.

Tutti i task Selezionare questa opzione se si desidera arrestare tutti i task utente. Dopo il raggiungimento di un punto di arresto attivo l'apparecchio SIMOTION passa allo stato operativo HALT; le uscite e gli oggetti tecnologici vengono disattivati (ODIS attivato). In tal caso, specificare anche se le uscite e gli oggetti tecnologici devono essere riabilitati dopo aver proseguito l'elaborazione del programma.

Con 'Continua' le uscite vengono attivate (ODIS disattivato).

Solo se Tutti i task è selezionato. Attivare la casella di controllo per riabilitare le uscite e gli oggetti tecnologici dopo la prosecuzione dell'elaborazione di programma. Con la casella di controllo deselezionata, le uscite e gli oggetti tecnologici vengono abilitati solo eseguendo un download del progetto.

ATTENZIONE Osservare il comportamento differente sul punto di arresto attivato in funzione dei task da interrompere; vedere la tabella in Definire il gruppo di task debug (Pagina 341).

È possibile modificare il gruppo di task debug soltanto se non è stato attivato alcun punto di arresto.



6.2.8.5 Tabella del parametro debug Nella tabella Debug sono illustrati tutti i punti di arresto nelle sorgenti di programma di un apparecchio SIMOTION.

Tabella 6- 13 Descrizione dei parametri Tabella di debug

Campo Descrizione Punti di debug (tabella) Attivo Viene visualizzato e può essere modificato lo stato di

attivazione del rispettivo punto di arresto: Attivo: il punto di arresto è attivato. Non attivo: il punto di arresto è disattivato. Vedere: Attivazione dei punti di arresto (Pagina 355).

Sorgente, riga (POE) Viene visualizzato il punto di codice con il punto di arresto impostato (con nome della sorgente di programma, numero di riga, nome della POE).

Percorso di richiamo Fare clic sul pulsante per specificare il percorso di richiamo del punto di arresto. Vedere: Definizione del percorso di richiamo per un singolo punto di arresto (Pagina 348).

Tutti i punti di arresto ... Attiva Fare clic sul pulsante per attivare tutti i punti di arresto (in

tutte le sorgenti del programma) dell'apparecchio SIMOTION. Vedere: Attivazione dei punti di arresto (Pagina 355).

Disattivazione Fare clic sul pulsante per disattivare tutti i punti di arresto (in tutte le sorgenti del programma) dell'apparecchio SIMOTION. Vedere: Attivazione dei punti di arresto (Pagina 355).

Elimina Fare clic sul pulsante per rimuovere tutti i punti di arresto (in tutte le sorgenti del programma) dell'apparecchio SIMOTION. Vedere: Impostazione dei punti di arresto (Pagina 344).

6.2.8.6 Impostazione dei punti di arresto

Presupposti: 1. La sorgente del programma con la POE (ad es. sorgente ST, MCC-Chart, programma

KOP/FUP) è aperta.

2. Deve sussistere un collegamento con il sistema di destinazione (modalità online).

3. SIMOTION SCOUT si trova nella modalità debug per il relativo apparecchio SIMOTION, vedere Impostazione della modalità debug (Pagina 339).

4. I task da arrestare sono specificati, vedere Definizione del gruppo di task di debug (Pagina 341).



Procedura Per impostare un punto di arresto, procedere come segue:

1. Scegliere un punto di codice in cui non sia impostato alcun punto di arresto:

– SIMOTION ST: nella sorgente ST posizionare il cursore in un riga contenente un'istruzione.

– SIMOTION MCC: in MCC-Chart selezionare un comando MCC (tranne modulo o blocco dei commenti).

– SIMOTION KOP/FUP: posizionare il cursore in una rete del programma KOP/FUP.

2. Eseguire la seguente azione (alternative):

– Selezionare il menu Debug > Imposta/rimuovi punto di arresto (tasto di scelta rapida F9).

– Fare clic nella barra degli strumenti Punti di arresto sul pulsante .

Per rimuovere un punto di arresto, procedere come segue:

1. Selezionare il punto di codice con il punto di arresto.


– Selezionare il menu Debug > Imposta/rimuovi punto di arresto (tasto di scelta rapida F9).


Procedere come segue per rimuovere tutti i punti di arresto (in tutte le sorgenti di programma) dell'apparecchio SIMOTION:

● Eseguire la seguente azione (alternative):

– Selezionare il menu Debug > Rimuovi tutti i punti di arresto (tasto di scelta rapida CTRL+F5).




Nota

Non è possibile impostare i punti di arresto: • SIMOTION ST: nelle righe contenenti esclusivamente un commento • SIMOTION MCC: sul modulo dei comandi o sul blocco dei commenti. • SIMOTION KOP/FUP: all'interno di una rete. • Nei punti di codice in cui sono già impostati altri punti debug (ad es. punti di trigger).

I punti di debug in tutte le sorgenti di programma dell'apparecchio SIMOTION si possono elencare nella Tabella di debug:

• Fare clic nella barra degli strumenti Punti di arresto sul pulsante per aprire la "tabella di debug".

Nella tabella di debug si possono anche rimuovere tutti i punti di arresto (in tutte le sorgenti di programma) dell'apparecchio SIMOTION: • Fare clic sul pulsante "Elimina tutti i punti di arresto".

I punti di arresto impostati restano memorizzati anche dopo che si esce dal modo operativo "Modalità debug", ma vengono visualizzati solo in modalità debug.

Le funzioni di diagnostica Stato programma (Pagina 334) e Punti di arresto possono essere utilizzate insieme in una sorgente di programma o POE. Valgono però le seguenti limitazioni in base ai linguaggi di programmazione::

● SIMOTION ST: Per la versione V3.2 del SIMOTION Kernel le righe (selezionate) della sorgente ST da testare con Stato programma non devono contenere punti di arresto.

● SIMOTION MCC e KOP/FUP: I comandi dell'MCC-Chart (o reti del programma KOP/FUP) da testare con Stato programma non devono contenere punti di arresto.

Ulteriore procedura 1. Stabilire il percorso di richiamo; vedere Definizione del percorso di richiamo per un

singolo punto di arresto (Pagina 348).

2. Attivare i punti di arresto; vedere Attivazione dei punti di arresto (Pagina 355).



6.2.8.7 Barra delle funzioni dei punti di arresto Questa barra degli strumenti contiene operazioni importanti per l'impostazione e l'attivazione di punti di arresto:

Tabella 6- 14 Barra degli strumenti dei punti di arresto

Simbolo Significato

Imposta/rimuovi punto di arresto Fare clic su questo simbolo per impostare un punto di arresto nel punto di codice selezionato, oppure per rimuovere un punto di arresto. Vedere: Impostazione dei punti di arresto (Pagina 344).

Attiva/disattiva punto di arresto Fare clic su questo simbolo per attivare o disattivare un punto di arresto nel punto di codice selezionato. Vedere: Attivazione dei punti di arresto (Pagina 355).

Modifica percorso di richiamo Fare clic su questo simbolo per definire il percorso di richiamo per i punti di arresto: • Se si seleziona un punto di codice con punto di arresto: il percorso di richiamo per

questo punto di arresto. • Se si seleziona un punto di codice senza punto di arresto: il percorso di richiamo

per tutti i punti di arresto della POE. Vedere: Definizione del percorso di richiamo per un singolo punto di arresto (Pagina 348), Definizione del percorso di richiamo per tutti i punti di arresto (Pagina 352).

Attivazione di tutti i punti di arresto delle POE attive Fare clic su questo simbolo per attivare tutti i punti di arresto nella sorgente di programma o nella POE attiva (ad es. sorgente ST, MCC-Chart, programma KOP/FUP). Vedere: Attivazione dei punti di arresto (Pagina 355).

Disattivazione di tutti i punti di arresto delle POE attive Fare clic su questo simbolo per disattivare tutti i punti di arresto nella sorgente di programma o nella POE attiva (ad es. sorgente ST, MCC-Chart, programma KOP/FUP). Vedere: Attivazione dei punti di arresto (Pagina 355).

Rimozione di tutti i punti di arresto delle POE attive Fare clic su questo simbolo per rimuovere tutti i punti di arresto nella sorgente di programma o nella POE attiva (ad es. sorgente ST, MCC-Chart, programma KOP/FUP). Vedere: Impostazione dei punti di arresto (Pagina 344).

Tabella di debug Fare clic su questo simbolo per visualizzare la tabella di debug. Vedere: Tabella dei parametri di debug (Pagina 344).



Simbolo Significato

Visualizza Call Stack Fare clic su questo simbolo per visualizzare, dopo il raggiungimento di un punto di arresto attivato: • il percorso di richiamo nel punto di arresto corrente, • il punto di codice nel quale sono stati arrestati gli altri task del gruppo dei task di

debug, e il relativo percorso di richiamo. Vedere: Visualizza Call Stack (Pagina 358).

Continua Fare clic su questa icona per proseguire l'esecuzione del programma dopo il raggiungimento di un punto di arresto attivato. Vedere: Attivazione dei punti di arresto (Pagina 355), Visualizzazione Call Stack (Pagina 358).

6.2.8.8 Definizione del percorso di richiamo per un singolo punto di arresto

Presupposti: 1. La sorgente del programma con la POE (ad es. sorgente ST, MCC-Chart, programma

KOP/FUP) è aperta.




5. Il punto di arresto è impostato (vedere Impostazione dei punti di arresto (Pagina 344)).

Procedura Per definire il percorso di richiamo per un singolo punto di arresto, procedere nel modo seguente:

1. Scegliere un punto di codice in cui sia già impostato un punto di arresto:

– SIMOTION ST: posizionare il cursore nella riga corrispondente della sorgente ST.

– SIMOTION MCC: selezionare un comando corrispondente in MCC-Chart.

– SIMOTION KOP/FUP: posizionare il cursore in una rete corrispondente del programma KOP/FUP.

2. Fare clic nella barra degli strumenti Punti di arresto sul pulsante "Modifica percorso di richiamo".

Nella finestra "Percorso di richiamo/Selezione task Punto di arresto" viene visualizzato il punto di codice selezionato (con il nome della sorgente di programma, il numero della riga, il nome della POE).



3. Selezionare il task nel quale viene arrestato il programma utente (ossia tutti i task nel gruppo di task di debug) al raggiungimento del punto di arresto selezionato.

Si può scegliere tra:

– Tutti i punti di richiamo a partire da questo livello di richiamo.

Il programma utente viene sempre arrestato quando in un task qualsiasi del gruppo di task di debug viene raggiunto il punto di arresto attivato.

– I singoli task dai quali può essere raggiunto il punto di arresto selezionato.

Il programma utente viene arrestato solo quando viene raggiunto il punto di arresto nel task selezionato. Il task deve trovarsi nel gruppo di task debug.

È possibile indicare il percorso di richiamo.

4. Solo per funzioni e blocchi funzionali: selezionare il percorso di richiamo, ossia il punto di codice che effettua il richiamo (nella POE che effettua il richiamo).



Il percorso di richiamo non è indicato. Il programma utente viene sempre arrestato sul punto di arresto attivato quando viene richiamata la POE nel task selezionato.

– Solo se viene selezionato un singolo task: i punti di codice richiamanti all'interno del task selezionato (con il nome della sorgente del programma, il numero di riga, il nome della POE).

Il percorso di richiamo viene indicato. Il programma utente viene arrestato sul punto di arresto attivato solo se la POE viene richiamata dal punto di codice selezionato.

Se la POE del punto di codice richiamante selezionato viene a sua volta richiamata da altri punti di codice, vengono visualizzate altre righe nelle quali è possibile procedere in modo analogo.

5. Se il punto di arresto deve essere attivato soltanto dopo aver raggiunto più volte il punto di codice, selezionare il numero relativo.

Nota

Il percorso di richiamo dei singoli punti di arresto può essere definito anche nella tabella di debug:

1. Fare clic nella barra degli strumenti Punti di arresto sul pulsante per aprire la "tabella di debug". Viene visualizzata la finestra "Tabella di debug".

2. Fare clic sul pulsante corrispondente nella colonna "Percorso di richiamo". 3. Procedere come indicato sopra:

– Definire il task. – Definire il percorso di richiamo (solo per le funzioni e i blocchi funzione). – Specificare il numero di cicli dopo il quale deve essere attivato il punto di arresto.



Ulteriore procedura: ● Attivare i punti di arresto; vedere Attivazione dei punti di arresto (Pagina 355).

Nota

Il percorso di richiamo di un punto di arresto corrente e i punti di codice nei quali sono stati arrestati altri gruppi di task di debug possono essere visualizzati con la funzione "Visualizza Call Stack (Pagina 358)".

Vedere anche Definizione del percorso di richiamo per tutti i punti di arresto (Pagina 352)

6.2.8.9 Parametri Percorso di richiamo/Selezione del task Punto di arresto

Tabella 6- 15 Descrizione dei parametri Percorso di richiamo/Selezione del task Punto di arresto

Campo Descrizione CPU selezionata L'apparecchio SIMOTION selezionato viene visualizzato. Task richiamante Selezionare il task nel quale viene arrestato il programma utente

(ossia tutti i task nel gruppo di task di debug) al raggiungimento del punto di arresto selezionato. Si può scegliere tra: • Tutti i punti di richiamo a partire da questo livello di richiamo.

Il programma utente viene sempre arrestato quando in un task qualsiasi del gruppo di task di debug viene raggiunto il punto di arresto attivato.

• I singoli task dai quali può essere raggiunta la POE con il punto di arresto selezionato.

Il programma utente viene arrestato solo quando viene raggiunto il punto di arresto nel task selezionato. Il task deve trovarsi nel gruppo di task debug.

È possibile indicare il percorso di richiamo. Punto di codice attuale Viene visualizzato il punto di codice con il punto di arresto impostato

(con nome della sorgente di programma, numero di riga, nome della POE).



Campo Descrizione viene richiamato da Solo per funzioni e blocchi funzionali.

Selezionare il percorso di richiamo, ossia il punto di codice che effettua il richiamo (nella POE che effettua il richiamo). Si può scegliere tra: • Tutti i punti di richiamo a partire da questo livello di richiamo.

Il percorso di richiamo non è indicato. Il programma utente viene sempre arrestato sul punto di arresto attivato quando viene raggiunta la POE nel task selezionato.

• Solo se viene selezionato un singolo task: i punti di codice che effettuano il richiamo all'interno del task selezionato (con il nome della sorgente del programma, il numero di riga, il nome della POE).

Il percorso di richiamo viene indicato. Il programma utente viene arrestato sul punto di arresto attivato solo se la POE viene richiamata dal punto di codice selezionato.


Punto di arresto attivato dopo … cicli

Se il punto di arresto deve essere attivato soltanto dopo aver raggiunto più volte il punto di codice, selezionare il numero relativo.

ATTENZIONE È possibile modificare il gruppo di task debug soltanto se non è stato attivato alcun punto di arresto.



6.2.8.10 Definizione del percorso di richiamo per tutti i punti di arresto Con questa procedura è possibile:

● Selezionare un'impostazione di default per tutti i punti di arresto successivi in una POE (ad es. MCC-Chart, programma KOP/FUP o POE in una sorgente ST):

● Applicare e adattare il percorso di richiamo per tutti i punti di arresto finora impostati in questa POE.

Presupposti 1. La sorgente del programma con la POE (ad es. sorgente ST, MCC-Chart, programma

KOP/FUP) è aperta.




Procedura Per definire il percorso di richiamo per tutti i punti di arresto successivi in una POE, procedere nel modo seguente:

1. Scegliere un punto di codice in cui non sia impostato alcun punto di arresto:




2. Fare clic nella barra degli strumenti Punti di arresto sul pulsante "Modifica percorso di richiamo".

Nella finestra "Percorso di richiamo/Selezione task Tutti i punti di arresto per POE" viene visualizzato il punto di codice selezionato (con il nome della sorgente di programma, il numero della riga, il nome della POE).

3. Selezionare il task nel quale viene arrestato il programma utente (ossia tutti i task nel gruppo di task di debug) al raggiungimento di un punto di arresto in questa POE.



Il programma utente viene sempre arrestato quando viene raggiunto un punto di arresto attivato della POE in un task qualsiasi del gruppo di task di debug.

– I singoli task dai quali può essere raggiunto il punto di arresto selezionato.

Il programma utente viene arrestato solo quando viene raggiunto un punto di arresto nel task selezionato. Il task deve trovarsi nel gruppo di task debug.

È possibile indicare il percorso di richiamo.



4. Solo per funzioni e blocchi funzionali: selezionare il percorso di richiamo, ossia il punto di codice che effettua il richiamo (nella POE che effettua il richiamo).



Il percorso di richiamo non è indicato. Il programma utente viene sempre arrestato su un punto di arresto attivato quando viene richiamata la POE nel task selezionato.

– Solo se viene selezionato un singolo task: i punti di codice richiamanti all'interno del task selezionato (con il nome della sorgente del programma, il numero di riga, il nome della POE).

Il percorso di richiamo viene indicato. Il programma utente viene arrestato su un punto di arresto attivato solo se la POE viene richiamata dal punto di codice selezionato.

Se il punto di codice richiamante selezionato viene a sua volta richiamato da diversi punti di codice, vengono visualizzate altre righe nelle quali è possibile procedere in modo analogo.

5. Se un punto di arresto deve essere attivato soltanto dopo aver raggiunto più volte il punto di codice, selezionare il numero relativo di esecuzioni.

6. Per applicare e adattare questo percorso di richiamo per tutti i punti di arresto impostati in questa POE, procedere come segue:

– Fare clic su Applica.

Ulteriore procedura: ● Attivare i punti di arresto; vedere Attivazione dei punti di arresto (Pagina 355).

Nota

Il percorso di richiamo di un punto di arresto corrente e i punti di codice nei quali sono stati arrestati altri gruppi di task di debug possono essere visualizzati con la funzione "Visualizza Call Stack (Pagina 358)".

Vedere anche Definizione del percorso di richiamo per un singolo punto di arresto (Pagina 348)



6.2.8.11 Parametri Percorso di richiamo/Selezione task Tutti i punti di arresto per POE Qui si immette un'impostazione predefinita per il percorso di richiamo di tutti i punti di arresto da impostare successivamente in una POE. Quest'impostazione può essere applicata anche per tutti i punti di arresto finora impostati di questa POE.

Tabella 6- 16 Descrizione dei parametri Percorso di richiamo/Selezione task Tutti i punti di arresto per POE

Campo Descrizione CPU selezionata L'apparecchio SIMOTION selezionato viene visualizzato. Task richiamante Selezionare il task nel quale viene arrestato il programma utente

(ossia tutti i task nel gruppo di task di debug) al raggiungimento di un punto di arresto in questa POE. Si può scegliere tra: • Tutti i punti di richiamo a partire da questo livello di richiamo.

Il programma utente viene sempre arrestato quando viene raggiunto un punto di arresto attivato della POE in un task qualsiasi del gruppo di task di debug.

• I singoli task dai quali può essere raggiunta la POE.

Il programma utente viene arrestato solo quando viene raggiunto un punto di arresto attivato nel task selezionato. Il task deve trovarsi nel gruppo di task debug.

È possibile indicare il percorso di richiamo. POE attuale Viene visualizzata la POE nella quale si trova il cursore (con nome

della sorgente del programma, nome della POE) viene richiamato da Solo per funzioni e blocchi funzionali.

Selezionare il percorso di richiamo, ossia il punto di codice che effettua il richiamo (nella POE che effettua il richiamo). Si può scegliere tra: • Tutti i punti di richiamo a partire da questo livello di richiamo.

Il percorso di richiamo non è indicato. Il programma utente viene sempre arrestato su un punto di arresto attivato quando viene richiamata la POE nel task selezionato.

• Solo se viene selezionato un singolo task: i punti di codice che effettuano il richiamo all'interno del task selezionato (con il nome della sorgente del programma, il numero di riga, il nome della POE).

Il percorso di richiamo viene indicato. Il programma utente viene arrestato su un punto di arresto attivato solo se la POE viene richiamata dal punto di codice selezionato.




Campo Descrizione Punto di arresto attivato dopo … cicli

Se il punto di arresto deve essere attivato soltanto dopo aver raggiunto più volte il punto di codice, selezionare il numero relativo.

Applicazione di questo percorso di richiamo per tutti i punti di arresto precedenti di questa POE

Fare clic sul pulsante Applica, se si intende applicare il percorso di richiamo per tutti i punti di arresto impostati fino a questo momento della POE attuale. Le impostazioni esistenti vengono sovrascritte.

6.2.8.12 Attivazione dei punti di arresto È necessario attivare i punti di arresto affinché essi siano efficaci nell'esecuzione del programma.

Presupposti 1. La sorgente del programma con la POE (ad es. sorgente ST, MCC-Chart, programma

KOP/FUP) è aperta.




5. I punti di arresto sono impostati (vedere Impostazione dei punti di arresto (Pagina 344)).

6. I percorsi di richiamo sono definiti (vedere Definizione del percorso di richiamo per un singolo punto di arresto (Pagina 348)).

Attivazione dei punti di arresto Per attivare un solo punto di arresto, procedere come segue:

1. Scegliere un punto di codice in cui sia già impostato un punto di arresto:





– Selezionare il menu Debug > Attiva/disattiva punto di arresto (tasto di scelta rapida F12).




Procedere come segue per attivare tutti i punti di arresto (in tutte le sorgenti di programma) dell'apparecchio SIMOTION:


– Selezionare il menu Debug > Attiva tutti i punti di arresto.


Dopo l'attivazione del primo punto di arresto l'apparecchio SIMOTION passa alla modalità debug, dove rimane fino alla disattivazione dell'ultimo punto di arresto.

Nella barra delle funzioni Stato del task (Pagina 359) i task con i punti di arresto attivati vengono visualizzati con sfondo grigio ( ).

Nota

I punti di arresto di tutte le sorgenti di programma dell'apparecchio SIMOTION possono essere attivati/disattivati nella tabella di debug:

1. Fare clic nella barra degli strumenti Punti di arresto sul pulsante per aprire la "tabella di debug". Viene visualizzata la finestra "Tabella di debug".

2. Eseguire la seguente azione indipendentemente dai punti che si intende attivare/disattivare: – Punti di arresto singoli: Attivare o disattivare la corrispondente casella di controllo. – Tutti i punti di arresto (in tutte le sorgenti di programma): Fare clic sul relativo pulsante

.

Con i punti di arresto attivati la funzione di prova "Passo singolo" del linguaggio di programmazione SIMOTION MCC non può essere utilizzata.

I punti di arresto non sono attivabili se la priorità di comando è presente nel pannello di controllo dell'asse. Viceversa, la priorità di comando per il pannello di controllo degli assi puòessere attivata, se viene attivato un punto di arresto.

Comportamento sul punto di arresto attivato Al raggiungimento di un punto di arresto attivato (eventualmente tramite il percorso di richiamo (Pagina 348) selezionato) vengono arrestati i task associati al gruppo di task di debug. Il comportamento dipende dai task contenuti nel gruppo di task di debug ed è descritto nella sezione "Definizione del gruppo di task debug (Pagina 341). Il punto di arresto viene evidenziato.

Nella barra delle funzioni Stato del task (Pagina 359) il task, nel quale è stato raggiunto il punto di arresto, viene rappresentato con sfondo rosso ( ).

Se il punto di arresto che ha provocato l'interruzione del task si trova in un programma o in un blocco funzione, i valori delle variabili statiche di questa POE vengono visualizzati nella scheda "Stato variabili" della visualizzazione dettagliata. Le variabili temporanee (anche i parametri di transito nel caso di blocchi funzione) non vengono visualizzate. Le variabili statiche di altre POE o le variabili Unit possono essere monitorate nel browser dei simboli (Pagina 323).



La funzione "Visualizza Call Stack (Pagina 358)" permette di visualizzare:

● il percorso di richiamo nel punto di arresto corrente,

● il punto di codice (con il relativo percorso di richiamo) nel quale sono stati arrestati gli altri task del gruppo dei task di debug.

Proseguimento del programma Per proseguire l'esecuzione del programma, procedere come segue:


– Selezionare il menu Debug > Prosegui (tasto di scelta rapida CTRL+F8).

– Fare clic nella barra degli strumenti Punti di arresto sul pulsante per "Prosegui".

Disattivazione dei punti di arresto Per disattivare un solo punto di arresto, procedere come segue:

1. Selezionare il punto di codice con il punto di arresto attivato.


– Selezionare il menu Debug > Attiva/disattiva punto di arresto (tasto di scelta rapida F12).


Procedere come segue per disattivare tutti i punti di arresto (in tutte le sorgenti di programma) dell'apparecchio SIMOTION:


– Selezionare il menu Debug > Disattiva tutti i punti di arresto.


Dopo la disattivazione dell'ultimo punto di arresto l'apparecchio SIMOTION passa al modo operativo "modalità test"; SIMOTION SCOUT rimane nella modalità debug.



6.2.8.13 Visualizzazione di Call Stack La funzione "Visualizza Call Stack" permette di visualizzare:

● il percorso di richiamo nel punto di arresto corrente,

● il punto di codice (con il relativo percorso di richiamo) nel quale sono stati arrestati gli altri task del gruppo dei task di debug.

Presupposto Il programma utente si trova in un punto di arresto attivato, vale a dire che i task del gruppo di task di debug (Pagina 341) sono arrestati.

Procedura Per richiamare la funzione "Visualizza Call Stack" procedere come segue:

● Fare clic nella barra delle funzioni Punti di arresto sul pulsante "Visualizza Call Stack".

Si apre la finestra di dialogo "Callstack punto di arresto. Viene visualizzato il percorso di richiamo corrente (incluso il task richiamante e il numero delle escuzioni impostate).

Il percorso di richiamo non può essere modificato.

Per utilizzare la funzione "Visualizza Call Stack" procedere come segue:

1. Lasciare aperta la finestra di dialogo "Call-Stack punto di arresto".

2. In questo modo viene visualizzato il punto di codice nel quale è stato arrestato un altro task:

– Selezionare il task corrispondente. Sono disponibili per la selezione tutti i task del gruppo di task debug.

Viene visualizzato il punto di codice con il percorso di richiamo. Se il punto di codice è contenuto in un programma utente, viene aperta la sorgente di programma interessata con la relativa POE (ad es. sorgente ST, MCC-Chart, programma KOP/FUP) e viene evidenziato il punto di codice.

3. Per proseguire l'esecuzione del programma, procedere come segue:

– Fare clic nella barra delle funzioni Punti di arrestosul pulsante "Continua" (tasto di scelta rapida CTRL+F8).

Al raggiungimento del successivo punto di codice attivato, i task del gruppo di task di debug vengono nuovamente attivati. Viene visualizzato il percorso di richiamo corrente incluso il task richiamante.

4. Per chiudere la finestra di dialogo "Callstack punto di arresto" premere OK.




6.2.8.14 Parametro Callstack punto di arresto Quando un punto di arresto attivato (Pagina 355) viene raggiunto, per ogni task del gruppo di task di debug (Pagina 341) è possibile visualizzare quanto segue:

● la posizione nel codice di programma (ad es. la riga di una sorgente ST) in corrispondenza della quale il task è stato arresto,

● il percorso di richiamo di questo punto di codice.

Tabella 6- 17 Descrizione del parametro percorso di richiamo punto di arresto

Campo Descrizione CPU selezionata L'apparecchio SIMOTION selezionato viene visualizzato. Task richiamante Selezionare il task per cui si desidera visualizzare il punto di codice

in cui è stato arrestato il task. Sono disponibili per la selezione tutti i task del gruppo di task debug.

Punto di codice attuale Il punto del codice di programma (ad es. una riga della sorgente ST) in cui è stato arrestato il task selezionato viene visualizzato (con nome della sorgente di programma, numero della riga, nome della POE).

viene richiamato da I punti di codice che richiamano all'interno del task selezionato il punto di codice attuale vengono visualizzati in modo ricorsivo (con nome della sorgente di programma, numero di riga, nome della POE, event. nome dell'istanza di un blocco funzionale).


6.2.9 Barra delle funzioni Stato del task La barra delle funzioni Stato del task indica in una combobox tutti i task dell'apparecchio SIMOTION attivo, a cui è assegnato un programma.

Viene visualizzata nelle seguenti condizioni:

1. SIMOTION SCOUT si trova nella modalità online.

2. Il relativo apparecchio SIMOTION è attivo, ad es.

– Nella navigazione di progetto è selezionato l'apparecchio SIMOTION o un elemento nella sua diramazione (ad es. sorgente di programma, oggetto tecnologico).

– Nell'area di lavoro è attiva una finestra aperta, che appartiene all'elemento nella diramazione dell'apparecchio SIMOTION.

3. L'apparecchio SIMOTION è coerente.

La colorazione dello sfondo indica il verificarsi di determinati eventi nel relativo task, vedere la seguente tabella. Il relativo task viene visualizzato secondo l'ordine dell'evento nella combobox della barra delle funzioni.



Tabella 6- 18 Significato dei colori di sfondo nella barra delle funzioni Stato del task

Colore di sfondo Significato Ordine

Azzurro Il relativo task, con funzione di prova "Passo singolo" attende un comando (solo con linguaggio di programmazione SIMOTION MCC).

Rosso Il relativo task si trova in un punto di arresto (Pagina 355).

Blu Nel relativo task è attivata la funzione di prova "Passo singolo" (solo con linguaggio di programmazione SIMOTION MCC).

Grigio Nel relativo task almeno 1 punto di arresto (Pagina 355) è attivato.

Giallo Nel relativo task è attivata la funzione di prova "Osservazione" (solo con linguaggio di programmazione SIMOTION MCC).

Bianco Nel relativo task non è attivata alcuna delle summenzionate funzioni di prova.

Superiore

Inferiore

Nota

La selezione di un task nella combobox è possibile soltanto con le seguenti funzioni di prova del linguaggio di programmazione SIMOTION MCC: • Osservazione • Passo singolo

6.2.10 Trace Con il tool Trace è possibile registrare e memorizzare il flusso temporale dei valori delle variabili (ad es. variabili Unit, variabili locali, variabili di sistema, variabili I/O). In questo modo si può documentare l'ottimizzazione, per es. degli assi.

E' possibile impostare la durata della registrazione, visualizzare un massimo di quattro canali, selezionare le condizioni di trigger, parametrizzare gli offset temporali, scegliere tra diverse rappresentazioni delle curve e diversi fattori di scala, ecc.

Accanto alla registrazione sincrona al clock è possibile anche selezionare Registrazione al punto del codice. In questo modo i valori delle variabili possono sempre essere registrati nel momento in cui il programma esegue un punto definito della sorgente ST.

Il tool Trace viene descritto nel dettagli all'interno della Guida in linea.



6.2.11 Confronto progetti

Per SIMOTION SCOUT è disponibile la funzione Confronto progetti(avvio mediante il pulsanteAvvia confronto oggetti ), per confrontare tra loro gli oggetti all'interno del medesimo progetto oppure con oggetti da altri progetti (online oppure offline).

Il Confronto progetti offre la possibilità di rilevare le differenze e di eseguire all'occorrenza un'acquisizione dati al fine di porre rimedio alle differenze.

Per oggetti si intendono gli apparecchi, i sotto-oggetti sono i programmi, gli oggetti tecnologici (TO) oppure gli oggetti di azionamento (DO) e le librerie. Attraverso il Confronto progetti si ottiene assistenza in caso di interventi di manutenzione all'impianto.

Per maggiori informazioni sul confronto progetti e dettagli vedere il Manuale di guida alle funzioni Confronto progetti SIMOTION.




Appendice AA.1 Descrizione formale del linguaggio

Questo capitolo contiene una panoramica di tutti gli elementi base di ST e un riassunto completo di tutti i diagrammi di sintassi con gli elementi linguistici. Questa appendice contiene un breve riepilogo dei principi fondamentali del linguaggio ST.

A.1.1 Strumenti per la descrizione del linguaggio Alla base della descrizione del linguaggio nei singoli capitoli vi sono i diagrammi di sintassi. Essi offrono una valida introduzione alla struttura sintattica (ossia grammaticale) di ST.

Le modalità di utilizzo del diagramma della sintassi si apprendono in Strumenti per la descrizione del linguaggio. Per gli utenti più esperti, i paragrafi successivi illustrano inoltre l'interessante differenza tra le regole con o senza formato definito.

A.1.1.1 Regole con formato definito (regole lessicali) Le regole lessicali descrivono la struttura degli elementi elaborati nell'analisi lessicale del compilatore. Di conseguenza, la scrittura ha un formato definito e le regole devono essere rispettate in modo rigoroso. In particolare, questo significa che:

● l'inserimento dei caratteri di formattazione non è consentito;

● l'inserimento dei commenti a blocchi e dei commenti a righe non è consentito;

● l'inserimento degli attributi degli identificatori non è consentito.

La seguente figura mostra una regola lessicale, più specificamente quella dell'identificatore consentito.

Figura A-1 Esempio di regola lessicale

Appendice A.1 Descrizione formale del linguaggio


Gli esempi validi secondo questa regola rappresentata sono i seguenti:

R_REGLER3

_A_FELD

_100_3_3_10

A.1.1.2 Regole senza formato definito (regole sintattiche) La struttura di ST viene descritta nelle regole sintattiche sulla base delle regole lessicali. Secondo queste regole, il programma ST può essere creato senza formato definito.

La proprietà dell'assenza di formato definito significa che:

● l'inserimento dei caratteri di formattazione è sempre possibile;

● l'inserimento dei commenti a blocchi e a righe è consentito.

L'esempio seguente mostra una regola sintattica riferita all'assegnazione del valore in un'istruzione.

Figura A-2 Esempio di regola sintattica



Gli esempi validi secondo questa regola rappresentata sono i seguenti:

VARIABLE_1 := 100; SWITCH := FALSE;

//Questo è un commento

VARIABLE_2:=3.2 +VARIABLE_1;

A.1.2 Elementi base (terminali) Il terminale è un elemento base che non viene spiegato tramite una regola specifica, bensì verbalmente. Nei diagrammi della sintassi il terminale è rappresentato da un ovale o da un cerchio.

A.1.2.1 Lettere, cifre e altri caratteri Le lettere e le cifre sono i caratteri più utilizzati. L'identificatore è costituito da lettere, cifre e carattere di sottolineatura. Quest'ultimo appartiene agli altri caratteri (diversi da lettere e cifre).

Tabella A- 1 Lettere e cifre

Carattere Sottogruppo Elementi del set di caratteri lettera maiuscola A .. Z Lettera lettera minuscola a .. z

Cifra cifra decimale 0 .. 9 Cifra a base otto cifra a base otto 0 .. 7 Cifra esadecimale cifra esadecimale 0 .. 9, A .. F, a .. f Bit cifra binaria 0, 1

Nei commenti si può utilizzare il set di caratteri ASCII completo ed esteso. A partire dall'equivalente decimale 32 (spazio vuoto) si possono utilizzare tutti i caratteri stampabili del codice ASCII.

Per i comandi linguistici, gli identificatori, le costanti, le espressioni e gli operatori, i caratteri diversi da lettere e cifre possono essere utilizzati solo seguendo determinate regole.

A.1.2.2 Caratteri di formattazione e di separazione nelle regole I caratteri di formattazione e di separazione vengono utilizzati in modo diverso nelle regole con formato definito (lessicali) e senza formato definito (sintattiche). Per informazioni sulle differenze tra regole sintattiche e lessicali, vedere Strumenti per la descrizione del linguaggio (Pagina 363).

Le seguenti tabelle elencano e descrivono i caratteri di formattazione e di separazione delle regole lessicali e sintattiche e tutte le regole in cui i caratteri di formattazione e di separazione sono utilizzati come terminali (vedere Regole (Pagina 379)).



Tabella A- 2 Caratteri di formattazione e di separazione nelle regole

Carattere Descrizione Regole lessicali : Carattere di separazione tra ore,

minuti e secondi Indicazione dell'ora del giorno

. Carattere di separazione per la rappresentazione di numeri a virgola mobile/intervalli di tempo e indirizzamento assoluto

Rappresentazione di numeri a virgola mobile, indicazione dell'ora del giorno, rappresentazione dei decimali, accesso all'istanza locale o globale

_ Carattere di

sottolineatura

Carattere di separazione per gli identificatori, carattere di separazione per i valori numerici nelle costanti

Identificatori, sequenza di cifre decimali, sequenza di cifre binarie, sequenza di cifre a base otto, esadecimali, rappresentazione a livelli

% Carattere iniziale dell'identificatore diretto dell'accesso alla memoria della CPU

Accesso alla memoria semplificato

// Comment Commento a righe (**) Comment Commento a blocchi

Tabella A- 3 Caratteri di formattazione e di separazione nelle regole sintattiche

Carattere Descrizione Regole sintattiche : Caratteri di separazione per

l'indicazione del tipo Funzione, dichiarazione delle variabili, dichiarazione dei componenti, istruzione CASE, dichiarazione di istanza

; Carattere finale di una dichiarazione o di un'istruzione

Blocco di costanti, istruzione, dichiarazione delle variabili, dichiarazione di istanza, dichiarazione dei componenti, parte delle istruzioni

, Carattere di separazione per gli elenchi

Dichiarazione di variabili, elenco di inizializzazione campo, dichiarazione di istanza, specifica del tipo di dati ARRAY, parametro del blocco funzionale, parametro della funzione, elenco dei valori

.. Indicazione del campo Specifica del tipo di dati ARRAY, elenco dei valori

. Accesso alla struttura Variabile strutturata ( ) Elenco di inizializzazione per gli

array, parentesi nelle espressioni, richiamo funzione e blocco funzionale

Elenco di inizializzazione campo, espressione, moltiplicazione semplice, operando, esponente, richiamo del blocco funzionale, richiamo della funzione

[ ] Dichiarazione dell'array, array di parte della variabile strutturata

Specifica del tipo di dati ARRAY

Vedere anche Strumenti per la descrizione del linguaggio (Pagina 91)



A.1.2.3 Caratteri di formattazione e di separazione per le costanti Di seguito vengono riportati tutti i caratteri di formattazione e di separazione per le costanti con l'indicazione delle regole lessicali in cui vengono utilizzati.

Tabella A- 4 Caratteri di formattazione e di separazione per le costanti

Carattere Identificatore per Regole lessicali 2# Costante a numero intero Sequenza di cifre binarie 8# Costante a numero intero Sequenza di cifre a base otto 16# Costante a numero intero Sequenza di cifre esadecimali E Caratteri di separazione per le

costanti di numeri a virgola mobile Esponente

e Caratteri di separazione per le costanti di numeri a virgola mobile

Esponente

D# Indicazione del tempo Data DATE# Indicazione del tempo Data DATE_AND_TIME# Indicazione del tempo Data e ora DT# Indicazione del tempo Data e ora T# Indicazione del tempo Durata TIME# Indicazione del tempo Durata TIME_OF_DAY# Indicazione del tempo Ora del giorno TOD# Indicazione del tempo Ora del giorno d Carattere di separazione per

l'intervallo di tempo (day) Giorni (regola della rappresentazione a livelli)

h Carattere di separazione per l'intervallo di tempo (hours)

Ore (regola: rappresentazione a livelli)

m Carattere di separazione per l'intervallo di tempo (minutes)

Minuti (regola: rappresentazione a livelli)

ms Carattere di separazione per l'intervallo di tempo (milliseconds)

Millisecondi (regola: rappresentazione a livelli)

s Carattere di separazione per l'intervallo di tempo (seconds)

Secondi (regola: rappresentazione a livelli)



A.1.2.4 Identificatori predefiniti per l'accesso all'immagine di processo Di seguito sono riportate tutte le variabili predefinite in ST con cui accedere alle aree di memoria della CPU (identificatore assoluto). Tenere presente che le uscite possono essere lette e scritte, ma gli ingressi possono solo essere letti.

Tabella A- 5 Identificatore assoluto

Identificatore Descrizione Regole lessicali %In.x o %IXn.x

Area di ingresso della CPU con indirizzo byte e bit

Accesso assoluto all'immagine di processo

%IBn Area di ingresso della CPU con indirizzo byte


%IWn Area di ingresso della CPU con indirizzo parola


%IDn Area di ingresso della CPU con indirizzo parola doppia


%Qn.x o %QXn.x

Area di uscita della CPU con indirizzo byte e bit


%QBn Area di uscita della CPU con indirizzo byte


%QWn Area di uscita della CPU con indirizzo parola


%QDn Area di uscita della CPU con indirizzo parola doppia


A.1.2.5 Identificatori dell'informazione di avvio dei task Gli identificatori seguenti sono definiti per Taskstartinfo:

Tabella A- 6 Identificatori dell'informazione di avvio dei task

Identificatore Tipo di dati Descrizione TSI#alarmNumber DINT Query del numero allarme TSI#commandId.high UDINT Query del CommandId (parola

di valore maggiore) TSI#commandId.low UDINT Query del CommandId (parola

di valore minore) TSI#currentTaskId StructTaskId Query del TaskId del proprio

task TSI#cycleTime TIME Query del tempo di ciclo

progettato del proprio task TSI#details DWORD Query dell'informazione

dettagliata TSI#executionFaultType UDINT Query del tipo di errore di

esecuzione



Identificatore Tipo di dati Descrizione TSI#interruptId UDINT Query dell'evento trigger TSI#logBaseAdrIn DINT Query dell'indirizzo di base

logico TSI#logBaseAdrOut DINT Query dell'indirizzo di base

logico TSI#logDiagAddr DINT Query dell'indirizzo logico di

diagnostica TSI#shutDownInitiator UDINT Query dell'attivazione per la

transizione in STOP TSI#startTime DT Query del tempo di avvio TSI#taskId StructTaskId Query del TaskId del task di

attivazione TSI#toInst ANYOBJECT Query dell'istanza TO

A.1.2.6 Operatori Di seguito vengono indicati tutti gli operatori di ST con l'indicazione delle regole sintattiche in cui vengono utilizzati.

Tabella A- 7 Operatori ST

Operatore Descrizione Regole := Operatore di assegnazione

(anche per i valori di inizializzazione))

Assegnazione del valore, assegnazione di ingresso, assegnazione di passaggio, dichiarazione delle variabili, dichiarazione delle costanti, tipi di dati definiti dall'utente, dichiarazione dei componenti

+, – Operatori aritmetici: Operatori unari, segno

Espressione, esponente

+, –, *, / MOD

Operatori aritmetici di base Espressione, operatore aritmetico di base

** Operatori aritmetici: operatore di potenza

Espressione

NOT Operatori logici: Negazione Espressione, operando AND, &, OR, XOR Operatori logici di base Operatore di base logico <, >, <=, >=, =, <> Operatore di confronto Operatore di confronto => Operatore di assegnazione Assegnazione di uscita



A.1.2.7 Parole riservate Di seguito vengono riportate in ordine alfabetico le parole chiave, gli identificatori predefiniti e le funzioni standard del sistema di base ST. Inoltre, vengono fornite una descrizione e le regole sintattiche della regolazione in cui queste vengono utilizzate come terminali. Le funzioni standard rappresentano un'eccezione, perché sono contenute soltanto implicitamente nella regola sintattica Richiamo della funzione come nome della funzione standard.

Nota

Il nome delle variabili deve essere diverso da quello delle parole chiave e degli identificatori predefiniti. Per informazioni dettagliate sugli identificatori vedere Identificatore in ST. Per una panoramica degli identificatori che dipendono dagli oggetti tecnologici e di altri identificatori riservati vedere Identificatori riservati.

Tabella A- 8 Parole chiave di ST e identificatori predefiniti nel sistema di base ST

Parole chiave/Identificatori Descrizione Regole ABS Funzione numerica standard Richiamo della funzione ACOS Funzione numerica standard Richiamo della funzione AND Operatore logico Operatore di base logico ANYOBJECT Tipo di dati generale per gli oggetti tecnologici Tipo di dati TO ANYOBJECT_TO_OBJECT Funzione standard per la conversione del tipo

(oggetti tecnologici) Richiamo della funzione

ANYTYPE_TO_BIGBYTEARRAY Funzione standard (Marshalling) Richiamo della funzione ANYTYPE_TO_LITTLEBYTEARRAY Funzione standard (Marshalling) Richiamo della funzione ARRAY Identificatore iniziale della specifica di un array,

seguito dall'indice tra [ e] Specifica del tipo di dati ARRAY

AS Identificatore iniziale dello spazio del nome – ASIN Funzione numerica standard Richiamo della funzione AT Identificatore riservato – ATAN Funzione numerica standard Richiamo della funzione BIGBYTEARRAY_TOANYTYPE Funzione standard (Marshalling) Richiamo della funzione BOOL Tipo di dati elementare per i dati binari Tipo di dati bit BOOL_TO_BYTE Funzione standard per la conversione del tipo Richiamo della funzione BOOL_TO_DWORD Funzione standard per la conversione del tipo Richiamo della funzione BOOL_TO_WORD Funzione standard per la conversione del tipo Richiamo della funzione BOOL_VALUE_TO_DINT Funzione standard per la conversione del tipo Richiamo della funzione BOOL_VALUE_TO_INT Funzione standard per la conversione del tipo Richiamo della funzione BOOL_VALUE_TO_LREAL Funzione standard per la conversione del tipo Richiamo della funzione BOOL_VALUE_TO_REAL Funzione standard per la conversione del tipo Richiamo della funzione BOOL_VALUE_TO_SINT Funzione standard per la conversione del tipo Richiamo della funzione BOOL_VALUE_TO_UDINT Funzione standard per la conversione del tipo Richiamo della funzione BOOL_VALUE_TO_UINT Funzione standard per la conversione del tipo Richiamo della funzione



Parole chiave/Identificatori Descrizione Regole BOOL_VALUE_TO_USINT Funzione standard per la conversione del tipo Richiamo della funzione BY Identificatore iniziale dell'incremento Istruzione FOR BYTE Tipo di dati elementare Tipo di dati bit BYTE_TO_BOOL Funzione standard per la conversione del tipo Richiamo della funzione BYTE_TO_DINT Funzione standard per la conversione del tipo Richiamo della funzione BYTE_TO_DWORD Funzione standard per la conversione del tipo Richiamo della funzione BYTE_TO_INT Funzione standard per la conversione del tipo Richiamo della funzione BYTE_TO_SINT Funzione standard per la conversione del tipo Richiamo della funzione BYTE_TO_UDINT Funzione standard per la conversione del tipo Richiamo della funzione BYTE_TO_UINT Funzione standard per la conversione del tipo Richiamo della funzione BYTE_TO_USINT Funzione standard per la conversione del tipo Richiamo della funzione BYTE_TO_WORD Funzione standard per la conversione del tipo Richiamo della funzione BYTE_VALUE_TO_LREAL Funzione standard per la conversione del tipo Richiamo della funzione BYTE_VALUE_TO_REAL Funzione standard per la conversione del tipo Richiamo della funzione CASE Identificatore iniziale dell'istruzione di controllo

per la selezione Istruzione CASE

CONCAT Funzione standard per l'elaborazione delle stringhe

Richiamo della funzione

CONCAT_DATE_TOD Funzione standard per la conversione del tipo Richiamo della funzione CONSTANT Identificatore iniziale della definizione delle

costanti Blocco di costanti

COS Funzione numerica standard Richiamo della funzione CTD Contatore decrementale Richiamo del blocco

funzionale CTD_DINT Contatore decrementale Richiamo del blocco

funzionale CTD_UDINT Contatore decrementale Richiamo del blocco

funzionale CTU Contatore incrementale Richiamo del blocco

funzionale CTU_DINT Contatore incrementale Richiamo del blocco

funzionale CTU_UDINT Contatore incrementale Richiamo del blocco

funzionale CTUD Incrementatore/decrementatore Richiamo del blocco

funzionale CTUD_DINT Incrementatore/decrementatore Richiamo del blocco

funzionale CTUD_UDINT Incrementatore/decrementatore Richiamo del blocco

funzionale DATE Tipo di dati elementare per la data Tipo di tempo DATE_AND_TIME Tipo di dati elementare per la data e l'ora Tipo di tempo DATE_AND_TIME_TO_DATE Funzione standard per la conversione del tipo Richiamo della funzione DATE_AND_TIME_TO_TIME_OF_DAY Funzione standard per la conversione del tipo Richiamo della funzione



Parole chiave/Identificatori Descrizione Regole DELETE Funzione standard per l'elaborazione delle

stringhe Richiamo della funzione

DINT Tipo di dati elementare per il numero intero a doppia precisione (double integer) nel campo di valori -2**31 .. 2**31-1

Tipo di dati numerico

DINT_TO_BYTE Funzione standard per la conversione del tipo Richiamo della funzione DINT_TO_DWORD Funzione standard per la conversione del tipo Richiamo della funzione DINT_TO_INT Funzione standard per la conversione del tipo Richiamo della funzione DINT_TO_LREAL Funzione standard per la conversione del tipo Richiamo della funzione DINT_TO_REAL Funzione standard per la conversione del tipo Richiamo della funzione DINT_TO_SINT Funzione standard per la conversione del tipo Richiamo della funzione DINT_TO_STRING Funzione standard per la conversione del tipo Richiamo della funzione DINT_TO_UDINT Funzione standard per la conversione del tipo Richiamo della funzione DINT_TO_UINT Funzione standard per la conversione del tipo Richiamo della funzione DINT_TO_USINT Funzione standard per la conversione del tipo Richiamo della funzione DINT_TO_WORD Funzione standard per la conversione del tipo Richiamo della funzione DINT_VALUE_TO_BOOL Funzione standard per la conversione del tipo Richiamo della funzione DO Identificatore iniziale della sezione di istruzioni

nell'istruzione FOR o nell'istruzione WAITFORCONDITION

Istruzione FOR, istruzione WHILE, istruzione WAITFORCONDITION

DT Abbreviazione di DATE_AND_TIME Tipo di tempo DT_TO_DATE Funzione standard per la conversione del tipo Richiamo della funzione DT_TO_TOD Funzione standard per la conversione del tipo Richiamo della funzione DWORD Parola doppia del tipo di dati elementari Tipo di dati bit DWORD_TO_BOOL Funzione standard per la conversione del tipo Richiamo della funzione DWORD_TO_BYTE Funzione standard per la conversione del tipo Richiamo della funzione DWORD_TO_DINT Funzione standard per la conversione del tipo Richiamo della funzione DWORD_TO_INT Funzione standard per la conversione del tipo Richiamo della funzione DWORD_TO_REAL Funzione standard per la conversione del tipo Richiamo della funzione DWORD_TO_SINT Funzione standard per la conversione del tipo Richiamo della funzione DWORD_TO_UDINT Funzione standard per la conversione del tipo Richiamo della funzione DWORD_TO_UINT Funzione standard per la conversione del tipo Richiamo della funzione DWORD_TO_USINT Funzione standard per la conversione del tipo Richiamo della funzione DWORD_TO_WORD Funzione standard per la conversione del tipo Richiamo della funzione DWORD_VALUE_TO_LREAL Funzione standard per la conversione del tipo Richiamo della funzione DWORD_VALUE_TO_REAL Funzione standard per la conversione del tipo Richiamo della funzione ELSE Identificatore iniziale del caso in cui le

condizioni non sono soddisfatte Istruzione IF, istruzione CASE

ELSIF Identificatore iniziale della condizione alternativa

Istruzione IF

END_CASE Fine dell'istruzione CASE Istruzione CASE END_EXPRESSION Fine dell'istruzione EXPRESSION Espressione END_FOR Fine dell'istruzione FOR Istruzione FOR END_FUNCTION Identificatore finale della funzione Funzione



Parole chiave/Identificatori Descrizione Regole END_FUNCTION_BLOCK Identificatore finale del blocco funzionale Blocco funzionale END_IF Fine dell'istruzione IF Istruzione IF END_IMPLEMENTATION Identificatore finale della parte Implementation Parte Implementation END_INTERFACE Identificatore finale della parte Interface Parte Interface END_LABEL Fine dell'istruzione LABEL – END_PROGRAM Fine del programma Programma END_REPEAT Fine dell'istruzione REPEAT Istruzione REPEAT END_STRUCT Identificatore finale della specifica di una

struttura Specifica del tipo di dati STRUCT

END_TYPE Fine della definizione UDT Tipo di dati definito dall'utente

END_VAR Identificatore finale del blocco di dichiarazione Blocco variabili , blocco parametri , blocco costanti

END_WAITFORCONDITION Identificatore finale dell'istruzione di controllo per un task in attesa di un evento programmabile

Istruzione WAITFORCONDITION

END_WHILE Fine dell'istruzione WHILE Istruzione WHILE ENUM_TO_DINT Funzione standard per la conversione del tipo Richiamo della funzione EXIT Uscita diretta dall'elaborazione dei loop Istruzione EXIT EXP Funzione numerica standard Richiamo della funzione EXPD Funzione numerica standard Richiamo della funzione EXPRESSION Evento programmabile per il task in attesa Espressione EXPT Funzione numerica standard Richiamo della funzione F_TRIG Riconoscimento fronte di discesa Richiamo del blocco

funzionale FALSE Costante booleana predefinita: condizione

logica non soddisfatta, valore uguale a 0 –

FIND Funzione standard per l'elaborazione delle stringhe


FOR Identificatore iniziale dell'istruzione di controllo per l'elaborazione dei loop

Istruzione FOR

FUNCTION Identificatore iniziale della funzione Funzione FUNCTION_BLOCK Identificatore iniziale del blocco funzionale Blocco funzionale GOTO Salto Istruzione GOTO IF Identificatore iniziale dell'istruzione di controllo

per la selezione Istruzione IF

IMPLEMENTATION Identificatore iniziale per la parte IMPLEMENTATION

Parte IMPLEMENTATION

INSERT Funzione standard per l'elaborazione delle stringhe


INT Tipo di dati elementare per il numero intero a precisione semplice (integer) nel campo di valori -2**15 .. 2**15-1


INT_TO_BYTE Funzione standard per la conversione del tipo Richiamo della funzione INT_TO_DINT Funzione standard per la conversione del tipo Richiamo della funzione



Parole chiave/Identificatori Descrizione Regole INT_TO_DWORD Funzione standard per la conversione del tipo Richiamo della funzione INT_TO_LREAL Funzione standard per la conversione del tipo Richiamo della funzione INT_TO_REAL Funzione standard per la conversione del tipo Richiamo della funzione INT_TO_SINT Funzione standard per la conversione del tipo Richiamo della funzione INT_TO_TIME Funzione standard per la conversione del tipo Richiamo della funzione INT_TO_UDINT Funzione standard per la conversione del tipo Richiamo della funzione INT_TO_UINT Funzione standard per la conversione del tipo Richiamo della funzione INT_TO_USINT Funzione standard per la conversione del tipo Richiamo della funzione INT_TO_WORD Funzione standard per la conversione del tipo Richiamo della funzione INT_VALUE_TO_BOOL Funzione standard per la conversione del tipo Richiamo della funzione INTERFACE Identificatore iniziale della parte Interface Parte Interface LABEL Definizione delle etichette di salto – LEFT Funzione standard per l'elaborazione delle


LEN Funzione standard per l'elaborazione delle stringhe


LIMIT Funzione standard per la selezione Richiamo della funzione LITTLEBYTEARRAY_TOANYTYPE Funzione standard (Marshalling) Richiamo della funzione LN Funzione numerica standard Richiamo della funzione LOG Funzione numerica standard Richiamo della funzione LREAL Tipo di dati elementare per il numero a virgola

mobile a doppia precisione (long real) con un'ampiezza di bit di 64


LREAL_TO_DINT Funzione standard per la conversione del tipo Richiamo della funzione LREAL_TO_INT Funzione standard per la conversione del tipo Richiamo della funzione LREAL_TO_REAL Funzione standard per la conversione del tipo Richiamo della funzione LREAL_TO_SINT Funzione standard per la conversione del tipo Richiamo della funzione LREAL_TO_STRING Funzione standard per la conversione del tipo Richiamo della funzione LREAL_TO_UDINT Funzione standard per la conversione del tipo Richiamo della funzione LREAL_TO_UINT Funzione standard per la conversione del tipo Richiamo della funzione LREAL_TO_USINT Funzione standard per la conversione del tipo Richiamo della funzione LREAL_VALUE_TO_BOOL Funzione standard per la conversione del tipo Richiamo della funzione LREAL_VALUE_TO_BYTE Funzione standard per la conversione del tipo Richiamo della funzione LREAL_VALUE_TO_DWORD Funzione standard per la conversione del tipo Richiamo della funzione LREAL_VALUE_TO_WORD Funzione standard per la conversione del tipo Richiamo della funzione MAX Funzione standard per la selezione Richiamo della funzione MID Funzione standard per l'elaborazione delle


MIN Funzione standard per la selezione Richiamo della funzione MOD Operatore aritmetico per il resto della divisione Operatore aritmetico di base MUX Funzione standard per la selezione Richiamo della funzione NOT Operatore logico, appartiene agli operatori unari Espressione, operando



Parole chiave/Identificatori Descrizione Regole OF Identificatore iniziale della specifica del tipo di

dati Specifica del tipo di dati ARRAY, istruzione CASE

OR Operatore logico Operatore di base logico PROGRAM Introduzione del programma Programma R_TRIG Riconoscimento del fronte di salita Richiamo del blocco

funzionale REAL Tipo di dati elementare per il numero a virgola

mobile a precisione semplice (real) con un'ampiezza di bit di 32


REAL_TO_DINT Funzione standard per la conversione del tipo Richiamo della funzione REAL_TO_DWORD Funzione standard per la conversione del tipo Richiamo della funzione REAL_TO_INT Funzione standard per la conversione del tipo Richiamo della funzione REAL_TO_LREAL Funzione standard per la conversione del tipo Richiamo della funzione REAL_TO_SINT Funzione standard per la conversione del tipo Richiamo della funzione REAL_TO_STRING Funzione standard per la conversione del tipo Richiamo della funzione REAL_TO_TIME Funzione standard per la conversione del tipo Richiamo della funzione REAL_TO_UDINT Funzione standard per la conversione del tipo Richiamo della funzione REAL_TO_UINT Funzione standard per la conversione del tipo Richiamo della funzione REAL_TO_USINT Funzione standard per la conversione del tipo Richiamo della funzione REAL_VALUE_TO_BOOL Funzione standard per la conversione del tipo Richiamo della funzione REAL_VALUE_TO_BYTE Funzione standard per la conversione del tipo Richiamo della funzione REAL_VALUE_TO_DWORD Funzione standard per la conversione del tipo Richiamo della funzione REAL_VALUE_TO_WORD Funzione standard per la conversione del tipo Richiamo della funzione REPEAT Identificatore iniziale dell'istruzione di controllo

per l'elaborazione dei loop Istruzione REPEAT

REPLACE Funzione standard per l'elaborazione delle stringhe


RETAIN Dichiarazione delle variabili bufferizzate Blocco delle variabili ritentivo RETURN Istruzione di controllo per tornare al

sottoprogramma Istruzione RETURN

RIGHT Funzione standard per l'elaborazione delle stringhe


ROL Funzioni delle stringhe di bit standard Richiamo della funzione ROR Funzioni delle stringhe di bit standard Richiamo della funzione RS Blocco funzionale bistabile

(reset prioritario) Richiamo del blocco funzionale

RTC Orologio in tempo reale Richiamo del blocco funzionale

SEL Funzione standard per la selezione Richiamo della funzione SHL Funzioni delle stringhe di bit standard Richiamo della funzione SHR Funzioni delle stringhe di bit standard Richiamo della funzione SIN Funzione numerica standard Richiamo della funzione SINT Tipo di dati elementare per il numero intero

breve (short integer) nel campo di valori -128 .. 127




Parole chiave/Identificatori Descrizione Regole SINT_TO_BYTE Funzione standard per la conversione del tipo Richiamo della funzione SINT_TO_DINT Funzione standard per la conversione del tipo Richiamo della funzione SINT_TO_DWORD Funzione standard per la conversione del tipo Richiamo della funzione SINT_TO_INT Funzione standard per la conversione del tipo Richiamo della funzione SINT_TO_LREAL Funzione standard per la conversione del tipo Richiamo della funzione SINT_TO_REAL Funzione standard per la conversione del tipo Richiamo della funzione SINT_TO_UDINT Funzione standard per la conversione del tipo Richiamo della funzione SINT_TO_UINT Funzione standard per la conversione del tipo Richiamo della funzione SINT_TO_USINT Funzione standard per la conversione del tipo Richiamo della funzione SINT_TO_WORD Funzione standard per la conversione del tipo Richiamo della funzione SINT_VALUE_TO_BOOL Funzione standard per la conversione del tipo Richiamo della funzione SQRT Funzione numerica standard Richiamo della funzione SR Blocco funzionale bistabile (impostazione

prioritaria) Richiamo del blocco funzionale

STRING Tipo di dati elementare per stringhe di caratteri Tipo di dati String STRING_TO_DINT Funzione standard per la conversione del tipo Richiamo della funzione STRING_TO_LREAL Funzione standard per la conversione del tipo Richiamo della funzione STRING_TO_REAL Funzione standard per la conversione del tipo Richiamo della funzione STRING_TO_UDINT Funzione standard per la conversione del tipo Richiamo della funzione STRUCT Identificatore iniziale della specifica di una

struttura, seguito dall'elenco dei componenti Specifica del tipo di dati STRUCT

StructAlarmId Tipo di dati per AlarmId – StructAlarmId_TO_DINT Funzione standard per la conversione del tipo Richiamo della funzione StructTaskId Tipo di dati per TaskId – TAN Funzione numerica standard Richiamo della funzione THEN Identificatore iniziale dell'azione successiva,

quando la condizione è soddisfatta Istruzione IF

TIME Tipo di dati elementare per le indicazioni del tempo

Tipo di tempo

TIME_OF_DAY Tipo di dati elementare per l'ora del giorno Tipo di tempo TIME_TO_INT Funzione standard per la conversione del tipo Richiamo della funzione TIME_TO_REAL Funzione standard per la conversione del tipo Richiamo della funzione TO Identificatore iniziale del valore finale Istruzione FOR TOD Abbreviazione di TIME_OF_DAY Tipo di tempo TOF Disattivazione ritardata Richiamo del blocco

funzionale TON Ritardo all'attivazione Richiamo del blocco

funzionale TP Impulsi Richiamo del blocco

funzionale TRUE Costante booleana predefinita: condizione

logica soddisfatta, valore diverso da 0 –

TRUNC Funzione numerica standard Richiamo della funzione



Parole chiave/Identificatori Descrizione Regole TYPE Introduzione della definizione UDT Tipo di dati definito

dall'utente UDINT Tipo di dati elementare a doppia precisione

(double integer) senza segno (unsigned) da 0 .. 2**32-1


UDINT_TO_BYTE Funzione standard per la conversione del tipo Richiamo della funzione UDINT_TO_DINT Funzione standard per la conversione del tipo Richiamo della funzione UDINT_TO_DWORD Funzione standard per la conversione del tipo Richiamo della funzione UDINT_TO_INT Funzione standard per la conversione del tipo Richiamo della funzione UDINT_TO_LREAL Funzione standard per la conversione del tipo Richiamo della funzione UDINT_TO_REAL Funzione standard per la conversione del tipo Richiamo della funzione UDINT_TO_SINT Funzione standard per la conversione del tipo Richiamo della funzione UDINT_TO_STRING Funzione standard per la conversione del tipo Richiamo della funzione UDINT_TO_UINT Funzione standard per la conversione del tipo Richiamo della funzione UDINT_TO_USINT Funzione standard per la conversione del tipo Richiamo della funzione UDINT_TO_WORD Funzione standard per la conversione del tipo Richiamo della funzione UDINT_VALUE_TO_BOOL Funzione standard per la conversione del tipo Richiamo della funzione UINT Tipo di dati elementari per il numero intero a

precisione semplice (integer) senza segno (unsigned) da 0 .. 2**16-1


UINT_TO_BYTE Funzione standard per la conversione del tipo Richiamo della funzione UINT_TO_DINT Funzione standard per la conversione del tipo Richiamo della funzione UINT_TO_DWORD Funzione standard per la conversione del tipo Richiamo della funzione UINT_TO_INT Funzione standard per la conversione del tipo Richiamo della funzione UINT_TO_LREAL Funzione standard per la conversione del tipo Richiamo della funzione UINT_TO_REAL Funzione standard per la conversione del tipo Richiamo della funzione UINT_TO_SINT Funzione standard per la conversione del tipo Richiamo della funzione UINT_TO_UDINT Funzione standard per la conversione del tipo Richiamo della funzione UINT_TO_USINT Funzione standard per la conversione del tipo Richiamo della funzione UINT_TO_WORD Funzione standard per la conversione del tipo Richiamo della funzione UINT_VALUE_TO_BOOL Funzione standard per la conversione del tipo Richiamo della funzione UNIT Identificatore iniziale per la parte UNIT Parte UNIT UNTIL Identificatore iniziale della condizione di

interruzione dell'istruzione REPEAT Istruzione REPEAT

USELIB Identificatore iniziale del nome della libreria – USEPACKAGE Identificatore iniziale del nome del pacchetto – USES Identificatore iniziale per il riferimento a un'altra

Unit –

USINT Tipo di dati elementare per il numero intero breve (short integer) senza segno (unsigned) nel campo di valori 0 .. 255


USINT_TO_BYTE Funzione standard per la conversione del tipo Richiamo della funzione USINT_TO_DINT Funzione standard per la conversione del tipo Richiamo della funzione USINT_TO_DWORD Funzione standard per la conversione del tipo Richiamo della funzione



Parole chiave/Identificatori Descrizione Regole USINT_TO_INT Funzione standard per la conversione del tipo Richiamo della funzione USINT_TO_LREAL Funzione standard per la conversione del tipo Richiamo della funzione USINT_TO_REAL Funzione standard per la conversione del tipo Richiamo della funzione USINT_TO_SINT Funzione standard per la conversione del tipo Richiamo della funzione USINT_TO_UDINT Funzione standard per la conversione del tipo Richiamo della funzione USINT_TO_UINT Funzione standard per la conversione del tipo Richiamo della funzione USINT_TO_WORD Funzione standard per la conversione del tipo Richiamo della funzione USINT_VALUE_TO_BOOL Funzione standard per la conversione del tipo Richiamo della funzione VAR Identificatore iniziale di un blocco di

dichiarazione delle variabili locali o costanti Blocco di variabili statico, blocco di variabili temporaneo FC, blocco di costanti

VAR_GLOBAL Identificatore iniziale di un blocco di dichiarazione per le variabili Unit (variabili globali) o costanti Unit

Variabili Unit, costanti Unit

VAR_IN_OUT Identificatore iniziale di un blocco di dichiarazione

Blocco di parametri

VAR_INPUT Identificatore iniziale di un blocco di dichiarazione

Blocco di parametri

VAR_OUTPUT Identificatore iniziale di un blocco di dichiarazione

Blocco di parametri

VAR_TEMP Identificatore iniziale di un blocco di dichiarazione

Blocco di variabili temporaneo in FB/programma

VOID Nessun valore di ritorno per la funzione Funzione WAITFORCONDITION Identificatore iniziale dell'istruzione di controllo

per un task in attesa di un evento programmabile


WHILE Identificatore iniziale dell'istruzione di controllo per l'elaborazione dei loop

Istruzione WHILE

WITH Aggiunta all'istruzione di controllo WAITFORCONDITION


WORD Parola con tipo di dati elementare Tipo di dati bit WORD_TO_BOOL Funzione standard per la conversione del tipo Richiamo della funzione WORD_TO_BYTE Funzione standard per la conversione del tipo Richiamo della funzione WORD_TO_DINT Funzione standard per la conversione del tipo Richiamo della funzione WORD_TO_DWORD Funzione standard per la conversione del tipo Richiamo della funzione WORD_TO_INT Funzione standard per la conversione del tipo Richiamo della funzione WORD_TO_SINT Funzione standard per la conversione del tipo Richiamo della funzione WORD_TO_UDINT Funzione standard per la conversione del tipo Richiamo della funzione WORD_TO_UINT Funzione standard per la conversione del tipo Richiamo della funzione WORD_TO_USINT Funzione standard per la conversione del tipo Richiamo della funzione WORD_VALUE_TO_LREAL Funzione standard per la conversione del tipo Richiamo della funzione WORD_VALUE_TO_REAL Funzione standard per la conversione del tipo Richiamo della funzione XOR Operatore logico Operatore di base logico



A.1.3 Regole La seguenti regole di sintassi del linguaggio ST sono suddivise in regole con formato definito di scrittura (regole lessicali) e senza formato definito di scrittura (regole sintattiche). Per informazioni sulle differenze tra regole sintattiche e lessicali, vedere Strumenti per la descrizione del linguaggio.

A.1.3.1 Definizioni

Figura A-3 Identificatore

Figura A-4 Numero



A.1.3.2 Scrittura delle costanti (letterale)

Letterale

Figura A-5 Letterale

Figura A-6 Numero intero



Figura A-7 Numero a virgola mobile

Figura A-8 Esponente

Figura A-9 Letterale di ora



Figura A-10 Stringa di caratteri



Figura A-11 Carattere



Sequenze delle cifre

Figura A-12 Sequenza di cifre decimali

Figura A-13 Sequenza di cifre binarie

Figura A-14 Sequenza di cifre a base otto

Figura A-15 Sequenza di cifre esadecimali



Data e ora

Figura A-16 Data

Figura A-17 Durata

Figura A-18 Ora del giorno



Figura A-19 Data e ora

Figura A-20 Indicazione della data

Figura A-21 Indicazione dell'ora del giorno



Figura A-22 Rappresentazione a livelli

Figura A-23 Rappresentazione decimale



A.1.3.3 Commenti Prestare attenzione all'inserimento dei commenti:

● L'annidamento di commenti a righe non è consentito.

● L'annidamento di commenti a blocchi non è ammesso, mentre è ammesso l'annidamento di commenti a righe nei commenti a blocchi.

● I commenti si possono inserire in qualsiasi punto nelle regole (sintattiche) senza formato.

● Nelle regole con formato definito (lessicali) non sono ammessi commenti.

Figura A-24 commento.

Figura A-25 Commento a righe

Figura A-26 Commento a blocchi



A.1.3.4 Sezioni della sorgente ST

Sezioni della sorgente ST

A.1.3.5 Struttura delle sorgenti ST

Figura A-27 Sorgente ST



Figura A-28 Definizione Unit

Figura A-29 Sezione interfaccia

Figura A-30 Sezione implementazione



Figura A-31 Prototipi POE

A.1.3.6 Unità organizzative di programma (POE)

Figura A-32 Expression

Figura A-33 Funzione FC



Figura A-34 Blocco funzionale FB

Figura A-35 Programma



A.1.3.7 Componenti di dichiarazione

Figura A-36 Sezione dichiarazione dell'espressione

Figura A-37 Sezione di dichiarazione FC



Figura A-38 Sezione di dichiarazione FB

Figura A-39 Sezione di dichiarazione programma



A.1.3.8 Costruzione dei blocchi di dichiarazione

Blocchi di constanti

Figura A-40 Blocco di costanti

Figura A-41 Costanti Unit / blocco di costanti globale

Blocchi di variabili

Figura A-42 Variabili Unit / blocco di variabili globale



Figura A-43 blocco delle variabili ritentivo

Figura A-44 Funzione del blocco di variabili temporaneo

Figura A-45 Blocco di variabili temporaneo in FB/programma

Figura A-46 Blocco di variabili statico



Blocchi di parametri

Figura A-47 Blocco parametri FB

Figura A-48 Blocco parametri FC



Figura A-49 Dichiarazione di un ARRAY con lunghezza dinamica

Etichette di salto

Figura A-50 Dichiarazione etichetta di salto

Dichiarazioni

Figura A-51 Dichiarazione costante



Figura A-52 Dichiarazione delle variabili

Figura A-53 Accesso simbolico all'immagine di processo

Figura A-54 Dichiarazione di istanza



Figura A-55 Specifica FB-ARRAY

Inizializzazione

Figura A-56 Inizializzazione



Figura A-57 Espressione di costante

Figura A-58 Elenco di inizializzazione del campo



Figura A-59 Elenco di inizializzazione della struttura

A.1.3.9 Tipi di dati

Figura A-60 Tipo di dati

Tipi di dati elementari

Figura A-61 Tipo di dati elementare



Figura A-62 Tipo di dati bit

Figura A-63 Tipo di dati numerico

Figura A-64 Tipo di dati numero intero



Figura A-65 Tipo di dati numeri a virgola mobile

Figura A-66 Tipo di dati temporali

Figura A-67 Tipo di dati String



Tipi di dati definiti dall'utente

Figura A-68 Tipo di dati definito dall'utente

Figura A-69 Specifica del tipo di dati ARRAY



Figura A-70 Specifica del tipo di dati STRUCT

Figura A-71 Dichiarazione dei componenti

Figura A-72 specifica del tipo di dati di enumerazione

A.1.3.10 Sezione istruzioni

Figura A-73 Sezione istruzioni



Figura A-74 Istruzione

A.1.3.11 Assegnazioni del valore e operazioni

Assegnazione del valore ed espressione

Figura A-75 Assegnazione valore



Figura A-76 Espressione



Operandi

Figura A-77 Operando

Figura A-78 Variabile strutturata



Figura A-79 Accesso assoluto all'immagine di processo

Figura A-80 Costante

Figura A-81 Valore di enumerazione



Figura A-82 Variabile esterna

Figura A-83 Accesso al parametro di uscita FB

Figura A-84 Accesso al parametro di ingresso FB



Figura A-85 Accesso bit

Operatori

Figura A-86 Operatore di base logico

Figura A-87 operatore aritmetico



Figura A-88 Operatore aritmetico di base

Figura A-89 Operatori di confronto

A.1.3.12 Richiamo di funzioni e di blocchi funzionali

Figura A-90 Richiamo FB



Figura A-91 Richiamo FC

Figura A-92 Parametro FB

Figura A-93 Parametro FC



Figura A-94 Assegnazione di ingresso

Figura A-95 Assegnazione di passaggio

Figura A-96 Assegnazione di uscita



A.1.3.13 Istruzioni di controllo

Diramazioni

Figura A-97 Istruzione IF

Figura A-98 Istruzione CASE



Figura A-99 Elenco dei valori

Istruzioni di ripetizione e di salto

Figura A-100 Istruzione di ripetizione e di salto



Figura A-101 Istruzione FOR

Figura A-102 Istruzione WHILE

Figura A-103 Istruzione REPEAT



Figura A-104 Istruzione EXIT

Figura A-105 Istruzione RETURN

Figura A-106 Istruzione WAITFORCONDITION



Figura A-107 Istruzione GOTO

Appendice A.2 Messaggi di errore del compilatore e informazioni per la loro rimozione


A.2 Messaggi di errore del compilatore e informazioni per la loro rimozione

Questo capitolo fornisce informazioni generali sui messaggi di errore del compilatore e sulla relativa eliminazione.

A.2.1 Errori di accesso al file (1000 - 1100)

Tabella A- 9 Errori di accesso al file (1000 - 1100)

Errore Descrizione 1000 Si è verificato un errore di lettura o scrittura durante l'accesso al file. 1001 Il caricamento dei file con i messaggi di errore in chiaro non è riuscito; impossibile l'emissione

testuale i messaggi di errore. Richiamare la guida online tramite il numero di errore! 1002 Impossibile archiviare il codice generato. Chiudere alcune finestre ed eseguire una nuova

compilazione. 1003 Si è verificato un errore di lettura o scrittura durante l'apertura del file specificato. Chiudere

l'applicazione e riprovare. 1100 L'opzione per l'indicazione di una definizione del preprocessore contiene un identificatore non

valido come token definito. La sintassi corretta dell'opzione di richiamo è: -D identifier[=[testo]] Esempi: • -D myident // Definizione di myident; può essere richiesta mediante #ifdef. • -D myident= // myident viene definito come sequenza di caratteri vuota • -D "myident=Questo è un testo" // myident viene definita come sequenza di caratteri 'Questo

è un testo'. Le virgolette devono essere utilizzate soltanto se il testo sostitutivo contiene degli spazi.

A.2.2 Errori dello scanner (2001, 2002)

Tabella A- 10 Errori dello scanner (2001, 2002)

Errore Descrizione 2001 Il carattere specificato non è ammesso. 2002 L'identificatore indicato contiene caratteri o combinazioni di caratteri non ammessi/e. Secondo

IEC61131 il primo carattere di un identificatore deve essere una lettera o un carattere di sottolineatura. Questo carattere può essere seguito da un numero qualunque di caratteri, cifre o caratteri di sottolineatura; i caratteri di sottolineatura tuttavia non devono trovarsi uno accanto all'altro.



A.2.3 Errori di dichiarazione nella POE (3002 - 3027)

Tabella A- 11 Errori di dichiarazione nella POE (3002 - 3027)

Errore Descrizione 3002 Per l'identificazione della sezione codice dell'unità di caricamento è richiesta la parola chiave

"IMPLEMENTATION". 3003 Il blocco di dichiarazione indicato non è ammesso in questo contesto. 3004 I blocchi di dichiarazione delle variabili VAR, VAR_INPUT, VAR_OUTPUT, VAR_IN_OUT,

VAR CONSTANT sono ammessi solo una volta per rispettiva POE. 3005 Istruzione TASK: per il task indicato, il collegamento al task è già stato effettuato nella sorgente.

Non è possibile un ulteriore collegamento al task. 3006 Le dimensioni dello stack indicate nel task sono errate. Sono ammessi solo valori in numeri interi

positivi. 3007 L'identificatore specificato deve essere un identificatore di task; vedere Configurazione del task. 3008 L'identificatore specificato deve essere un identificatore di programma. La dichiarazione avviene

mediante l'istruzione PROGRAM xx ... END_PROGRAM. 3009 Alla parola chiave EXPRESSION deve seguire un identificatore. La dichiarazione avviene

mediante l'istruzione EXPRESSION xx ... END_EXPRESSION. 3010 L'identificatore specificato non è l'identificatore di una EXPRESSION. Verificare se la

dichiarazione è avvenuta mediante l'istruzione EXPRESSION xx ... END_EXPRESSION. 3011 L'istruzione TASK non è ammessa nella Unit. Utilizzare la configurazione task di Workbench. 3012 L'identificatore specificato è già stato dichiarato in un'altro punto. Non è possibile utilizzarlo

nuovamente come identificatore di una funzione. 3013 L'identificatore specificato è già stato dichiarato in un'altro punto. Non è possibile utilizzarlo

nuovamente come identificatore di un blocco funzionale. 3014 In attesa dell'istruzione UNIT. Sono ammesse le seguenti forme:

• UNIT myunit; • UNIT myunit : dvtype; L'istruzione UNIT è necessaria solo in caso di compilazione su file ASCII. In caso di richiamo del compilatore dalla workbench, l'istruzione è facoltativa.

3015 La sorgente non termina con END_IMPLEMENTATION. Rispettare la struttura della sorgente! 3016 Dopo la parola chiave END_IMPLEMENTATION non è possibile specificare altre istruzioni. 3017 La dichiarazione del task non termina con END_TASK. Rispettare la struttura della sorgente! 3018 La dichiarazione POE non si conclude con END_FUNCTION, END_FUNCTION_BLOCK o

END_PROGRAM. Rispettare la struttura della sorgente! 3019 L'unità POE deve iniziare con le parole chiave FUNCTION, FUNCTION_BLOCK o PROGRAM. 3020 E' richiesta l'istruzione per il collegamento del task. Struttura: TASK tname ... END_TASK; 3022 È richiesta la parola chiave INTERFACE. Vedere la struttura di una sorgente. 3023 È richiesta la parola chiave INTERFACE o IMPLEMENTATION. Vedere la struttura di una

sorgente. 3024 Errore di sintassi nell'istruzione TASK. Struttura corretta: TASK tname ... END_TASK; 3025 L'identificatore specificato è già stato dichiarato in un'altro punto. Non è possibile utilizzarlo

nuovamente come identificatore di un programma.



Errore Descrizione 3026 L'istruzione WAITFORCONDITION non può essere utilizzata in modo ricorsivo. Si è cercato di

utilizzare WAITFORCONDITION una seconda volta all'interno di un'istruzione WAITFORCONDITION. Ciò non è possibile.

3027 Si è tentato di inserire all'interno di un blocco EXPRESSION ... END_EXPRESSION un'istruzione WAITFORCONDITION. Ciò non è possibile. L'istruzione WAITFORCONDITION non può essere utilizzata all'interno di un'espressione.

A.2.4 Errori di dichiarazione nelle dichiarazioni del tipo di dati (4001 - 4051)

Tabella A- 12 Errori di dichiarazione nelle dichiarazioni del tipo di dati (4001 - 4051)

Errore Descrizione 4001 L'identificatore indicato è un identificatore della funzione standard che non può essere

sovrascritto. Scegliere un altro identificatore. 4002 L'identificatore specificato è già stato utilizzato. Il suo uso come identificatore del tipo non è

possibile. Scegliere un altro identificatore. 4003 L'identificatore specificato è già stato utilizzato. Il suo uso come identificatore della costante non

è possibile. Scegliere un altro identificatore. 4004 Il valore di inizializzazione specificato ha un formato non valido. Scegliere il valore di

inizializzazione in base alla dichiarazione del tipo di dati. 4005 Errore di sintassi nella dichiarazione del tipo. 4006 Errore di sintassi durante l'indicazione di un elemento strutturale nella dichiarazione della

struttura. 4007 Errore di sintassi durante la dichiarazione di un tipo di dati ARRAY. 4008 Errore di sintassi durante l'indicazione di un elenco degli identificatori. Gli indicatori devono

essere separati da una virgola. 4009 L'identificatore della costante indicato è stato occupato da diversi valori. Questo errore si verifica

durante la dichiarazione dei tipi di dati di enumerazione. Elementi di enumerazione uguali in tipi di dati di enumerazione differenti nella dichiarazione del tipo devono trovarsi nella stessa posizione.

4010 L'identificatore specificato del tipo non viene esportato dalla sorgente, sebbene l'unità POE in cui è utilizzato sia esportata. Utilizzare un altro tipo di dati oppure dichiarare il tipo di dati nella sezione implementazione.

4011 Una dichiarazione di costante richiede obbligatoriamente l'indicazione di un valore di inizializzazione. Esempio: x : DINT := 5;

4012 Il tipo di dati specificato deve essere dichiarato al di fuori della POE. Con VAR_INPUT, VAR_OUTPUT, VAR_IN_OUT gli identificatori del tipo non vanno dichiarati localmente nella POE poiché gli stessi, allo scopo della trasmissione dei parametri, devono essere noti anche esternamente.

4013 Il valore indicato viene utilizzato più volte nel tipo di dati di enumerazione. Tuttavia, nel tipo di dati di enumerazione i valori devono essere reciprocamente diversi.

4020 L'identificatore specificato è già stato utilizzato come identificatore del tipo di dati. La definizione non si differenzia tuttavia da quella attuale. Questo non è consentito. Selezionare un altro identificatore oppure adeguare le definizioni dei tipi. Se compare questo messaggio quando si caricano biblioteche o pacchetti tecnologici, è possibile utilizzare anche spazi dei nomi (ad es. USELIB mylib AS Namespace_1).



Errore Descrizione 4050 La dichiarazione del tipo di dati o della variabile genera un tipo di dati che eccede le dimensioni

massime specificate. 4051 La dichiarazione della variabile richiede un'area di memoria maggiore o uguale alla dimensione

dell'area massima consentita indicata.

A.2.5 Errori di dichiarazione nelle dichiarazioni delle variabili (5001 - 5509)

Tabella A- 13 Errori di dichiarazione nelle dichiarazioni delle variabili (5001 - 5509)

Errore Descrizione 5001 Il valore di costante specificato provoca il superamento dell'intervallo di valori e non può essere

convertito nel tipo richiesto. 5002 L'identificatore specificato è già stato utilizzato. Il suo uso come identificatore della variabile non è

possibile. Scegliere un altro identificatore. 5003 Errore di sintassi nella dichiarazione della variabile. 5004 È richiesta l'indicazione di un tipo di dati (tipo di dati semplice o derivato). 5005 Il valore della costante specificato è di tipo di dati errato o provoca un superamento dell'intervallo

di valori. 5006 Durante l'inizializzazione di un array va verificato il numero di valori di inizializzazione. 5007 Errore di sintassi nell'indicazione dei letterali di ora e data. 5008 Non è possibile creare l'istanza di un blocco funzionale nella posizione indicata. Ad esempio, non

è possibile generare istanze FB nelle funzioni. Anche i parametri di uscita (VAR_OUTPUT) dei blocchi funzionali non possono essere istanze FB.

5009 Il tipo di dati indicato nella dichiarazione non è utilizzabile sulla variabile con indirizzo assoluto. È necessario utilizzare un tipo di dati a numero intero o a bit con un'ampiezza di bit adatta.

5010 Si è cercato di assegnare un indirizzo di salvataggio a una variabile. Ciò non è possibile nel punto indicato. Utilizzare questa assegnazione solo all'interno della dichiarazione VAR_GLOBAL della Unit o all'interno della dichiarazione VAR di un PROGRAM.

5012 La preassegnazione delle variabili indicate con un valore di inizializzazione non è consentita. 5014 L'inizializzazione di una struttura dati non è corretta. Il valore di inizializzazione di un componente

è stato inserito più volte. 5016 Non è possibile inizializzare le variabili e i tipi di dati con gli oggetti tecnologici definiti nel

progetto. Gli oggetti tecnologici sono anch'essi delle variabili e non possono pertanto essere utilizzati per l'inizializzazione.

5100 La preassegnazione delle variabili indicate con un valore di inizializzazione non è consentita. 5110 L'inserimento di un carattere speciale mediante $... rende possibili le seguenti impostazioni: $$,

$', $L, $N, $P, $R, $T. Inoltre, il valore numerico di un carattere può essere inserito utilizzando $xx, dove xx rappresenta il valore esadecimale a due cifre del codice.

5111 L'inserimento del carattere speciale può avvenire solo con $... . Ciò riguarda i seguenti codici: $L, $N, $P, $R, $T

5112 Costanti di stringhe di caratteri di più righe non sono ammesse. Per inserire un'interruzione di riga nell'output utilizzare i caratteri speciali corrispondenti presenti nella stringa di caratteri, ad es. $N, $R$L.

5200 La definizione dei tipi di dati contiene una ricorsione in modo diretto o indiretto. Questo non è consentito. Rimuovere l'uso di questo tipo di dati nel punto corrispondente.



Errore Descrizione 5201 Il richiamo della funzione genera una ricorsione in modo diretto o indiretto. Questo non è

consentito. Rimuovere il richiamo della funzione nel punto corrispondente. 5500 L'identificatore delle etichette di salto indicato è già stato definito. Utilizzare un altro nome. 5501 L'identificatore delle etichette di salto indicato non è stato definito. Applicare questo identificatore

nella dichiarazione LABEL. 5502 L'identificatore dell'etichetta di salto è stato assegnato più volte. È tuttavia possibile assegnare

solo una volta un'etichetta come etichetta di salto. 5503 L'etichetta di salto è specificata come destinazione del salto, ma manca l'etichetta associata. 5504 Impossibile passare a strutture di controllo subordinate (ad es., i loop WHILE). L'etichetta di salto

specificata non può essere utilizzata in questo punto. 5505 Impossibile passare a strutture di controllo subordinate (ad es., i loop WHILE). La destinazione

del salto indicata non può essere raggiunta. 5506 Impossibile passare ai blocchi WAITFORCONDITION. L'etichetta di salto specificata non può

essere utilizzata in questo punto. 5507 Impossibile passare ai blocchi WAITFORCONDITION. La destinazione del salto indicata non può

essere raggiunta. 5509 All'interno di un'istruzione CASE non è ammessa l'indicazione di etichette di salto. La sintassi non

consente di distinguere un'etichetta di salto dall'elenco dei valori di un'istruzione CASE.

A.2.6 Errori di espressione (6001 - 6201)

Tabella A- 14 Errori di espressione (6001 - 6201)

Errore Descrizione 6001 Errore di sintassi: È richiesta un'istruzione che termina con un punto e virgola,

ad es. a := b*c; 6002 Errore di sintassi: È richiesta un'espressione, ad es. x < y. 6003 L'identificatore indicato non è un identificatore di variabile. È necessario indicare un identificatore

di variabile. Controllare se l'identificatore indicato è nascosto. Fino alla versione V4.0 compresa, l'accesso agli identificatori globali dell'apparecchio all'interno di un programma o di un blocco funzionale con lo stesso nome era possibile nonostante l'avviso 16021.

6004 Negli accessi ai campi l'indice deve essere del tipo di dati DINT. Eseguire una conversione del tipo corrispondente o utilizzare un'altra espressione.

6005 Nell'espressione è presente un conflitto di tipo. Non è possibile convertire uno degli operandi nel tipo di dati del calcolo, oppure l'assegnazione del risultato produce un conflitto di tipo.

6006 Non è possibile accedere alla variabile indicata. Non è quindi possibile utilizzarla nell'espressione. Le cause possibili sono: • la variabile non è leggibile. • si è cercato di accedere a una variabile locale di una funzione o di un blocco funzionale

dall'esterno.

6007 Impossibile scrivere la variabile indicata. Non è possibile un'assegnazione del valore. 6008 La funzione indicata non restituisce alcun valore di ritorno. L'uso nell'espressione non è quindi

consentito (funzione dichiarata con valore di ritorno VOID).



Errore Descrizione 6009 L'identificatore indicato non rimanda ad alcuna funzione o istanza di blocco funzionale. Non è

perciò possibile utilizzarlo come identificatore di funzione. 6010 L'identificatore indicato non è contenuto nella dichiarazione della POE (funzione o blocco

funzionale) come parametro di ingresso (VAR_INPUT) o parametro di passaggio (VAR_IN_OUT). Non è quindi possibile utilizzarlo per il richiamo della POE.

6011 Il numero degli argomenti di funzione nel richiamo è diverso dalla dichiarazione, oppure il richiamo non contiene i parametri di richiamo da indicare necessari.

6012 RETURN non è ammesso in questa posizione per motivi di sintassi. È possibile utilizzare RETURN solo nelle funzioni.

6013 EXIT non è ammesso in questa posizione per motivi di sintassi. EXIT può essere utilizzato solo all'interno di FOR, WHILE, REPEAT.

6014 Il valore di indice specificato supera i limiti di array. Sono ammessi solo valori indice conformi alla dichiarazione dell'array.

6015 Il comando di attivazione del task indicato non può essere utilizzato per il task. Non è ammesso per il tipo di task.

6016 Il task specificato è disattivato nel sistema esecutivo. Per poterlo utilizzare è necessario attivarlo. 6017 Errore di sintassi durante l'indicazione dei programmi compresi in un task. I programmi devono

essere enumerati per nome, separati da una virgola. 6018 L'identificatore specificato non rimanda a un PROGRAM. Non è perciò possibile utilizzarlo come

identificatore del programma. 6019 Un programma à stato associato più volte a un task. È possibile solo un'associazione singola. 6020 Errore di sintassi nella definizione di variabili direttamente rappresentate. Gli input devono avere

la sintassi %Ix.y, gli output la sintassi %Qx.y. 6021 L'offset di byte indicato delle variabili direttamente rappresentate non rientra nello spazio di

memoria ammesso. 6022 L'offset di bit indicato delle variabili direttamente rappresentate non rientra nello spazio di

memoria ammesso. I valori ammessi sono compresi tra 0 e 7. 6023 Il valore di ritorno della funzione non è stato assegnato. L'assegnazione è tuttavia

obbligatoriamente richiesta. 6024 Le informazioni di avvio del task non contengono una variabile con l'identificatore specificato. 6025 La variabile di condizione e i valori di condizione di un'istruzione CASE devono essere del tipo di

dati SINT, INT, DINT, USINT, UINT o UDINT. Deve essere possibile la conversione implicita dei valori di condizione nel tipo di dati delle variabili di condizione.

6026 L'identificatore dei messaggi non è contenuto nella progettazione dei messaggi. Aprire la progettazione dei messaggi e aggiungere l'identificatore.

6027 L'accesso alla variabile di sistema è possibile solo direttamente tramite un riferimento TO. L'accesso non può avvenire mediante una struttura o un campo. Creare una variabile locale del tipo TO e legare a questa variabile il riferimento TO. È quindi possibile accedere tramite questa variabile TO locale alla variabile di sistema desiderata.

6028 L'espressione presenta un conflitto di tipo nell'operazione indicata. Non è possibile convertire uno degli operandi nel tipo di dati del calcolo, oppure l'assegnazione del risultato produce un conflitto di tipo. Nell'espressione è richiesto il tipo di dati specificato.

6029 Il parametro di funzione indicato non ha un valore predefinito e va perciò obbligatoriamente specificato durante la chiamata.

6030 Si è cercato di assegnare un'espressione a un parametro di passaggio (VAR_IN_OUT). Ciò non è possibile. Come parametri di passaggio devono essere indicate delle variabili utente.



Errore Descrizione 6031 Si è tentato di trasferire una variabile di sistema (TO, accesso diretto I/O) a un parametro di

passaggio (VAR_IN_OUT). Ciò non è possibile. Come parametri di passaggio devono essere indicate delle variabili utente.

6032 Si è cercato di assegnare una variabile dell'immagine di processo a un parametro di passaggio (VAR_IN_OUT). Ciò non è possibile. Come parametri di passaggio devono essere indicate delle variabili utente.

6033 Si è cercato di assegnare a un parametro di passaggio (VAR_IN_OUT) una variabile che non corrisponde al tipo di dati. Non è tuttavia possibile un'ulteriore conversione di tipo. Come parametri di passaggio è necessario indicare delle variabili utente con il tipo di dati corretto.

6034 Si è cercato di assegnare a un parametro di passaggio (VAR_IN_OUT) una variabile non scrivibile. Questa operazione non è consentita; i parametri di passaggio devono essere scrivibili.

6035 Si è cercato di assegnare una costante a un parametro di passaggio (VAR_IN_OUT). Questa operazione non è consentita; i parametri di passaggio devono essere variabili utente.

6036 Un'operazione è stata applicata a una costante. Il valore della costante eccede l'intervallo di definizione della funzione. Alcuni esempi: • Uso di SQRT su un numero negativo. • Uso delle funzioni logaritmiche su un numero <= 0. • uso di ASIN o ACOS su un numero al di fuori dell'intervallo [0..1].

6037 Si è tentato di eseguire una divisione per zero con una costante. Questa operazione non è ammessa.

6038 Il parametro di funzione indicato è contenuto più volte nell'elenco argomenti. 6039 La POE indicata (funzione o blocco funzionale) non può essere utilizzata. Cause possibili:

• Nella sezione implementazione manca la definizione della POE. Nella sezione interfaccia è stato specificato solo il prototipo.

• La POE viene definita completamente solo dopo il suo utilizzo (ad es. richiamo, dichiarazione di istanza). Spostare all'occorrenza questa POE davanti alla POE in cui viene utilizzata nella sorgente di programma.

• Un'istanza di un blocco funzionale non può essere dichiarata come variabile Unit nella stessa sorgente di programma in cui è definito questo blocco funzionale.

6040 Come semafori possono essere impiegate solo le variabile semplici; non è possibile una indicizzazione.

6041 La funzione di segnalazione richiede un valore di accompagnamento del tipo di dati indicato. Non è possibile una conversione di tipo.

6042 La funzione di segnalazione richiede l'indicazione di un numero di messaggio. Il numero di messaggio indicato non è valido.

6050 L'espressione presenta un conflitto di tipo nell'operazione / nelle variabili indicate. Non è possibile convertire uno degli operandi nel tipo del calcolo, oppure l'assegnazione del risultato produce un conflitto di tipo. Non è possibile la conversione tra il tipo di sorgente e il tipo di destinazione.

6051 Nell'espressione è presente un conflitto di tipo per l'operazione indicata. Non è possibile convertire uno degli operandi nel tipo di dati dell'altro operando a scopo di calcolo, oppure i tipi di dati degli operandi non sono ammessi per l'operazione.

6052 Nell'espressione è presente un conflitto di tipo. Non è possibile utilizzare nell'operazione il tipo di dati indicato (vedere le funzioni marshalling).

6053 Nell'espressione è presente un conflitto di tipo per l'operazione indicata. Questa operazione non è ammessa sul tipo di dati indicato.



Errore Descrizione 6054 Nell'espressione è presente un conflitto di tipo. La variabile indicata non può essere utilizzata

come variabile di campo indicizzata. 6060 Nella chiamata di funzione sono presenti allocazioni di argomenti di funzione e parametri di

impostazione. Utilizzare una forma della chiamata di funzione. Esempio: • f(x, y); oppure • f (in1 := x, in2 := y);

6061 Il parametro indicato della funzione o del blocco funzionale è un parametro di passaggio. Al richiamo della POE è perciò necessario assegnare obbligatoriamente una variabile al parametro.

6062 L'identificatore indicato non può essere utilizzato come argomento di funzione. Come argomento di funzione sono ammesse solo le variabili dei blocchi di dichiarazione VAR_INPUT e VAR_IN_OUT.

6063 L'identificatore indicato non può essere utilizzato come argomento di funzione. Come argomento di funzione sono ammesse solo le variabili dei blocchi di dichiarazione VAR_INPUT e VAR_IN_OUT.

6070 L'accesso ai dati di configurazione è consentito solo per le variabili indicate completamente. Aggiungere il nome corrispondente ai dati di configurazione dell'oggetto tecnologico selezionato.

6071 L'accesso ai dati di configurazione è consentito solo per le variabili indicate completamente. Non è possibile impiegare indici Array eliminabili solo nel runtime.

6080 La variabile specificata non è una variabile di ingresso o uscita direttamente accessibile. Tale variabile deve essere dichiarata nel contenitore I/O del relativo apparecchio con la sintassi PI* o PQ*.

6100 Il costrutto specificato può essere compilato solo con un tipo di apparecchio impostato. Aggiungere l'istruzione UNIT al tipo di apparecchio o impostare il tipo di apparecchio nel contenitore di programma.

6110 Il costrutto specificato non può essere utilizzato nelle librerie. 6111 Il costrutto specificato non può essere utilizzato nelle librerie. 6112 Il costrutto specificato non può essere utilizzato nelle librerie. 6113 L'accesso agli oggetti tecnologici e agli apparecchi non è consentito nelle librerie. 6114 È stato impiegato un blocco funzionale da un'altra sorgente della stessa libreria. All'interno di una

libreria ciò è possibile solo se la sorgente dichiarante viene compilata con l'impostazione del compilatore "Consenti dichiarazioni anticipative".

6130 L'indicazione di un intervallo non è ammesso nell'istruzione CASE per il tipo di dati indicato. 6140 L'indicazione di una costante in ENUM_TO_DINT richiede l'indicazione del tipo di dati nella forma

enum_type#wert. 6150 Con il tipo di dati fornito l'offset di bit indicato è al di fuori dell'intervallo valido. 6160 Il tipo di dati di Array definito senza indicazione della lunghezza è consentito solo per la

dichiarazione di parametri VAR_IN_OUT in funzioni e blocchi funzionali. 6200 Solo nell'opzione del compilatore "Consenti estensioni lingua" (-C lang_ext):

Il PROGRAM richiamato contiene dati di istanza (blocco di dichiarazione VAR … END_VAR) salvati nella memoria utente del task assegnato. Di conseguenza non è possibile richiamare PROGRAM da un'altra POE. Compilare la sorgente con l'opzione del compilatore "Crea dati di istanza del programma solo una volta" (-C prog_once), oppure eliminare i dati di istanza.

6201 Solo nell'opzione del compilatore "Consenti estensioni lingua" (-C lang_ext): Le funzioni non supportano il richiamo di un PROGRAM. Tali richiami possono essere eseguiti solo nei blocchi funzionali o in altri PROGRAM.



A.2.7 Errori di sintassi, errori di espressione (7000 - 7014)

Tabella A- 15 Errori di sintassi, errori di espressione (7000 - 7014)

Errore Descrizione 7000 Si è verificato un errore di sintassi. Le cause possibili sono:

• strutture di controllo non correttamente concluse (ad es. END_IF mancante) • istruzioni non concluse con ; • parentesi mancanti

7001 L'identificatore indicato non designa alcuna costante. Specificare una costante attraverso un valore o un'identificatore.

7002 È richiesto un numero intero con segno. Può essere del tipo di dati SINT, INT o DINT. 7003 Nell'indicazione dell'intervallo, il valore iniziale deve essere minore o uguale al valore finale.

Questa regola vale per la dichiarazione degli array e per l'indicazione dell'intervallo nelle condizioni di selezione CASE.

7004 È richiesto un valore di inizializzazione. Questo deve essere una costante. Le costanti possono essere impostate: • direttamente tramite il valore, • simbolicamente mediante una precedente dichiarazione della costante • come espressione contenente solo costanti.

7005 L'inizializzazione di tipi di dati identici in sorgenti differenti richiede anche un valore di inizializzazione identico. Adeguare i valori di inizializzazione.

7009 Come condizione per WHILE REPEAT, IF è richiesta un'espressione che fornisce il tipo di dati BOOL. Ciò può essere ottenuto anche specificando una variabile del tipo di dati BOOL o mediante un'espressione di confronto. È inoltre consentito indicare una funzione con valore di ritorno del tipo di dati BOOL.

7010 Si è verificato un errore di sintassi. Le cause possibili sono: • strutture di controllo non correttamente concluse (ad es., END_IF mancante) • istruzioni non concluse con ; • parentesi mancanti

7011 Si è verificato un errore di sintassi. Le cause possibili sono: • strutture di controllo non correttamente concluse (ad es., END_IF mancante) • istruzioni non concluse con ; • parentesi mancanti

7012 Si è verificato un errore di sintassi nell'istruzione che inizia nella riga indicata. Le cause possibili sono: • strutture di controllo non correttamente concluse (ad es., END_IF mancante) • istruzioni non concluse con ; • parentesi mancanti



Errore Descrizione 7013 Si è verificato un errore di sintassi. Viene utilizzato un costrutto non ammesso. 7014 Si è verificato un errore di sintassi. Le cause possibili sono:

• strutture di controllo non correttamente concluse (ad es., END_IF mancante) • istruzioni non concluse con ; • parentesi mancanti

A.2.8 Errore nel collegamento di una sorgente (8001, 8100)

Tabella A- 16 Errore nel collegamento di una sorgente (8001, 8100)

Errore Descrizione 8001 La POE specificata è stata esportata nella sezione INTERFACE, ma manca un'implementazione

nella sezione IMPLEMENTATION. Eliminare l'istruzione di esportazione o indicare un'implementazione valida.

8100 La dimensione massima del campo dati raggiungibile mediante HMI è 65536 byte. Nel caso delle variabili specificate questo limite viene superato. Anche tutte le variabili successive risultano non raggiungibili.

A.2.9 Errore nel caricamento dell'interfaccia di un'altra UNIT o di un pacchetto tecnologico (10000 - 10101)

Tabella A- 17 Errore nel caricamento dell'interfaccia di un'altra UNIT o di un pacchetto tecnologico (10000 – 10101)

Errore Descrizione 10000 La Unit indicata ha un formato file non valido. Probabilmente è stata creata con una versione

precedente del compilatore o con opzioni incompatibili. Se si tratta di una Unit, è opportuno prima compilarla e poi ripetere la compilazione corrente. Se si tratta di un pacchetto, si consiglia di installare una versione più recente.

10001 Il nome della Unit ha un formato non valido. Per il nome della Unit valgono le regole dell'identificatore in ST, e in particolare per la lunghezza: • fino alla versione V4.0 del kernel SIMOTION: 8 caratteri. • A partire dalla versione V4.1 del kernel SIMOTION: 128 caratteri.

10002 Errore durante il caricamento dell'interfaccia di un'altra Unit, libreria o pacchetto tecnologico. L'identificatore indicato è presente in due diverse Unit, librerie o pacchetti tecnologici importati. • Rimuovere una Unit, una libreria o un pacchetto tecnologico dall'elenco delle importazioni,

oppure • Rendere univoci gli identificatori delle Unit, delle librerie e dei pacchetti tecnologici importati.

Elaborare le Unit da esportare nella sezione interfaccia o indicare un namespace per una libreria o un pacchetto tecnologico (USELIB … AS namespace; USEPACKAGE … AS namespace; ).



Errore Descrizione 10003 Il tipo di dati indicato ha un layout di memoria non valido. Probabilmente è stato creato con una

versione precedente del compilatore o con opzioni incompatibili. Se si tratta di una Unit, è opportuno prima compilarla e poi ripetere la compilazione corrente. È anche possibile eseguire il comando "Salva e compila tutto di nuovo". Se si tratta di un pacchetto, si consiglia di installare una versione più recente. Se in seguito l'errore continua a ripetersi, informare l'assistenza.

10004 Gli identificatori esportati della Unit indicata non possono essere caricati. Chiudere alcune applicazioni e riprovare.

10005 Si è verificata una ricorsione durante il caricamento dei pacchetti. Il pacchetto indicato è già stato caricato da USEPACKAGE e non può essere specificato una seconda volta.

10006 Si è verificata una ricorsione durante il caricamento delle Unit. La Unit indicata è già stata caricata da USES e non può essere specificata una seconda volta.

10007 È stato superato il numero massimo delle Unit importate referenziabili in una Unit. Per ogni unità di caricamento sono ammesse fino a 223 Unit importate. Questo numero comprende sia le Unit direttamente importate da USES, sia quelle indirettamente importate da tali Unit.

10008 È stato superato il numero di pacchetti importati referenziabili in una Unit. Per ogni Unit di caricamento sono ammessi fino a 127 pacchetti importati.

10009 Il pacchetto indicato viene utilizzato nella Unit ma non è disponibile nell'apparecchio. Questo messaggio di errore compare se si esegue la compilazione con l'opzione Utilizzo implicito del pacchetto e se è stata programmata un'istruzione USEPACKAGE il cui contenuto si differenzia da quello dei pacchetti specificati sull'apparecchio.

10010 Il pacchetto specificato viene utilizzato in una Unit ma non ma non nella Unit b. Questo messaggio di errore si visualizza se si specificano pacchetti diversi per USEPACKAGE in Unit con riferimenti reciproci con USES. Correggere le istruzioni USEPACKAGE.

10011 La Unit specificata viene utilizzata da se stessa, direttamente o indirettamente, attraverso un'altra o più Unit. Correggere le istruzioni USES.

10012 La Unit specificata viene importata in più Unit, direttamente o indirettamente, in diversi stadi di compilazione. Compilare nuovamente tutte le Unit che referenziano la Unit specificata nell'istruzione USES.

10013 La Unit indicata non è stata ancora compilata oppure si è verificato un errore durante l'ultima compilazione. Affinché la compilazione avvenga correttamente, è necessario compilare prima di tutto questa Unit.

10014 Il tipo di oggetto tecnologico (TO) indicato non viene supportato dai pacchetti specificati finora durante la compilazione con USEPACKAGE. Utilizzare un pacchetto contenente il tipo TO.

10015 È stato superato il numero massimo degli oggetti tecnologici (TO) referenziabili in una Unit. È possibile referenziare al massimo 65535 TO.

10016 L'indicazione del tipo di apparecchio non è disponibile Se alla Unit da compilare non è stato assegnato alcun apparecchio, utilizzare l'istruzione UNIT xx: dvtype;

10017 L'indicazione del tipo di apparecchio non è univoca. Nella Unit, con l'istruzione UNIT xx : dvtype; viene preimpostato un altro tipo di apparecchio rispetto a quello rilevato attraverso l'assegnazione della Unit all'apparecchio.

10018 Impossibile trovare la Unit specificata. Verificare se il nome della Unit è disponibile nel contenitore PROGRAM di Workbench o se il file indicato è contenuto nella directory di lavoro corrente (solo riga di comando u7bt00ax).

10019 Impossibile trovare il pacchetto tecnologico specificato. Controllare i precedenti output di errore. 10020 Si è verificato un errore nel caricamento del pacchetto tecnologico. Controllare gli altri output di

errore.



Errore Descrizione 10021 Il pacchetto tecnologico è utilizzato nel sorgente indicato, ma non è selezionato sull'apparecchio.

Correggere l'istruzione USEPACKAGE o selezionare il pacchetto tecnologico sull'apparecchio. 10022 Il pacchetto tecnologico specificato viene utilizzato con versioni diverse. Correggere le

impostazioni per la selezione del pacchetto tecnologico sull'apparecchio ed eventualmente nella libreria. È possibile utilizzare solo una versione di pacchetto tecnologico per apparecchio.

10024 Il pacchetto tecnologico definito non contiene componenti utilizzabili nell'ambiente di programmazione. Pertanto non può neppure essere impiegato nell'istruzione USEPACKAGE.

10025 L'identificatore specificato non è l'identificatore di un pacchetto tecnologico valido o installato. Pertanto non può neppure essere impiegato nell'istruzione USEPACKAGE.

10030 L'indicazione del tipo di apparecchio non è univoca. Nella Unit, con l'istruzione UNIT xx : dvtype; viene preimpostato un altro tipo di apparecchio rispetto a quello rilevato attraverso l'assegnazione della Unit al contenitore delle librerie.

10031 La libreria specificata viene utilizzata da se stessa, direttamente o indirettamente, attraverso un'altra o più librerie. Correggere le istruzioni USELIB.

10032 Impossibile trovare la libreria specificata. Verificare il progetto. 10033 Si è verificata una ricorsione durante il caricamento della libreria. La libreria indicata è già stata

caricata da USELIB e non può essere specificata una seconda volta. 10034 La libreria specificata non è completamente compilata. Cause possibili:

• La libreria non è stata compilata • La libreria non è stata compilata per tutti i tipi di apparecchio specificati nel contenitore delle

librerie (ad es. per una compilazione di tutto il progetto. • Durante l'ultima compilazione si è verificato un errore. Compilare prima questa libreria singolarmente (Applica e compila).

10035 Impossibile trovare la libreria specificata. Verificare se il nome della libreria è disponibile nel progetto di Workbench o se il file indicato è contenuto nella directory di lavoro corrente (solo riga di comando u7bt00ax).

10036 Il pacchetto specificato viene utilizzato nel sorgente ma non è disponibile nella libreria. Di base, le librerie vengono compilate tenendo conto delle versioni di pacchetto specificate nel contenitore delle librerie. È stata programmata un'istruzione USEPACKAGE il cui contenuto diverge dai pacchetti specificati nella libreria. Selezionare la versione corretta del pacchetto o rimuovere l'istruzione USEPACKAGE dal sorgente.

10037 Nella libreria indicata non è selezionata la variante del codice per il tipo di apparecchio attuale. Pertanto questa libreria non può essere utilizzata. Attivare la variante del codice su questa libreria.

10038 Una libreria DCC può essere impiegata solo in DCC. L'implementazione di una libreria di questo tipo in altri linguaggi di programmazione non è consentito.

10100 Il tipo indicato di oggetto tecnologico è contenuto in più pacchetti referenziati dalla sorgente. Effettuare la scelta di un pacchetto tecnologico che corrisponda alle proprie esigenze.

10101 Il TO specificato non è compatibile con i tipi di oggetti tecnologici supportati dai pacchetti caricati. Eseguire un aggiornamento del pacchetto o adattare il tipo dell'oggetto tecnologico.



A.2.10 Limitazioni d'implementazione (15001 - 15700)

Tabella A- 18 Limitazioni d'implementazione (15001 - 15700)

Errore Descrizione 15001 Il costrutto indicato non viene supportato dalla versione corrente del compilatore. 15002 L'apparecchio correntemente selezionato non supporta la funzione indicata. Per utilizzare la

funzione è necessario selezionare un'altra versione dell'apparecchio. Eseguire allo scopo una sostituzione di CPU nel Catalogo hardware ed eventualmente un aggiornamento firmware.

15003 L'identificatore indicato è una parola chiave non supportata e, di conseguenza, non è utilizzabile in modo specifico dall'utente per garantire la compatibilità con le versioni successive del compilatore.

15004 L'identificatore specificato identifica una funzione standard non supportata e non è utilizzabile come identificatore specifico dell'utente al fine di garantire la compatibilità con versioni successive del compilatore.

15005 L'identificatore specificato identifica un blocco funzioni standard non supportato e non è utilizzabile come identificatore specifico dell'utente al fine di garantire la compatibilità con versioni successive del compilatore.

15006 Il costrutto specificato può essere utilizzato solo in sorgenti generati con MCC. Non è possibile utilizzarlo in ST.

15007 Nella sezione implementazione è stata utilizzata direttamente o indirettamente una sorgente/libreria/pacchetto senza indicazione di namespace. Nella sezione interfaccia vengono utilizzati namespace. Risolvere il conflitto indicando un namespace nella sezione interfaccia per la sorgente/libreria/pacchetto citata.

15070 Il costrutto specificato non è conforme allo standard del linguaggio, ma per ragioni di compatibilità è comunque supportato sulle vecchie piattaforme. Cambiare la posizione di utilizzo, impostando l'alternativa indicata.

15152 In una sezione nascosta mediante compilazione condizionata è stata trovata un'istruzione USES, USELIB o USEPACKAGE. Questo non è consentito. Le sezioni del file sorgente contenenti questi statement non possono essere compilate in modo condizionato.

15153 La definizione indicata non viene presa in considerazione in fase di generazione del codice. Non è possibile definire in modo diverso le parole chiave.

15154 L'applicazione di un commento alle righe e l'utilizzo di commenti di più righe non è consentito nella parte della definizione.

15200 L'indicazione di un offset di bit su una variabile della stringa di bit è possibile solo utilizzando l'opzione del compilatore "Consenti estensioni lingua" (-C lang_ext).

15700 Il costrutto indicato non viene supportato dalla versione di SIMOTION SCOUT nella quale deve avvenire la conversione.



A.2.11 Avvisi (16001 - 16700) L'emissione di avvisi e informazioni può essere controllata:

● Nelle Impostazioni globali del compilatore (Pagina 59).

● Nelle Impostazioni locali del compilatore (Pagina 61).

● In una sorgente ST indicando il seguente attributo (Pagina 304) all'interno di un pragma (Pagina 299): { _U7_PoeBld_CompilerOption := warning:n:on } oppure { _U7_PoeBld_CompilerOption := warning:n:off }, dove n sta per la classe di avviso o il numero di avviso/informazione.

È inoltre possibile ridefinire singoli avvisi e informazioni quali errori:

● In una sorgente ST indicando il seguente attributo (Pagina 304) all'interno di un pragma (Pagina 299): { _U7_PoeBld_CompilerOption := warning:n:err }, dove n sta per il numero di avviso/informazione.

Tabella A- 19 Avvisi (16001 - 16700)

Errore Descrizione 16001 (classe di avviso: 0)

Solo in combinazione con l'opzione del compilatore "Connessione selettiva". La funzione indicata, il blocco funzionale o il programma non vengono esportati e non vengono richiamati nella Unit specifica. Non viene generato codice.

16002 (classe di avviso: 0) Solo in combinazione con l'opzione del compilatore "Connessione selettiva". La Unit specificata non contiene PROGRAM esportati né collegamenti al task. Non viene generato codice per la Unit.

16003 (classe di avviso: 2) Gli operandi dell'operazione di confronto non contengono alcuna determinazione esplicita del tipo. Il tipo di dati utilizzato per il confronto è visibile nell'emissione del messaggio di avviso. Inserire il tipo di dati delle costanti utilizzate in modo esplicito con <tipo>#<valore>.

16004 (classe di avviso: 2) La conversione del tipo specificata può provocare una modifica del valore delle variabili a causa della esigua ampiezza di visualizzazione o della modesta precisione del tipo di dati di destinazione.

16005 (classe di avviso: 2) Durante la conversione del tipo è possibile che si verifichi, a seconda del valore delle variabili, un cambio di segno.

16006 (classe di avviso: 2) A causa della insufficiente ampiezza di visualizzazione, il valore specificato viene arrotondato al prossimo valore rappresentabile.

16007 (classe di avviso: 2) Durante la conversione del tipo si è verificata una perdita di precisione. Non tutte le cifre decimali vengono considerate.

16008 (classe di avviso: 2) Durante l'inizializzazione delle variabili specificate si è verificata una perdita di precisione. La costante viene convertita nel tipo di dati indicato. Non tutte le cifre decimali vengono considerate.




Binding selettivo non in relazione a un'opzione del compilatore. La Unit indicata non contiene alcun PROGRAM esportato e alcun collegamento al task. Il codice della Unit non è raggiungibile. Non è possibile una chiamata alla POE contenuta.

16010 (classe di avviso: 0) Il PROGRAM indicato non viene esportato nella Unit, non è perciò possibile un impiego nella progettazione a livello esecutivo.

16011 (classe di avviso: 0) La sorgente non contiene variabili globali esportate. Non vengono caricati dati nel sistema di destinazione.

16012 (classe di avviso: 0) Il nome specificato della sorgente è stato tratto dal contenitore PROGRAMMI dell'apparecchio selezionato. La definizione della sorgente nell'istruzione UNIT è stata ignorata.

16013 (classe di avviso: 2) Il tipo di dati indicato non può essere convertito in formato trasferibile dalla funzione marshalling. Utilizzare solo gli apparecchi SIMOTION in associazione a questo tipo di dati o eseguire una conversione esplicita del tipo di dati.

16014 (classe di avviso: 2) Nell'operazione indicata è stata eseguita una conversione del tipo di dati tra "con segno" (signed) e "senza segno" (unsigned). Dato che in questo caso viene ripresa la stringa di bit, il valore numerico risultante può discostarsi dal valore indicato.

16015 (classe di avviso: 2) Nell'assegnazione delle costanti delle stringhe di caratteri alle variabili viene applicata solo una parte delle costanti, in quanto la lunghezza delle variabili non è sufficiente per l'applicazione di tutti i caratteri.

16016 (classe di avviso: 2) Gli operandi dell'espressione non contengono alcuna determinazione esplicita del tipo. Il tipo di dati dell'operazione è determinato tramite l'indicazione dei valori. Il tipo di dati risultante in cui viene calcolata l'espressione è visibile nell'emissione del messaggio di avviso. Per la definizione del tipo di dati: • Inserire il tipo di dati delle costanti utilizzate in modo esplicito con <tipo>#<valore>, oppure • Utilizzare una conversione del tipo di dati esplicita.

16017 (classe di avviso: 2) Gli operandi dell'espressione contengono solo costanti. Il tipo di dati dell'operazione può essere determinato indicando il tipo di dati (nella forma <tipo>#<valore>), oppure tramite la conversione esplicita del tipo di dati. Questo output consente di ricercare gli errori, in particolare quando si utilizzano costanti simboliche, dal momento che in questo caso il tipo di dati dell'operazione non è generalmente facile da seguire.

16018 (classe di avviso: 2) Il tipo di dati dell'operazione di confronto si determina sulla base del valore di una costante con campo di valori più ampio rispetto alla variabile contenuta. Il confronto non viene eseguito con il tipo di dati delle costanti.

16020 (classe di avviso: 1) La dichiarazione copre l'identificatore indicato, definito in modo globale in una propria sorgente o in una sorgente importata. Gli accessi all'identificatore globale non sono più possibili dalla POE di dichiarazione locale dell'identificatore.




La dichiarazione copre l'identificatore indicato definito sull'apparecchio. E' possibile accedere all'identificatore globale dell'apparecchio con _device.<name>.

16022 (classe di avviso: 1) La dichiarazione copre l'identificatore indicato definito nel progetto (ad es. oggetto tecnologico o apparecchio). E' possibile accedere all'identificatore globale del progetto con _project.<name>.

16023 (classe di avviso: 1) La dichiarazione copre l'identificatore indicato per il tipo di dati di un oggetto tecnologico. Non è più possibile accedere all'identificatore del tipo di dati.

16024 (classe di avviso: 1) La dichiarazione nasconde l'accesso all'oggetto tecnologico sull'apparecchio. Gli accessi a questo TO sono possibili con _to.<name>.

16025 (classe di avviso: 1) La dichiarazione nasconde la funzione standard IEC con lo stesso nome. Nel contesto corrente non è più possibile accedere a questa funzione.

16026 (classe di avviso: 1) L'identificatore specificato è riservato per potenziali estensioni SIEMENS. L'utilizzo di questo identificatore può determinare in fasi successive la visualizzazione di messaggi di errore del compilatore. Per evitare questo problema cambiare l'identificatore utilizzato.

16027 (Classe di avviso: 1) L'identificatore indicato, riservato per l'accesso a I/O-Qualities, è già preconfigurato sull'apparecchio. L'accesso alle I/O-Qualities non è quindi possibile.

16030 (classe di avviso: 1) Un'etichetta di salto è stata inserita più volte in un'istruzione CASE. Viene sempre valutata solo la prima etichetta. Le altre indicazioni non hanno nessun effetto.

16102 (classe di avviso: 3) L'opzione per l'output del codice per la funzione di diagnostica Stato programma viene ignorata poiché non vengono generate informazioni di debug. L'output delle informazioni di debug è stato deselezionato tramite le opzioni del compilatore.

16103 (classe di avviso: 3) L'opzione per l'output del codice per la funzione di diagnostica Stato programma alla libreria viene ignorata. Il codice per lo stato programma viene generato, secondo l'opzione, per le singole sorgenti.

16113: (Classe di avviso: 3) In pragma è presente un errore di sintassi nella dichiarazione di un attributo. La sintassi valida è la seguente: <identificatore attributo> := <valore attributo>; .

16150 (classe di avviso: 7) Viene impostata una nuova definizione per l'identificatore indicato. La definizione precedente non è più valida. Questo avviso consente di monitorare il lavoro del preprocessore.

16151 (classe di avviso: 7) Si è cercato di cancellare la definizione dell'identificatore indicato con #undef. L'identificatore tuttavia non è definito oppure la definizione è già stata cancellata. Questo avviso consente di monitorare il lavoro del preprocessore.




La definizione indicata non viene presa in considerazione in fase di generazione del codice. La causa può risiedere nel fatto che il preprocessore per la sorgente compilata è disattivato.

16153 (classe di avviso: 7) Il preprocessore non è attivo nella sorgente attuale, anche se vengono utilizzate le relative istruzioni. Attivare il preprocessore o eliminare le istruzioni.

16154 (Classe di avviso: -) Il preprocessore non può essere impiegato per il comando dei contenuti di istruzioni USEPACKAGE, USELIB e USES. La definizione automatica delle dipendenze dalle sorgenti per le funzioni "Salva progetto e compila modifiche" o "Salva progetto e compila tutto di nuovo" non è più garantita.

16170 (classe di avviso: -) Le definizioni delle sorgenti importate tramite USES non vengono tenute in considerazione durante la generazione dei codici.

16171 (classe di avviso: -) Impossibile caricare la definizione della sorgente indicata importata tramite USES. Compilare prima la sorgente specificata.

16200 (classe di avviso: 4) L'adozione di un semaforo richiede una variabile globale affinché sia possibile accedervi da un altro task. I processi task locali non devono essere bloccati mediante semafori.

16210 (classe di avviso: 4) La base della funzione di potenza (funzione standard EXPT o dell'operatore **) è negativa. L'operazione può essere eseguita per il runtime solo alle seguenti condizioni: 1. Utilizzo su un apparecchio con kernel SIMOTION a partire dalla versione V4.1. 2. Utilizzo di un numero intero come esponente. Anche con esponenti diversi da numeri interi o su apparecchi con versione del kernel SIMOTION fino alla V4.0 viene eseguito il task ExecutionFaultTask. Il programma viene interrotto in questo punto.

16220 (classe di avviso: 4) La condizione di un'istruzione IF, WHILE o REPEAT è un'espressione costante.

16230 (classe di avviso: 4) L'espressione con i valori dati non determina alcuna variazione del risultato; il codice viene creato in modo ottimale.

16240 (classe di avviso: 4) L'espressione con i valori dati eccede il campo di definizione dell'operazione. Il risultato può essere errato.

16300 (classe di avviso: 5) Il valore di accompagnamento presenta un tipo di dati non convertibile nel tipo di dati progettato del messaggio.

16301 (classe di avviso: 5) Il valore di accompagnamento indicato non viene valutato durante l'output del messaggio.

16302 (classe di avviso: 5) Il tipo di dati del valore di accompagnamento non può essere rilevato dalla progettazione dei messaggi. Viene impiegato il tipo di dati specificato.




Non è stato specificato un valore di accompagnamento per la funzione, sebbene la progettazione dei messaggi richieda tale valore. È stato integrato un valore predefinito del relativo tipo di dati.

16304 (classe di avviso: 5) È stato indicato un errore di accompagnamento dell'allarme tramite una costante o un'espressione della costante. Il tipo di dati risultante dal valore di accompagnamento dell'allarme è visibile nell'output del messaggio di avviso. Per la definizione del tipo di dati: • Inserire il tipo di dati delle costanti utilizzate in modo esplicito con <tipo>#<valore>, oppure • Utilizzare una conversione del tipo di dati esplicita.

16400 (classe di avviso: 6) È stata creata una variabile globale in una libreria. Ciò può eventualmente impedire un impiego multiplo della libreria.

16420 (classe di avviso: 6) All'interno della funzione non è stato assegnato il valore di ritorno. Se viene richiamata questa funzione viene fornito un valore casuale.

16421 (classe di avviso: 6) È stata dichiarata una variabile che non è stata assegnata né letta nel codice.

16450 (classe di avviso: –) È stata creata una variabile globale nello spazio di memoria ritentivo. Questa dichiarazione non è ammessa nel punto indicato.

16451 (classe di avviso: –) L'inizializzazione di ampi campi contenenti valori diversi da 0 causa un elevato accumulo di dati nel controllo. Ciò causa tempi di caricamento lunghi e una sollecitazione eccessiva della memoria.

16452 (classe di avviso: –) Il programma indicato possiede una grande quantità di dati di istanza da inizializzare. Durante l'avvio del task ciò può provocare un superamento del runtime, dato che vengono eseguiti sia il codice di inizializzazione sia il codice utente. Si consiglia cautela, soprattutto per i SynchronousTask.

16470 (classe di avviso: -) Il costrutto specificato non è conforme allo standard del linguaggio, ma per ragioni di compatibilità è comunque supportato sulle vecchie piattaforme. Cambiare la posizione di utilizzo, impostando l'alternativa indicata.

16600 (classe di avviso: 6) La variabile specificata non è contenuta nell'elenco di inizializzazione. Viene utilizzato il valore di inizializzazione predefinito.





Errore Descrizione 16603 (Classe di avviso: 6)

Il blocco funzionale indicato non presenta dati di istanza e ha quindi una dimensione pari a 0 byte. Per la trasmissione dei riferimenti come Array adimensionale, le dimensioni dell'elemento vengono fissate sull'elemento 1.

16700 (classe di avviso: 3) L'apparecchio SIMOTION può essere utilizzato anche con versioni precedenti di SIMOTION SCOUT. Il costrutto indicato non viene supportato da tutte le versioni precedenti del compilatore.

A.2.12 Informazioni (32010 - 32653) L'output di queste informazioni è impostato unitamente agli Avvisi (Pagina 434):

Tabella A- 20 Informazioni (32010 - 32653)


L'identificatore specificato dell'etichetta di salto è stato dichiarato ma non utilizzato. 32020 (classe di avviso: –)

La variabile specificata è stata dichiarata globalmente, in questo sorgente o in un altro, con il tipo di dati indicato. Questa informazione è utile per la ricerca della causa di un errore durante la compilazione e Viene emessa assieme ai messaggi di errore.

32021 (classe di avviso: –) La variabile indicata è stata dichiarata sull'apparecchio come variabile I/O, come variabile globale dell'apparecchio o come variabile di sistema. Questa informazione è utile per la ricerca della causa di un errore durante la compilazione e Viene emessa assieme ai messaggi di errore.

32022 (classe di avviso: –) La variabile indicata è stata dichiarata sul progetto come identificatore globale. Questa informazione è utile per la ricerca della causa di un errore durante la compilazione e Viene emessa assieme ai messaggi di errore.

32023 (classe di avviso: –) Non è stata trovata alcuna dichiarazione valida per l'identificatore indicato. Questa informazione viene emessa insieme ai messaggi di errore.

32024 (classe di avviso: 0) La variabile indicata è stata dichiarata come identificatore globale nella Unit corrente o in una Unit importata. Questa informazione è utile per la ricerca della causa di un errore durante la compilazione e Viene emessa assieme ai messaggi di errore.

32030 (classe di avviso: 0) L'inizializzazione del campo specificata non è conforme alla norma IEC 61131/-3. Per i programmi portabili occorre racchiudere i valori di inizializzazione del campo in parentesi quadre. Esempio di inizializzazione del campo conforme alla norma: x : ARRAY [0..1] OF INT := [ 1, 2];

Appendice A.3 Template per Unit di esempio



La dimensione massima raggiungibile mediante HMI è 65536 byte. Nel caso delle variabili specificate, questo limite viene superato. Anche tutte le variabili successive risultano non raggiungibili.

32300 (classe di avviso: 1) Un'etichetta di salto è stata inserita più volte in un'istruzione CASE. Viene sempre valutata solo la prima etichetta. Le altre indicazioni non hanno nessun effetto.

32650 (classe di avviso: 7) L'identificatore indicato verrà sostituito con il testo emesso. Questa informazione consente di monitorare il lavoro del preprocessore.

32651 (classe di avviso: 7) La definizione dell'identificatore indicato è stata cancellata con #undef. Questa informazione consente di monitorare il lavoro del preprocessore.

32652 (classe di avviso: 7) L'identificatore viene utilizzato nella sorgente con il testo sostitutivo indicato. Avviene una compilazione con il testo sostitutivo. Questa informazione consente di monitorare il lavoro del preprocessore.

32653 (classe di avviso: 7) L'identificatore indicato verrà sostituito con il testo emesso. Questa informazione viene visualizzata se vengono caricate delle sostituzioni aggiuntive con un'istruzione USES. Questa informazione consente di monitorare il lavoro del preprocessore.

A.3 Template per Unit di esempio

A.3.1 Informazioni in anteprima In questo capitolo è riprodotto il template che può essere richiamato con la guida in linea, corredato di un commento dettagliato. Esso può essere utilizzato come modello per una nuova sorgente ST.

//============================================================================

//(organisation)

//(division / place)

//(c)Copyright 2009 All Rights Reserved

//-----------------------------------------------------------------------------

// project name: (name)

// file name: (name as soon as saved)

// library: (that the source is dedicated to)

// system: (target system)

// version: (SIMOTION / SCOUT version)

// application: (relation to project/ product/ usage)

// restrictions:

// requirements: (hardeware, technological package, memory needed, etc.)



// search items: (with the purpose of browser usage)

// functionality: (that is implemented)

//-----------------------------------------------------------------------------

// change log table:

// version date expert in charge changes applied

//

//=============================================================================

INTERFACE

// Tutte le istruzioni inserite fra INTERFACE e END_INTERFACE/

// Le parole chiave servono a definire quali contenuti sorgente

// (variabili, funzioni, blocchi funzionali ecc.) sono a disposizione anche nelle

// altre sorgenti (unit) o possono essere in esse esportati.

USEPACKAGE cam;

// Qui i pacchetti tecnologici da utilizzare vengono riconosciuti e

// sono resi utilizzabili nella sorgente. I comandi specifici per l'oggetto

// tecnologico (TO) possono essere utilizzati in questa UNIT solo se

// il pacchetto corrispondente è stato collegato.

// Se per USES viene inserita una sorgente che utilizza USEPACKAGE cam

// questa caratteristica viene "ereditata". USEPACKAGE può essere quindi omesso.

// Il pacchetto utilizzato nell'esempio è "cam". Sono tuttavia utilizzabili anche

// altri pacchetti tecnologici (vedere la documentazione).

// USELIB testlib;

// Nel caso si debbano utilizzare nella sorgente funzioni di una libreria, queste

// devono essere rese sempre riconoscibili da parte della sorgente. Se la libreria

// con il nome "testlib" non esiste nel progetto, il

// messaggio di errore

// "Errore 10035 Impossibile caricare la libreria "testlib.lib""

// "Errore 10032 Impossibile caricare la libreria "testlib""

// viene emesso.

// Se non si utilizzano le librerie, questa riga può essere cancellata.

//.

// USES header;

// Tramite USES i contenuti esportati da una sorgente diversa (NOME in questo caso

// "header") vengono importati e resi utilizzabili in "sttemp_l_de".

// Se la sorgente con il nome "header" non esiste nel progetto, il

// messaggio di errore

// "Errore 10018 Impossibile caricare la sorgente "header""

// viene emesso.



A.3.2 Definizione del tipo in Interface // ******************************************************

// * Definizione del tipo in INTERFACE *

// ******************************************************

VAR_GLOBAL CONSTANT

PI : REAL := 3.1415;

ARRAY_MAX1 : INT := 4;

ARRAY_MAX2 : INT := 4;

COLLECTION_MAX : INT := 6;

GLOBARRAY_MAX : INT := 12;

END_VAR

// Dichiarazione di una costante globale. All'identificatore non può essere assegnato

// nessun altro valore nella sorgente.

// Fra TYPE e END_TYPE vengono

// determinati tipi di variabili definiti dall'utente (UDT).

TYPE

ai16Dim1 : ARRAY [0..ARRAY_MAX1-1] OF INT;

// Definizione di un campo unidimensionale con quattro elementi di campo del

// tipo INT con il nome ai16Dim1". Con "ai16Dim1" come tipo di dati

// possono essere ora dichiarati in tutte le sezioni sorgente i campi

// unidimensionali del tipo INT.

aaDim2 : ARRAY [0..ARRAY_MAX2-1] OF ai16Dim1;

// Un campo bidimensionale è un campo appartenente a campi unidimensionali.

// Qui si trova un campo bidimensionale con 16 elementi

// del tipo INT con il nome "aaDim2"

eTrafficLight : (RED, YELLOW, GREEN);

// Definizione di un enumeratore "eTrafficLight" come

// tipo di variabile definita dall'utente. Le variabili di questo tipo possono

// avere esclusivamente i valori "RED", "YELLOW" e "GREEN".

sCollection : STRUCT

toAxisX : posaxis;

aInStructDim1 : ai16Dim1;

eTrafficInStruct : eTrafficLight;

i16Counter : INT;

b16Status : WORD;

END_STRUCT;

// Qui viene creata una struttura definita dall'utente. Possono essere

// raggruppati in una struttura tipi di dati elementari (qui INT e WORD)

// oppure tipi di dati utente già definiti

// (qui "array1dim" e "eTrafficLight")

//. Inoltre anche i tipi di

// oggetti tecnologici vengono utilizzati.



// Nell'esempio la struttura contiene un elemento del tipo (TYPE)

// di un asse di posizionamento (posaxis).

// Nella definizione è necessario prestare attenzione affinchè le variabili

// vengano ordinate in sequenza crescente in base alle relative dimensioni

// (ARRAY, STRUCT, LREAL, DWORD, INT, BOOL ...)

aCollection : ARRAY [0..5] OF sCollection;

// E' consentito anche l'annidamento. Il tipo "aCollection"

// contiene un campo composto da sei elementi del tipo "sCollection"

END_TYPE



A.3.3 Dichiarazione delle variabili in Interface // ******************************************************

// * Dichiarazione delle variabili in INTERFACE *

// ******************************************************

VAR_GLOBAL // Nella memoria utente della UNIT.

// Visualizzabile anche con i servizi di servizio e supervisione.

gaMyArray : ARRAY [0..GLOBARRAY_MAX-1] OF REAL := [3 (2(4), 2(18))];

// Esempio di una dichiarazione di un campo unidimensionale senza

// precedente dichiarazione del tipo. L'inizializzazione qui effettuata

// va letta come di seguito:

// Ogni volta due elementi vengono inizializzati con il valore 4,

// e altri due elementi con il valore 18. Questo modello viene utilizzato tre

volte

// "in sequenza nel campo "gaMyArray".

// Gli elementi di campo sono quindi occupati come segue:

// 4, 4, 18, 18, 4, 4, 18, 18, 4, 4, 18, 18.

gaMy2dim : aaDim2;

// Esempio di una dichiarazione di un campo bidimensionale.

gaMy1dim : ai16Dim1;

// Esempio di una dichiarazione di un campo unidimensionale in cui

// si utilizza una dichiarazione del tipo.

gsMyStruct : sCollection;

// Creazione di una variabile del tipo o con la struttura di

// user_struct.

gaMyArrayOfStruct : aCollection;

// La variabile qui generata contiene un campo di

// elementi strutturali così come sono stati dichiarati nella sezione

// TYPE/END_TYPE.

gtMyTime : TIME := T#0d_1h_5m_17s_4ms;

// ...come tipi di tempo elementari e tipi di dati derivati.

geMyTraffic : eTrafficLight := RED;

// Qui viene creato un enumeratore del tipo "eTrafficLight", al

// quale viene preassegnato il valore "RED".

gi16MyInt : INT := -17;

// Le variabili dei tipi di dati numerici elementari possono

// essere dichiarate anche nelle dichiarazioni delle variabili...

END_VAR



VAR_GLOBAL RETAIN

END_VAR

// Le variabili dichiarate con l'aggiunta RETAIN vengono memorizzate

// nel campo dati RETAIN della piattaforma hardware impiegata e

// sono perciò protette da un guasto alla rete.

// La dichiarazione di VAR, VAR CONSTANT, VAR_TEMP, VAR_INPUT, VAR_OUTPUT

// e VAR_IN_OUT non è qui consentita.

// Le variabili che vengono definite in questa sezione e quindi esportate

// possono essere nuovamente importate tramite USES "sttemp_l_de"

// in una diversa sorgente (UNIT).

FUNCTION FCmyFirst;

FUNCTION_BLOCK FBmyFirst;

PROGRAM myPRG;

// I blocchi funzionali (FB), le funzioni (FC), e i programmi definiti nella parte

// Implementation devono essere qui esportati nella parte Interface,

// in modo da poter essere utilizzati nelle altre Unit.

// Gli FB e le FC non esportati possono essere utilizzati solo in questa sorgente

// ("information hiding", posizionare in Interface solo

// ciò che è strettamente necessario alle altre Unit).

// Un programma non esportato non può essere associato ad alcun TASK.

END_INTERFACE

A.3.4 Implementation // ******************************************************

// * Parte IMPLEMENTATION *

// ******************************************************

IMPLEMENTATION

// Nella parte IMPLEMENTATION di una Unit le sezioni di codice eseguibili sono

collocate

// in diverse unità organizzative di programma (POE) sullo sfondo.

// Una POE può essere un programma, una FC oppure un FB.

VAR_GLOBAL CONSTANT

END_VAR

TYPE

END_TYPE

// La definizione del tipo può essere eseguita anche nella parte IMPLEMENTATION.

// Tuttavia questa definizione non è successivamente importabile in un'altra sorgente.

// La definizione del tipo può comunque essere utilizzata per le variabili in tutte

// le POE della sorgente "sttemp_l_de". La definizione dei tipi può

// avvenire prima della dichiarazione delle variabili.



VAR_GLOBAL // Nella memoria utente della UNIT.

gboDigInput1 : BOOL;

// Variabile booleana per l'esempio "EXPRESSION" (vedere sotto).

END_VAR

VAR_GLOBAL RETAIN

END_VAR

// Le variabili dichiarate con l'aggiunta RETAIN vengono memorizzate

// nel campo dati RETAIN della piattaforma hardware impiegata e

// sono perciò protette da un guasto alla rete.

// Dichiarazione delle variabili nella parte IMPLEMENTATION.

// La dichiarazione di VAR, VAR CONSTANT, VAR_TEMP, VAR_INPUT, VAR_OUTPUT

// e VAR_IN_OUT non è qui consentita.

EXPRESSION xCond

xCond := gboDigInput1;

END_EXPRESSION

// Definizione di una EXPRESSION.

// Una EXPRESSION è un caso particolare di una funzione e riconosce solo il

// valore di ritorno TRUE e FALSE. Questa viene utilizzata in combinazione con

// l'istruzione WAITFORCONDITON (ved. myPRG) e dovrebbe essere utilizzata solo

// se il programma viene eseguito nell'ambito di un MotionTask

//. Se "gboDigInput1" (generalmente un ingresso digitale o una

// condizione nel programma) assume il valore 1, il valore di ritorno della

// EXPRESSIONTRUE.

A.3.5 Function // ******************************************************

// * FUNCTION *

// ******************************************************

// La dichiarazione di un FB o di una FC deve essere posizionata prima della vera e

// propria applicazione (richiamo) all'interno della sorgente, in modo che il codice

// del blocco sia già noto nella posizione da richiamare.

FUNCTION FCmyFirst : INT

// Qui inizia la sezione delle istruzioni della POE FUNCTION. Il valore di ritorno

// della funzione è in questo caso associato al tipo Integer.

// Lo stack del TASK da richiamare viene inizializzato con

// ogni richiamo. Il valore di ritorno si trova sullo stack e viene scritto prima

// della FUNCTION.

VAR CONSTANT

END_VAR



TYPE

END_TYPE

// La dichiarazione del tipo può essere eseguita anche nelle POE. La

// differenza principale consiste nel campo di validità della

// dichiarazione del tipo. Un tipo dichiarato in una POE può essere utilizzato

// solo per variabili all'interno della relativa POE.

VAR_INPUT // Nello stack del TASK da richiamare, al richiamo

// viene posizionato sullo stack, da assegnare in modo opzionale.

END_VAR

VAR // Nello stack del TASK da richiamare,

// viene utilizzato in FUNCTION.

END_VAR

// Dichiarazione delle variabili in una FC.

// La dichiarazione di VAR_TEMP, VAR_GLOBAL, VAR_GLOBAL CONSTANT,

// VAR_GLOBAL RETAIN, VAR_OUTPUT e VAR_IN_OUT qui non è

// consentita.

// L'utilizzo di variabili globali dell'unità per la trasmissione dei dati alle FC

// e agli FB rappresenta l'opzione più rapida al runtime. L'utilizzo

// dei parametri di ingresso VAR_INPUT e il ritorno tramite

// valore di ritorno è più lento, poichè i valori vengono ogni volta copiati.

// Nota: le variabili dichiarate con VAR e con VAR CONSTANT sono

// temporanee. Con il successivo richiamo i contenuti del richiamo precedente,

// a differenza dell'FB, non sono più disponibili.

// ********************************************

// * Campo per il codice e le istruzioni della FC *

// ********************************************)

// Il codice si trova nella memoria utente.

geMyTraffic := YELLOW; // ad es. commutazione del semaforo.

FCmyFirst := 17;

// In questo esempio, la funzione restituisce il valore "17" al

// programma da richiamare.

END_FUNCTION



A.3.6 Function Block // ******************************************************

// * FUNCTION_BLOCK *

// ******************************************************

// La dichiarazione di un FB o di una FC deve essere posizionata prima della vera e

// propria applicazione (richiamo) all'interno della sorgente, in modo che il codice

// del blocco sia già noto nella posizione da richiamare.

FUNCTION_BLOCK FBmyFirst

// Qui inizia la sezione delle istruzioni della POE FUNCTION_BLOCK.

// I dati di istanza sono posizionati in base alla posizione di generazione

// dell'istanza (vedere commenti alla fine del template) all'interno della memoria

// utente della UNIT o del TASK e vengono inizializzati con STOP->RUN oppure

// all'avvio del TASK.

// L'identificatore dei dati di istanza viene trasferito durante il richiamo.

VAR CONSTANT

END_VAR

// Le variabili dichiarate in VAR e VAR CONSTANT sono

// statiche, ossia i contenuti sono ancora disponibili e validi al successivo

// richiamo del blocco.

TYPE

END_TYPE

// La definizione del tipo può essere eseguita anche nelle POE. La


// definizione del tipo. Un tipo dichiarato in una POE può essere utilizzato solo

// per variabili all'interno della relativa POE.

VAR_INPUT // Nella memoria utente della UNIT o del TASK,

// da assegnare in modo opzionale al richiamo.

END_VAR

VAR_IN_OUT // Nella memoria utente della UNIT o del TASK,

// il riferimento deve essere assegnato al richiamo.

END_VAR

VAR_OUTPUT // Nella memoria utente della UNIT o del TASK.

END_VAR

VAR // Nella memoria utente della UNIT o del TASK,

// può essere utilizzato nell'FB.

END_VAR

VAR_TEMP // Nello stack del TASK da richiamare,

// viene inizializzato a ogni richiamo.

END_VAR



// Dichiarazione delle variabili in un FB.

// La dichiarazione di VAR_GLOBAL, VAR_GLOBAL CONSTANT e

// VAR_GLOBAL RETAIN non è qui consentita.

// ********************************************

// * Campo per il codice e le istruzioni dell'FB *

// ********************************************

geMyTraffic := GREEN; // ad es. commutazione del semaforo.

END_FUNCTION_BLOCK

A.3.7 Program // ******************************************************

// * PROGRAM *

// ******************************************************

PROGRAM myPRG

// Qui inizia la sezione delle istruzioni della POE PROGRAM.

VAR CONSTANT

END_VAR

TYPE

END_TYPE

// La definizione del tipo può essere eseguita anche nelle POE. La


// definizione del tipo. Un tipo dichiarato in una POE può essere utilizzato solo

// per variabili all'interno della relativa POE.

VAR // Nella memoria utente del TASK.

instFBMyFirst : FBmyFirst;

// Per poter richiamare un FB è necessario generare un campo per variabili

// statiche (generazione di un'istanza). In questo caso

// si tratta della "memoria" dell'FB.

retFCMyFirst : INT;

// Variabile per il valore di ritorno della funzione.

END_VAR

VAR_TEMP // Nello stack del TASK, inizializzato a ogni esecuzione.

END_VAR

// Dichiarazione delle variabili in un PROGRAMM.

// La dichiarazione di VAR_GLOBAL, VAR_GLOBAL CONSTANT,

// VAR_GLOBAL RETAIN, VAR_INPUT, VAR_OUTPUT e VAR_IN_OUT

// non è qui consentita.



// Nota: La temporaneità delle variabili locali dichiarate tramite VAR

// dipende dal contesto del task in cui è utilizzato il PROGRAM

//.

//

// Nei task non ciclici (StartupTask, ShutdownTask, MotionTasks,

// SystemInterruptTasks e UserInterruptTasks) i contenuti precedenti

// di VAR e VAR_TEMP non sono più disponibili.

// Quindi le variabili sono temporanee.

//

// Nei task ciclici (BackgroundTask, IPOsynchronousTask,

// IPOsynchronousTask_2 e TimerInterruptTasks) i contenuti delle variabili

// dichiarate nella sezione VAR vengono mantenuti per la successiva

// esecuzione. Quindi le variabili sono statiche.

// Le variabili di VAR_TEMP sono temporanee in qualunque caso.

instFBMyFirst ();

// Richiamo dell'FB con un'istanza valida.

retFCMyFirst := FCmyFirst();

// Richiamo dell'FC e assegnazione del valore di ritorno.

WAITFORCONDITION xCond WITH TRUE DO

// Le istruzioni qui programmate vengono immediatamente eseguite

// quando la condizione "xcond" definita nella corrispondente

// EXPRESSION diventa logicamente vera.

;


// WAITFORCONDITION in genere viene utilizzato solo nei MotionTask.

// Questi vengono arrestati in posizione e la condizione definita

// nell'espressione EXPRESSION viene verificata con priorità elevata.

END_PROGRAM

END_IMPLEMENTATION


indice

i –, 149

# #define, 302 #else, 302 #endif, 302 #ifdef, 302 #ifndef, 302 #undef, 302

* *, 149 **, 149

/ /, 149

: :, 115, 128 :=, 138, 184, 185

_ _AdditionObjectType, 125 _alarm, 290 _CamTrackType, 124 _ControllerObjectType, 125 _device, 279, 290 _direct, 251, 257, 279, 290 _FixedGearType, 125 _FormulaObjectType, 125 _getSafeValue

Impiego, 279 _PathAxis, 125 _PathObjectTpye, 125 _project, 290 _quality, 265, 290

_SensorType, 125 _setSafeValue

Impiego, 279 _task, 290 _to, 290 _U7_PoeBld_CompilerOption, 304

+ +, 149

< <, 152 <=, 152 <>, 152

= =, 152 =>, 186

> >, 152 >=, 152

1 -1.#IND, 326, 328 1.#INF, 326, 328 -1.#INF, 326, 328 -1.#INF, 326, 328 1.#QNAN, 326, 328 -1.#QNAN, 326, 328 -1.#QNAN, 326, 328

A Accessi simbolici alle aree indirizzi di I/O

Immagine di processo, 276 Accesso alla memoria della CPU

identificatore per l'accesso all'immagine di processo, 368 Modello di variabile, 220

Indice analitico


Accesso diretto, 251, 256 Modello di variabile, 220 Proprietà, 252

Ambiente di programmazione, 17 ANY, 113 ANY_BIT, 113 ANY_DATE, 113 ANY_ELEMENTARY, 113 ANY_INT, 113 ANY_NUM, 113 ANY_REAL, 113 ANYOBJECT, 125 Apparecchio

Impostazioni, 309 Regole per gli identificatori, 307

Apparecchio SIMOTION Impostazioni, 309 Regole per gli identificatori, 307

Aprire Sorgente ST, 24

ARRAY con lunghezza definita, 118 con lunghezza dinamica, 182 Tipo di dati, 118

Assegnazione del valore Descrizione, 137 Sintassi, 407

Assegnazione di ingresso Sintassi, 184

Assegnazione di passaggio Sintassi, 186

Attributi di codice, 298 Attributo

Opzione compilatore, 304 Avvertenza per il lettore, 5

B Blocchi, 92 Blocchi di parametri

Sintassi, 397 Blocchi di variabili

Sintassi, 395 Blocco di costanti

Sintassi, 395 Blocco funzionale, 176

definizione, 177 Differenza rispetto alla funzione, 192 Esempio, 192 Fonti di errore al richiamo, 191 Istanze, 188 Nomi, 188

Parametri di ingresso, 181 Parametri di passaggio, 181 Parametri di uscita, 181 Percorso di richiamo, 336 Richiamo, 188 Richiamo, sintassi, 189 Sezione file sorgente, 207 Sintassi, 177 Struttura, 177 Variabili locali, 181

BlockInit_OnChange, 305 BlockInit_OnDeviceRun, 305 BOOL, 110 Browser dei simboli, 323 BYTE, 110

C Campi

Assegnazione del valore, 143, 144 con lunghezza definita, 118 con lunghezza dinamica, 182 Tipo di dati, 118

CamType, 125 Caratteri di formattazione, 365 Caratteri di separazione, 365 Classe di avviso, 67, 300 Comandi

Panoramica del linguaggio ST, 100 panoramica sistema di base, 370

Combinazione di tasti Editor script, 54 Editor ST, 54

Commenti, 108 Sezione file sorgente, 108 Sintassi, 388

Compilatore, 84 Attributo, 304 avvio, 58 Avvio, 84 Avvisi, 434 Correzione errori, 58, 84 Errore di dichiarazione nelle dichiarazioni del tipo, 423 Errore durante il caricamento dell'interfaccia di un'altra UNIT o di un pacchetto tecnologico, 430 Errori dello scanner, 421 Errori di accesso al file, 421 Errori di dichiarazione, 422 Errori di dichiarazione nelle dichiarazioni delle variabili, 424 Errori di sintassi, errori di espressione, 429

Indice analitico


Errori nel collegamento di una sorgente, 430 Impostazione, 58 Informazioni, 439 Limitazioni d'implementazione, 433

Compilatore ST. Vedere Compilatore, 58 Compilazione

Libreria, 281 Confronto progetti

Sommario, 361 CONSTANT, 131, 135 Conversioni esplicite del tipo di dati, 173 Conversioni implicite dei tipi di dati, 170 costanti

bit, 104 caratteri di formattazione e di separazione, 367 Costanti Unit, 224 Data e ora, sintassi, 385 Indicazioni del tempo, 111 Letterali, sintassi, 380 Nomi simbolici, 135 Numero a virgola mobile, 103 Numero intero, 102 Sequenze delle cifre, sintassi, 384 Tipi di dati per le costanti, 109 Validità globale, 224

Costanti di bit, 104 Costanti Unit

Definizione;, 224

D DATE, 111 DATE_AND_TIME, 111 Dati booleani, 104 Dati di riferimento, 292 Definizioni

Sintassi, 379 Derivazione di tipi di dati semplici, 117 Descrizione comandi, 49 Descrizione del linguaggio

strumenti, 91, 363, 365 Diagramma della sintassi, 91 Dichiarazione

Parametri, 130 Variabili, 130

Dichiarazione anticipativa, 310 Dichiarazione del tipo, 115 Dichiarazione di istanza FB

Sintassi, 188, 189 Dichiarazione LABEL, 313 Dichiarazioni

Sintassi, 398

DINT, 110 DINT#MAX, 112 DINT#MIN, 112 Diramazioni

Sintassi, 416 Download

Influsso sull'inizializzazione delle variabili, 237 DriveAxis, 124 DT, 111 DWORD, 110

E Editor, 27

Barra degli strumenti, 50 Esempio di programma, 82 Utilizzo, 83

Editor ST, 27 Coppie di parentesi, 48

Elaborazione ciclica del programma Influsso sugli accessi I/O, 251, 256, 267 Influsso sull'inizializzazione delle variabili, 237

Elaborazione sequenziale dei programmi Influsso sugli accessi I/O, 251, 256 Influsso sull'inizializzazione delle variabili, 237

Elementi base ST, 93

Elenco dei riferimenti incrociati, 292 Controllo passi singoli (MCC), 293 Creazione, 292 Dati visualizzati, 293 Filtraggio, 296 Ordinare, 295 Traccia luminosa (MCC), 293 TSI#currentTaskId, 293 TSI#dwuser_1, 293 TSI#dwuser_2, 293

Elevazione a potenza, 149 Enumeratori, 120 Enumerazione

Definizione, 120 Esempio, 121

Ereditarietà Importazione/esportazione, 218 Per gli oggetti tecnologici, 125

Errore Richiamo blocco funzionale o funzione, 191

Esecuzione del programma, 330 Barra delle funzioni, 331

Esempio completo FB e FC, 192 Rotazione bit su byte in uscita, 79

Indice analitico


Sorgente ST (template), 440 tipi di dati definiti dall'utente, 123 Uso dei tipi di dati degli oggetti tecnologici, 126

Esponente Descrizione, 103

Esportazione Sorgente ST, 71

espressione logica; espressione a sequenza di bit logico,

Espressioni Aritmetiche, 148 Espressioni di confronto, 151, 156 Logiche, 156 Regole per la creazione, 146, 156

Espressioni di confronto, 151 Etichette di salto

Sintassi, 398 EXPRESSION

Descrizione, 209 Sintassi, 197

ExternalEncoderType, 124

F FB, 176 FC, 176 File

Vedere il file sorgente, 105 File sorgente

Struttura, 105 File sorgente ST

Vedere il file sorgente, 105 FollowingAxis, 125 FollowingObjectType, 125 Funzione, 176

definizione, 176 Esempio, 192 Fonti di errore al richiamo, 191 Parametri di ingresso, 181 Percorso di richiamo, 336 Richiamo, 187 Sezione file sorgente, 206 Sintassi, 176 Struttura, 176 Variabili locali, 181

Funzioni di base, 148 Funzioni di conversione del tipo, 169 Funzioni di sistema

Ereditarietà, 125 Funzioni standard, 148

H Hardware

Configurazione, 80 Hiding di aree di validità, 285 HMI_Export, 304

I Identificatore

Predefinito, 368 Regole per gli apparecchi SIMOTION, 307 Regole per la creazione, 93 Riservati per ST, 100, 370 Sintassi, 93

Identificatore assoluto Sommario, 368

Identificatori riservati, 95, 370 Immagine di processo

Accesso simbolico, 276 Principio e uso, 251, 267 Proprietà, 252 Task ciclici, 256

Immagine di processo dei task ciclici, 251 Immagine di processo del BackgroundTask, 251 Implementation

Sezione file sorgente, 204 Importazione

Sorgente ST, 73 Impostazione

Compilatore, 58 Inizializzazione

Istante di inizializzazione delle variabili, 237 Sintassi, 400 Tipi di dati, 131 Variabili, 131

INT, 110 INT#MAX, 112 INT#MIN, 112 Interface

Sezione file sorgente, 202 Istruzione

Sezione file sorgente, 107, 210 Istruzione CASE

Descrizione, 158 Istruzione del preprocessore

Esempio, 303 Istruzione EXIT

Descrizione, 165 Istruzione FOR

Descrizione, 161 Istruzione GOTO, 313

Indice analitico


Istruzione IF Descrizione, 156

Istruzione REPEAT Descrizione, 164

Istruzione RETURN Descrizione, 165

Istruzione WHILE Descrizione, 163

Istruzioni di controllo, 156 Istruzioni di ripetizione e di salto

Sintassi, 417

L Libreria, 280

Compilazione, 281 utilizzo, 284

LREAL, 111

M MeasuringInputType, 124 Memoria necessaria, 232, 237 Messaggi di errore

Avvisi, 434 Errore di dichiarazione nelle dichiarazioni del tipo, 423 Errore durante il caricamento dell'interfaccia di un'altra UNIT o di un pacchetto tecnologico, 430 Errori dello scanner, 421 Errori di accesso al file, 421 Errori di dichiarazione, 422 Errori di dichiarazione nelle dichiarazioni delle variabili, 424 Errori di sintassi, errori di espressione, 429 Errori nel collegamento di una sorgente, 430 Informazioni, 439 Limitazioni d'implementazione, 433

MOD, 149 Modalità debug, 317, 339 Modalità di processo, 316 Modalità test, 317, 333 Modello di dati, 220 Modo operativo

Modalità debug, 317, 339 Modalità di processo, 316 Modalità test, 317, 333

N Nomi, 93

Numerazione numeri di righe, 49 Numeri

Descrizione, 102 Notazione, 102 Tipi di dati per i numeri, 109

Numero a virgola mobile Descrizione, 103 Notazione, 103 Tipi di dati, 110

Numero in virgola mobile Vedere Numero a virgola mobile, 103

Numero intero Descrizione, 102 Notazione, 102 Tipi di dati, 110 Vedere Numero intero, 102

Nuovo Variabile I/O, 261, 278

O Oggetto tecnologico

Ereditarietà, 125 Tipo di dati, 124

Operandi Sintassi, 409

Operatori, 369 Operatori di confronto, 151 Ordine, 156 Sintassi, 412

Operatori aritmetici, 148 Opzione compilatore, 58, 68 Osservazione variabili

Stato variabile, 329 OutputCamType, 124

P Parametri

Dichiarazione generale, 130 Tempi di accesso, 187 Trasferimento (parametri di passaggio), 185

Parametri di ingresso Blocco funzionale, 181

Parametri di passaggio Blocco funzionale, 181 Trasferimento, 185

Parametri di uscita Blocco funzionale, 181

Parametro Blocco (sintassi), 178

Indice analitico


Dichiarazione, 177 Funzione e blocco funzionale, 177 Trasferimento (parametri di ingresso), 184 Trasferimento (parametri di uscita), 186 Trasferimento (principio), 184

Parametro di ingresso Accesso nel blocco funzionale, 190 Funzione, 181 Trasferimento, 184

Parametro di uscita Accesso nel blocco funzionale, 190 Trasferimento, 186

Percorso di richiamo Callstack, 358 Esecuzione del programma, 330 Punto di arresto, 348, 352 Stato programma, 336

PosAxis, 125 Pragma

Attributo, 304 Istruzione del preprocessore, 301

Preprocessore Attivazione, 60, 62 Classe di avviso, 67 Comando, 300 Istruzione del preprocessore, 301 utilizzo, 60, 62

Progetto Apertura, 79

Programma Assegnazione dei task, 86 avvio, 86 Avvio, 89 Collegamento al sistema di destinazione, 87 Creazione (esempio), 82 Download, 88 Esecuzione, 86, 89 Limitazione degli errori, 316 Percorso di richiamo, 336 Sezione file sorgente, 208 Stato (strumento di test), 332 Test, 316 Traduzione, 84

Protezione know-how Librerie, 283 Sorgenti, 69

Prototipi, 214 Prototipo

Unità di organizzazione programma, 310 Punto di arresto, 338

Attivazione, 355 Barra degli strumenti, 347

Call-Stack, 358 disattivazione, 357 Impostazione, 344 Percorso di richiamo, 348, 352 Rimozione, 344

R REAL, 110 Regole

con formato definito, 363, 379 Semantica, 92 senza formato definito, 364, 379

RETAIN, 131, 225 Riferimento, 124 RUN

Influsso sull'inizializzazione delle variabili, 237

S Scrittura maiuscola, 49 Scrittura minuscola, 49 Segnalibro, 45 Set di caratteri, 93, 365 Sezione di programma

Vedere Sezione file sorgente, 201 Sezione dichiarazione

Sintassi, 393 Sezione file sorgente, 201

Blocco funzionale, 207 Dichiarazione del tipo di dati, 211 Dichiarazione delle variabili, 211 Funzione, 206 Implementation, 204 Interface, 202 Istruzione, 107 Istruzione Unit, 214 Programma, 208 Sezione dichiarazione, 210 Sezione istruzioni, 210 Unità di organizzazione del programma, 205

Sezione file sorgente ST Vedere Sezione file sorgente, 201

Sezione istruzioni Sintassi, 406

Sezioni Sintassi, 389

Shortcut, 54 SINT, 110 SINT#MAX, 112 SINT#MIN, 112

Indice analitico


Sistemi numerici Notazione, 103

Sorgente ST Aprire, 24 Esportazione, 71 importazione, 73 Stampa, 74 Template (esempio), 440

Spazio del nome definito dall'utente, 288 Predefinito, 290

Specifica del tipo di dati ARRAY, 118 Elementari, 117 Enumerazione, 120 STRUCT, 122

Stack dati locali, 232, 237 Stampa

Sorgente ST, 74 Stato

Programma (strumento di test), 332 Variabile I/O, 265

Stato variabile Osservazione variabili, 329

STOP su RUN Influsso sull'inizializzazione delle variabili, 237

STRING, 111 Assegnazione, 139 Diagramma della sintassi, 112 Elemento, 140 Modifica, 140

StructAlarmId, 113 STRUCTALARMID#NIL, 114 StructTaskId, 113 STRUCTTASKID#NIL, 114 Struttura

Definizione, 122 Esempio, 123 Sintassi, 389

Struttura del programma, 296 Strutturazione di programmi, 156

T T#MAX, 112 T#MIN, 112 Tabelle Watch, 327 Task

Assegnazione dei programmi, 86 Influsso sull'inizializzazione delle variabili, 237

Tasto di scelta rapida, 54 TemperatureControllerType, 125

Tempi di accesso Parametri, 187

Template Sorgente ST, 440

Terminali, 93 Test di un programma, 316 TIME, 111 TIME#MAX, 112 TIME#MIN, 112 TIME_OF_DAY, 111 TIME_OF_DAY#MAX, 112 TIME_OF_DAY#MIN, 112 Tipi di dati

ARRAY, 118 Conversioni, 169 Conversioni esplicite, 173 Conversioni implicite, 170 definita dall'utente, sintassi, 405 Definiti dall'utente, 115 Derivazione di tipi semplici, 117 elementare, sintassi, 402 Elementari, 110 Enumeratori, 120 Enumerazione, 120 Ereditarietà, 125 Inizializzazione, 131 numerico, 110 Oggetto tecnologico, 124 Sintassi, 402 STRING, 111 STRUCT, 122 Struttura, 122 Tempo, 111 Tipo di dati bit, 110 TYPE, 115

Tipi di dati bit, 110 Tipi di dati composti, 118, 122 Tipi di dati di enumerazione, 120 Tipi di dati elementari

Panoramica, 110 Tipi di dati numerici, 110 Tipi di dati semplici

Derivazione, 117 Tipi di tempo

Conversioni, 169 Funzioni, 148 Panoramica, 111

Tipo di dati definito dall'utente Sintassi, 115

Tipo di dati derivato ARRAY, 118 Campo, 118

Indice analitico


Enumeratore, 120 Enumerazione, 120 STRUCT, 122 Struttura, 122

TO#NIL, 125 TOD, 111 TOD#MAX, 112 TOD#MIN, 112 Tool Trace, 360 TSI#currentTaskId

Elenco dei riferimenti incrociati, 293 TSI#dwuser_1

Elenco dei riferimenti incrociati, 293 TSI#dwuser_2

Elenco dei riferimenti incrociati, 293 TYPE, 115

U UDINT, 110 UDINT#MAX, 112 UDINT#MIN, 112 UDT

Vedere Tipo di dato definito dall'utente, 114 UINT, 110 UINT#MAX, 112 UINT#MIN, 112 Unit

Sezione file sorgente, 214 Template (esempio), 440

UNIT, 214 Unità di organizzazione del programma

Sezione file sorgente, 205 Unità organizzative di programma

Sintassi, 391 USELIB, 203, 288 USEPACKAGE, 203, 288 USES, 203, 205, 217 USINT, 110 USINT#MAX, 112 USINT#MIN, 112

V VAR, 130, 229, 230 VAR CONSTANT, 131, 135 VAR_GLOBAL, 130, 224 VAR_GLOBAL CONSTANT, 131, 136 VAR_GLOBAL RETAIN, 131, 225 VAR_IN_OUT, 130, 179 VAR_INPUT, 130, 179

VAR_OUTPUT, 130, 179 VAR_TEMP, 131, 230 Variabile di destinazione, 137 Variabile I/O

Accesso diretto, 251, 256 Creare, 261, 278 Creazione, 261, 278 Immagine di processo, 251, 256 Immagine di processo del BackgroundTask, 269 Modello di variabile, 220 Stato, 265

Variabili, 128 ARRAY, 143, 144 Blocco funzionale, 181 Bufferizzate, 225 Dichiarazione, 130 dichiarazione (sezione file sorgente), 211 Dichiarazione di istanza FB, 188 Dichiarazione parametri, 177 Elementari, 139 Funzioni, 181 Hiding di aree di validità, 285 Immagine di processo, 251, 267 Inizializzazione, 131 Istante di inizializzazione, 237 locali, 226 Ritentive, 225 statiche, 226 Stesso nome, 285 Strutturate, 144 Tabelle Watch, 327 temporanee, 226 Tipo di dati Enumerator, 143 Tipo di dati enumerazione, 143 Validità, 220 Variabile Unit, 224

Variabili a più elementi, 143, 144 Variabili a singolo elemento, 139 Variabili applicative globali dell'apparecchio

Definizione, 231 Modello di variabile, 220

Variabili blocco funzionale/funzione Definizione, 226 Modello di variabile, 220

Variabili di programma Definizione, 226 Modello di dati, 225 Modello di variabile, 220

Variabili di sistema Ereditarietà, 125 Modello di variabile, 220

Variabili locali

Indice analitico


Modello di variabile, 220 Variabili ritentive

Definizione, 225 Modello di variabile, 220

Variabili strutturate, 143, 144 Variabili Unit, 224

Definizione, 223 Modello di variabile, 220 non ritentivo, 224

W WORD, 110 Workbench

Ambiente di programmazione, 17 Elementi, 19

Workbench SCOUT > vedere Workbench, 17

Indice analitico


Documents

SIMOTION ST Structured Text - cache. · PDF fileSIMOTION ST Structured Text Manuale di programmazione e d'uso, 02/2012 3 Prefazione Campo di validità Il presente documento fa parte