Vai al contenuto

Dashboard SCADA dai segnali del PLC

In questa pagina

AnyAutomation Studio può trasformare i segnali del tuo programma PLC in una dashboard web funzionante (una schermata SCADA) senza doverla costruire a mano. Scegli i segnali, li organizzi in pagine, scegli come la dashboard si connette all'impianto e invii il risultato alla tua istanza FUXA, uno SCADA web gratuito e open source. Puoi anche salvare la dashboard come file e importarla in FUXA a mano. Il tuo lavoro vive come progetto SCADA nel tuo workspace, quindi le pagine, le regole, le destinazioni a cui invii e il registro di ogni invio sono file che vedi in Esplora risorse e che puoi tenere sotto controllo di versione.

SCADA Dashboards fa parte del piano Pro quando costruisci tu le dashboard. Lasciare che l'assistente della chat ci lavori per te (vedi Lascia che sia l'assistente a costruirla) fa parte di IA per SCADA nel piano Pro+. Vedi Licenze per i piani.

Prima di iniziare

Ti servono tre cose:

  • Un'istanza FUXA ospitata da te. FUXA è un'applicazione web separata che esegue la dashboard finita. Puoi eseguirne una tu stesso, oppure lasciare che sia Studio ad avviarla per te (vedi Distribuire un'istanza FUXA più avanti).
  • Un elenco di segnali. La dashboard viene costruita dai segnali della tua macchina: i punti dati con il loro tipo di dati e il commento, più le variabili delle tue tabelle delle variabili con il loro indirizzo. Li carichi nella vista Segnali dal node set OPC UA esportato di un PLC, dal progetto TIA connesso o direttamente da una CPU in funzione. Puoi anche produrre una configurazione SCADA in Forge (contrassegna i blocchi come interfacce SCADA ed esporta una selezione).
  • Accesso all'impianto. La dashboard generata si connette a una sorgente live, tramite OPC UA, un collegamento diretto Siemens S7 o un broker MQTT.

Apri la barra laterale SCADA

Seleziona l'icona SCADA nella barra delle attività (l'icona della dashboard sul bordo sinistro) per aprire la barra laterale SCADA. Si comporta come Esplora risorse: l'icona la apre e la chiude, e anche SCADA nel menu Visualizza la apre. La barra laterale contiene cinque viste, che puoi comprimere, ridimensionare e spostare come qualsiasi altra vista:

  • Progetto: i file del progetto SCADA aperto, con le azioni per inviare e salvare.
  • Segnali: i segnali di un PLC, per selezionarli e trascinarli su una pagina.
  • Pagine: le pagine del progetto, cioè le schermate della dashboard.
  • Simboli: i tuoi simboli SVG.
  • Regole: le regole da cui vengono costruite le pagine, con i loro interruttori e il numero di corrispondenze.

Le altre parti di SCADA si trovano attorno alla barra laterale. Ogni pagina si apre nell'editor di pagina nell'area dell'editor. La vista Proprietà SCADA nella barra laterale secondaria a destra mostra le proprietà, le associazioni, gli stati e la regola dell'elemento selezionato. La scheda SCADA del pannello in basso contiene Diagnostica, Invio e Corrispondenze delle regole. La barra di stato mostra la destinazione, il proprietario della pagina, le regole e la sorgente dei segnali, e il canale SCADA della vista Output registra ciò che è stato eseguito.

Apri pagina SCADA nel riquadro comandi (Ctrl+Shift+P) apre la barra laterale e la pagina iniziale del progetto nell'editor di pagina, oppure la prima pagina quando non è impostata una pagina iniziale. Senza un progetto aperto mostra la vista Progetto, e per un progetto senza pagine la vista Pagine. Se una finestra mostrava ancora la pagina SCADA di una versione precedente di Studio, Studio apre al suo posto la barra laterale e la pagina iniziale.

Se il tuo piano non include SCADA, la barra laterale mostra solo la vista Progetto, con una nota e un link Gestisci licenza.

Lavorare in un progetto SCADA

Un progetto SCADA conserva la tua dashboard come file in una cartella a tua scelta: un file di progetto e un file di pagina per ogni pagina. Studio ricorda il progetto aperto per il workspace, così è di nuovo aperto la prossima volta che lavori in quel workspace.

La vista Progetto mostra il progetto aperto. Senza un progetto offre Crea progetto SCADA e Apri progetto SCADA. Con un progetto aperto, la prima riga indica il nome del progetto e il file da cui provengono i suoi segnali, e conta gli elenchi di testi e i file con modifiche non salvate. Quando i file del progetto presentano problemi, una seconda riga li conta e Mostra in Diagnostica apre l'elenco (vedi Diagnostica). Sotto c'è un albero dei file del progetto: il file di progetto, il file delle regole e il registro degli invii, poi le cartelle pages, symbols, texts, targets e backups. Un file con modifiche non salvate è contrassegnato come non salvato. Fai clic su un file per aprirlo; un file di pagina si apre nell'editor di pagina. L'albero segue ogni modifica nella cartella del progetto.

La barra del titolo della vista Progetto contiene Invia a FUXA, Crea progetto SCADA..., Apri progetto SCADA... e, mentre un progetto è aperto, Importa elenco di testi... (vedi Elenchi di testi). Il suo menu ... contiene Salva file FUXA..., Salva file di esportazione SCADA..., Imposta indice dello spazio dei nomi... (per una connessione OPC UA) e Chiudi progetto SCADA. Il riquadro comandi offre gli stessi comandi.

  • Creare un progetto. Scegli una cartella che non contiene ancora un progetto SCADA e inserisci un nome; il file di progetto prende quel nome. Studio scrive il file di progetto e le cartelle pages, targets, symbols, texts e backups, aggiunge una destinazione di sviluppo presa dalle tue impostazioni FUXA (mai una password) e apre il progetto. I segnali già caricati vengono copiati nel progetto. Quando non è impostato un indirizzo FUXA valido, il progetto viene creato senza destinazione e un messaggio ti chiede di impostare l'indirizzo.
  • Aprire un progetto. Scegli il suo file di progetto, che termina con .scadaproject.json. Studio carica le sue pagine, le sue destinazioni, i suoi segnali e la sua cartella dei simboli.
  • Chiudere un progetto. I file restano nella loro cartella; le viste SCADA non mostrano più il progetto né i segnali che aveva caricato.
  • Importare un piano delle schermate salvato. Carica piano schermate... nel menu ... della vista Pagine, oppure Importa piano schermate nel progetto SCADA... nel riquadro comandi, trasforma un piano delle schermate salvato in precedenza in file di pagina. Se il progetto ha già delle pagine, Studio chiede prima di sostituirle; i file di pagina che il piano non contiene vengono rimossi, e un solo Annulla ripristina tutte le pagine e l'elenco delle pagine in una volta; Studio chiede prima quando annulli da una pagina o dal file di progetto. Un messaggio elenca ogni sfondo o simbolo che si trova fuori dalla cartella del progetto, così puoi farlo puntare a un file del progetto prima di inviare.

Il progetto ricorda i suoi segnali: i segnali che carichi mentre il progetto è aperto vengono copiati nella sua cartella, e l'apertura del progetto li carica di nuovo. Ricorda anche la cartella dei simboli che scegli nella vista Simboli, purché si trovi all'interno del progetto. Anche i segnali che spunti nella vista Segnali vengono conservati con il progetto: ogni spunta è una modifica non salvata del file di progetto che puoi annullare, e una volta salvato, gli stessi segnali risultano di nuovo spuntati la prossima volta che apri il progetto.

Le modifiche che fai nelle viste SCADA, nell'editor di pagina e nella vista Proprietà arrivano subito ai file del progetto. Una modifica a un file già esistente resta non salvata finché non la salvi, come qualsiasi modifica, e puoi annullarla. Quando apri nell'editor il file di progetto o un file di destinazione, oppure un file di pagina con Apri con... nell'editor di testo, l'editor suggerisce i campi e segnala gli errori mentre scrivi.

Indica a Studio la tua istanza FUXA

L'indirizzo della tua istanza FUXA si trova nelle impostazioni. Apri la categoria SCADA delle impostazioni oppure, con un progetto aperto, fai clic sulla voce della destinazione SCADA nella barra di stato e scegli Cambia indirizzo e connessione FUXA.... Inserisci l'indirizzo, ad esempio http://localhost:1881. Se la tua istanza richiede un login, inserisci lì anche il nome utente e imposta la password con Imposta password...; viene salvata in modo sicuro e non viene mai più mostrata. Una volta salvato un login per questo indirizzo con Imposta login e ambiente della destinazione (vedi Destinazioni e ambienti più avanti), Studio accede con quel login. Il tooltip della voce della destinazione SCADA indica l'indirizzo a cui Studio invia (vedi Impostazioni per l'intera categoria SCADA).

Testa connessione FUXA, nel riquadro comandi e nelle azioni della voce della destinazione SCADA, rilegge il progetto corrente dall'istanza. Una notifica indica quanti dispositivi, viste e tag contiene, e la versione FUXA dell'istanza con l'indicazione se Studio l'ha verificata: verificata con Studio, verificata con alcune verifiche non superate, non ancora verificata con Studio, oppure sconosciuta. Se l'istanza non è raggiungibile, la notifica indica il motivo preciso; senza indirizzo offre Apri impostazioni SCADA. Per una versione non ancora verificata, con alcune verifiche non superate o sconosciuta, compare un avviso una volta per versione mentre la finestra è aperta; nulla viene bloccato e puoi continuare a inviare. Se hai installato FUXA direttamente su questo computer, scegli la sua cartella in Cartella di installazione FUXA nelle impostazioni, e Studio legge la versione esatta da quella cartella invece di chiederla all'istanza in esecuzione. La versione nella barra di stato è quella trovata dall'ultimo invio a quell'indirizzo; il test non la modifica.

Apri FUXA apre l'istanza in una scheda del browser all'interno di Studio, così puoi osservare la dashboard accanto al tuo lavoro. Lo trovi nelle azioni della voce della destinazione SCADA, nella vista Invio del pannello SCADA e nei messaggi dopo un invio o una distribuzione. Apri FUXA nel browser di sistema nelle azioni della destinazione apre invece l'istanza nel tuo browser abituale.

Destinazioni e ambienti

Una destinazione è un'istanza FUXA a cui viene inviato il tuo progetto, insieme al suo ambiente: Sviluppo mentre costruisci, Test per verificare il progetto prima che entri in funzione e Produzione per l'impianto in esercizio. Ogni destinazione è un file nella cartella targets del progetto, uno per ambiente (dev.json, test.json e prod.json), con l'indirizzo dell'istanza e, se vuoi, la versione FUXA minima che accetta; un invio a un FUXA più vecchio mostra un avviso e prosegue. Una destinazione non contiene mai una password. La creazione di un progetto scrive la destinazione di sviluppo dalle tue impostazioni. Per aggiungere un sistema di test o di produzione, copia la destinazione di sviluppo, cambia il suo ambiente e il suo indirizzo e aggiungila alle destinazioni elencate nel file di progetto; l'editor suggerisce i campi. Apri file di destinazione nelle azioni della voce della destinazione SCADA apre la destinazione dell'indirizzo FUXA corrente.

Studio invia all'Indirizzo FUXA nelle impostazioni SCADA, e la destinazione con quell'indirizzo decide l'ambiente dell'invio; la voce della destinazione SCADA nella barra di stato mostra quell'ambiente. Per inviare al tuo sistema di test, imposta l'Indirizzo FUXA sull'indirizzo della sua destinazione, oppure scegli quella destinazione nella finestra di invio (vedi La finestra di invio più avanti). Un indirizzo senza destinazione conta come sviluppo, a meno che tu non abbia salvato un altro ambiente per esso. Il modo in cui la dashboard generata si connette all'impianto deriva comunque dalle impostazioni Connessione all'impianto.

Una destinazione può anche indicare come la dashboard raggiunge ogni PLC del progetto, nella sua mappatura dei dispositivi: per ogni PLC la connessione (OPC UA, Siemens S7 o MQTT) e il suo indirizzo, per OPC UA la modalità di sicurezza, la policy e l'utente, e per Siemens S7 il rack e lo slot. Studio connette quindi ogni PLC come indica la sua voce, e un PLC che la destinazione non elenca usa le impostazioni Connessione all'impianto. Se una destinazione elenca dei PLC ma ne omette uno usato dalla dashboard, Studio non invia e indica il PLC mancante. Aggiungi il PLC mancante con la sua connessione alla destinazione, oppure rinomina una voce della destinazione in modo che corrisponda. Quando scegli un'altra destinazione nella finestra di invio, Studio ricostruisce la dashboard per i PLC di quella destinazione. Una destinazione creata dalle tue impostazioni precedenti elenca già il tuo unico PLC, quindi continua a funzionare senza modifiche. La password OPC UA che imposti nelle impostazioni vale per ogni PLC che accede con un utente.

Imposta login e ambiente della destinazione nel riquadro comandi, disponibile anche nelle azioni della voce della destinazione SCADA, registra, una volta per istanza, il login che Studio usa e l'ambiente che confermi per essa. Scegli l'istanza tra le destinazioni del progetto, prendi l'indirizzo FUXA dalle impostazioni oppure inserisci un altro indirizzo. Poi scegli l'ambiente e inserisci il nome utente (lascialo vuoto quando l'istanza consente l'accesso anonimo) e la password. La password viene salvata in modo sicuro e non viene mai più mostrata; quando esegui di nuovo il comando per lo stesso utente, lascia vuota la password per mantenere quella salvata. Per l'indirizzo FUXA delle impostazioni, il nome utente e la password che inserisci qui diventano anche quelli delle impostazioni Istanza FUXA. Cancella login e ambiente della destinazione rimuove ciò che hai salvato per un'istanza.

Studio verifica l'ambiente a ogni invio:

  • A una destinazione di sviluppo si può inviare senza un login e un ambiente salvati.
  • Una destinazione di test o di produzione viene rifiutata finché non hai salvato il suo login e il suo ambiente.
  • Quando l'ambiente nei file di destinazione e l'ambiente che hai salvato non coincidono, l'invio viene rifiutato finché non ne correggi uno; il messaggio li indica entrambi.
  • L'invio a una destinazione di produzione chiede sempre una seconda conferma (vedi Cosa succede a ogni invio più avanti).

Caricare i segnali

La vista Segnali porta nel progetto i segnali di un PLC. Finché non sono caricati segnali, offre i modi per caricarli, e le stesse azioni si trovano nella sua barra del titolo:

  • Carica file node set... carica un node set esportato in precedenza da una CPU.
  • Carica da progetto TIA... esporta il node set OPC UA di una CPU del progetto TIA connesso e lo carica. È disponibile non appena Studio è connesso a TIA Portal, anche se Esplora progetto non è mai stato aperto; mentre Studio sta ancora leggendo il progetto, attende finché le CPU non sono note.
  • Carica da CPU... legge i segnali direttamente da una CPU in funzione tramite la sua connessione PLC / OPC UA (vedi Caricare i segnali da una CPU in funzione più avanti).

Mentre è in corso un caricamento, le azioni di caricamento non sono disponibili, quindi non può partire un secondo caricamento. Un messaggio indica quanti blocchi dati sono stati caricati e da dove; un file che non è un node set, o che non contiene blocchi dati, riceve un errore che lo dice. Con un progetto SCADA aperto, i segnali caricati diventano la sorgente dei segnali del progetto: Studio li copia nella cartella del progetto, e il messaggio indica il file che il progetto ora usa.

Se hai prodotto una configurazione SCADA in Forge, apri invece quel file con Genera progetto FUXA (vedi I due comandi sui file più avanti).

Caricare i segnali da una CPU in funzione

Seleziona Carica da CPU... nella barra del titolo della vista Segnali, oppure esegui SCADA: Carica segnali da CPU... nel riquadro comandi. Quando ci sono CPU connesse in PLC / OPC UA, scegline una dall'elenco; la CPU da cui provengono i segnali caricati è elencata per prima. Quando nessuna CPU è ancora connessa, oppure quando scegli Connetti a un'altra CPU in PLC / OPC UA..., si apre PLC / OPC UA e una notifica attende finché non ti connetti lì alla CPU. I segnali si caricano non appena la connessione è attiva, e puoi annullare l'attesa. Connettiti alla CPU con OPC UA in PLC / OPC UA: quando la connessione non usa OPC UA, un messaggio lo dice e il caricamento termina. Una notifica di avanzamento conta i nodi letti, e puoi annullarla.

Studio legge soltanto la CPU e non vi scrive mai. All'interno di un progetto SCADA i segnali vengono salvati come file del progetto, così il progetto si riapre anche senza connessione. I segnali letti da una CPU non hanno commenti, quindi i token nei commenti come unità, limiti e allarmi, e le regole che guardano i commenti, richiedono un file node set o l'esportazione del progetto TIA. Quando alcuni segnali riportano un tipo di dati che Studio non sa nominare, vengono caricati senza tipo di dati e non possono essere associati su una pagina; un avviso lo segnala, e il canale SCADA della vista Output li elenca. Se la lettura potrebbe essere incompleta, un avviso ti chiede di caricare di nuovo i segnali. Il caricamento da una CPU richiede nel tuo piano PLC / OPC UA oltre a SCADA.

Selezionare e trovare i segnali

Una volta caricati, la vista Segnali elenca i segnali per blocco dati e struttura. La sua intestazione mostra quanti sono selezionati e da dove provengono, ad esempio 12 of 340 selected, PLC_1.xml. Ogni riga contiene:

  • una casella di controllo: spunta i segnali che vuoi sulla dashboard. La casella di una struttura o di un blocco dati seleziona o deseleziona tutto ciò che contiene, e una selezione parziale mostra uno stato misto;
  • una maniglia di trascinamento, per trascinare la riga su una pagina (vedi Rilasciare segnali e simboli su una pagina più avanti);
  • il nome e il tipo di dati di un segnale;
  • per una struttura o un blocco dati, un chip con il nome del suo tipo: fai clic per mostrare ogni struttura esattamente di quel tipo;
  • RW per un segnale che un widget può scrivere nel PLC, e Nessun accesso per un segnale che il server OPC UA non legge né scrive;
  • Perché? per un segnale mostrato da un widget di una pagina: spiega quel widget (vedi Spiegare un widget più avanti), oppure ti fa scegliere quando più widget lo mostrano.

La casella di filtro sopra l'albero filtra per nome e per nome del tipo. Digita type: seguito dal nome di un tipo per mostrare esattamente le strutture di quel tipo, come fa il chip del tipo; qui maiuscole e minuscole contano. Un badge conta le corrispondenze. Mentre un filtro è attivo, Seleziona tutti i segnali e Cancella selezione segnali nella barra del titolo agiscono solo sui segnali filtrati, quindi un chip del tipo seguito da Seleziona tutti i segnali seleziona ogni segnale nelle strutture di quel tipo. Espandi tutto e Comprimi tutto si trovano nel menu .... Da tastiera, Space spunta o toglie la spunta dalla riga con lo stato attivo, e Tab passa ai suoi chip.

Senza pagine, la dashboard viene costruita dai segnali spuntati, e Proponi schermate costruisce pagine a partire da essi.

Scegliere come si connette la dashboard

La Connessione nelle impostazioni SCADA (in Connessione all'impianto) sceglie come la dashboard finita raggiunge l'impianto, e Indirizzo accetta l'indirizzo corrispondente. L'Indirizzo inizialmente è vuoto e mostra un esempio per la connessione scelta finché non inserisci il tuo; fino ad allora, l'invio o il salvataggio indica l'indirizzo mancante e non genera nulla. Il tooltip della voce della destinazione SCADA nella barra di stato mostra la connessione e l'indirizzo che la dashboard userà.

  • Server OPC UA (il valore predefinito). Inserisci l'URL dell'endpoint OPC UA del PLC, ad esempio opc.tcp://192.168.0.5:4840. Nelle impostazioni compaiono un Indice dello spazio dei nomi e una sezione Sicurezza OPC UA: scegli la sicurezza dei messaggi (None, Sign oppure Sign and Encrypt) e, quando non è None, una policy e un nome utente facoltativo con una password salvata. Il PLC deve considerare attendibile il certificato client di FUXA; nella tua CPU, aggiungilo ai client attendibili del server OPC UA oppure consenti di accettare i client in fase di esecuzione. Un progetto SCADA aperto mantiene un proprio indice dello spazio dei nomi: i segnali che carichi portano il loro indice nel progetto, e Imposta indice dello spazio dei nomi... nel menu ... della vista Progetto lo modifica (un numero intero da 0 a 65535). Senza progetto, i segnali caricati portano il proprio indice.
  • PLC Siemens S7. Inserisci l'indirizzo IP del PLC e imposta Rack e Slot (S7-1200 e S7-1500 usano rack 0 e slot 1). Vengono inclusi solo i segnali che hanno un indirizzo hardware fisso, cioè merker, ingressi e uscite delle tabelle delle variabili e indirizzi assoluti dei blocchi dati. I membri simbolici dei blocchi dati non hanno un indirizzo fisso e vengono esclusi; un messaggio elenca ciò che è stato escluso, e quei segnali richiedono invece una connessione OPC UA.
  • Broker MQTT. Inserisci l'URL del broker, ad esempio mqtt://192.168.0.20:1883. Ogni segnale diventa un topic con il suo nome, e la dashboard si sottoscrive a esso. Un segnale di lettura/scrittura rimanda anche il suo valore al proprio topic quando lo modifichi sulla dashboard da un campo di input o da un pulsante. Per leggere un valore da un messaggio JSON anziché da un intero topic, oppure per impostare quale topic usa un segnale, aggiungi un token al commento del segnale (vedi Leggere un membro JSON o impostare il topic più avanti).

I pulsanti Imposta password... e Cancella password della sezione Sicurezza OPC UA (disponibili anche come Imposta la password OPC UA e Cancella la password OPC UA nel riquadro comandi) gestiscono la password di login OPC UA quando ne usi una.

Leggere un membro JSON o impostare il topic

In una dashboard MQTT, due token nel commento di un segnale ti danno più controllo. Si scrivono come i token di unità e di allarme e vengono rimossi dall'etichetta mostrata sulla dashboard:

  • {topic=plant/motor1/status} imposta il topic esatto usato dal segnale, invece del nome del segnale. In questo modo più segnali possono puntare a percorsi di topic strutturati.
  • {jsonkey=speed} associa il segnale al membro speed di un messaggio JSON sul topic, invece che a un intero valore del topic. Più segnali possono condividere un topic con chiavi diverse, ognuno leggendo il proprio membro. Un segnale di lettura/scrittura con una chiave riscrive quel membro.

Un segnale invia allo stesso topic da cui legge, quindi un segnale corrisponde a un topic. Un topic di comando e un topic di stato separati sono due segnali separati.

Più PLC

Un progetto può leggere i segnali di più di un PLC, ad esempio il PLC di una linea e il PLC di una macchina di confezionamento. Elenca ogni PLC una volta tra le sorgenti dei segnali del file di progetto, con un nome breve tutto suo, il file dei segnali che legge e, se serve, il suo indice dello spazio dei nomi; l'editor suggerisce i campi. La prima voce è il PLC predefinito del progetto. Un progetto con un solo PLC non ha bisogno di questo elenco. Ogni PLC ha una propria voce nelle destinazioni (vedi Destinazioni e ambienti sopra) e un proprio allarme di connessione (vedi L'allarme di connessione più avanti).

  • Una pagina legge il PLC predefinito, a meno che tu non scelga un altro PLC per essa.
  • Un widget mostra i segnali di un solo PLC: il proprio, oppure il PLC della sua pagina. Lo sfondo della pagina segue il PLC della sua pagina.
  • Gli Allarmi dai commenti dei segnali e dalle regole di allarme vengono generati per il PLC predefinito. Un token di allarme nel commento di un segnale di un altro PLC viene escluso, e la vista Diagnostica lo segnala.
  • I segnali spuntati della vista Segnali, da cui Proponi schermate costruisce le pagine e da cui viene costruita una dashboard senza pagine, devono provenire da un solo PLC. Quando provengono da più PLC, Studio rifiuta e lo dice; posiziona i segnali degli altri PLC sulle pagine nell'editor di pagina o con l'assistente.

Quando le schermate di un progetto vengono riscritte per intero, ad esempio dall'assistente, ogni pagina che rimane mantiene il suo PLC e i suoi ruoli, e un allarme mantiene i suoi ruoli quando cambia il suo livello.

I PLC nella vista Segnali

Quando un progetto legge più PLC, la vista Segnali mostra ogni PLC come riga propria sopra i suoi blocchi dati, con il PLC predefinito per primo. La riga indica il nome del PLC, la sua connessione e il suo indirizzo nella destinazione, e quanti dei suoi segnali sono spuntati. Un PLC che la destinazione non elenca è contrassegnato come Non assegnato e viene connesso con le impostazioni SCADA. Spunta la casella di un PLC per selezionare tutti i suoi segnali.

Il PLC di una pagina e di un widget

  • Pagina. Con la pagina selezionata, la scheda Proprietà della vista Proprietà mostra il suo PLC; fai clic su Cambia... per scegliere quale PLC legge la pagina. La stessa scelta è Imposta PLC della pagina... nel menu di un punto vuoto della pagina nell'editor di pagina, e nel riquadro comandi. Gli slot dei widget che non hanno un PLC proprio seguono la pagina. Se uno dei loro segnali non esiste sul PLC scelto, la pagina mantiene il suo PLC e un avviso indica i segnali mancanti: associa prima quegli slot a segnali del PLC scelto, oppure scegli il PLC dei loro widget nella scheda Associazioni. Se la pagina ha slot di questo tipo e non sono caricati segnali, mantiene anch'essa il suo PLC. Dopo una modifica, un messaggio indica quale PLC legge ora la pagina e quanti slot dei suoi widget si sono spostati con essa.
  • Widget. La scheda Associazioni mostra nella sua colonna PLC quale PLC legge ogni slot. Fai clic su PLC... per passare il widget a un altro PLC; la modifica vale per ogni slot associato del widget, perché un widget mostra i segnali di un solo PLC.
  • Rilasciare segnali. Puoi rilasciare su una pagina segnali di qualsiasi PLC. Un segnale di un altro PLC rilasciato su un widget, oppure uno stato di una parte dello sfondo di un PLC diverso da quello della pagina, viene rifiutato finché non passi il widget a quel PLC. Assegna variabile... elenca i segnali di ogni PLC, con il PLC accanto a ciascun segnale.
  • Barra di stato. Il tooltip della destinazione SCADA elenca ogni PLC con la sua connessione, e indica un PLC che la destinazione non elenca come connesso con le impostazioni.
  • Diagnostica. I problemi relativi ai PLC del progetto hanno la categoria PLC (vedi Diagnostica più avanti).

Una vista di dettaglio non ha un PLC proprio; legge il PLC della struttura che la apre (vedi Viste di dettaglio più avanti).

Organizzare le pagine

Per impostazione predefinita la dashboard è una semplice tabella dei valori dei segnali spuntati. Per costruire una dashboard strutturata con più pagine, apri o crea un progetto SCADA e usa la vista Pagine. Ogni pagina è un file di pagina nella cartella pages del progetto.

La vista Pagine elenca per prima la pagina iniziale, contrassegnata come pagina iniziale, insieme alle altre pagine di panoramica; poi le pagine di processo, le pagine dei dispositivi (raggruppate in Pagine dei dispositivi quando sono più di otto) e le pagine che contengono una tabella degli allarmi. Ogni riga mostra il nome della pagina, il suo id e un chip del proprietario: Studio per una pagina che costruisce Studio, Editor del runtime per una pagina che appartiene all'editor nel browser del runtime, che Studio mostra in sola lettura ed esclude da ogni invio (vedi Unire o sostituire più avanti); il tooltip del chip dice da quando. Un file di pagina con problemi è contrassegnato con presenta problemi. Fai clic su una pagina per aprirla nell'editor di pagina; selezionare una pagina, con il mouse o con i tasti freccia, mostra anche i suoi campi nella vista Proprietà e il suo proprietario nella barra di stato.

  • Nuova pagina... chiede un nome, crea la pagina con un id ricavato dal nome e la apre.
  • Proponi schermate trasforma i segnali spuntati in pagine: una pagina di panoramica con riquadri di navigazione, una pagina per ogni modulo macchina di primo livello e pagine di dettaglio per i gruppi grandi. Se il progetto ha già delle pagine, Studio chiede prima di sostituirle, e un solo Annulla ripristina l'intera modifica; Studio chiede prima quando annulli da una pagina o dal file di progetto.
  • Applica regole costruisce le pagine dalle regole (vedi Assegnare i widget con le regole più avanti).
  • Nel menu ..., Salva piano schermate... scrive le pagine in un file di piano, Carica piano schermate... importa un piano salvato (vedi Lavorare in un progetto SCADA sopra) e Svuota piano schermate rimuove tutte le pagine del progetto dopo aver chiesto conferma.
  • Con un progetto EPLAN aperto in Studio, Proponi schermate per struttura EPLAN... nel menu ... costruisce le pagine seguendo la struttura dell'impianto di EPLAN. Scegli Luogo di montaggio, Assegnazione funzionale o Impianto, e i segnali spuntati ricevono una pagina per ciascuna di queste strutture, con il suo nome e la sua descrizione EPLAN, ad esempio +A1 Feed. I segnali che EPLAN conosce senza quella struttura finiscono in Nessuna struttura EPLAN, gli altri in Non in EPLAN. Un segnale viene trovato in EPLAN quando il suo nome è l'indirizzo simbolico in EPLAN o il nome della variabile TIA del segnale, oppure quando il suo nome o il suo commento contiene la sigla del dispositivo EPLAN, ad esempio =GL1+A1-QA1. Come con Proponi schermate, Studio chiede prima di sostituire le pagine esistenti. Richiede una licenza EPLAN (Pro+ o Enterprise).
  • Fai clic con il tasto destro su una pagina per Rinomina pagina... (F2), Imposta come pagina iniziale, Sposta pagina in alto e Sposta pagina in basso (Alt+Up e Alt+Down, all'interno del suo gruppo) ed Elimina pagina (Delete). Rinominare una pagina, qui o nel campo Nome della vista Proprietà, rinomina anche i riquadri di navigazione e i pulsanti che la aprono e che portano ancora il suo vecchio nome come etichetta; un'etichetta che hai modificato tu resta, e un solo Annulla ripristina entrambi. L'eliminazione chiede prima conferma, e la domanda elenca ciò che viene rimosso: il file della pagina, la voce della pagina nel progetto e nella navigazione e, quando altre pagine hanno pulsanti o riquadri che aprono questa pagina, quali di essi non la aprono più e quali vengono rimossi perché aprire questa pagina era tutto ciò che facevano. Annulla ripristina tutto in una volta. La pagina iniziale può essere eliminata solo quando un'altra pagina è la pagina iniziale. Una pagina il cui file è scomparso, ad esempio perché è stato eliminato fuori da Studio, può essere eliminata allo stesso modo; facendo clic su di essa compare un messaggio invece di aprirla. I tasti funzionano mentre una pagina dell'elenco ha lo stato attivo; sulla riga del gruppo delle pagine dei dispositivi, Delete e F2 non fanno nulla.

Ogni modifica è una modifica non salvata dei file di pagina e di progetto che puoi annullare. Senza pagine, la vista offre Proponi schermate, Applica regole e Nuova pagina.

Una pagina ha un layout: Riquadri, Sezioni, Tabella o Libero. L'editor di pagina passa una pagina al layout libero non appena sposti o ridimensioni un widget, rilasci dei segnali su uno spazio vuoto o vi rilasci un simbolo. Per scegliere un altro layout, o per dare alla pagina un'immagine di sfondo (un SVG dalla cartella del progetto, per esempio un disegno dell'impianto esportato da uno strumento di progettazione), impostalo nel file della pagina o chiedilo all'assistente. Lo sfondo resta dietro i widget, e tutto ciò che nel suo file non è sicuro viene rimosso prima dell'uso.

Finché il progetto ha delle pagine, l'invio e il salvataggio costruiscono la dashboard multipagina pianificata invece della semplice tabella.

La cartella dei simboli

La vista Simboli mostra i tuoi simboli SVG come riquadri: un piccolo disegno di ogni simbolo, il suo nome (il suo percorso nella cartella senza .svg, ad esempio pumps/pump) e quanti stati gli assegna il suo manifest. Scegli cartella dei simboli... nella sua barra del titolo carica una cartella di simboli, compresi quelli conservati nelle sottocartelle, così una libreria di simboli annidata viene acquisita per intero. Un messaggio indica quanti simboli sono stati caricati e quanti file sono stati saltati, e la vista continua a mostrare quanti simboli contiene la cartella e quanti file non è stato possibile usare. Quando alcuni file sono stati saltati, un avviso indica ciascuno di essi con il suo primo problema e conta quelli oltre i primi cinque. Tieni la cartella all'interno del progetto, così il progetto la ricorda e i file di pagina possono usare i suoi simboli; per una cartella fuori dal progetto la vista indica che i file di pagina non possono fare riferimento ai suoi simboli. Trascina un riquadro su una pagina per posizionare il simbolo (vedi Rilasciare segnali e simboli su una pagina più avanti). Esporta simboli in FUXA scrive la libreria in un FUXA che hai installato direttamente (vedi I tuoi simboli nell'editor di FUXA più avanti).

Un simbolo semplice trasforma il suo widget in un interruttore on/off associato che usa i suoi colori di spento e acceso; un simbolo con associazioni di stato segue invece queste (vedi Simboli con stati più avanti).

Modifica una pagina nell'editor di pagina

Un file di pagina si apre nell'editor di pagina: dalla vista Pagine, dalla vista Progetto, da Esplora risorse o con Apri pagina SCADA. La scheda mostra l'id della pagina; Apri con... offre invece l'editor di testo per il file di pagina. L'editor di pagina mostra la pagina come la costruisce l'invio: un'unica immagine dell'intera pagina, con una cornice sopra ogni widget.

La barra degli strumenti contiene, da sinistra a destra:

  • Seleziona: fai clic su un widget per selezionarlo, Shift+clic per aggiungerne o rimuoverne uno, e trascina su uno spazio vuoto per selezionare ogni widget toccato dal rettangolo.
  • Sposta la vista: trascina per spostare la vista della pagina. Tenendo premuto Space ottieni lo stesso effetto con qualsiasi strumento.
  • Griglia: mostra una griglia di 10 pixel; i widget spostati e ridimensionati vi si agganciano finché è visibile.
  • Inserisci widget...: inserisce una tabella degli allarmi, una tabella dei messaggi o un riquadro di navigazione (vedi Inserisci un widget più avanti). Non è disponibile su una pagina di sola lettura né nell'anteprima.
  • Applica regole e Anteprima (vedi Anteprima più avanti).
  • Invia a FUXA e Visualizza in FUXA (vedi Visualizza in FUXA più avanti).
  • Riduci, Ingrandisci, Zoom al 100 % e Adatta alla vista, con il livello di zoom. La rotellina del mouse esegue lo zoom nel punto del puntatore.
  • Mostra proprietà: apre la vista Proprietà per il widget selezionato, anche quando la barra laterale secondaria è nascosta.

Per spostare e ridimensionare i widget:

  • Trascina un widget, o l'intera selezione, per spostarlo.
  • Trascina una delle otto maniglie di un singolo widget selezionato per ridimensionarlo. Tieni premuto Shift per mantenerne le proporzioni e premi Escape per annullare.
  • I tasti freccia spostano la selezione di 1 pixel, o di 10 con Shift. Mentre la griglia è visibile, la spostano di un passo di griglia, o di cinque passi di griglia con Shift, e il widget selezionato si aggancia alla griglia; gli altri widget selezionati mantengono la loro distanza da esso.
  • Delete o Backspace elimina la selezione.
  • Ctrl+A seleziona tutti i widget, Ctrl+Right e Ctrl+Left selezionano il widget successivo e quello precedente, e Escape annulla la selezione.
  • Fai clic con il pulsante destro su un widget, oppure premi Shift+F10 o il tasto Menu sul widget selezionato, per aprirne il menu: Assegna variabile..., Rimuovi associazione, Salva come predefinito del simbolo, Salva come regola per tutti quelli del suo tipo, Deriva regola dal widget e Mostra proprietà. Ogni voce compare solo sui widget su cui funziona; Rimuovi associazione non viene offerta quando il widget non può esistere senza il segnale del suo slot. Su una pagina che puoi modificare, il menu offre anche Inserisci widget....
  • Fai clic con il pulsante destro su uno spazio vuoto della pagina, oppure premi Shift+F10 o il tasto Menu senza alcun widget selezionato, per aprire il menu della pagina. Offre Inserisci widget... e lascia la selezione com'è.

Ogni gesto è una sola modifica che un solo Annulla revoca (Ctrl+Z, e Ctrl+Y per ripetere, mentre la pagina ha il focus), e le tue modifiche restano non salvate finché non salvi la pagina. Se premi Annulla più volte delle modifiche fatte e raggiungi una modifica che ha toccato più file, come Applica regole, un piano delle schermate nuovo o importato o l'eliminazione di una pagina, Studio chiede prima, per esempio "Vuoi annullare 'Applica regole SCADA'?". No lascia tutto com'è; Sì revoca l'intera modifica in una volta. Ripeti non chiede nulla. Una pagina con il layout Riquadri, Sezioni o Tabella passa al layout libero al primo spostamento o ridimensionamento, o quando rilasci per la prima volta segnali su uno spazio vuoto o un simbolo su di essa, e ogni widget mantiene la posizione che ha sullo schermo. Una modifica che il file di pagina non può accettare non viene applicata: un avviso ne indica il motivo e il widget torna dove lo prevede il file.

L'immagine ti dice come verrà la pagina. Un widget che l'invio tralascerebbe ha una cornice rossa tratteggiata, e un simbolo continua a mostrare il suo disegno al suo interno. Un controllo che FUXA disegna da sé (un cursore, un grafico, una tabella degli allarmi, una tabella dei messaggi, una selezione, un campo di input, un indicatore o un'immagine) ha una cornice grigia tratteggiata. All'interno di quella cornice, una tabella degli allarmi mostra la sua etichetta e ciò che il suo filtro lascia passare (i livelli, il testo, il gruppo e il numero di segnali, oppure Tutti gli allarmi), e una tabella dei messaggi mostra la sua etichetta, una riga di intestazione con le etichette delle colonne e quanti slot di quale buffer mostra; il runtime le riempie entrambe con gli allarmi live e gli slot del buffer. Un badge numerico conta le segnalazioni di un widget, e il suo tooltip spiega ogni segnalazione in una frase. Sotto la pagina, una legenda riassume la pagina (i suoi widget, quelli tralasciati e quelli disegnati dal runtime) ed elenca ogni widget che ha una segnalazione, con le sue segnalazioni in frasi; fai clic su una riga per selezionare il widget. Quando non è possibile costruire alcuna immagine, per esempio prima che i segnali siano caricati, la legenda ne spiega il motivo, i simboli mostrano il loro disegno e gli altri widget mostrano la loro etichetta in un riquadro tratteggiato. Per un momento dopo una modifica, finché Studio non l'ha recepita, l'immagine è attenuata e una nota lo segnala.

Inserisci un widget

Per aggiungere una tabella degli allarmi, una tabella dei messaggi o un riquadro di navigazione, fai clic su Inserisci widget... nella barra degli strumenti, oppure fai clic con il pulsante destro sulla pagina, su un widget o su un punto vuoto, e scegli Inserisci widget.... Mentre un editor di pagina è attivo, il comando si trova anche nel riquadro comandi. Un elenco chiede quale widget vuoi:

  • Riquadro di navigazione: un secondo elenco chiede la pagina che il riquadro apre (la pagina che stai modificando non viene offerta), e il riquadro prende come etichetta il nome di quella pagina.
  • Tabella degli allarmi: imposta il suo filtro in seguito nella vista Proprietà (vedi Proprietà più avanti).
  • Tabella dei messaggi: un secondo elenco offre i buffer dei messaggi presenti nei segnali caricati, ciascuno con il suo numero di slot e i suoi membri. La tabella parte con le colonne Time, Module, Number e Additional Info, che puoi modificare nella vista Proprietà (vedi Tabella dei messaggi più avanti).

Il widget viene posizionato dove hai fatto clic con il pulsante destro, altrimenti al centro della parte visibile della pagina, e sempre all'interno della pagina. Una pagina con il layout Riquadri, Sezioni o Tabella passa al layout libero. Il nuovo widget viene selezionato, la vista Proprietà si apre accanto alla pagina e un solo Annulla revoca l'inserimento. Un messaggio interrompe l'inserimento quando non sono caricati segnali, quando i segnali non contengono alcun buffer dei messaggi, quando il progetto non ha un'altra pagina che un riquadro di navigazione possa aprire, o quando la pagina è diventata di sola lettura mentre l'elenco era aperto.

Anteprima

Anteprima esegue la pagina nell'editor di pagina senza scrivere nulla. Fai clic su un widget che apre una pagina come scheda, per esempio la pagina di un dispositivo, e la scheda compare centrata sopra la pagina attenuata; fai clic su un pulsante o su un riquadro che apre un'altra pagina, e viene mostrata quella pagina. Escape chiude una scheda, poi torna alla pagina che stai modificando. FUXA sposta una scheda di 48 pixel verso l'alto quando la sua navigazione è nascosta; l'anteprima no.

Sotto la pagina, Valori simulati degli slot elenca gli slot associati del widget selezionato, ciascuno con un campo. Digita un numero, true o false, e la pagina mostra i colori, la visibilità e la variante prodotti da quel valore. Per uno slot che mostra un bit di un segnale, true o un numero diverso da 0 imposta quel bit e false o 0 lo azzera. Una parte lampeggiante mostra il suo primo colore di lampeggio, e le parti che si spostano o ruotano restano ferme. Quando un valore non cambia nulla, il campo ne spiega il motivo. Seleziona di nuovo Anteprima per tornare alla modifica.

Visualizza in FUXA

Visualizza in FUXA apre questa pagina sul target di sviluppo del progetto in una scheda del browser all'interno di Studio, così puoi confrontarla con la dashboard in esecuzione dopo un invio. Quando il progetto non ha un target di sviluppo, un messaggio lo segnala, e quando la pagina non può essere aperta, un messaggio ne spiega il motivo.

Pagine di sola lettura

L'editor di pagina mostra una pagina in sola lettura, con un banner che ne spiega il motivo, quando la pagina appartiene all'editor nel browser del runtime (proprietario Editor del runtime, vedi Unisci o sostituisci), quando il tuo piano non include SCADA, o quando il file di pagina stesso è di sola lettura. Puoi selezionare widget e usare l'anteprima, ma non è possibile spostare, rilasciare o modificare nulla. Nemmeno Proponi schermate e Carica piano delle schermate... riscrivono una pagina dell'editor FUXA: un messaggio indica la pagina e non viene modificato nulla. Un file di pagina che non può essere letto mostra il suo primo problema; aprilo nell'editor di testo per ripararlo.

Rilascia segnali e simboli su una pagina

Trascina segnali, strutture o blocchi dati dalla vista Segnali su una pagina nell'editor di pagina. Mentre trascini sopra la pagina, una cornice indica dove verranno rilasciati, che si tratti di un widget, di una parte di un simbolo, di una parte dello sfondo della pagina o dell'intera pagina, e un breve testo dice cosa farà il rilascio, per esempio Posiziona 3 widget, Associa slot fault o Aggiungi uno stato alla parte badge. Quando il rilascio non è possibile, il testo indica invece il motivo, per esempio BOOL previsto, REAL trascinato, e non viene rilasciato nulla.

  • Su uno spazio vuoto, Studio posiziona i widget che le regole assegnano ai segnali, in una griglia a partire dal punto in cui li rilasci, all'interno della pagina. Una pagina con il layout Riquadri, Sezioni o Tabella passa al layout libero, e i suoi altri widget mantengono le loro posizioni.
  • Su un simbolo, il segnale viene associato all'unico slot libero del simbolo adatto a esso. Quando sono adatti più slot, o quando tieni premuto Alt durante il rilascio, un elenco Associa segnale a uno slot ti permette di scegliere lo slot, anche uno slot già associato, il cui segnale viene allora sostituito. Una struttura rilasciata su un simbolo riempie tutti gli slot che può, e un messaggio dice quanti slot sono stati associati.
  • Un segnale intero su uno slot sì o no: Studio chiede quale bit dell'intero mostra lo slot.
  • Su una parte di un simbolo che non ha ancora uno stato, Studio chiede cosa cambia il segnale: Colore di riempimento, Colore del contorno, Visibilità, Lampeggio, Rotazione continua, Rotazione in base al valore, Spostamento in base allo stato o Posizione in base al valore. Aggiunge uno stato con un primo insieme di valori, seleziona il widget e apre la scheda Stati della vista Proprietà con il nuovo stato evidenziato, così puoi regolare i valori.
  • Su una parte dello sfondo della pagina, accade lo stesso per la parte dello sfondo. Un widget sulla pagina deve già mostrare il segnale.

Ogni rilascio è un passo di Annulla e lascia la pagina non salvata, e un'utilità per la lettura dello schermo annuncia il risultato. Dopo che hai associato un segnale, il messaggio offre Salva come regola per tutti i tipo (vedi Riutilizza un'associazione più avanti). Se invece li rilasci in un editor di testo, i segnali vengono inseriti come percorsi, uno per riga.

I simboli della vista Simboli si rilasciano allo stesso modo: trascina un riquadro su una pagina e una cornice delle dimensioni del simbolo mostra dove verrà posizionato. Come un rilascio di segnali su uno spazio vuoto, fa passare al layout libero una pagina impaginata. Un simbolo di un altro progetto SCADA, un simbolo che non si trova nella cartella dei simboli o un rilascio su una pagina di sola lettura vengono rifiutati, e la cornice ne indica il motivo.

Assegna una variabile da tastiera

Seleziona il widget, premi Shift+F10 o il tasto Menu e scegli Assegna variabile.... Scegli lo slot quando il widget ne ha più di uno, poi un segnale tra quelli caricati il cui tipo di dati sia adatto; per uno slot associato, il segnale che scegli sostituisce quello che mostra. Per un segnale intero su uno slot sì o no, inserisci il numero del bit. Assegna variabile... si trova anche nella scheda Associazioni della vista Proprietà e nel riquadro comandi. Dal riquadro comandi, i comandi di associazione agiscono sul widget selezionato nell'editor di pagina; solo senza una selezione chiedono la pagina e il widget. È offerto su ogni widget che può mostrare un segnale, il che esclude immagini, riquadri di navigazione e tabelle degli allarmi.

Rimuovi associazione svuota di nuovo uno slot. L'applicazione delle regole non riempie di nuovo quello slot. Uno slot senza il quale il widget non può esistere, come il valore di un visualizzatore di valori o di una lampada, non può essere svuotato; scegli invece un altro segnale per esso.

Riutilizza un'associazione

  • Salva come predefinito del simbolo scrive gli slot e gli stati di un widget simbolo nel manifest del suo simbolo, così ogni nuovo utilizzo del simbolo parte con essi. Il manifest resta non salvato finché non lo salvi.
  • Salva come regola per tutti quelli del suo tipo aggiunge in cima al file delle regole una regola che crea questo widget, con le sue associazioni, per ogni segnale dello stesso tipo. Richiede un segnale associato la cui struttura abbia un nome di tipo. La nuova regola mette ogni struttura di quel tipo sulla pagina del proprio blocco dati e lascia la pagina di un singolo segnale alle altre regole; il widget da cui l'hai salvata resta sulla sua pagina.
  • Deriva regola dal widget aggiunge una regola esattamente per il segnale che questo widget mostra, con le sue associazioni, la sua etichetta e la sua pagina.

Entrambi i comandi di regola richiedono che i segnali del progetto siano caricati, e aprono il file delle regole sulla nuova regola. Il widget stesso viene preso in carico dalla nuova regola, così il successivo Applica regole lo aggiorna invece di posizionarne un secondo; un messaggio lo segnala. Quando il progetto non ha ancora un file delle regole, non viene aggiunta alcuna regola e il messaggio offre Crea file delle regole.

La vista Proprietà

La vista Proprietà SCADA si trova nella barra laterale secondaria a destra mentre è aperto un progetto SCADA. Segue ciò che selezioni nell'editor di pagina o nella vista Pagine e legge la pagina così com'è nell'editor, quindi le modifiche non salvate compaiono subito. La sua intestazione indica la selezione, per esempio un widget con la sua pagina. Un campo ha effetto quando premi Enter o lo lasci, e Escape ripristina il valore precedente; ogni modifica è una modifica non salvata che puoi annullare. Per una pagina che appartiene all'editor FUXA, o quando il tuo piano non include SCADA, un banner lo segnala e tutto è di sola lettura, tranne Apri regola e Perché questo widget?.

La vista ha quattro schede.

Proprietà

Con una pagina selezionata, la scheda mostra il suo id, il suo Nome e le sue Dimensioni (entrambi modificabili), il suo sfondo, il suo proprietario e il numero dei suoi widget. Mentre il progetto legge più PLC, mostra anche il PLC della pagina, con Cambia... per sceglierne un altro (vedi Più PLC sopra). Per una vista di dettaglio mostra Vista di dettaglio di con il tipo di dati (vedi Viste di dettaglio più avanti). Senza selezione o con solo una pagina selezionata, l'Anteprima dell'assistente si trova in fondo, inizialmente compressa; mostra le schermate che l'assistente propone in chat.

Con un widget selezionato, la scheda mostra:

  • Widget: il suo tipo, l'id, il nome (modificabile) e la pagina.
  • Posizione e dimensioni: un valore che digiti sposta o ridimensiona il widget esattamente come un trascinamento sulla pagina. Su una pagina che non ha il layout libero, la pagina diventa libera e ogni altro widget mantiene la sua posizione, e un solo Annulla revoca entrambe le cose. Mentre il layout posiziona il widget, i campi sono vuoti, i valori in grigio mostrano dove viene disegnato e una nota lo segnala. Quando il layout non posiziona affatto il widget, i campi non sono disponibili e una nota ne spiega il motivo.
  • Simbolo: un elenco dei simboli presenti nella cartella dei simboli. Per un widget di altro tipo la prima voce, Nessuno, mantieni il widget tipo, lo lascia com'è. Un widget simbolo offre anche Ripristina il simbolo della regola, oppure Ripristina il widget della regola quando le regole danno al suo segnale un altro tipo di widget; da quel momento le regole lo gestiscono di nuovo. Finché nessuna regola decide il widget, il pulsante non è disponibile e una riga ne spiega il motivo.
  • Righe del riquadro (solo riquadri): l'etichetta, l'unità e il numero di decimali di ogni riga, che puoi spostare in su o in giù o rimuovere.
  • Azione del pulsante (solo pulsanti): per un pulsante con un segnale, Commuta il valore (selezionato finché non è impostata alcuna azione) o Scrivi un valore fisso con il valore che scrive; un pulsante senza segnale mostra Nessuna scrittura, il pulsante apre solo una pagina.
  • Eventi (non per le tabelle dei messaggi): le pagine che un clic sul widget apre, ciascuna con Apri come scheda e, per una scheda, Chiudi le altre schede. Aggiungi evento ne aggiunge uno. Una scheda che apre una vista di dettaglio ha un campo per l'istanza, la struttura di cui la scheda mostra i valori. Quando il clic apre già una pagina, per esempio su un riquadro di navigazione, la sezione indica quella pagina. Sotto un evento di scheda che l'invio ignorerebbe, per esempio perché lo stesso clic apre già una pagina, un avviso ne spiega il motivo.
  • Filtro allarmi (tabelle degli allarmi): quali degli allarmi attivi mostra la tabella. Spunta i Livelli da mostrare (High High, High, Low e Info; se non ne spunti nessuno, vengono mostrati tutti i livelli), digita una parte del testo dell'allarme sotto Testo o del gruppo sotto Gruppo (maiuscole e minuscole non contano), e aggiungi segnali sotto Segnali con Aggiungi un segnale.... L'elenco offre i segnali che la pagina associa e i segnali che hanno generato allarmi nell'ultima build, contrassegnati con (allarme dell'ultima build). Rimuovi un segnale con la croce sul suo chip; finché non è scelto alcun segnale, il campo riporta Tutti i segnali. La tabella mostra gli allarmi attivi che corrispondono a tutti i filtri impostati. Ogni modifica è un passo di Annulla, e un filtro che svuoti completamente viene rimosso.
  • Tabella dei messaggi (tabelle dei messaggi): il Buffer che mostra, il numero di Slot e le Colonne. Ogni colonna mostra un membro di ogni slot, con la sua Etichetta, la sua Larghezza (vuota per il valore predefinito) e una Lista testi; i pulsanti della riga spostano la colonna in su o in giù o la rimuovono, e Aggiungi colonna aggiunge una colonna per il membro successivo non ancora mostrato, fino a otto. Una riga sotto gli slot conta i segnali che la tabella associa rispetto al budget e diventa un avviso quando la tabella lo supera (vedi Tabella dei messaggi più avanti). Finché i segnali del progetto non sono caricati, il buffer viene mostrato come testo con una nota che invita a caricarli. Ogni modifica è un passo di Annulla.

Un valore che il file di pagina non può accettare, per esempio 0 slot, viene mostrato come errore alla fine della sua sezione.

Con più widget selezionati, la scheda li elenca, e un clic su uno di essi lo seleziona da solo.

Associazioni

Una riga per ogni slot del widget, con lo Slot, la Variabile che mostra, il suo Tipo, il suo Accesso e, sotto Stato, un campione di colore per ogni colore di riempimento o di contorno che lo slot controlla. Uno slot vuoto offre Assegna variabile...; uno slot associato offre Sostituisci... e Rimuovi associazione, e uno slot senza il quale il widget non può esistere offre solo Sostituisci.... Trascina un segnale dalla vista Segnali su una riga per associarlo; viene associato un segnale di tipo adatto, un intero su uno slot sì o no chiede prima il bit, e un segnale di altro tipo viene rifiutato con un messaggio che indica entrambi i tipi. Su uno slot associato, il segnale rilasciato sostituisce quello precedente solo mentre tieni premuto Alt; senza Alt, un messaggio lo segnala e non cambia nulla. Per riempire più slot da una struttura, rilasciala sul simbolo nell'editor di pagina.

Mentre il progetto legge più PLC, la colonna PLC mostra il PLC che legge ciascuno slot, e PLC... passa l'intero widget a un altro PLC (vedi Più PLC sopra). In una vista di dettaglio la tabella mostra Membro invece di Variabile, e Membro... sceglie un membro del tipo di dati (vedi Viste di dettaglio più avanti).

Sotto la tabella, Riutilizza mostra la nuova associazione non appena è sulla pagina e offre Salva come regola per tutti i tipo, Deriva regola dal widget e, per un simbolo, Salva come predefinito del simbolo (vedi Riutilizza un'associazione sopra).

Stati

Stati del simbolo è la tabella degli stati di un widget simbolo. Ogni slot è un gruppo, con il segnale a cui è associato. Ogni riga contiene:

  • Valore o intervallo: un valore come 3, un intervallo come 2..5, ..5 o 5.., oppure Altrimenti per ogni altro valore;
  • Significato: l'effetto a parole;
  • Destinazione: l'intero simbolo, una parte o una parte dello sfondo;
  • Proprietà: Colore di riempimento, Colore del contorno, Visibilità, Lampeggio, Rotazione continua, Rotazione in base al valore, Variante, Spostamento in base allo stato o Posizione in base al valore;
  • Impostazione: il colore, mostrato o nascosto, i due colori di lampeggio con l'intervallo, la direzione, la variante, lo spostamento, oppure, per un valore che viene seguito, l'intervallo di valori con l'angolo o la distanza in cui si traduce;
  • pulsanti per spostare la riga in su o in giù, rimuoverla o cancellare il valore predefinito.

Aggiungi riga aggiunge una riga per il successivo valore libero. Una striscia per ogni slot mostra il simbolo in ogni stato, disegnato come lo disegna l'editor di pagina; le parti che si spostano o ruotano sono mostrate ferme. Le note sotto la tabella segnalano righe sovrapposte, un'associazione senza valore predefinito e ogni combinazione che FUXA non può mostrare (vedi Quando un'associazione non può essere mostrata più avanti).

Finché il widget non ha stati propri, la tabella mostra gli stati predefiniti del suo simbolo; la prima modifica li copia nel widget, che da quel momento mantiene i propri stati. Salva come predefinito del simbolo sotto la tabella scrive gli stati e gli slot del widget nel manifest del simbolo. Quando lo sfondo della pagina ha delle parti, Stati dello sfondo è una seconda tabella per le parti dello sfondo controllate dai segnali di questo widget. Dopo un rilascio che aggiunge uno stato, la scheda si apre con il nuovo stato evidenziato.

Regola

  • Creato da elenca le regole che hanno creato il widget, ciascuna con Apri regola, che apre il file delle regole su quella regola, oppure la vista Regole per una regola integrata. Quando nessuna regola ha creato il widget, per esempio un widget che hai posizionato a mano, la scheda lo segnala, e l'applicazione delle regole lascia il widget com'è.
  • Origine dei campi elenca ogni campo con il suo valore e la sua origine: una regola, una regola integrata, a mano, con trascinamento della selezione, dal layout automatico, dai modelli di stato o non registrata.
  • Traccia delle regole elenca le regole che corrispondono, poi ogni altra regola con la prima condizione che non soddisfa; le restanti vengono contate, e Perché questo widget? mostra l'elenco completo. Richiede che i segnali del progetto siano caricati.
  • Perché questo widget? apre la spiegazione completa (vedi Spiega un widget più avanti).
  • Vista di dettaglio, per un widget che apre una vista di dettaglio come scheda: la pagina che apre, l'istanza e se l'ha impostata una regola o tu.

Assegna i widget con le regole

Invece di scegliere ogni widget a mano, puoi lasciare che siano le regole a decidere quale widget riceve ogni segnale, come viene etichettato e su quale pagina e in quale sezione compare. Le regole di un progetto si trovano in un unico file accanto al file di progetto, rules.scadarules.json. Tre comandi lavorano con esso mentre è aperto un progetto SCADA; li trovi nel riquadro comandi e nella barra del titolo della vista Regole:

  • Crea file delle regole scrive il file delle regole con un elenco di regole vuoto e le regole integrate attivate, e lo apre. Se il progetto ne ha già uno, Studio apre invece quello.
  • Apri file delle regole apre il file delle regole. Se il progetto non ne ha ancora uno, un messaggio offre Crea file delle regole; fino ad allora, Applica regole usa le regole integrate.
  • Applica regole applica le regole alle pagine del progetto (vedi Applica le regole più avanti). Si trova anche nella barra del titolo della vista Pagine e nella barra degli strumenti dell'editor di pagina.

Nell'editor, il file delle regole suggerisce ogni campo con una breve descrizione e segnala gli errori mentre digiti. Ogni regola ha un id, un description facoltativo, le sue condizioni sotto when e ciò che imposta sotto then:

  • Le condizioni scelgono segnali e strutture in base al nome del tipo (typeName, anche quello del genitore o di qualsiasi struttura superiore), al percorso nella forma Block::a.b.c (* sta per un livello, ** per un numero qualsiasi di livelli), al nome, al blocco dati, al tipo di dati o all'accesso, al commento o a un token di commento come {symbol=pump} (token). all, any e not combinano le condizioni.
  • Gli effetti impostano il tipo di widget con la sua etichetta e le sue opzioni, un simbolo con i membri associati ai suoi slot e le sue associazioni di stato, la pagina, la sezione e la posizione al suo interno, oppure fanno di un booleano lo stato del suo riquadro di panoramica. Una regola può anche far sì che ogni struttura di un tipo di dati apra la vista di dettaglio di quel tipo come scheda (vedi Viste di dettaglio più avanti). exclude esclude un segnale, o una struttura con tutto il suo contenuto. Etichette, pagine e sezioni possono usare segnaposto come ${name}, ${parent} e ${block}.

Per ogni campo decide la prima regola del file che corrisponde. Sposta una regola più in alto per darle la precedenza, e imposta stop in modo che nessuna regola successiva venga considerata per un segnale a cui la regola corrisponde. Un file delle regole può usare altri file delle regole del progetto dopo le proprie regole (extends), con al massimo due livelli di profondità.

Questa regola trasforma ogni struttura del tipo Pump in un simbolo di pompa sulla pagina del suo blocco dati e associa lo slot running del simbolo al membro status.bRunning; consume impedisce che i membri associati ricevano widget propri:

{
  "id": "pump-symbol",
  "description": "Every pump becomes a pump symbol.",
  "when": { "node": "container", "typeName": "Pump" },
  "then": {
    "widget": { "kind": "symbol", "label": "${name}" },
    "symbol": { "ref": "pumps/pump" },
    "slots": { "running": "status.bRunning" },
    "place": { "page": "${block}" },
    "consume": "slots"
  }
}

L'editor delle regole

Aprendo il file delle regole, dalla vista Regole, da Esplora risorse, con Apri file delle regole o da una segnalazione nella vista Diagnostica, viene mostrato l'editor delle regole: a sinistra un modulo con le Impostazioni, le Regole dei widget e le Regole di allarme, a destra il JSON dello stesso file con gli stessi suggerimenti e controlli descritti sopra. Una modifica su uno dei due lati cambia lo stesso file, è un passo che puoi annullare e resta non salvata finché non salvi il file.

  • Nel modulo attivi o disattivi una regola (Attiva), la rinomini, ne modifichi la descrizione, la sposti con Sposta su e Sposta giù o la rimuovi con Rimuovi regola. Ogni scheda di regola mostra a parole quando si applica e cosa imposta, e a quanti segnali corrisponde e su quanti prevale, per esempio Hits: 12, won: 10.
  • Le nuove regole si scrivono sul lato JSON; il modulo non ha un pulsante per aggiungerne una. Per un campo che il modulo non mostra, apri JSON della regola sulla scheda, modificalo e fai clic su Applica JSON.
  • Ogni scheda di regola di allarme mostra quanti allarmi ha generato l'ultima build, in totale e per livello, per esempio Alarms in the last build: 3 (High: 3), e i primi esempi con il loro segnale, livello e testo dell'allarme; prima della prima build lo segnala. Un testo di allarme che rimanda a un testo di una lista testi mostra quel testo nella lingua predefinita del progetto, come lo mostra la dashboard.
  • Problemi in fondo al modulo elenca gli errori del file; fai clic su uno per raggiungerlo. Le regole sono elencate nell'ordine in cui hanno la precedenza: per ogni campo prevale la prima regola corrispondente.
  • Applica regole nella barra degli strumenti applica le regole alle pagine. L'Anteprima refactoring mostra prima ogni modifica, e nulla viene scritto finché non la applichi lì.

Per usare invece l'editor di testo, scegli Apri con... sul file.

La vista Regole

La vista Regole elenca le regole da cui vengono costruite le pagine. I problemi dei file delle regole compaiono in alto. Sotto si trovano Regole del progetto con il tuo file delle regole, un gruppo Regole estese per ogni file che il tuo file delle regole estende, e Regole integrate, inizialmente compresso, con quante di esse sono attive. Ogni regola mostra un interruttore, il suo nome (la sua descrizione, o il suo id quando non ne ha una) e a quanti segnali corrisponde e per quanti decide un campo, per esempio Hits: 83, won: 83. Mentre i conteggi vengono calcolati la riga riporta conteggio in corso, e finché non possono essere contati, per esempio prima che i segnali del progetto siano caricati, riporta non conteggiato.

  • L'interruttore di una delle tue regole la attiva o la disattiva nel file delle regole, come modifica non salvata che un solo Annulla revoca. Space fa lo stesso per la regola con il focus.
  • Le regole di un file esteso qui sono di sola lettura; il tooltip indica il file da modificare.
  • L'interruttore di una regola integrata attiva o disattiva insieme tutte le regole integrate, come fa il file delle regole.
  • Fai clic su una regola per elencarne le corrispondenze nella vista Corrispondenze delle regole del pannello SCADA (vedi Corrispondenze delle regole più avanti). Fai doppio clic su di essa, o premi Enter, per aprire il file delle regole su quella regola.

Le tue regole di allarme (vedi Regole di allarme più avanti) si trovano in un gruppo Regole di allarme sotto le regole del loro file, che indica quante di esse sono attive. Ciascuna mostra un interruttore, il suo id, ciò a cui corrisponde e quale stato del segnale genera l'allarme, per esempio typeName=mixerT; signal bool true, e, dopo che le pagine sono state costruite, il numero di allarmi che ha generato in quella build. Un trattino sostituisce il numero finché non è possibile indicarne uno, e il suo tooltip ne spiega il motivo, per esempio che le pagine non sono state costruite da quando il progetto è stato aperto. L'interruttore, Space, Enter e il doppio clic funzionano come per le altre regole, e le regole di allarme di un file esteso sono di sola lettura. Gli avvisi sulle regole di allarme compaiono come righe sotto il gruppo. Finché nessun file delle regole ha regole di allarme, il gruppo lo segnala; un clic apre il file delle regole, dove le aggiungi sotto alarmRules, oppure chiedi all'assistente.

Il titolo della vista indica quante regole sono attive e quante regole integrate sono attivate. Senza un file delle regole, la vista spiega che Applica regole usa le regole integrate e offre Crea file delle regole. Le regole di layout della navigazione non sono elencate qui; le attivi o disattivi nel file di progetto.

Applica le regole

Applica regole esegue le regole su ogni segnale del set di nodi caricato. I segnali spuntati nella vista Segnali non lo limitano; per escludere dei segnali, scrivi una regola con exclude. Studio apre quindi l'Anteprima refactoring con ogni modifica: le modifiche a ogni file di pagina, i file di pagina che crea e la modifica al file di progetto. Nulla viene scritto finché non fai clic su Applica lì; Scarta lascia il progetto com'era. In seguito un messaggio indica quante pagine sono state modificate e quante create. I file restano non salvati finché non li salvi, e puoi annullare la modifica. Quando le pagine seguono già le regole, un messaggio lo segnala.

Se nell'Anteprima refactoring applichi solo una parte delle modifiche, il messaggio conta solo quelle applicate. Quando ciò lascia il progetto incoerente, per esempio perché elenca una nuova pagina il cui file di pagina non è stato creato, un errore indica il problema e ti consiglia di annullare la modifica o di applicare di nuovo le regole.

Se dopo aver applicato le regole annulli da una pagina e raggiungi la modifica applicata, Studio chiede "Vuoi annullare 'Applica regole SCADA'?" prima che accada qualcosa. Sì revoca l'intera modifica in una volta, insieme a ogni pagina che ha creato; No lascia tutto com'è.

Quando il file di una pagina è scomparso, per esempio perché è stato eliminato al di fuori di Studio, Applica regole ricrea la pagina nella sua posizione precedente se le regole la generano ancora, e la pagina mantiene la sua voce di navigazione. Se le regole non generano più quella pagina, le regole non vengono applicate e un messaggio indica la pagina e il suo file: elimina la pagina nella vista Pagine, o ripristina il suo file, e applica di nuovo le regole.

Una regola che apre la vista di dettaglio dà a ogni struttura di quel tipo un widget che, al clic, apre la vista di dettaglio come scheda. Se nessuna pagina del progetto è la vista di dettaglio di quel tipo, Applica regole lo segnala, e il widget resta come sarebbe senza quell'effetto. Un evento che imposti tu stesso su un widget resta come l'hai impostato.

Ciò che imposti tu resta sempre:

  • Un campo che imposti nell'editor di pagina, nella vista Proprietà o tramite l'assistente conta come impostato a mano, e nessuna regola lo modifica. Questo include un simbolo che scegli, un widget che sposti o ridimensioni, un segnale che rilasci su uno slot e un'associazione che rimuovi.
  • Un widget creato a mano mantiene la sua posizione, anche quando mostra già un segnale a cui una regola darebbe un widget proprio: le regole non lo sostituiscono mai e non aggiungono un secondo widget per quel segnale. Una nota dopo l'applicazione indica questi widget.
  • Una pagina che il progetto ha già, per esempio la pagina di un blocco dati che hai creato tu o con Proponi schermate, viene riutilizzata quando le regole posizionano segnali su una pagina con quel nome: i segnali finiscono su di essa, che mantiene il suo nome e l'etichetta del suo riquadro di panoramica, invece di creare una seconda pagina. I nomi che differiscono solo per maiuscole e minuscole contano come la stessa pagina.
  • Le pagine che appartengono all'editor nel browser del runtime non vengono mai modificate, e l'applicazione delle regole non elimina mai una pagina.

I widget posizionati da Proponi schermate contano come creati dalle regole integrate, quindi una tua regola li modifica al successivo Applica regole. I widget che le regole avevano creato in precedenza e che non producono più vengono rimossi. Quando una nuova pagina riceve comunque il nome di una pagina precedente, per esempio perché i membri di due blocchi dati hanno lo stesso nome, viene creata lo stesso, e una nota dopo l'applicazione indica entrambe le pagine, così puoi modificare le regole o rinominarne una. Quando le regole tralasciano widget o slot, per esempio una riga di riquadro senza un segnale associato, un avviso li elenca. Applica regole richiede che i segnali del progetto siano caricati; quando il file delle regole ha un problema, il messaggio lo indica e offre Apri file delle regole.

Le regole integrate

Senza un file delle regole, e dopo le tue regole a meno che non le disattivi, decide un insieme di regole integrate. Costruiscono lo stesso tipo di pagine di Proponi schermate:

  • Un BOOL scrivibile riceve un pulsante, un BOOL di sola lettura chiamato bError una lampada che si accende nel colore di guasto, e qualsiasi altro BOOL una lampada.
  • Un numero scrivibile con {min=} e {max=} nel commento riceve un cursore, qualsiasi altro numero scrivibile un campo di input; un numero di sola lettura con un tale intervallo riceve un indicatore, qualsiasi altro un visualizzatore di valori.
  • Un blocco dati con non più di 40 segnali diventa una pagina. In uno più grande, i segnali direttamente nel blocco vanno su una pagina del blocco, e ogni membro riceve una pagina propria con una sezione General, una sezione per ogni gruppo piccolo e, per ogni gruppo più grande, una pagina di dettaglio con un pulsante che la apre. Imposta un altro limite con detailThreshold sotto settings nel file delle regole.
  • La panoramica riceve un riquadro per ogni pagina che nessun altro widget apre. Il suo stato segue il primo booleano chiamato bIsOk, bReady o bError, con bError mostrato invertito.

Le regole integrate non possono essere modificate. Una tua regola viene prima e sovrascrive il campo che imposta; per disattivare tutte le regole integrate, imposta "includeBuiltins": false sotto settings nel file delle regole, oppure usa l'interruttore di una regola integrata nella vista Regole.

Tre regole di layout integrate decidono la navigazione della dashboard: la panoramica e le pagine di processo vi compaiono e le pagine di dettaglio no, le pagine che si aprono come scheda ne restano fuori, e ogni voce mostra l'icona del ruolo della sua pagina. Le attivi o disattivi una per una nel file di progetto (vedi Intestazione e navigazione più avanti).

Spiegare un widget

Perché questo widget? spiega da dove viene un widget del progetto aperto. Avvialo dal riquadro comandi e scegli la pagina e poi il widget, ciascuno elencato con etichetta, tipo e id. Lo raggiungi anche dal chip Perché? di un segnale nella vista Signals, dalla scheda Regola della vista Properties e facendo clic su una riga della vista Corrispondenze delle regole; lì Studio spiega il widget che mostra il segnale, oppure ti lascia scegliere quando sono più di uno. Si apre un documento di sola lettura intitolato Why this widget, in tre parti:

  • Campi e relativa provenienza: ogni campo del widget con il suo valore e la sua origine, ad esempio la regola o la regola integrata che lo ha impostato, impostato a mano, posizionato dal layout automatico oppure non registrato.
  • Traccia delle regole: i dati del segnale, ogni regola con l'indicazione se corrisponde o della prima condizione che non soddisfa e, per ogni campo, la regola che ha prevalso e le regole che ha scavalcato. Se il widget non è stato creato dalle regole, il documento lo dice e indica che applicare le regole lo lascia com'è.
  • Navigazione: se la pagina del widget compare nella navigazione, con il suo testo, la sua posizione e la sua icona, e se ce l'ha messa una voce del file di progetto, una regola di layout integrata o il valore predefinito.

La traccia delle regole richiede che i segnali del progetto siano caricati, e la navigazione richiede anche pagine che si possano generare. Senza segnali, il documento ti chiede di caricarli e mostra comunque da dove vengono i campi. Esegui di nuovo il comando per aggiornare il documento.

Simboli con stati

I tuoi simboli SVG possono mostrare lo stato dell'impianto: una parte cambia colore, lampeggia, compare o scompare, ruota o si sposta quando cambia un segnale. Tieni i simboli nella cartella dei simboli del progetto e caricala con Choose Symbol Folder... nella vista Symbols (vedi La cartella dei simboli sopra). Se la cartella si trova nel progetto, l'assistente può dirti perché un file è stato saltato. Ovunque, nell'elenco Simbolo della vista Properties, nei file di pagina e nelle regole, un simbolo è indicato con il suo percorso nella cartella, con barre in avanti e senza .svg, ad esempio pumps/pump.

Quando apri un progetto i cui file di pagina indicano ancora un simbolo con il percorso del file, Studio converte il percorso in questa forma come modifica non salvata, che un solo Annulla ripristina. Se un file di pagina indica un simbolo che la cartella non contiene, il progetto si apre con un avviso e l'invio tralascia solo quel widget finché non correggi il nome.

Contrassegnare le parti di un simbolo

Nel tuo programma di disegno, assegna agli elementi che devono cambiare un id che inizia con uno di questi marcatori:

  • part-<name>, ad esempio part-body, contrassegna una parte di cui possono cambiare colore, visibilità, lampeggio, rotazione o posizione. Cambiano colore solo le parti contrassegnate; tutto il resto mantiene i propri colori.
  • variant-<name> contrassegna uno di più disegni alternativi del simbolo, di cui ne viene mostrato uno alla volta.
  • keep-<name> contrassegna un elemento all'interno di una parte che mantiene i propri colori quando la parte cambia colore.

Un simbolo senza associazioni di stato proprie e senza associazioni predefinite in un manifest funziona come un semplice interruttore acceso/spento, come prima.

Aggiungere un manifest

Accanto all'SVG puoi mettere un manifest con lo stesso nome e l'estensione .scadasymbol.json, ad esempio pumps/pump.scadasymbol.json accanto a pumps/pump.svg. L'editor suggerisce i suoi campi e segnala gli errori mentre scrivi. Il manifest fornisce:

  • size: la larghezza e l'altezza predefinite del simbolo; il simbolo mantiene le proprie proporzioni.
  • slots: gli ingressi con nome del simbolo, come running o speed, ciascuno con i tipi di dati che accetta.
  • defaultBindings: le associazioni di stato che ogni widget con questo simbolo usa finché non ne ha di proprie.
  • parts: parti indicate con l'id di un elemento, per un disegno i cui id non portano alcun marcatore part-.

Salva come predefinito del simbolo scrive per te nel manifest gli slot e gli stati di un widget (vedi Riutilizzare un'associazione sopra). Dopo aver modificato un disegno o un manifest a mano, carica di nuovo la cartella dei simboli con Choose Symbol Folder....

Modificare gli stati predefiniti

Modifica stati del simbolo apre l'editor degli stati di un simbolo. Avvialo dal riquadro comandi e scegli il simbolo, fai clic sull'icona Modifica stati su un riquadro della vista Symbols (oppure fai clic con il tasto destro sul riquadro e scegli Modifica stati), oppure fai clic su Modifica predefiniti del simbolo nella scheda Stati della vista Properties per il simbolo del widget selezionato. Se il simbolo non ha ancora un manifest, Studio ne crea uno per te a partire da dimensioni, slot e stati predefiniti attuali del simbolo; lo fa solo per una cartella dei simboli all'interno del progetto.

  • Disegno mostra il simbolo e Parti elenca il simbolo intero, le sue parti contrassegnate e le sue varianti. Punta una riga della tabella o una voce dell'elenco e la parte che modifica viene evidenziata con un contorno nel disegno.
  • Stati predefiniti è la stessa tabella della scheda Stati, per gli slot del manifest: per ogni slot e valore, come appare il simbolo o una delle sue parti. Ogni modifica è un passo che puoi annullare, e il manifest resta non salvato finché non lo salvi. Ogni nuovo utilizzo del simbolo parte da questi stati.
  • Anteprima di tutti gli stati mostra il simbolo una volta per ogni stato prodotto dalla tabella, etichettato con lo slot e il valore; le parti che si spostano e ruotano sono mostrate a riposo.
  • Controlli elenca problemi come lampeggio e visibilità sulla stessa parte, intervalli sovrapposti, un valore predefinito mancante e stati che FUXA non può mostrare.

Se il disegno non contrassegna alcuna parte, gli stati modificano il simbolo intero; per aggiungere parti, assegna agli elementi dell'SVG un id che inizia con part-, ad esempio part-door. Apri come testo apre il manifest nell'editor di testo. La scheda Stati della vista Properties continua a modificare solo gli stati del widget selezionato.

Associare una parte a un segnale

Un'associazione di stato fa sì che il simbolo intero (destinazione item), una parte contrassegnata (part:<name>) o una parte contrassegnata dello sfondo della pagina (background.part:<name>) segua un valore. Il valore viene da uno slot del simbolo o direttamente da un segnale, e può esserne un singolo bit. property indica cosa cambia:

  • fill o stroke: il colore del riempimento o del contorno;
  • visible: visibile o nascosto;
  • blink: lampeggio tra due colori, con un intervallo da 100 a 10000 millisecondi;
  • spin: rotazione continua, in senso orario o antiorario, oppure fermo;
  • variant: quale variante del simbolo viene mostrata;
  • move: una posizione per ogni stato;
  • rotate: un angolo che segue il valore;
  • position: uno spostamento lungo un asse che segue il valore.

La maggior parte delle proprietà usa righe sotto map: ogni riga vale per un valore (eq) o un intervallo (min, max) e indica il relativo value, e default vale quando nessuna riga corrisponde. rotate e position usano invece linear, con i quattro numeri inMin, inMax, outMin e outMax: i valori da inMin a inMax diventano l'angolo da outMin a outMax in gradi oppure, per position, lo spostamento dalla posizione iniziale in pixel lungo l'asse axis x o y. Una rotazione parte da inMin 0 e va da un outMin minore a un outMax maggiore; rispecchia il disegno per ruotare nell'altro verso. Questa associazione ruota la parte vane da 0 a 270 gradi mentre lo slot speed va da 0 a 100:

{
  "id": "vane-speed",
  "target": "part:vane",
  "property": "rotate",
  "source": { "slot": "speed" },
  "linear": { "inMin": 0, "inMax": 100, "outMin": 0, "outMax": 270 }
}

Per spostare una parte con un valore, indica anche l'asse: "linear": { "axis": "x", "inMin": 0, "inMax": 100, "outMin": 0, "outMax": 200 }.

Il modo più semplice per associare una parte è trascinarvi sopra un segnale nell'editor di pagina e regolare i valori nella scheda Stati della vista Properties (vedi La vista Properties sopra). Le associazioni predefinite stanno nel manifest, quelle di un singolo widget sotto stateBindings nel suo file di pagina; l'assistente può impostarle per te. Un widget con associazioni proprie usa solo quelle, e i colori spento e acceso di un widget simbolo valgono solo per un simbolo senza associazioni di stato.

Anche lo sfondo della pagina può avere parti contrassegnate, ad esempio il contorno di un'area dell'impianto che segue lo stato del suo modulo: contrassegna allo stesso modo gli elementi nell'SVG di sfondo con part-<name>, elenca i loro nomi sotto parts dello sfondo nel file di pagina e associali da un widget di quella pagina con la destinazione background.part:<name>, oppure trascina il segnale sulla parte dello sfondo.

Lo spostamento con un valore richiede FUXA 1.3.4 o successivo. Un invio a FUXA 1.3.3 viene rifiutato e il messaggio indica l'effetto; per una versione di FUXA che Studio non ha verificato compare invece un avviso e l'invio prosegue.

Quando un'associazione non può essere mostrata

Alcune combinazioni non possono essere mostrate in FUXA. Quando Studio genera la dashboard, tralascia tale associazione e genera il resto della pagina; un simbolo le cui associazioni falliscono tutte mantiene il suo disegno senza stati. Un avviso dopo l'invio o il salvataggio dice che alcune voci non si sono potute generare e indica, per ogni tipo di problema, la pagina e il widget in cui si verifica; anche la vista Diagnostics le elenca, e l'assistente spiega ogni voce con parole semplici, con una soluzione. Studio rifiuta queste combinazioni:

  • Una parte che si sposta dentro qualcosa che si sposta. Una parte non può spostarsi all'interno di un simbolo o di una parte che si sposta a sua volta, perché FUXA sposta un gruppo insieme a tutto ciò che contiene. Il movimento esterno viene mantenuto; disegna la parte mobile al di fuori, in modo che ciascuna si sposti per conto proprio.
  • Una parte che ruota mentre si sposta. Una parte o un simbolo che si sposta non può anche ruotare, e nulla all'interno di una parte mobile può ruotare. Il movimento viene mantenuto e la rotazione tralasciata; disegna ciò che ruota come parte o simbolo separato che non si sposta. Neanche una parte che ruota può contenere una parte che si sposta, ma il simbolo intero può ruotare mentre le parti al suo interno si spostano.
  • Due assi su una parte. Una parte si sposta lungo un solo asse. Una seconda associazione position sull'altro asse viene tralasciata; disegna la parte come due parti che non si contengono a vicenda e dai a ciascuna la propria associazione.
  • Colori da due segnali. Il riempimento e il contorno di una parte prendono i colori da un solo segnale; combina gli stati in un'unica parola di stato nel PLC.
  • Stati da testo. FUXA confronta gli stati solo come numeri; pilotali con un numero o una parola di stato.

Intestazione e navigazione

L'intestazione e la navigazione della dashboard in esecuzione vengono dalla sezione layout del file di progetto. L'editor suggerisce ogni campo con una descrizione, e l'assistente può impostarli per te.

  • Navigazione. La dashboard mostra una voce di navigazione per pagina, con il nome della pagina e un'icona. Per impostazione predefinita, le regole di layout integrate decidono quali pagine compaiono e quale icona mostra ogni voce (vedi Le regole integrate sopra); attivale o disattivale una per una sotto rules nella sezione layout, e scegli un'altra icona per ogni ruolo di pagina. Una tua voce di navigazione per una pagina ne imposta la posizione e l'icona, aggiunge una pagina che le regole lasciano fuori oppure la nasconde. Una vista di dettaglio non compare mai nella navigazione.
  • Intestazione. Attiva ciò che l'intestazione mostra: un titolo con il nome del progetto, la data e l'ora in un formato a tua scelta e il nome dell'utente che ha effettuato l'accesso accanto al pulsante di accesso. In un progetto con lingue, l'intestazione può mostrare anche il pulsante della lingua, con cui l'operatore cambia la lingua della dashboard (vedi Lingue sotto). Il contatore degli allarmi attivi compare da solo non appena il progetto ha allarmi, e un contatore informativo separato non appena ha un allarme di livello Info; FUXA mostra il pulsante di accesso ogni volta che il suo accesso è attivo.

Modifiche in FUXA. Nella finestra di layout di FUXA puoi ancora aggiungere voci di navigazione per pagine create in FUXA o per link, aggiungere pulsanti all'intestazione e modificare impostazioni che Studio non imposta, come il tema o lo zoom: Studio le mantiene tutte a ogni invio con unione. Le voci delle pagine di Studio, gli elementi dell'intestazione che Studio aggiunge e i colori, le dimensioni e lo stile dell'intestazione e della navigazione appartengono a Studio: se sono stati modificati in FUXA, l'invio successivo mostra la differenza e, una volta che confermi, Studio ripristina i propri (vedi Cosa succede a ogni invio sotto). Un invio che sostituisce l'intero progetto scrive solo l'intestazione e la navigazione di Studio, quindi rimuove ciò che è stato aggiunto in FUXA. Per lasciare l'intestazione e la navigazione interamente all'editor di FUXA, imposta owner su fuxa nella sezione layout; Studio le lascia allora come sono, e la sostituzione dell'intero progetto resta bloccata finché non le restituisci a Studio.

Pulsanti di comando, riquadri e schede

Alcune forme di widget fanno più che mostrare un valore. Le imposti nella scheda Proprietà della vista Properties (Azione del pulsante, Righe del riquadro ed Eventi), nel file di pagina (l'editor suggerisce i campi), con una regola oppure chiedendolo all'assistente.

  • Pulsante di comando. Normalmente un pulsante attiva e disattiva il suo segnale a ogni clic, anche quando nessun altro widget della pagina mostra quel segnale. Per un comando che il programma del PLC esegue e poi azzera, assegna invece al pulsante un'azione che scrive un valore fisso (Scrivi un valore fisso, nel file di pagina ad esempio "action": { "kind": "setValue", "value": 1 }): ogni clic scrive quel solo valore, e il pulsante non lo azzera mai; lo fa il programma del PLC una volta gestito il comando. Un pulsante di questo tipo scrive solo su un segnale che l'elenco dei segnali indica come lettura/scrittura, di tipo BOOL (scritto come 1 o 0), un tipo intero, TIME, REAL, LREAL, STRING o WSTRING; per qualsiasi altro segnale il pulsante viene tralasciato e un avviso lo segnala. Quando l'accesso di FUXA è attivo, solo un utente che ha effettuato l'accesso può usare il pulsante.
  • Riquadro. Un riquadro mostra più valori di un'unità d'impianto sotto un unico titolo: una riga per valore, ognuna con la propria etichetta, unità e numero di decimali, e può colorare la cornice in base allo stato del suo segnale principale. Su una pagina con layout Riquadri ogni riquadro ha la stessa dimensione e mostra al massimo due righe; su una pagina Sezioni o Libero un riquadro cresce con le sue righe. Le righe che non entrano in un riquadro vengono omesse, e un avviso lo segnala.
  • Scheda. Un riquadro di navigazione, un pulsante che non scrive alcun segnale o un elemento di visualizzazione come una lampada o un simbolo possono aprire una pagina come scheda sopra la pagina corrente invece di passare a essa (Apri come scheda, nel file di pagina un evento come { "kind": "openCard", "target": "speed" }, dove target è l'id della pagina). La scheda compare centrata sulla pagina, e ogni widget apre al massimo una scheda. Con Chiudi le altre schede ("replaceCards": true), le schede già aperte si chiudono prima che si apra quella nuova; altrimenti la nuova scheda si aggiunge a quelle aperte. Un evento scheda su un widget il cui clic apre già una pagina viene ignorato, perché aprire una pagina chiude tutte le schede; la sezione Eventi della vista Properties lo segnala. Le pagine che si aprono come scheda restano fuori dalla navigazione. L'anteprima dell'editor di pagina mostra le schede prima dell'invio.

Viste di dettaglio

Una vista di dettaglio è una pagina che mostra i membri di un tipo di dati, ad esempio un motore, e si apre come scheda per qualsiasi struttura di quel tipo, con i valori di quella struttura. Un tipo con molte istanze richiede così una sola pagina invece di una pagina per istanza.

  1. Rendere una pagina la vista di dettaglio. Assegna alla pagina il ruolo detail nel suo file di pagina, oppure chiedilo all'assistente. La scheda Proprietà mostra allora Vista di dettaglio di: scegli lì il tipo di dati tra i tipi dei segnali caricati, oppure Nessuno, una pagina normale per farla tornare una pagina normale.
  2. Associare i membri. In una vista di dettaglio, la scheda Associazioni mostra i membri del tipo invece dei segnali. Fai clic su Member... per sceglierne uno, oppure trascina un segnale dall'interno di una struttura di quel tipo su una riga di slot; il membro deve adattarsi allo slot, e un intero su uno slot sì o no chiede prima il bit. Lì i segnali non possono essere trascinati sulla vista di dettaglio stessa né associati con Assign Variable...; un messaggio ti rimanda a Member.... Una vista di dettaglio può mostrare valori, lampade, pulsanti e simboli con stati, ma nessun grafico, tabella degli allarmi o tabella dei messaggi, perché questi non possono seguire la struttura che apre la scheda.
  3. Aprirla per un'istanza. Su un widget di un'altra pagina, aggiungi un evento con Apri come scheda che apre la vista di dettaglio, e inserisci l'istanza, ovvero la struttura di cui la scheda mostra i valori. Oppure lascia che lo faccia una regola per ogni struttura del tipo (vedi Applicare le regole sopra). Ogni motore apre allora la stessa pagina con i propri valori.

Ogni struttura che apre la vista di dettaglio deve contenere tutti i membri che la pagina mostra; la vista Diagnostics indica un membro mancante. Una vista di dettaglio legge il PLC della struttura che la apre, quindi non ha un PLC proprio. Si apre solo come scheda, quindi non può essere la pagina iniziale né una voce visibile della navigazione; Studio lo rifiuta quando lo imposti e quando invii, e una scheda di una vista di dettaglio non può aprire un'ulteriore vista di dettaglio. Il piano delle schermate non mostra le viste di dettaglio e non le rimuove mai; modifica una vista di dettaglio nella sua pagina.

Ruoli

I ruoli decidono chi vede e chi comanda cosa nella dashboard in esecuzione. Elenca i ruoli del tuo runtime nel file di progetto, ciascuno con un id e un nome, ad esempio Operator e Maintenance; l'editor suggerisce i campi. Poi scegli, nel file di pagina e nel file delle regole oppure tramite l'assistente:

  • per ogni pagina, quali ruoli la vedono nella navigazione e quali ruoli possono comandarla;
  • per ogni widget, quali ruoli lo vedono e quali ruoli possono comandarlo; un widget senza una scelta propria segue la sua pagina;
  • per ogni regola di allarme, quali ruoli vedono i suoi allarmi e quali ruoli possono confermarli.

Se scegli solo chi vede una pagina, un widget o un allarme, gli stessi ruoli possono anche comandarlo o confermarlo. Un ruolo che scegli deve essere tra quelli elencati nel progetto; altrimenti Studio non carica il progetto e indica il ruolo. Se tralasci i ruoli, ogni pagina, widget e allarme resta aperto a tutti.

Quando invii, Studio crea i ruoli ancora mancanti sul runtime e passa il runtime ai ruoli, prima di salvare il backup e scrivere il progetto. Il passaggio del runtime ai ruoli lo riavvia una volta: ogni allarme attivo viene azzerato e torna non confermato, e i valori live si fermano per alcuni secondi. Per questo il primo invio di un progetto con ruoli ti chiede prima conferma: la finestra di invio avvisa del riavvio, la conferma indica il numero di allarmi attivi e il messaggio dopo l'invio dice che i ruoli sono stati attivati e il runtime è stato riavviato. La modalità live non lo fa mai: interrompe un invio di questo tipo e ti chiede di inviare una volta con Invia a FUXA. Non rimuove mai un ruolo e non modifica mai un account utente, e dopo averli scritti verifica i ruoli sul runtime. Se un nome di ruolo del tuo progetto è già usato da un altro ruolo sul runtime, l'invio si interrompe prima di modificare qualsiasi cosa e indica entrambi i ruoli. Se il runtime non può passare ai ruoli, l'invio si interrompe e te lo dice, così le tue restrizioni non vengono mai pubblicate senza effetto. Se dopo il passaggio il progetto sull'istanza risulta diverso, Studio verifica di nuovo l'invio e ti chiede di nuovo conferma solo se l'invio farebbe ora più di quanto hai confermato. Se annulli un invio con ruoli, o se non raggiunge il runtime, Studio disattiva di nuovo i ruoli del runtime, così le schermate precedenti restano utilizzabili.

Assegna i ruoli ai tuoi utenti nella gestione utenti del runtime. Un utente che ha effettuato l'accesso senza nessuno dei ruoli del progetto vede solo ciò che è aperto a tutti; le pagine generate dai segnali spuntati, in un progetto senza pagine, sono aperte a ogni utente che ha effettuato l'accesso. Una volta che il runtime usa i ruoli, le voci senza ruoli, ad esempio pagine o voci di navigazione create nell'editor nel browser del runtime, potrebbero non essere più visibili agli utenti che hanno effettuato l'accesso e non sono amministratori; assegna loro dei ruoli nell'editor nel browser del runtime. Se il runtime usa già i ruoli ma il tuo progetto non ne elenca nessuno, Studio ti avvisa che gli utenti che hanno effettuato l'accesso e non sono amministratori potrebbero non vedere la navigazione.

Allarmi

La dashboard genera un allarme quando un segnale entra nel suo stato di allarme, e mostra un banner di allarme nell'intestazione finché un allarme è attivo. Gli allarmi vengono da tre fonti: un token nel commento di un segnale, le regole di allarme del file delle regole e l'allarme di connessione che ogni progetto riceve. Vengono generati ogni volta che si generano le pagine: a ogni invio, nell'anteprima e quando salvi un file FUXA.

Contrassegnare un segnale nel suo commento

Contrassegni un singolo segnale aggiungendo un token al suo commento, ad esempio {alarm=high}, con un gruppo e un testo del messaggio facoltativi, e una banda analogica con {alarmmin=} e {alarmmax=}. Un segnale contrassegnato genera il suo allarme anche quando nessuna pagina lo mostra. Per quel segnale, il token prevale su ogni regola di allarme.

Regole di allarme

Le regole di allarme generano allarmi per intere famiglie di segnali in una volta, ad esempio per ogni bit di guasto di ogni motore, senza un widget su alcuna pagina. Le scrivi sotto alarmRules nel file delle regole, accanto alle regole dei widget (vedi Assegnare i widget con le regole sopra); l'editor suggerisce ogni campo con una descrizione e segnala gli errori mentre scrivi. Una regola di allarme ha:

  • un id, univoco nel file delle regole, e facoltativamente enabled, false per disattivarla;
  • match: quali segnali o strutture colpisce, con le stesse condizioni di when di una regola dei widget, come il nome del tipo, il percorso, il nome, il blocco dati o un token del commento;
  • facoltativamente commentPattern: un'espressione regolare di al massimo 200 caratteri, con gruppi con nome, che legge il commento del segnale; i suoi gruppi possono scegliere il livello e fornire il testo. Studio rifiuta un pattern che potrebbe continuare a girare per molto tempo, anche uno con più di due ripetizioni aperte di seguito che possono corrispondere agli stessi caratteri, come .*.*.*; metti tra loro un separatore che la parte precedente non può riconoscere su un commento lungo e indica la parte da riscrivere;
  • signal: lo stato che genera l'allarme, di uno di quattro tipi. Quando la regola colpisce una struttura, member indica il membro sottostante che porta il segnale.
    • bool: un BOOL, attivo finché è vero, oppure finché è falso con "activeWhen": "false".
    • bits: un BYTE, WORD o DWORD, un allarme per bit, per tutti i bit o per i numeri di bit che elenchi; attivo finché il bit è impostato, oppure finché è azzerato con "activeWhen": "clear".
    • band: un numero, attivo finché il suo valore è compreso tra min e max; basta uno dei due.
    • equals: un numero, attivo finché è uguale a value.
  • effect: il level (highhigh, high, low o info, oppure preso da un gruppo del pattern del commento tramite un map), il text, il group e come viene confermato l'allarme (ack).

Il text è un elenco di fonti, e prevale la prima che fornisce un testo: { "comment": true } prende il commento del segnale senza i suoi token, { "template": "..." } un tuo testo, { "regexGroup": "name" } un gruppo del pattern del commento e { "bitTexts": { "0": "...", "1": "..." } } un testo per ogni bit di un segnale bits. Un modello, un testo di bit e anche il group possono usare queste variabili: {block}, {path}, {name}, {parent}, {idx} (l'indice di array più interno), {bit}, {n} (il numero di messaggio di un bit in una parola di stato compatta), {comment}, {seg:N} e {segi:N} (il nome e l'indice della parte N del percorso, contata dalla fine quando N è negativo) e {re:group}. Aggiungi |padN per completare un numero con zeri, ad esempio {idx|pad3}. Quando nessuna fonte fornisce un testo, l'allarme viene tralasciato, quindi termina l'elenco con un modello.

Questa regola genera un allarme per ciascuno dei primi tre bit del membro faultWord di ogni struttura del tipo Motor. I bit 0 e 1 hanno un testo proprio, il bit 2 riceve il modello, ad esempio Motor1: fault 2, e gli allarmi sono raggruppati per blocco dati:

"alarmRules": [
  {
    "id": "motor-faults",
    "match": { "typeName": "Motor" },
    "signal": { "kind": "bits", "member": "faultWord", "bits": [0, 1, 2] },
    "effect": {
      "level": "high",
      "text": [
        { "bitTexts": { "0": "Overload", "1": "Phase failure" } },
        { "template": "{parent}: fault {bit}" }
      ],
      "group": "{block}"
    }
  }
]

Quando più regole di allarme colpiscono lo stesso segnale con lo stesso livello, prevale la prima regola nel file e le altre vengono segnalate. Se il file delle regole contiene un errore, l'invio si interrompe e indica il problema, quindi correggi prima il file delle regole. Fai attenzione a questi avvisi:

  • Un allarme attivo finché un valore è falso o un bit è azzerato viene generato anche ogni volta che si perde la connessione al PLC, perché il valore allora risulta 0: su tutti i segnali corrispondenti contemporaneamente, in aggiunta all'allarme di connessione. Usalo solo per un segnale che per progetto vale 0 in caso di guasto.
  • Quando un nome di gruppo è parte di un altro, ad esempio Line1 e Line10, un filtro di gruppo di una tabella degli allarmi li mostra entrambi. Completa i numeri con |padN, oppure rinomina i gruppi.
  • Un progetto contiene al massimo 1000 allarmi. Oltre questo limite, il resto viene tralasciato nell'ordine del file, e un avviso indica quanti. Restringi le regole, oppure imposta un alarmBudget più alto sotto settings nel file delle regole.

L'allarme di connessione

Ogni progetto che invii genera un allarme del livello più alto per ciascun PLC quando la connessione a esso si perde per più di 10 secondi. Non devi configurarlo.

La tabella degli allarmi

Un widget alarm table elenca gli allarmi attivi con ora, messaggio, gruppo e conferma. Posizionalo con Insert Widget... nell'editor di pagina (vedi Inserire un widget sopra) e scegli quali allarmi mostra in Filtro allarmi nella vista Properties (vedi Proprietà sopra). Quando nessuno dei segnali del suo filtro può essere letto, la tabella viene tralasciata invece di mostrare tutti gli allarmi, e la vista Diagnostics lo segnala.

Un allarme di livello Info è elencato in ogni tabella degli allarmi il cui filtro lascia passare Info. Nell'intestazione della dashboard non viene conteggiato nel contatore degli allarmi ma nel contatore informativo separato, che Studio mostra non appena il progetto ha un allarme Info.

Allarmi e invio

Studio scrive gli allarmi nell'istanza FUXA solo quando sono cambiati. Un invio i cui allarmi non sono cambiati mantiene gli allarmi attivi. Quando gli allarmi sono cambiati, viene scritto l'intero progetto, e la conferma di riavvio dice che FUXA ricarica tutti gli allarmi, quindi ogni allarme attivo viene azzerato, e indica quanti allarmi sono attivi in quel momento. Invia le modifiche agli allarmi in una finestra di manutenzione. Il primo invio dopo l'aggiornamento di Studio che ha introdotto i ruoli scrive una volta l'intero progetto e azzera gli allarmi attivi, anche in un progetto senza ruoli.

Quando l'istanza FUXA contiene già un allarme sullo stesso segnale e livello con un altro nome, ad esempio da una versione precedente del progetto, Studio non aggiunge quel livello una seconda volta. Gli altri livelli vengono scritti, un avviso dopo l'invio indica entrambi gli allarmi e la vista Diagnostics li elenca. Rimuovi il vecchio allarme, ad esempio con un invio che rimuove ciò che Studio non genera più, e invia di nuovo. Quando un allarme non può essere generato affatto, ad esempio una banda senza minimo o massimo oppure un bit fuori da 0-31, un messaggio dopo l'invio indica gli allarmi tralasciati e il motivo.

Notifiche

Una notifica avvisa una persona o un sistema quando sono attivi allarmi dei livelli scelti, via e-mail o con una chiamata a un indirizzo web. Elenchi le notifiche nel file di progetto, ciascuna con un nome, i livelli di allarme che segnala, un ritardo e un intervallo di ripetizione facoltativi in minuti e un nome di destinatario; l'editor suggerisce i campi. Il nome è l'oggetto dell'e-mail, quindi tienilo su una riga e al massimo 120 caratteri. Il file di progetto indica solo il destinatario, mai l'indirizzo stesso. Il runtime invia le e-mail tramite il server di posta impostato nelle sue impostazioni.

Per dare un indirizzo a un destinatario, esegui Set Notification Receiver... dal riquadro comandi su ogni computer che invia al runtime. Scegli il nome del destinatario dall'elenco, che mostra se è memorizzato un indirizzo e quali notifiche lo usano, poi inserisci l'indirizzo e-mail o l'indirizzo web, che inizia con http:// o https:// e non contiene nome utente né password. L'immissione è mascherata, e l'indirizzo viene memorizzato in modo sicuro su questo computer e non viene mai più mostrato. Clear Notification Receiver... lo rimuove di nuovo.

  • Quando invii, Studio usa gli indirizzi memorizzati su questo computer; il salvataggio di un file FUXA o l'anteprima non li includono mai.
  • Senza un indirizzo memorizzato o valido, un invio da questo computer non aggiorna quella notifica e lo segnala; il runtime mantiene la versione che ha già. Un collega che invia senza l'indirizzo non disattiva quindi mai i tuoi avvisi.
  • Se un invio segnala che i destinatari memorizzati non si sono potuti leggere, non è stato inviato nulla; riprova, oppure memorizza di nuovo i destinatari.
  • Dopo un invio che modifica le notifiche, il messaggio di risultato indica quante notifiche sono state scritte e rimosse.
  • Quando rimuovi una notifica dal progetto, l'invio successivo chiede conferma prima di rimuoverla dal runtime, e la indica. Un indirizzo che hai memorizzato per essa resta su questo computer finché non lo cancelli.

Il runtime conserva l'indirizzo, quindi compare anche nei backup che Studio salva prima di ogni invio.

Dove compaiono i problemi degli allarmi

La vista Diagnostica elenca i problemi delle regole di allarme e i risultati sugli allarmi dell'ultima generazione, ad esempio una regola che non corrisponde ad alcun segnale, e un clic su una riga apre la regola o mostra il segnale (vedi Diagnostica sotto). La vista Regole mostra quanti allarmi ha generato ogni regola (vedi La vista Rules sopra), e le Corrispondenze degli allarmi della vista Corrispondenze delle regole li elencano uno per uno (vedi Corrispondenze delle regole sotto). L'assistente può contrassegnare un segnale, scrivere regole di allarme e inserire una tabella degli allarmi per te.

Tabella dei messaggi

Molti programmi PLC conservano i loro messaggi in un buffer dei messaggi: un array di strutture con uno slot per messaggio, in cui ogni slot contiene membri come l'ora, il modulo e il numero del messaggio. Un widget message table mostra un buffer di questo tipo su una pagina, una riga per slot e una colonna per ogni membro che scegli.

  • Posizionalo con Insert Widget... nell'editor di pagina e scegli il buffer (vedi Inserire un widget sopra).
  • In Tabella dei messaggi nella vista Properties, scegli il buffer, il numero di slot e le colonne, ciascuna con il suo membro, la sua etichetta e la sua larghezza (vedi Proprietà sopra).
  • L'editor di pagina mostra la tabella con le etichette delle colonne e il numero di slot; il runtime riempie gli slot.

La tabella mostra gli slot attuali del buffer, non uno storico dei messaggi: quando il PLC sovrascrive uno slot, la riga mostra il nuovo messaggio. L'ora in una tabella dei messaggi viene dall'orologio del PLC, mentre la tabella degli allarmi mostra l'ora del runtime SCADA. I due orologi possono differire di qualche minuto, quindi confronta le ore solo all'interno di una stessa tabella.

Questa versione mostra numeri: una colonna mostra il numero del messaggio, non il suo testo. Puoi già scegliere una lista di testi per una colonna (vedi Liste di testi sotto); Studio conserva la scelta, e una versione successiva mostrerà il testo.

Ogni cella della tabella legge un segnale, quindi una tabella associa tanti segnali quanti sono i suoi slot moltiplicati per le sue colonne. La riga sotto gli slot nella vista Properties li conteggia rispetto al budget di 800 segnali per tabella, o al messageTableTagBudget che imposti sotto settings nel file delle regole. Una tabella oltre il budget viene tralasciata e la vista Diagnostics lo segnala: mostra meno slot o colonne. Lì viene segnalata anche una colonna il cui membro non è contenuto negli slot del buffer.

Liste di testi

Una lista di testi assegna un testo a ogni chiave, ad esempio a ogni numero di messaggio, in una lingua. Le liste di testi del progetto stanno nella sua cartella texts, un file per lista e lingua.

Per importare una lista di testi, fai clic su Import Text List... nella barra del titolo della vista Project (l'icona a forma di nuvola), oppure esegui SCADA: Import Text List... dal riquadro comandi:

  1. Scegli un file CSV o JSON. Un file CSV ha due colonne, la chiave e il testo, separate da un punto e virgola o da una virgola. Se Studio non riesce a capire quale separatore usa il file, aggiungi come prima riga la riga di intestazione key;text o key,text. Un file JSON contiene un oggetto che associa ogni chiave al suo testo, oppure un elenco di voci con key e text.
  2. Scegli la lista in cui importare, oppure New Text List... e inserisci il suo id, ad esempio messages, con lettere, cifre, punti, trattini e trattini bassi.
  3. Scegli la lingua tra le lingue del progetto e delle liste di testi esistenti, oppure Other Language... e inserisci un tag di lingua come en o de-CH.

Se la lista esiste già in quella lingua, Studio chiede conferma prima di sostituirne i testi. La lista finisce poi nella cartella texts e il file di progetto la elenca: una nuova lista viene salvata subito, mentre una lista sostituita e il file di progetto restano non salvati finché non li salvi, e un solo Annulla annulla l'intera importazione. Un messaggio indica quanti testi sono stati importati, oppure che la lista contiene già esattamente questi testi. Un file con problemi non viene importato: il messaggio indica i primi problemi con le relative righe, e non viene scritto nulla.

La vista Project mostra ogni lista di testi sotto texts con la sua lingua e il suo numero di voci, e la sua prima riga conta le liste di testi. Una lista che non si può leggere mostra non leggibile e il problema accanto al file, e la vista Diagnostics indica il motivo. Un file nella cartella texts il cui nome non ha la forma lista, lingua e .json, ad esempio messages.en.json, non viene letto come lista di testi, e la vista Diagnostics lo segnala. L'assistente può importare una lista di testi per te.

Lingue

La dashboard può mostrare i suoi testi in più lingue. Elenca le lingue del tuo runtime nel file di progetto, ciascuna con un codice di lingua come en o de-CH e il nome che mostra il suo menu delle lingue, e contrassegnane esattamente una come predefinita; l'editor suggerisce i campi. Ogni codice inizia con due lettere, e due lingue non possono iniziare con le stesse due lettere, quindi de-CH e de-DE non possono essere elencati entrambi.

Ogni lista di testi che importi per una lingua elencata viene inviata con il progetto. Le voci di navigazione, il titolo dell'intestazione e i testi degli allarmi che fanno riferimento a un testo di una lista di testi tramite la sua chiave compaiono allora nella lingua che l'operatore sceglie con il pulsante della lingua nell'intestazione del runtime (vedi Intestazione e navigazione sopra). Se un testo manca nella lingua predefinita, il runtime lo mostra in un'altra lingua, e la vista Diagnostics indica i testi da completare; lì viene segnalato anche un testo di allarme la cui chiave non indica alcun testo. Senza lingue elencate, la dashboard ha una sola lingua: una chiave mostra il testo inglese della sua lista, oppure la sua prima lingua.

Una modifica successiva a un testo o a una traduzione viene pubblicata con l'invio successivo senza riavviare il runtime e senza azzerare gli allarmi attivi, e dopo averli scritti Studio verifica sul runtime i testi e le lingue modificati. Quando il progetto non contiene più testi che Studio ha inviato in precedenza, l'invio li rimuove dopo la tua conferma, e la conferma li elenca. I testi che il runtime aveva già restano.

Valori, unità e trend

Un valore mostra l'unità e il numero di decimali indicati nel commento del segnale, ad esempio {unit=bar}{digits=1}, e un campo di immissione mantiene i valori inseriti entro i limiti del segnale quando indichi {min=} e {max=}. Un grafico di trend conserva il suo storico e si apre già riempito con i valori recenti.

Inviare e salvare

Tre azioni completano la dashboard:

  • Invia a FUXA, nella barra del titolo della vista Progetto, nella barra degli strumenti dell'editor di pagina e nel riquadro comandi, invia la dashboard all'indirizzo FUXA indicato nelle impostazioni. A ogni invio scegli nella finestra di invio se la dashboard viene unita al progetto sull'istanza o lo sostituisce, come descritto più avanti.
  • Salva file FUXA..., nel menu ... della vista Progetto, scrive un file di progetto FUXA (.fuxa.json) che puoi importare in FUXA a mano.
  • Salva file di esportazione SCADA..., nello stesso menu, scrive i segnali spuntati in un file di configurazione dei segnali (.scada.json), così puoi riutilizzarlo in seguito.

Dopo un invio riuscito dell'intero progetto, un messaggio indica quanti dispositivi, tag e viste contiene ora il progetto sull'istanza e offre Apri FUXA per vedere il risultato; un invio delle sole pagine modificate riporta invece queste ultime (vedi Inviare solo le pagine modificate più avanti). Quando usi una connessione Siemens S7, un messaggio elenca i segnali tralasciati. L'invio compare poi nella vista Invio del pannello SCADA.

Quando alcune voci delle pagine non possono essere generate, per esempio un collegamento che FUXA non può mostrare o un simbolo che la cartella non contiene, il resto della dashboard viene comunque generato e un avviso elenca i problemi: ogni tipo una sola volta, con la pagina e, dove Studio lo può stabilire, il widget in cui si presenta; oltre cinque, conta i restanti. La vista Diagnostica del pannello SCADA elenca ogni voce e l'editor di pagina contrassegna i widget. Quando le pagine non possono essere generate affatto, il messaggio elenca i problemi allo stesso modo.

Unire o sostituire

Per impostazione predefinita un invio unisce la dashboard al progetto già presente sull'istanza:

  • Le pagine, i dispositivi e gli allarmi che hai aggiunto a mano in FUXA vengono mantenuti.
  • Le pagine, i dispositivi e gli allarmi generati da Studio vengono aggiornati. Una pagina che hai consegnato all'editor nel browser del runtime resta esattamente com'è (vedi più avanti); quando una pagina di Studio è stata comunque modificata sull'istanza, Studio indica le pagine interessate e chiede prima conferma.
  • Anche le pagine, gli allarmi e i dispositivi che Studio ha inviato in precedenza dal tuo progetto e che il progetto non contiene più vengono rimossi dall'istanza. Studio li elenca e chiede conferma prima di rimuoverli.
  • Se Studio non riesce a distinguere le proprie pagine sull'istanza, per esempio perché un altro progetto o un altro utente di Studio vi ha inviato dati, oppure perché in FUXA è stata caricata una copia precedente, non rimuove nulla, indica le pagine interessate e chiede conferma prima di sovrascriverle.

Nella sezione Modalità della finestra di invio puoi scegliere invece Sostituisci l'intero progetto: l'intero progetto sull'istanza viene sostituito da quello generato, il che riavvia il suo runtime. La scelta vale solo per quell'invio; l'invio successivo si apre di nuovo con Unisci nel progetto.

Una pagina appartiene a Studio finché non la consegni all'editor nel browser del runtime. Per modificare lì una pagina, salvala e inviala prima alla destinazione di sviluppo, poi scegli Modifica nell'editor del runtime: fai clic con il tasto destro sulla pagina nella vista Pagine, apri Altre azioni (...) nella barra degli strumenti dell'editor di pagina oppure eseguilo dal riquadro comandi. Studio apre l'editor nel browser del runtime in una scheda del browser dentro Studio e ti indica quale vista scegliere lì. Il messaggio offre anche la tavolozza dei simboli per l'editor del runtime (vedi I tuoi simboli nell'editor FUXA più avanti). Da quel momento la vista Pagine contrassegna la pagina con Editor del runtime, l'editor di pagina la mostra in sola lettura con un banner e ogni invio la lascia com'è sull'istanza, così le modifiche fatte nell'editor del runtime vengono mantenute. Se la pagina ha modifiche non salvate, non faceva parte dell'ultimo invio alla destinazione di sviluppo o è stata modificata sull'istanza dopo quell'invio, Studio non la consegna e ti dice cosa fare prima.

Per riprendere la pagina, scegli Ripristina lo stato di Studio negli stessi punti. Studio salva la versione del runtime della pagina nella cartella backups del progetto, mostra affiancate le differenze tra quel backup e la versione di Studio e ti chiede di confermare. Dopo la conferma la pagina appartiene di nuovo a Studio, e Studio invia il progetto alla destinazione di sviluppo, che rimette sull'istanza la versione di Studio della pagina.

Finché una pagina, oppure l'intestazione e la navigazione, appartiene all'editor nel browser del runtime, la sostituzione dell'intero progetto viene rifiutata: un invio con Sostituisci, il ripristino dei volumi del runtime e la distribuzione di un file Compose sul container in esecuzione. Il messaggio indica le pagine; riprendile prima con Ripristina lo stato di Studio.

Inviare solo le pagine modificate

Quando invii il tuo progetto SCADA con unione e dall'ultimo invio di Studio a questa istanza sono cambiate solo pagine, oppure l'intestazione e la navigazione, Studio scrive soltanto le pagine modificate, una dopo l'altra, e verifica ciascuna sull'istanza. FUXA resta in esecuzione: non c'è alcun riavvio né conferma di riavvio, gli allarmi attivi restano come sono e i valori live continuano a scorrere. Il messaggio dopo l'invio dice che le modifiche sono state inviate senza riavviare il runtime e conta le pagine nuove, modificate, rimosse e invariate; aggiunge che sono state aggiornate anche l'intestazione e la navigazione quando sono cambiate e offre Apri FUXA. I visualizzatori FUXA aperti mantengono le pagine vecchie finché non vengono ricaricati.

Studio scrive invece l'intero progetto, e FUXA si riavvia, quando è necessario: al primo invio a un'istanza, quando sono cambiati i dispositivi o i loro tag, gli allarmi, i grafici o altre impostazioni del progetto, quando due pagine del progetto hanno lo stesso nome, quando sono cambiate più pagine di quante l'istanza ne accetti una alla volta, oppure quando Studio non riesce a confermare sull'istanza il suo invio precedente. La conferma di riavvio indica allora il motivo, per esempio che Studio non ha traccia di un invio precedente a questa istanza FUXA. Un invio con Sostituisci scrive sempre l'intero progetto.

Al primo invio a un'istanza che contiene già un progetto, rispondi a un'unica domanda di riavvio. Oltre al motivo, essa dice che Studio non sa ancora distinguere le proprie pagine da quelle create altrove e cosa fa l'invio per questo: con l'unione, una pagina con lo stesso id di una delle tue viene sovrascritta e nessuna pagina viene rimossa; con Sostituisci, l'intero progetto sull'istanza viene sostituito, comprese le pagine create altrove. Non c'è una seconda domanda al riguardo.

Se un invio di pagine modificate si interrompe a metà, il messaggio dice cosa è andato storto, per esempio quale pagina l'istanza non ha mantenuto. Quando una parte delle modifiche potrebbe già trovarsi sull'istanza, lo dice e, dove Studio lo sa, quante scritture sono state eseguite, per esempio 2 di 5. Invia di nuovo per completarlo. Se annulli un invio di questo tipo dopo l'inizio della scrittura, un avviso dice che l'istanza potrebbe contenere solo una parte delle modifiche.

La finestra di invio

Quando invii, Studio mostra un'unica finestra, Invia il progetto SCADA, prima di scrivere qualsiasi cosa:

  • Destinazione: la destinazione a cui va l'invio. Se scegli un'altra destinazione, fai clic su Pianifica di nuovo l'invio e Studio mostra di nuovo la finestra con il piano per quella destinazione, creato per i PLC che la destinazione elenca; nel frattempo non viene scritto nulla. Quando poi invii, quella destinazione diventa quella attiva e l'indirizzo FUXA nelle impostazioni la segue. Se invece annulli, l'indirizzo FUXA e la modalità live restano come erano. Finché la finestra è aperta con un'altra destinazione, la modalità live non invia nulla e un invio live già in corso viene prima completato.
  • Modalità: Unisci nel progetto aggiunge o aggiorna le pagine, i dispositivi e gli allarmi che appartengono a Studio e mantiene tutto il resto sull'istanza; Sostituisci l'intero progetto sostituisce l'intero progetto sull'istanza con quello generato, il che riavvia il suo runtime. Ogni invio si apre con l'unione. Finché una pagina, oppure l'intestazione e la navigazione, appartiene all'editor nel browser del runtime, Sostituisci l'intero progetto non può essere scelto e una frase sotto spiega perché. Se scegli l'altra modalità, le pagine mostrano ancora il piano della modalità di partenza, una nota lo segnala e il pulsante diventa Pianifica di nuovo l'invio: Studio pianifica allora l'invio con la modalità scelta, insieme a una nuova destinazione se ne hai scelta una, e ti mostra il nuovo piano prima di scrivere qualsiasi cosa. Scegliere un'altra modalità o destinazione riporta inoltre la scelta per le pagine modificate sull'istanza su Annulla l'invio e cancella l'approvazione per la produzione.
  • Pagine: ogni pagina con l'indicazione se è nuova, modificata, invariata, rimossa o saltata. Quando vengono inviate solo le pagine modificate, puoi togliere la spunta a una pagina per trattenerla; quella pagina resta com'è sull'istanza. Togliere la spunta a una pagina rimossa la mantiene sull'istanza e la sua riga indica allora Mantenuta sull'istanza. Quando viene scritto l'intero progetto, ogni pagina è spuntata e la spunta non può essere tolta. Le pagine che appartengono all'editor nel browser del runtime appaiono in grigio come saltate e non vengono inviate.
  • Backup: sempre spuntato, la spunta non può essere tolta. Indica il file in cui Studio salva il progetto attuale dell'istanza prima di scrivere qualsiasi cosa.
  • Se dall'ultimo invio sono state modificate pagine sull'istanza, per esempio nell'editor nel browser del runtime, la finestra lo segnala e chiede come gestirle: Annulla l'invio (l'opzione predefinita), Sovrascrivi dopo il backup oppure, per un invio delle pagine modificate a una destinazione di sviluppo, Consegna all'editor del runtime. La consegna mantiene quelle modifiche: Studio consegna le pagine modificate all'editor nel browser del runtime e annulla questo invio, e il pulsante diventa Consegna e annulla l'invio. Invia poi di nuovo per inviare le altre modifiche.
  • Per una destinazione di produzione, spunta Ho controllato le modifiche e approvo l'invio alla destinazione di produzione. prima di poter inviare.
  • Avvisi sulla versione di FUXA, sugli effetti che Studio non ha verificato, su un riavvio del runtime, sugli allarmi, i dispositivi, i testi e le notifiche che l'invio rimuove e sull'editor del runtime quando è aperto in una scheda del browser di Studio sulla stessa istanza; una scheda che mostra solo la dashboard in esecuzione non conta.
  • Salva e invia elenca i file SCADA con modifiche non salvate; Studio li salva quando invii.

Il pulsante che invia indica Unisci nel progetto, Sostituisci progetto, Invia in produzione, Sovrascrivi dopo il backup o Pianifica di nuovo l'invio, a seconda di ciò che hai scelto, e resta disattivato finché qualcosa blocca l'invio; la finestra elenca cosa lo blocca ancora. Annulla non invia nulla. Se hai tolto la spunta a una pagina e nel frattempo l'istanza è cambiata in modo che l'invio farebbe ora di più, Studio mostra di nuovo la finestra prima di scrivere qualsiasi cosa. Se le impostazioni dell'area di lavoro fissano l'indirizzo FUXA, cambialo lì; la finestra non può cambiarlo.

Cosa succede a ogni invio

Ogni invio esegue le stesse protezioni, sia che parta dalla barra laterale SCADA, dall'editor di pagina, da uno dei comandi sui file o dall'assistente. Anche la modalità live le esegue, ma non chiede nulla, tranne prima di rimuovere pagine (vedi Modalità live più avanti). Per un invio che avvii tu, le domande seguenti sono tutte nella finestra di invio (vedi La finestra di invio sopra); un invio dell'assistente le pone una dopo l'altra.

  1. Se i file SCADA del progetto hanno modifiche non salvate, Studio chiede prima di salvarli, perché invia solo file salvati.
  2. Studio verifica l'ambiente della destinazione (vedi Destinazioni e ambienti sopra) e rifiuta l'invio quando l'ambiente non è confermato.
  3. Studio legge il progetto attuale dall'istanza. Se non ci riesce, non viene salvato alcun backup e non viene inviato nulla. L'invio si ferma qui anche quando una pagina del tuo progetto ha il nome di una pagina sull'istanza che Studio non ha creato: un avviso indica entrambe le pagine, così puoi rinominarne una e inviare di nuovo. Si ferma anche quando le pagine usano un effetto che la versione di FUXA della destinazione non supporta, per esempio lo spostamento in base a un valore su FUXA 1.3.3; il messaggio indica l'effetto e tu aggiorni FUXA sulla destinazione o rimuovi l'effetto dalle pagine.
  4. Una conferma indica cosa contiene ora l'istanza e se la dashboard viene unita a quel contenuto o lo sostituisce. Seguono altre conferme dove pertinenti: le pagine, gli allarmi, i dispositivi, i testi e le notifiche di Studio che l'invio rimuove; quando viene scritto l'intero progetto, il riavvio del runtime FUXA, con il numero di allarmi attivi in quel momento e il motivo per cui viene scritto l'intero progetto; quando il runtime passa ai ruoli, il riavvio che ne deriva, con il numero di allarmi attivi in quel momento; per una destinazione di produzione, una seconda conferma che indica la destinazione e il suo ambiente; e le modifiche fatte sull'istanza che l'invio sovrascriverebbe, compresi un'intestazione o una navigazione modificate nella finestra del layout di FUXA.
  5. Quando il progetto elenca dei ruoli, Studio crea sull'istanza i ruoli mancanti e la fa passare ai ruoli, il che riavvia il runtime una volta dopo la tua conferma (vedi Ruoli sopra). Studio salva poi un backup del progetto che si trovava sull'istanza nella cartella backups del tuo progetto SCADA, un file per invio, con il nome della data e dell'ora.
  6. Studio invia la dashboard e un registro degli invii nella cartella del progetto annota l'ora, la destinazione con il suo ambiente e il risultato; la vista Invio del pannello SCADA lo mostra. Subito prima della prima scrittura, Studio verifica che il progetto sull'istanza sia ancora quello letto al passo 3. Se nel frattempo è cambiato, per esempio nell'editor FUXA mentre era aperta una conferma, non viene scritto nulla: il messaggio dice che non è stato inviato nulla e ti chiede di inviare di nuovo per controllare la modifica. La modifica sull'istanza e il backup restano entrambi.

Senza un progetto SCADA aperto, il backup e il registro degli invii finiscono in una cartella di Studio e un messaggio indica dove è stato salvato il backup.

Quando Studio scrive l'intero progetto, FUXA riavvia il suo runtime per caricarlo: ogni allarme attivo viene azzerato e torna non confermato, e i valori live si fermano per qualche secondo. A ogni invio, i visualizzatori FUXA aperti continuano a mostrare le pagine vecchie finché non vengono ricaricati, e un editor del runtime aperto può riscrivere la sua copia vecchia, quindi chiudilo prima di inviare; la finestra di invio ti avvisa quando l'editor del runtime è aperto in una scheda di Studio. Se la versione di FUXA non è stata verificata da Studio, o è precedente alla versione minima che la destinazione accetta, un avviso lo segnala e l'invio prosegue. Lo stesso vale per gli effetti sulle pagine, come i colori di stato o le pagine aperte come scheda, che Studio non ha ancora verificato con la versione di FUXA della destinazione.

Modalità live

La modalità live invia le tue modifiche al sistema di sviluppo ogni volta che salvi, così FUXA segue il tuo lavoro. Esegui SCADA: Attiva/disattiva modalità live nel riquadro comandi. Si attiva solo mentre è aperto un progetto SCADA e l'indirizzo FUXA nelle impostazioni appartiene a una destinazione di sviluppo del progetto; altrimenti un avviso spiega perché resta disattivata. All'attivazione chiede conferma una volta e indica l'indirizzo.

Mentre la modalità live è attiva, la barra di stato mostra Live e il suo tooltip indica l'indirizzo a cui invia.

  • Ogni salvataggio del file di progetto, di una pagina, del file delle regole o di un manifesto dei simboli invia le modifiche alla destinazione di sviluppo un secondo dopo l'ultimo salvataggio, un invio alla volta. Salvare di nuovo durante un invio porta a un ulteriore invio subito dopo.
  • Un invio live non chiede altro, tranne prima di rimuovere pagine che Studio ha inviato in precedenza. Quando riesce, non compare alcun messaggio; la sua riga appare nella vista Invio del pannello SCADA.
  • Quando altri file SCADA del progetto non sono salvati, l'invio attende e lo segnala una volta.
  • Quando non è stato possibile generare alcune voci delle pagine, l'invio parte comunque e un avviso rimanda alla vista Diagnostica.
  • Le modifiche fatte dall'assistente vengono inviate solo dopo che le hai salvate tu, con Salva o Ctrl+S; un salvataggio automatico non le invia. Con il salvataggio automatico attivo, un avviso indica i file modificati dall'assistente e trattiene gli invii finché non salvi tu uno di quei file o scegli Invia ora nell'avviso. Una modifica ai file fatta da un altro programma non attiva mai un invio.

La modalità live si disattiva da sola, con un avviso che ne indica il motivo, ogni volta che un invio richiede più di un rapido aggiornamento: il primo invio all'istanza (invia una volta con Invia a FUXA, poi riattiva la modalità live), un invio che scrive l'intero progetto e riavvia FUXA, un invio che farebbe passare il runtime ai ruoli e quindi lo riavvierebbe, un conflitto con pagine create altrove, un progetto modificato sull'istanza, un invio che richiede una conferma, un invio rifiutato o non riuscito e una modifica dell'indirizzo FUXA, del progetto o della destinazione. Si disattiva anche quando la tua licenza non include più SCADA. Per disattivarla tu stesso, fai clic su Live nella barra di stato o esegui di nuovo il comando.

Il pannello SCADA e la barra di stato

La scheda SCADA del pannello in fondo alla finestra contiene tre viste. Senza un progetto aperto, ognuna offre Apri progetto SCADA e Crea progetto SCADA.

Diagnostica

Diagnostica è un unico elenco di tutti i problemi del progetto aperto: i problemi dei file di progetto, di pagina e di destinazione, le voci che l'ultimo invio o salvataggio non è riuscito a generare e gli avvisi di versione e di effetto dell'ultimo invio. Ogni riga mostra la gravità, un codice, la pagina o il file, la posizione nel file e il dettaglio, e il titolo della vista conta errori, avvisi e note. La casella di filtro cerca in codice, pagina, file, posizione e testo. Fai clic su una riga, o premi Enter, per aprire il file nell'editor di testo in quella posizione; un avviso di un invio apre il canale SCADA della vista Output, che lo registra. Gli stessi risultati sono sottolineati nell'editor di testo ed elencati nella vista Problemi.

L'elenco contiene anche i problemi degli elenchi di testi, i risultati sugli allarmi dell'ultima generazione, una riga per tipo con un conteggio ed esempi, e un avviso per ogni allarme che l'istanza FUXA contiene già con un altro nome (vedi Allarmi e invio sopra). Un risultato di una regola di allarme indica la regola, per esempio rule motor-faults, nella colonna della posizione; fai clic per aprire il file delle regole su quella regola. Un risultato su un segnale indica il segnale; fai clic per vedere il segnale selezionato nella vista Segnali, con l'eventuale filtro che lo nasconderebbe rimosso. Passa il mouse su un codice per vederne il significato.

Mentre il progetto legge più PLC, una colonna Categoria contrassegna con PLC e il nome del PLC i problemi dei suoi PLC, delle loro sorgenti di segnali, del PLC di una pagina o di uno slot e dei PLC di una destinazione, e anche la casella di filtro cerca in essa. Un problema di PLC che non indica alcuna pagina o file mostra, quando fai clic, la riga di quel PLC nella vista Segnali.

Invio

Invio elenca gli invii del progetto aperto, dal più recente: l'ora, la destinazione con il suo ambiente, se sono state scritte solo le pagine modificate o l'intero progetto, il risultato (Inviato, Inviato in parte o Non riuscito), quante pagine quell'invio ha scritto e rimosso, e l'errore. Le righe di invii di una versione precedente di Studio che scrivevano solo le pagine modificate mostrano invece il numero di pagine di Studio, per esempio Studio pages: 5, removed: 0. Mostra backup mostra il backup che Studio ha scritto prima di quell'invio e Apri FUXA apre la destinazione di quella riga. La vista segue il registro degli invii, così un nuovo invio compare subito. Da questa vista non viene inviato nulla.

Corrispondenze delle regole

Corrispondenze delle regole mostra cosa fanno le regole ai segnali caricati. Con una regola selezionata nella vista Regole, elenca le corrispondenze di quella regola: il segnale, se è un blocco dati, una struttura o un segnale, il campo, l'esito (Vincente, Scavalcata o Interrotta) e cosa l'ha scavalcata, un'altra regola o un'assegnazione manuale. Senza selezione, elenca tutte le vincenti, raggruppate per regola. Vengono elencate al massimo le prime 1000 righe di una regola e il titolo della vista lo segnala quando alcune righe sono state tralasciate. Fai clic su una riga per spiegare il widget che mostra quel segnale.

Due chip sopra la tabella scelgono cosa elenca la vista: Corrispondenze delle regole, l'elenco descritto sopra, e Corrispondenze degli allarmi, gli allarmi generati dalle tue regole di allarme nell'ultima generazione. Per ogni allarme mostra la regola, il segnale (con il bit per un allarme su bit) e il livello, ordinati per regola e poi per segnale, al massimo 1000 righe per regola. Il titolo indica quanti allarmi provengono da quante regole, per esempio Alarm hits: 3, alarm rules with hits: 1, e aggiunge una nota quando il file delle regole è cambiato dopo quella generazione, così da ricordarti di generare di nuovo le pagine. Fai clic su una riga, o premi Enter, per spiegare il widget che mostra il suo segnale. I tasti freccia passano da un chip all'altro.

Output

Il canale SCADA della vista Output registra ciò che è stato eseguito: i passi di ogni invio con i relativi avvisi, le voci che un invio o un salvataggio non è riuscito a generare, ogni applicazione delle regole, ogni progetto aperto o chiuso, ogni caricamento di segnali, ogni lettura di una CPU e ogni test di connessione. Guarda lì quando un messaggio rimanda all'output SCADA.

La barra di stato

Mentre è aperto un progetto SCADA, la barra di stato mostra:

  • La destinazione SCADA, per esempio SCADA: dev, FUXA 1.3.4 checked: l'ambiente della destinazione dell'indirizzo FUXA e la versione di FUXA rilevata dall'ultimo invio, con l'indicazione se Studio ha verificato quella versione. Il suo tooltip indica il file di destinazione, l'indirizzo FUXA e la connessione della dashboard; mentre il progetto legge più PLC, elenca ogni PLC con la sua connessione e contrassegna un PLC che la destinazione non elenca come connesso con le impostazioni. Fai clic per le azioni sulla destinazione: Imposta login e ambiente della destinazione..., Cancella login e ambiente della destinazione, Testa connessione FUXA, Apri FUXA, Apri FUXA nel browser di sistema, Apri file di destinazione e Cambia indirizzo e connessione FUXA....
  • Il proprietario della pagina selezionata o aperta, Owner: Studio o Owner: Runtime editor. Fai clic per mostrare la vista Pagine.
  • Le regole, per esempio Rules: 4 active, 6 built-in, oppure Rules: problems con il primo problema nel tooltip. Fai clic per mostrare la vista Regole.
  • La sorgente dei segnali: il file da cui provengono i segnali, contrassegnato con (non caricato) finché non vengono caricati. Il suo tooltip indica il numero di blocchi dati e l'indice del namespace. Fai clic per mostrare la vista Segnali.

Mentre la modalità live è attiva, compare anche Live (vedi Modalità live sopra).

Distribuire un'istanza FUXA

Se non usi ancora FUXA, Studio può avviarne una per te in un container Docker. Apri la categoria SCADA delle impostazioni e usa la sezione Distribuzione: imposta l'Host Docker (vuoto per il motore Docker locale, oppure un motore remoto), poi Verifica Docker e Distribuisci una nuova istanza, oppure Distribuisci da file Compose... con un tuo file Docker Compose. Avvia, Arresta e Riavvia controllano poi il container. Le stesse azioni si trovano nel riquadro comandi, per esempio Distribuisci FUXA in Docker. Ognuna mostra avanzamento e risultato come notifica, e un'istanza distribuita compila per te l'indirizzo FUXA. Serve che Docker sia installato e in esecuzione sull'host scelto. Se hai installato FUXA direttamente, per esempio su un portatile senza Docker, salta le azioni Docker e inserisci solo il suo indirizzo; anche per questa installazione funzionano il backup della cartella dei dati e l'attivazione del login.

Distribuisci installa una release di FUXA verificata da Studio. Prima di creare il container, Studio chiede dove FUXA deve essere raggiungibile: Solo sull'host Docker (consigliato: gli altri computer non possono aprire FUXA e Studio lo raggiunge solo quando Docker è in esecuzione su questo computer), oppure su un indirizzo di rete dell'host Docker che inserisci tu, così le postazioni operatore di quella rete possono aprirlo; in tal caso attiva il login di FUXA e proteggi quella rete con un firewall. Il container si riavvia da solo quando si riavvia l'host Docker, a meno che tu non l'abbia arrestato. Il tuo progetto FUXA, gli utenti, i log e una libreria di simboli preparata sono conservati in volumi Docker, quindi restano quando il container viene sostituito da una release verificata più recente. Quando esiste già un container FUXA, Distribuisci chiede conferma prima di sostituirlo: Studio esegue prima il backup dei volumi in una cartella che scegli, avvia il nuovo container e rimuove quello vecchio solo quando il nuovo è in esecuzione. Se qualcosa non riesce, torna il container vecchio. Un container che esegue già la release verificata resta com'è.

Attivare il login di FUXA

Dopo la prima distribuzione, Studio propone di attivare subito il login di FUXA: inserisci il nome utente dell'amministratore FUXA (viene suggerito quello predefinito admin) e una nuova password di almeno 8 caratteri, due volte. Studio conserva la password in modo sicuro e da quel momento la usa per accedere. Se salti questo passo, un messaggio avvisa che chiunque raggiunga l'indirizzo ha i diritti di amministratore finché non attivi il login.

Per attivarlo più tardi, o per un FUXA installato direttamente, esegui Abilita login FUXA (il pulsante Abilita login... della riga Login FUXA nelle impostazioni). Dopo la tua conferma, chiunque apra FUXA deve eseguire l'accesso, operatori compresi, e Studio sostituisce la password dell'amministratore che indichi e la conserva.

Backup, ripristino e installazione offline

La riga Backup e installazione offline della sezione Distribuzione, e i comandi corrispondenti nel riquadro comandi, si occupano dell'istanza:

  • Esegui backup... (Esegui backup dei volumi FUXA) scrive i volumi del container FUXA in un unico file di archivio in una cartella che scegli; il container si ferma per breve tempo durante la copia. Per un FUXA installato direttamente, copia invece la cartella dei dati con cui FUXA è in esecuzione; arresta FUXA prima di farlo.
  • Ripristina... (Ripristina volumi FUXA) riporta un backup dei volumi creato da Studio. Studio scrive prima un nuovo backup dello stato attuale in una cartella che scegli, e la conferma indica cosa sostituisce il ripristino: l'intero progetto sull'istanza con i suoi utenti, lo storico degli allarmi e i log, quante pagine vengono sostituite e che gli allarmi attivi vengono azzerati. Un container che era in esecuzione viene poi riavviato.
  • Carica file immagine... (Carica immagine FUXA da file) carica in Docker un file immagine di FUXA, per un host Docker senza accesso a internet. Quando il file contiene la release verificata, Distribuisci funziona poi offline; altrimenti il messaggio ti dice cosa cambiare.
  • Esporta modello Compose... (Esporta modello Docker Compose) scrive un file Docker Compose per la release verificata, con l'indirizzo su cui FUXA è in ascolto e, se lo scegli, un reverse proxy che serve FUXA tramite HTTPS. Distribuiscilo con Distribuisci da file Compose....

Ogni modifica dell'immagine FUXA e ogni ripristino scrivono prima un backup.

I tuoi simboli nell'editor FUXA

La dashboard generata incorpora già i simboli usati dalle tue pagine, quindi non serve altro per vederli. Se modifichi una pagina nell'editor nel browser del runtime (vedi Unire o sostituire sopra) e vuoi scegliere lì i tuoi simboli dalla sua tavolozza, rendili disponibili una volta nella sezione Libreria di simboli delle impostazioni SCADA: Prepara nel container... copia una cartella di simboli nel container Docker in esecuzione e riavvia FUXA. Un container distribuito da Studio mantiene la libreria quando viene sostituito da una release più recente; qualsiasi altro container richiede di nuovo la preparazione dopo essere stato ricreato. Esporta..., disponibile anche come Esporta simboli in FUXA nella barra del titolo della vista Simboli, scrive la libreria nella cartella delle forme di un FUXA installato direttamente e la registra lì; riavvia poi FUXA. Vedi Impostazioni per i dettagli.

Lascia che sia l'assistente a costruirlo

L'assistente della chat lavora sul progetto SCADA aperto. Fa parte di IA per SCADA nel piano Pro+, e la prova gratuita lo sblocca; con il piano Pro costruisci i dashboard da solo, e la chat non offre né gli strumenti SCADA né l'agente SCADA Builder. Su tua istruzione può:

  • leggere il progetto, le sue pagine e le sue destinazioni, e i segnali caricati per il progetto;
  • creare, aprire o chiudere un progetto e importare un piano delle schermate salvato;
  • caricare i segnali di una CPU che hai collegato in PLC / OPC UA, come sorgente dei segnali del progetto. Legge soltanto la CPU e chiede prima, e mentre carica, le azioni di caricamento della vista Segnali non sono disponibili;
  • proporre pagine: sceglie i segnali che contano, li raggruppa in pagine con un nome, contrassegna gli allarmi e scrive il risultato nei file delle pagine. Le pagine modificate restano non salvate finché non le salvi, e l'Anteprima dell'assistente nella vista Proprietà e i segnali spuntati nella vista Segnali mostrano che cosa ha proposto. La sua conferma nomina ogni pulsante delle pagine proposte che commuta un segnale nel PLC;
  • con un progetto EPLAN aperto, raggruppare i segnali caricati secondo la struttura dell'impianto di EPLAN e costruire una pagina per ogni luogo di installazione, assegnazione funzionale o impianto (richiede una licenza EPLAN);
  • modificare singole pagine e widget: creare, rinominare, ridimensionare, spostare o eliminare pagine, posizionare, spostare, ridimensionare, etichettare o rimuovere widget, scegliere un simbolo o tornare al widget indicato dalle regole, impostare colori, pulsanti di comando, schede e righe di riquadri, e modificare l'intestazione e la navigazione. Prima di modificare le pagine, la sua conferma nomina ogni pulsante che dopo la modifica scrive nel PLC per la prima volta o in modo diverso: un pulsante che commuta il suo segnale, e un pulsante di comando con il valore che scrive. Se Studio prevede che la modifica venga rifiutata, la conferma lo dice e spiega perché. I campi di input e i cursori, dove è un operatore a inserire il valore, non fanno parte di questo elenco;
  • lavorare su una pagina come fai tu nell'editor delle pagine: spostare, ridimensionare, aggiungere, rinominare e rimuovere widget come fa un trascinamento o un rilascio, una modifica alla volta, e selezionare widget, così che l'editor delle pagine e la vista Proprietà ti mostrino quali intende. La sua conferma nomina la pagina e i widget, e indica quando la pagina viene prima portata sul layout libero;
  • collegare segnali: collegare, sostituire e rimuovere i segnali degli slot, aggiungere o modificare stati, posizionare i widget che le regole assegnano ai segnali rilasciati, salvare un collegamento come predefinito del suo simbolo, e salvare un widget come regola per il suo tipo o per il suo unico segnale. La sua conferma nomina che cosa cambia e ogni pulsante che in seguito scrive nel PLC;
  • disegnare una pagina come la mostra l'anteprima dell'editor delle pagine, con valori simulati e una scheda aperta, per verificare il proprio lavoro prima di un invio;
  • aprire FUXA in una scheda del browser di Studio, leggere la pagina e fare uno screenshot, per esempio per confrontare una pagina dopo un invio;
  • creare il file delle regole, che resta non salvato finché non lo salvi e che Annulla rimuove di nuovo, modificarne le regole, attivarle e disattivarle, e applicarle tramite la stessa Anteprima refactoring, dove decidi tu che cosa viene scritto;
  • leggere e modificare le regole degli allarmi: aggiungerle, modificarle, spostarle e rimuoverle, attivarle e disattivarle, e dirti quali allarmi ha generato ogni regola nell'ultima compilazione e che cosa significano gli avvisi su di esse. Le sue modifiche restano non salvate finché non salvi il file delle regole, e un solo Annulla le ritira;
  • importare un elenco di testi dal contenuto di un file CSV o JSON, ed elencare gli elenchi di testi del progetto con le loro voci;
  • impostare il filtro allarmi di una tabella allarmi e il buffer, gli slot e le colonne di una tabella messaggi;
  • spiegare un widget come fa Perché questo widget?, compreso il modo in cui la sua pagina è entrata nella navigazione;
  • impostare i collegamenti di stato di un simbolo o dello sfondo della pagina, impostare gli stati predefiniti di un simbolo nel suo manifest, ed elencare i simboli della cartella dei simboli del progetto con le loro parti, i loro slot e i loro problemi. Prima di impostare gli stati predefiniti, la sua conferma nomina il simbolo e il numero di stati; il manifest resta non salvato finché non lo salvi, e Annulla ritira la modifica;
  • verificare che cosa farebbe un invio prima di inviare: il backup, le voci di Studio che un'unione rimuoverebbe, se vengono scritte solo le pagine modificate o l'intero progetto e perché, il riavvio del runtime con il numero di allarmi attivi, ed eventuali avvisi di versione;
  • inviare le pagine salvate a una destinazione di sviluppo o di test, sempre come unione e solo le pagine modificate dove basta, e dirti chiaramente se l'invio è andato a buon fine, è stato rifiutato o non è riuscito, e che cosa ha inviato;
  • salvare un file di progetto FUXA o un file di configurazione SCADA;
  • modificare i dettagli di una destinazione esistente, come il suo nome utente FUXA, la versione minima di FUXA che accetta, o il modo in cui raggiunge ogni PLC del progetto;
  • scegliere quale PLC legge una pagina e collegare un widget ai segnali di qualsiasi PLC del progetto;
  • scegliere quali ruoli vedono e gestiscono una pagina o un singolo widget, e quali ruoli vedono e confermano gli allarmi di una regola degli allarmi;
  • impostare le lingue del progetto, e mostrare o nascondere il pulsante della lingua nell'intestazione del runtime;
  • rendere una pagina la vista di dettaglio di un tipo di dati, che ogni struttura di quel tipo apre come scheda. Non rende mai una vista di dettaglio la pagina iniziale e non la mostra mai nella navigazione, e quando un file di pagina ha problemi, ti chiede di ripararlo prima di rendere quella pagina la pagina iniziale o di mostrarla nella navigazione;
  • aggiungere, modificare o rimuovere una notifica, una alla volta. Nomina soltanto il destinatario: l'indirizzo e-mail o l'indirizzo web lo memorizzi tu con Imposta destinatario delle notifiche..., e l'assistente non lo vede mai;
  • gestire il deployment Docker: verificare Docker, eseguire il deployment, avviare, arrestare o riavviare il container, preparare i simboli dal progetto ed esportare un modello Docker Compose;
  • consegnare una pagina all'editor nel browser del runtime e riprenderla con Ripristina stato di Studio, inviare a una destinazione di produzione, e sostituire l'intero progetto su un'istanza. Ognuna di queste azioni ti chiede prima nella chat e poi di nuovo in Studio, prima che cambi qualcosa: una consegna nella propria finestra di dialogo, anche quando la chat approva i propri passaggi da sola, una ripresa con il backup, le differenze e la sua conferma, e un invio in produzione o una sostituzione con le conferme di invio di Studio. Una sostituzione resta rifiutata finché una pagina appartiene all'editor nel browser del runtime.

Qualunque cosa l'assistente modifichi nei file del progetto resta non salvata finché non la salvi, e puoi annullarla; modificare i file non invia mai nulla. Usa soltanto i PLC, i ruoli, i tipi di dati e i membri che il tuo progetto ha già. Con la modalità live attiva, le sue modifiche vengono inviate solo quando le salvi tu.

L'assistente non modifica una pagina che appartiene all'editor nel browser del runtime (proprietario Editor del runtime). Quando una richiesta modificherebbe una pagina di questo tipo, non viene modificato nulla, e l'assistente ti dice di quale pagina si tratta. Può comunque spostare quella pagina nell'elenco, renderla la pagina iniziale, modificarne la voce di navigazione o eliminarla.

Prima che l'assistente faccia clic, digiti, trascini o passi il mouse in una pagina web, per esempio in FUXA in una scheda del browser di Studio, te lo chiede: la domanda Fare clic sull'elemento?, Digitare nella pagina?, Trascinare l'elemento? o Passare il mouse sull'elemento? nomina l'elemento e la pagina, e per la digitazione il testo o il tasto. Un clic su un controllo di un dashboard in esecuzione può scrivere un valore nel PLC, quindi verifica l'elemento prima di consentirlo. Quando lasci che la chat approvi i propri passaggi da sola, queste domande vengono saltate come ogni altra conferma.

Alcuni passaggi restano a te: elencare i ruoli del progetto, configurare gli utenti del runtime, memorizzare o cancellare un destinatario delle notifiche, caricare un file node set o l'esportazione del progetto TIA, connetterti a una CPU in PLC / OPC UA, scegliere la cartella dei simboli, attivare o disattivare la modalità live, impostare l'indice dello spazio dei nomi, creare una destinazione, impostare il login e lo stadio di una destinazione, eseguire il backup e il ripristino dei volumi, caricare un file immagine, eseguire il deployment da un file Compose, aggiungere o modificare disegni di simboli, modificare a mano le dimensioni, gli slot e le parti di un manifest di simbolo, ed esportare la libreria dei simboli in un'installazione FUXA. Le password non passano mai attraverso l'assistente: quando un'azione ne richiede una, Studio te la chiede direttamente.

Gli strumenti SCADA dell'assistente compaiono come gruppo a sé in Autorizzazioni strumenti, così puoi decidere per ciascuno di essi, o per l'intero gruppo, se chiede ogni volta, viene eseguito senza chiedere o viene sempre negato (vedi Chat IA). Uno strumento che modifica qualcosa e che hai impostato su nega sempre resta negato anche mentre la chat approva gli strumenti da sola. Un invio dall'assistente mostra comunque le conferme di Studio, e l'applicazione delle regole apre comunque l'Anteprima refactoring.

I due comandi da file

Due comandi funzionano direttamente da un file, senza un progetto SCADA:

  • Genera progetto FUXA, nel menu contestuale di un file *.scada.json (o dal riquadro comandi), costruisce un progetto FUXA da quella configurazione e lo salva oppure lo invia alla tua istanza; la finestra di invio ti permette di unirlo al progetto sull'istanza o di sostituire quel progetto.
  • Genera SCADA dai nodi OPC UA, nel menu contestuale di un file node set *.xml (o dal riquadro comandi), legge il node set OPC UA esportato di una CPU e ne costruisce lo stesso dashboard, poi offre di salvare una configurazione, inviarla alla tua istanza o scrivere un file di progetto.

Entrambi chiedono l'indirizzo a cui si connette il dashboard, corrispondente alla Connessione nelle impostazioni, ed eseguono le stesse protezioni a ogni invio: il controllo dello stadio, le conferme, il backup e il registro degli invii. Poiché non inviano il tuo progetto SCADA, non rimuovono mai nulla dall'istanza, e il loro backup e il loro registro degli invii vanno in una cartella di Studio, che il messaggio dopo il backup indica.