using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using NLog;

namespace SCMA.AdapterPLC
{
    using AdapterCom;
    using MTC;
    using OPC_UA_REDIS;

    #region macro oggetti da istanziare a blocchi da configurazione XML

    /// <summary>
    /// Singola pompa da vuoto, 0..n
    /// </summary>
    public class VacuumPump : element
    {
        /// <summary>
        /// Stato: ACTIVE/INACTIVE
        /// </summary>
        public string statusKey { get { return string.Format("{0}_Status", ident); } }

        /// <summary>
        /// Valore work time della pompa vuoto
        /// </summary>
        public string workTimeKey { get { return string.Format("{0}_WrkTime", ident); } }

        /// <summary>
        /// Classe Vacuum Pump (pompa)
        /// </summary>
        /// <param name="baseElem">element base contenente parametri (da XML)</param>
        public VacuumPump(element baseElem)
        {
            ident = baseElem.ident;
            dataRefList = baseElem.dataRefList;
        }
    }

    /// <summary>
    /// Singolo attuatore vuoto, 0..n
    /// </summary>
    public class VacuumAct : element
    {
        /// <summary>
        /// valore contatore azioni
        /// </summary>
        public string countKey { get { return string.Format("{0}_Count", ident); } }

        /// <summary>
        /// Classe Vacuum Actuator (valvola)
        /// </summary>
        /// <param name="baseElem">element base contenente parametri (da XML)</param>
        public VacuumAct(element baseElem)
        {
            ident = baseElem.ident;
            dataRefList = baseElem.dataRefList;
        }
    }

    /// <summary>
    /// Singolo attuatore per lubrificazione, 0..n
    /// </summary>
    public class Lubro : element
    {
        /// <summary>
        /// Stato: ACTIVE/INACTIVE
        /// </summary>
        public string statusKey { get { return string.Format("{0}_Status", ident); } }

        /// <summary>
        /// valore contatore (numero pompate necessarie per far scattare sensore)
        /// </summary>
        public string countKey { get { return string.Format("{0}_Count", ident); } }

        /// <summary>
        /// Classe Lubrorefrigerante
        /// </summary>
        /// <param name="baseElem">element base contenente parametri (da XML)</param>
        public Lubro(element baseElem)
        {
            ident = baseElem.ident;
            dataRefList = baseElem.dataRefList;
        }
    }

    /// <summary>
    /// Singola Slitta Mag, 0..n
    /// </summary>
    public class SlittaMag : element
    {
        /// <summary>
        /// valore contatore (numero attivazioni/disattivazioni slitta magazzino)
        /// </summary>
        public string countKey { get { return string.Format("{0}_Count", ident); } }

        /// <summary>
        /// Classe Slitta Magazzino
        /// </summary>
        /// <param name="baseElem">element base contenente parametri (da XML)</param>
        public SlittaMag(element baseElem)
        {
            ident = baseElem.ident;
            dataRefList = baseElem.dataRefList;
        }
    }

    /// <summary>
    /// Singolo attuatore Protezione Magazzino, 0..n
    /// </summary>
    public class ProtMag : element
    {
        /// <summary>
        /// valore contatore (numero attivazioni/disattivazioni valvola)
        /// </summary>
        public string countKey { get { return string.Format("{0}_Count", ident); } }

        /// <summary>
        /// Classe Protezione Magazzino
        /// </summary>
        /// <param name="baseElem">element base contenente parametri (da XML)</param>
        public ProtMag(element baseElem)
        {
            ident = baseElem.ident;
            dataRefList = baseElem.dataRefList;
        }
    }

    /// <summary>
    /// Singolo refrigeratore, 0..n
    /// </summary>
    public class Cooler : element
    {
        /// <summary>
        /// Stato: ACTIVE/INACTIVE
        /// </summary>
        public string statusKey { get { return string.Format("{0}_Status", ident); } }

        /// <summary>
        /// Classe refrigeratore
        /// </summary>
        /// <param name="baseElem">element base contenente parametri (da XML)</param>
        public Cooler(element baseElem)
        {
            ident = baseElem.ident;
            dataRefList = baseElem.dataRefList;
        }
    }

    /// <summary>
    /// Singola Pressione rilevata, 0..n
    /// </summary>
    public class Press : element
    {
        /// <summary>
        /// valore variabile (valore pressione istantaneo)
        /// </summary>
        public string valueKey { get { return string.Format("{0}_Value", ident); } }

        /// <summary>
        /// Classe pressione con Idx e descrizione
        /// </summary>
        /// <param name="baseElem">element base contenente parametri (da XML)</param>
        public Press(element baseElem)
        {
            ident = baseElem.ident;
            dataRefList = baseElem.dataRefList;
        }
    }

    /// <summary>
    /// Singola temperatura rilevata, 0..n
    /// </summary>
    public class Tempe : element
    {
        /// <summary>
        /// valore variabile (valore temperatura istantaneo)
        /// </summary>
        public string valueKey { get { return string.Format("{0}_Value", ident); } }

        /// <summary>
        /// Classe temperatura con Idx e descrizione
        /// </summary>
        /// <param name="baseElem">element base contenente parametri (da XML)</param>
        public Tempe(element baseElem)
        {
            ident = baseElem.ident;
            dataRefList = baseElem.dataRefList;
        }
    }

    /// <summary>
    /// Singola Area Memoria (Kvara 1..4)
    /// </summary>
    public class MemArea : element
    {
        /// <summary>
        /// Programma caricato
        /// </summary>
        public string prgNameKey { get { return string.Format("{0}_PROG_NAME", ident); } }

        /// <summary>
        /// Programma caricato
        /// </summary>
        public string prgRunningKey { get { return string.Format("{0}_RUNNING", ident); } }

        /// <summary>
        /// Programma caricato
        /// </summary>
        public string numExeKey { get { return string.Format("{0}_NUM_EXE", ident); } }

        /// <summary>
        /// Programma caricato
        /// </summary>
        public string numRepKey { get { return string.Format("{0}_NUM_REP", ident); } }

        /// <summary>
        /// INIT Classe Memory Area
        /// </summary>
        /// <param name="baseElem">element base contenente parametri (da XML)</param>
        public MemArea(element baseElem)
        {
            ident = baseElem.ident;
            dataRefList = baseElem.dataRefList;
        }
    }

    /// <summary>
    /// Singolo path, da 1..20
    /// </summary>
    public class Path : element
    {
        /// <summary>
        /// Tipo Path (LAVOR/ASSERV)
        /// </summary>                        
        public string pathTypeKey { get { return string.Format("{0}_Type", ident); } }
        /// <summary>
        /// Cod Particolare su Path
        /// </summary>                                
        public string partIdKey { get { return string.Format("{0}_PartId", ident); } }
        /// <summary>
        /// Contapezzi x PATH
        /// </summary>                         
        public string partCountKey { get { return string.Format("{0}_PZ_TOT", ident); } }
        /// <summary>
        /// Codici M sul PATH
        /// </summary>                        
        public string pathCodMKey { get { return string.Format("{0}_Cod_M", ident); } }
        /// <summary>
        /// Codici S sul PATH
        /// </summary>                      
        public string pathCodSKey { get { return string.Format("{0}_Cod_S", ident); } }
        /// <summary>
        /// Codici T sul PATH
        /// </summary>                     
        public string pathCodTKey { get { return string.Format("{0}_Cod_T", ident); } }
        /// <summary>
        /// Modalità RUN del PATH: AUTO/EDIT/MDI/JOG/JOGINC/REF/HANDLE
        /// </summary>
        public string runModeKey { get { return string.Format("{0}_RUN_MODE", ident); } }
        /// <summary>
        /// Modalità execution del path: RUN/HOLD/FEED_HOLD/...
        /// </summary>                         
        public string exeModeKey { get { return string.Format("{0}_EXE_MODE", ident); } }
        /// <summary>
        /// Programma corrente
        /// </summary>          
        public string currProgKey { get { return string.Format("{0}_CurrProg", ident); } }
        /// <summary>
        /// Area Programma corrente/selezionata
        /// </summary>            
        public string currAreaKey { get { return string.Format("{0}_CurrArea", ident); } }
        /// <summary>
        /// num riga corrente
        /// </summary>            
        public string currProgRowNumKey { get { return string.Format("{0}_CurrProg_RowNum", ident); } }
        /// <summary>
        /// Assi attivi per path
        /// </summary>         
        public string activeAxesKey { get { return string.Format("{0}_ActiveAxes", ident); } }
        /// <summary>
        /// Feedrate
        /// </summary>                  
        public string feedKey { get { return string.Format("{0}_FeedRate", ident); } }
        /// <summary>
        /// Override feed
        /// </summary>       
        public string feedOverKey { get { return string.Format("{0}_FeedOverr", ident); } }
        /// <summary>
        /// Override speed
        /// </summary>     
        public string rapidOverKey { get { return string.Format("{0}_RapidOverr", ident); } }
        /// <summary>
        /// Override Jog
        /// </summary>    
        public string jogOverKey { get { return string.Format("{0}_JogOverr", ident); } }
        /// <summary>
        /// Override Spindle_01
        /// </summary>       
        public string spindleOver_01_Key { get { return string.Format("{0}_SpindleOver_01", ident); } }
        /// <summary>
        /// Override Spindle_02
        /// </summary>                          
        public string spindleOver_02_Key { get { return string.Format("{0}_SpindleOver_02", ident); } }
        /// <summary>
        /// Override Spindle_03
        /// </summary>                       
        public string spindleOver_03_Key { get { return string.Format("{0}_SpindleOver_03", ident); } }
        /// <summary>
        /// Override Spindle_04
        /// </summary>                   
        public string spindleOver_04_Key { get { return string.Format("{0}_SpindleOver_04", ident); } }
        /// <summary>
        /// Posizione X
        /// </summary>  
        public string posAct_X_Key { get { return string.Format("{0}_PosActX", ident); } }
        /// <summary>
        /// Posizione Y
        /// </summary>                    
        public string posAct_Y_Key { get { return string.Format("{0}_PosActY", ident); } }
        /// <summary>
        /// Posizione Z
        /// </summary>               
        public string posAct_Z_Key { get { return string.Format("{0}_PosActZ", ident); } }
        /// <summary>
        /// Angolo I
        /// </summary>       
        public string posAct_I_Key { get { return string.Format("{0}_PosActI", ident); } }
        /// <summary>
        /// Angolo J
        /// </summary>    
        public string posAct_J_Key { get { return string.Format("{0}_PosActJ", ident); } }
        /// <summary>
        /// Angolo K
        /// </summary>   
        public string posAct_K_Key { get { return string.Format("{0}_PosActK", ident); } }
        /// <summary>
        /// Stato dei codici G attivi
        /// </summary>  
        public string gCodeAct_Key { get { return string.Format("{0}_CodG_Act", ident); } }
        /// <summary>
        /// Stato dei SubMode attivi
        /// </summary>               
        public string subModeKey { get { return string.Format("{0}_SubMode", ident); } }
        /// <summary>
        /// Allarmi CNC del PATH
        /// </summary>          
        public string alarmCncKey { get { return string.Format("{0}_AlarmCNC", ident); } }
        /// <summary>
        /// Allarmi PCL del PATH
        /// </summary>      
        public string alarmPlcKey { get { return string.Format("{0}_AlarmPLC", ident); } }
        /// <summary>
        /// Classe Path con Idx e descrizione
        /// </summary>
        /// <param name="baseElem">element base contenente parametri (da XML)</param>
        public Path(element baseElem)
        {
            ident = baseElem.ident;
            dataRefList = baseElem.dataRefList;
        }
    }

    /// <summary>
    /// Singolo mandrino, 1..n
    /// </summary>
    public class UnOp : element
    {
        /// <summary>
        /// ToolID
        /// </summary>                     
        public string toolIdKey { get { return string.Format("{0}_ToolId", ident); } }
        /// <summary>
        /// valore numero Cambi Utensili effettuato
        /// </summary>                       
        public string numCUKey { get { return string.Format("{0}_NumCU", ident); } }
        /// <summary>
        /// status utensili
        /// </summary>                        
        public string statusKey { get { return string.Format("{0}_Status", ident); } }
        /// <summary>
        /// valore vita residua utensile
        /// </summary>                      
        public string vitaResKey { get { return string.Format("{0}_VitaRes", ident); } }
        /// <summary>
        /// tipologia di vita residua utensile:
        /// 0 : "ND" (famiglia senza gestione vitautensili)
        /// 1 : "Time [s]"
        /// 2 : "Stroke [n]"
        /// 3 : "Distance [m]" ([ft] se la macchina è impostata in pollici)
        /// </summary> 
        public string vitaResTypeKey { get { return string.Format("{0}_VitaResType", ident); } }
        /// <summary>
        /// valore speed
        /// </summary>                       
        public string speedKey { get { return string.Format("{0}_Speed", ident); } }
        /// <summary>
        /// valore speed override
        /// </summary>                            
        public string speedOverKey { get { return string.Format("{0}_SpeedOverr", ident); } }
        /// <summary>
        /// valore load
        /// </summary>                         
        public string loadKey { get { return string.Format("{0}_Load", ident); } }
        /// <summary>
        /// valore tempo cumulato di impiego
        /// </summary>                       
        public string accTimeKey { get { return string.Format("{0}_AccTime", ident); } }
        /// <summary>
        /// contatore cumulato di giri mandrino (migliaia)
        /// </summary>                       
        public string kRevKey { get { return string.Format("{0}_KRev", ident); } }
        /// <summary>
        /// contatore cumulato di apertura testa
        /// </summary>                       
        public string countKey { get { return string.Format("{0}_Count", ident); } }
        /// <summary>
        /// Classe Unita Operatrice (Mandrino) con Idx e descrizione
        /// </summary>
        /// <param name="baseElem">element base contenente parametri (da XML)</param>
        public UnOp(element baseElem)
        {
            ident = baseElem.ident;
            dataRefList = baseElem.dataRefList;
        }
    }

    /// <summary>
    /// Asse singolo, 1..n
    /// </summary>
    public class Axis : element
    {
        /// <summary>
        /// Descrizione asse (nome assegnato)
        /// </summary>
        public string descriptionKey { get { return string.Format("{0}_Descr", ident); } }
        /// <summary>
        /// Processo di appartenenza
        /// </summary>                           
        public string mainProcKey { get { return string.Format("{0}_MainProc", ident); } }
        /// <summary>
        /// Bit se sia master (=1) o slave (=0)
        /// </summary>    
        public string isMastKey { get { return string.Format("{0}_IsMast", ident); } }
        /// <summary>
        /// ID del master
        /// </summary>                        
        public string mastIdKey { get { return string.Format("{0}_MastId", ident); } }
        /// <summary>
        /// Gruppo di appartenenza dell'asse
        /// </summary>        
        public string groupKey { get { return string.Format("{0}_Grp", ident); } }
        /// <summary>
        /// Tipo asse: lineare, rotazionale...
        /// </summary>         
        public string typeKey { get { return string.Format("{0}_Type", ident); } }
        /// <summary>
        /// Bit direzione: 1 = avanti/clockwise, 0 indietro/counterclockwise
        /// </summary>             
        public string directionKey { get { return string.Format("{0}_Dir", ident); } }
        /// <summary>
        /// load
        /// </summary>                                
        public string loadKey { get { return string.Format("{0}_Load", ident); } }
        /// <summary>
        /// posizione attuale
        /// </summary>                          
        public string posActKey { get { return string.Format("{0}_PosAct", ident); } }
        /// <summary>
        /// posizione target
        /// </summary>
        public string posTgtKey { get { return string.Format("{0}_PosTgt", ident); } }
        /// <summary>
        /// feed attuale
        /// </summary>                        
        public string feedrateKey { get { return string.Format("{0}_FeedAct", ident); } }
        /// <summary>
        /// Feed Override
        /// </summary>                          
        public string feedOverKey { get { return string.Format("{0}_FeedOver", ident); } }
        /// <summary>
        /// Accelerazione Attuale
        /// </summary>  
        public string accelActKey { get { return string.Format("{0}_AccelAct", ident); } }
        /// <summary>
        /// Tempo Lavoro cumulato
        /// </summary>    
        public string accTimeKey { get { return string.Format("{0}_AccTime", ident); } }
        /// <summary>
        /// Carica batteria
        /// </summary>                    
        public string batteryKey { get { return string.Format("{0}_Battery", ident); } }
        /// <summary>
        /// Distanza compiuta nell'intervallo di tempo
        /// </summary>
        public string distDoneKey { get { return string.Format("{0}_DistDone", ident); } }
        /// <summary>
        /// numero di inversioni di direzione fatte nell'intervallo di tempo
        /// </summary>
        public string invDDoneKey { get { return string.Format("{0}_InvDDone", ident); } }
        /// <summary>
        /// Allarmi CNC del PATH
        /// </summary>                                           
        public string alarmCncKey { get { return string.Format("{0}_AlarmCNC", ident); } }
        /// <summary>
        /// Allarmi PCL del PATH
        /// </summary>                            
        public string alarmPlcKey { get { return string.Format("{0}_AlarmPLC", ident); } }

        /// <summary>
        /// Classe Asse con relativo ID UNIVOCO
        /// </summary>
        /// <param name="baseElem">element base contenente parametri (da XML)</param>
        public Axis(element baseElem)
        {
            ident = baseElem.ident;
            // valori da conf esplicita
            dataRefList = baseElem.dataRefList;
        }
    }

    #endregion macro oggetti da istanziare a blocchi da configurazione XML

    public class Generic
    {
        /// <summary>
        /// inizializzo l'oggetto sulla form SULLA BASE DEL FILE DI CONFIGURAZIONE letto
        /// </summary>
        /// <param name="caller">FORM chaimante</param>
        /// <param name="adpConf">CONFIGURAZIONE adapter</param>
        /// <param name="gatewayObj">OGGETTO gestione comunicazione OUT (tipologia e metodi)</param>
        public Generic(MainForm caller, AdapterConf adpConf, Gateway gatewayObj)
        {
            lg = LogManager.GetCurrentClassLogger();
            lg.Info("Avvio preliminare AdapterGeneric");

            currGateway = gatewayObj;
            lg.Info(string.Format("Impostato protocollo di comunicazione {0}", currGateway.protocollo));

            procIotMem = utils.CRB("procIotMem");

            currAdpConf = adpConf;

            // inizializzo vettore gruppi assi, MAX 20!!!
            FeedRateGrp = new int[20];

            // inizializzo FeedRatePath...
            FeedRatePath = new int[adpConf.nPath];
            // init override path...
            FeedRateOverPath = new int[adpConf.nPath];
            RapidOverPath = new int[adpConf.nPath];
            SpeedRateOverPath = new int[adpConf.nPath];

            // salvo il form chiamante
            parentForm = caller;
            addItemsToGateway(adpConf);

            // inizializzo vettori code MST x num path...
            codaM = new List<string>[adpConf.nPath];
            codaS = new List<string>[adpConf.nPath];
            codaT = new List<string>[adpConf.nPath];
            for (int i = 0; i < adpConf.nPath; i++)
            {
                codaM[i] = new List<string>();
                codaS[i] = new List<string>();
                codaT[i] = new List<string>();
            }

            // concluso!
            lg.Info("Istanziata classe preliminare AdapterGeneric");
        }

        /// <summary>
        /// Effettua aggiunta items a Gateway...
        /// </summary>
        /// <param name="adpConf"></param>
        private void addItemsToGateway(AdapterConf adpConf)
        {

            // solo se sono in modalità SOUR aggiungo item cablati...
            if (currGateway.protocollo == gwProtocol.SOURS)
            {
                currGateway.addItemNodeAndSet("Alarm", itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet("Emergency", itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
            }
            // solo se sono in modalità MTC aggiungo item cablati...
            else
            {
                // item disponibilità
                currGateway.addItemNodeAndSet("AVAIL", itemType.Event, availStatus.AVAILABLE.ToString());
                currGateway.addItemNodeAndSet("MESSAGE", itemType.Message, "");
                // assets
                currGateway.addItemNodeAndSet("MTC_asset_chg", itemType.Event, "");
                currGateway.addItemNodeAndSet("MTC_asset_rem", itemType.Event, "");
                // modalità esecutiva e funzionale
                currGateway.addItemNodeAndSet("FUNCT_MODE", itemType.Message, "");
                // dati utente
                currGateway.addItemNodeAndSet("OperatorId", itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet("CLOCK", itemType.Sample, DateTime.Now.Date.ToFileTimeUtc());
                currGateway.addItemNodeAndSet("SlittaTastatore_Count", itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
            }
            // status, clock, emergency stop
            currGateway.addItemNodeAndSet("E_STOP", itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
            currGateway.addItemNodeAndSet("STATUS", itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());

            // tempi, potenza, processo, counters vari ACC_TIME_WORK
            currGateway.addItemNodeAndSet("ACC_TIME", itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
            currGateway.addItemNodeAndSet("ACC_TIME_WORK", itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());

            currGateway.addItemNodeAndSet("POWER", itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());

            // testing e autodiagnostica
            currGateway.addItemNodeAndSet("TESTING_DATA", itemType.Message, "");

            // strobe/status non riconosciuti
            currGateway.addItemNodeAndSet("UNK_STATUS", itemType.Message, "");
            currGateway.addItemNodeAndSet("UNK_STROBE", itemType.Message, "");

            // Aree memoria
            vettMemArea = new MemArea[adpConf.nMemArea];
            for (int i = 0; i < adpConf.nMemArea; i++)
            {
                vettMemArea[i] = new MemArea(adpConf.MemArea[i]);
                currGateway.addItemNodeAndSet(vettMemArea[i].prgNameKey, itemType.Message, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettMemArea[i].prgRunningKey, itemType.Message, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettMemArea[i].numExeKey, itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettMemArea[i].numRepKey, itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
            }
            // Pompe vuoto
            vettVacPump = new VacuumPump[adpConf.nVacuumPump];
            for (int i = 0; i < adpConf.nVacuumPump; i++)
            {
                vettVacPump[i] = new VacuumPump(adpConf.VacuumPump[i]);
                currGateway.addItemNodeAndSet(vettVacPump[i].statusKey, itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettVacPump[i].workTimeKey, itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
            }

            // Attuatori vuoto
            vettVacAct = new VacuumAct[adpConf.nVacuumAct];
            for (int i = 0; i < adpConf.nVacuumAct; i++)
            {
                vettVacAct[i] = new VacuumAct(adpConf.VacuumAct[i]);
                currGateway.addItemNodeAndSet(vettVacAct[i].countKey, itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
            }
            // Lubrorefrigeranti
            vettLubro = new Lubro[adpConf.nLubro];
            for (int i = 0; i < adpConf.nLubro; i++)
            {
                vettLubro[i] = new Lubro(adpConf.Lubro[i]);
                currGateway.addItemNodeAndSet(vettLubro[i].countKey, itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
                if (currGateway.protocollo != gwProtocol.SOURS)
                {
                    currGateway.addItemNodeAndSet(vettLubro[i].statusKey, itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
                }
            }
            // Slitta Mag
            vettSlittaMag = new SlittaMag[adpConf.nSlittaMag];
            for (int i = 0; i < adpConf.nSlittaMag; i++)
            {
                vettSlittaMag[i] = new SlittaMag(adpConf.SlittaMag[i]);
                currGateway.addItemNodeAndSet(vettSlittaMag[i].countKey, itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
            }
            // Protezione Mag
            vettProtMag = new ProtMag[adpConf.nProtMag];
            for (int i = 0; i < adpConf.nProtMag; i++)
            {
                vettProtMag[i] = new ProtMag(adpConf.ProtMag[i]);
                currGateway.addItemNodeAndSet(vettProtMag[i].countKey, itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
            }
            // Cooler
            vettCooler = new Cooler[adpConf.nCooler];
            for (int i = 0; i < adpConf.nCooler; i++)
            {
                vettCooler[i] = new Cooler(adpConf.Cooler[i]);
                currGateway.addItemNodeAndSet(vettCooler[i].statusKey, itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
            }
            // Press
            vettPress = new Press[adpConf.nPress];
            for (int i = 0; i < adpConf.nPress; i++)
            {
                vettPress[i] = new Press(adpConf.Press[i]);
                currGateway.addItemNodeAndSet(vettPress[i].valueKey, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
            }
            // Temp
            vettTempe = new Tempe[adpConf.nTemp];
            for (int i = 0; i < adpConf.nTemp; i++)
            {
                vettTempe[i] = new Tempe(adpConf.Temp[i]);
                currGateway.addItemNodeAndSet(vettTempe[i].valueKey, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
            }
            // 2019.08.28 RIMETTO GESTIONE PROCESSO SEL!
            //// lo riporto SOLO SE HO almeno 2 processi AND protocollo NON OPC-UA
            //if (currGateway.protocollo != gwProtocol.SOURS && currAdpConf.nPath > 1)
            //{
            currGateway.addItemNodeAndSet("PROC_SEL", itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
            //}
            vettPath = new Path[adpConf.nPath];
            for (int i = 0; i < adpConf.nPath; i++)
            {
                vettPath[i] = new Path(adpConf.Path[i]);
                //samples
                currGateway.addItemNodeAndSet(vettPath[i].feedKey, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettPath[i].feedOverKey, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettPath[i].rapidOverKey, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                // SOLO SE NON sono SOUR...
                if (currGateway.protocollo != gwProtocol.SOURS)
                {
                    currGateway.addItemNodeAndSet(vettPath[i].spindleOver_01_Key, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                    currGateway.addItemNodeAndSet(vettPath[i].spindleOver_02_Key, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                    currGateway.addItemNodeAndSet(vettPath[i].spindleOver_03_Key, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                    currGateway.addItemNodeAndSet(vettPath[i].spindleOver_04_Key, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                    currGateway.addItemNodeAndSet(vettPath[i].jogOverKey, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                    currGateway.addItemNodeAndSet(vettPath[i].posAct_X_Key, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                    currGateway.addItemNodeAndSet(vettPath[i].posAct_Y_Key, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                    currGateway.addItemNodeAndSet(vettPath[i].posAct_Z_Key, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                    currGateway.addItemNodeAndSet(vettPath[i].posAct_I_Key, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                    currGateway.addItemNodeAndSet(vettPath[i].posAct_J_Key, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                    currGateway.addItemNodeAndSet(vettPath[i].posAct_K_Key, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                    currGateway.addItemNodeAndSet(vettPath[i].partIdKey, itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
                    currGateway.addItemNodeAndSet(vettPath[i].partCountKey, itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
                    currGateway.addItemNodeAndSet(vettPath[i].currProgKey, itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
                    currGateway.addItemNodeAndSet(vettPath[i].currProgRowNumKey, itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
                    currGateway.addItemNodeAndSet(vettPath[i].currAreaKey, itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
                    // conditions...
                    currGateway.addItemNodeAndSet(vettPath[i].alarmCncKey, itemType.Condition, availStatus.UNAVAILABLE.ToString().ToLower());
                    currGateway.addItemNodeAndSet(vettPath[i].alarmPlcKey, itemType.Condition, availStatus.UNAVAILABLE.ToString().ToLower());
                    currGateway.addItemNodeAndSet(vettPath[i].activeAxesKey, itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
                }
                // messages & events
                currGateway.addItemNodeAndSet(vettPath[i].pathTypeKey, itemType.Message, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettPath[i].pathCodMKey, itemType.Message, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettPath[i].pathCodSKey, itemType.Message, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettPath[i].pathCodTKey, itemType.Message, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettPath[i].runModeKey, itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettPath[i].exeModeKey, itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettPath[i].gCodeAct_Key, itemType.Message, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettPath[i].subModeKey, itemType.Message, availStatus.UNAVAILABLE.ToString().ToLower());
            }
            // UnOp
            vettUnOp = new UnOp[adpConf.nUnOp];
            for (int i = 0; i < adpConf.nUnOp; i++)
            {
                vettUnOp[i] = new UnOp(adpConf.UnOp[i]);
                currGateway.addItemNodeAndSet(vettUnOp[i].toolIdKey, itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettUnOp[i].numCUKey, itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettUnOp[i].statusKey, itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettUnOp[i].vitaResKey, itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettUnOp[i].vitaResTypeKey, itemType.Message, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettUnOp[i].speedKey, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettUnOp[i].speedOverKey, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettUnOp[i].loadKey, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettUnOp[i].accTimeKey, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettUnOp[i].countKey, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());

                // SOLO SE NON sono SOUR...
                if (currGateway.protocollo != gwProtocol.SOURS)
                {
                    currGateway.addItemNodeAndSet(vettUnOp[i].kRevKey, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                }
            }
            // Assi
            vettAxis = new Axis[adpConf.nAxis];
            for (int i = 0; i < adpConf.nAxis; i++)
            {
                vettAxis[i] = new Axis(adpConf.Axis[i]);
                // SOLO SE NON sono SOUR...
                if (currGateway.protocollo != gwProtocol.SOURS)
                {
                    currGateway.addItemNodeAndSet(vettAxis[i].batteryKey, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                    currGateway.addItemNodeAndSet(vettAxis[i].groupKey, itemType.Message, availStatus.UNAVAILABLE.ToString().ToLower());
                    currGateway.addItemNodeAndSet(vettAxis[i].accelActKey, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                    currGateway.addItemNodeAndSet(vettAxis[i].isMastKey, itemType.Message, availStatus.UNAVAILABLE.ToString().ToLower());
                    // conditions...
                    currGateway.addItemNodeAndSet(vettAxis[i].alarmCncKey, itemType.Condition, availStatus.UNAVAILABLE.ToString().ToLower());
                    currGateway.addItemNodeAndSet(vettAxis[i].alarmPlcKey, itemType.Condition, availStatus.UNAVAILABLE.ToString().ToLower());
                    currGateway.addItemNodeAndSet(vettAxis[i].mastIdKey, itemType.Message, availStatus.UNAVAILABLE.ToString().ToLower());
                }
                currGateway.addItemNodeAndSet(vettAxis[i].descriptionKey, itemType.Message, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettAxis[i].mainProcKey, itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettAxis[i].directionKey, itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettAxis[i].loadKey, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettAxis[i].posActKey, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettAxis[i].posTgtKey, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettAxis[i].feedrateKey, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettAxis[i].feedOverKey, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettAxis[i].accTimeKey, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettAxis[i].distDoneKey, itemType.Sample, availStatus.UNAVAILABLE.ToString().ToLower());
                currGateway.addItemNodeAndSet(vettAxis[i].invDDoneKey, itemType.Event, availStatus.UNAVAILABLE.ToString().ToLower());
            }

            // allarmi "base"
            currGateway.addAlarmNodes();

            // 2019.07.22 NON RIPORTO USER_ACTION x SOUR
            if (currGateway.protocollo != gwProtocol.SOURS)
            {
                // azioni utente
                currGateway.addItemNodeAndSet("USER_ACTION", itemType.Message, "");
            }
        }

        /// <summary>
        /// alias booleano false = R
        /// </summary>
        public bool R = false;

        /// <summary>
        /// alias booleano true = W
        /// </summary>
        public bool W = true;

        /// <summary>
        /// wrapper di log
        /// </summary>
        public static Logger lg;

        /// <summary>
        /// valore booleano di check se sia in fase di COMUNICAZIONE ATTIVA con il PLC/NC
        /// </summary>
        protected bool adpCommAct;

        /// <summary>
        /// valore booleano di check se sia stato AVVIATO l'adapter (Running)
        /// </summary>
        public bool adpRunning = false;

        /// <summary>
        /// valore booleano di check se l'adapter STIA SALVANDO
        /// </summary>
        public bool adpSaving = false;

        /// <summary>
        /// valore booleano (richiesta di riavvio automatico)
        /// </summary>
        public bool adpTryRestart;

        /// <summary>
        /// Ultimo valore watchdog rilevato
        /// </summary>
        public bool lastWatchDog = false;

        /// <summary>
        /// Determina se utilizzare blocchi di memoria IOT contigui (e quindi processing "monoblocco" semplificato"=
        /// </summary>
        public bool procIotMem = false;

        /// <summary>
        /// porta x adapter (x restart)
        /// </summary>
        protected int adpPortNum;

        /// <summary>
        /// DataOra ultimo avvio adapter x watchdog
        /// </summary>
        protected DateTime adpStartRun;

        /// <summary>
        /// Data/ora ultimo avvio adapter
        /// </summary>
        public DateTime dtAvvioAdp = DateTime.Now;

        /// <summary>
        /// Data/ora ultimo spegnimento adapter
        /// </summary>
        public DateTime dtStopAdp = DateTime.Now;

        /// <summary>
        /// vettore gestione cronometraggi
        /// </summary>
        public DateTime inizio;

        /// <summary>
        /// Conteggio ATTUALE ore macchina ON
        /// </summary>
        public double contOreMaccOn;

        /// <summary>
        /// Conteggio ATTUALE ore macchina IN LAVORO
        /// </summary>
        public double contOreMaccLav;

        /// <summary>
        /// Conteggio ATTUALE numero movimenti Slitta Tastatore
        /// </summary>
        public double contSlittaTast;

        /// <summary>
        /// Vettore ATTUALE dei contatori giri cumulati elettromandrino (migliaia)
        /// </summary>
        public uint[] contGiriElettrom;
        /// <summary>
        /// Vettore ATTUALE dei contatori ore lavorate elettromandrino
        /// </summary>
        public uint[] contOreElettrom;

        /// <summary>
        /// Vettore ATTUALE dei contatori del movimento degli assi
        /// </summary>
        public double[] contDistMovAssi;

        /// <summary>
        /// Vettore ATTUALE dei contatori del tempo cumulato degli assi
        /// </summary>
        public double[] contAccTimeAssi;

        /// <summary>
        /// Vettore ATTUALE dei contatori del num inv degli assi
        /// </summary>
        public uint[] contNumInvAssi;

        /// <summary>
        /// vettore dei ProgramName dei path ATTIVI
        /// </summary>
        public string[] currPathProgrName;

        /// <summary>
        /// vettore dei PartId dei path ATTIVI
        /// </summary>
        public string[] currPathPartId;

        /// <summary>
        /// Vettore ATTUALE dei contatori del num pezzi fatti x PartId
        /// </summary>
        public uint[] currPathPartCount;

        /// <summary>
        /// Vettore ATTUALE dei contatori del work time x VacPump
        /// </summary>
        public uint[] currVacPumpWrkTime;

        /// <summary>
        /// Vettore ATTUALE dei contatori del numero impieghi VacAct
        /// </summary>
        public uint[] currVacActCount;

        /// <summary>
        /// Vettore ATTUALE dei contatori del Lubro
        /// </summary>
        public uint[] currLubroCount;

        /// <summary>
        /// Vettore ATTUALE dei contatori del numero cambi utensili x UnOp
        /// </summary>
        public uint[] currNumCambiUt;
        /// <summary>
        /// Vettore ATTUALE dei contatori del numero cambi utensili x UnOp
        /// </summary>
        public uint[] currRepetitionUnOp;

        /// <summary>
        /// Vettore ATTUALE dei contatori GENERICI MONOTONI CRESCENTI
        /// </summary>
        public uint[] currCounters;
        /// <summary>
        /// Vettore ATTUALE dei contatori GENERICI LIBERI
        /// </summary>
        public uint[] currRTCounters;
        /// <summary>
        /// Vettore ATTUALE dei contatori x VALORI GENERICI 
        /// </summary>
        public int[] currRTVCount;

        /// <summary>
        /// Vettore ATTUALE dei contatori del numero movimenti Slitta Magazzino
        /// </summary>
        public uint[] currSlittaMag;

        /// <summary>
        /// Vettore ATTUALE dei contatori del numero movimenti Protezione Magazzino
        /// </summary>
        public uint[] currProtMag;

        /// <summary>
        /// Conteggio ISTANTANEO ore macchina ON
        /// </summary>
        public sampleVect istOreMaccOn;

        /// <summary>
        /// isteggio ISTANTANEO ore macchina IN LAVORO
        /// </summary>
        public sampleVect istOreMaccLav;

        /// <summary>
        /// Conteggio ISTANTANEO contatore del numero movimenti Slitta Tastatore
        /// </summary>
        public sampleVect istSlittaTast;

        /// <summary>
        /// Vettore ISTANTANEO dei contatori giri cumulati elettromandrino (migliaia)
        /// </summary>
        public sampleVect[] istGiriElettrom;
        /// <summary>
        /// Vettore ISTANTANEO dei contatori Apertura teste
        /// </summary>
        public sampleVect[] istRepetitionUnOp;
        /// <summary>
        /// Vettore ISTANTANEO dei contatori ORE LAVORATE elettromandrino
        /// </summary>
        public sampleVect[] istOreElettrom;
        /// <summary>
        /// Vettore ISTANTANEO dei contatori del movimento degli assi
        /// </summary>
        public sampleVect[] istDistMovAssi;

        /// <summary>
        /// Vettore ISTANTANEO dei contatori del LOAD degli assi
        /// </summary>
        public sampleVect[] istLoadAssi;

        /// <summary>
        /// Vettore ISTANTANEO dei contatori del tempo cumulato degli assi
        /// </summary>
        public sampleVect[] istAccTimeAssi;

        /// <summary>
        /// Vettore ISTANTANEO dei contatori del num inv degli assi
        /// </summary>
        public sampleVect[] istNumInvAssi;

        /// <summary>
        /// vettore dei Program Name dei path ISTANTANEI (nuovi/letti)
        /// </summary>
        public string[] istPathProgrName;

        /// <summary>
        /// vettore dei PartId dei path ISTANTANEI (nuovi/letti)
        /// </summary>
        public string[] istPathPartId;

        /// <summary>
        /// Vettore ISTANTANEO dei contatori del num pezzi fatti x PartId
        /// </summary>
        public sampleVect[] istPathPartCount;

        /// <summary>
        /// Vettore ISTANTANEO dei contatori del work time x VacPump
        /// </summary>
        public sampleVect[] istVacPumpWrkTime;

        /// <summary>
        /// Vettore ISTANTANEO dei contatori del numero impieghi VacAct
        /// </summary>
        public sampleVect[] istVacActCount;

        /// <summary>
        /// Vettore ISTANTANEO dei contatori del Lubro
        /// </summary>
        public sampleVect[] istLubroCount;

        /// <summary>
        /// Vettore ISTANTANEO dei contatori del numero cambi utensili x UnOp
        /// </summary>
        public sampleVect[] istNumCambiUt;

        /// <summary>
        /// Vettore ISTANTANEO dei contatori generici MONOTONI CRESCENTI
        /// </summary>
        public sampleVect[] istCounters;
        /// <summary>
        /// Vettore ISTANTANEO dei contatori generici LIBERI
        /// </summary>
        public sampleVect[] istRTCounters;
        /// <summary>
        /// Vettore ISTANTANEO dei contatori generici LIBERI x VALORI
        /// </summary>
        public sampleVect[] istRTVCount;

        /// <summary>
        /// Vettore ISTANTANEO dei contatori del numero movimenti Slitta Magazzino
        /// </summary>
        public sampleVect[] istSlittaMag;

        /// <summary>
        /// Vettore ISTANTANEO dei contatori del numero movimenti Protezione Magazzino
        /// </summary>
        public sampleVect[] istProtMag;

        /// <summary>
        /// vettore valori in file interscambio
        /// </summary>
        public Dictionary<string, string> generalStatus;

        /// <summary>
        /// Contenuto valori contatori manutenzione da PLC
        /// </summary>
        public otherData[] maintData;

        /// <summary>
        /// Contenuto valori variabili analogiche da PLC
        /// </summary>
        public otherData[] analogData;

        /// <summary>
        /// Contenuto valori variabili stringa da PLC
        /// </summary>
        public otherData[] stringData;

        /// <summary>
        /// Contenuto valori status data da PLC
        /// </summary>
        public otherData[] statusData;

        /// <summary>
        /// data-ora ultimo controllo movimento assi
        /// </summary>
        public DateTime lastChekAccumTimeAxis;

        /// <summary>
        /// posizione precedente assi per calcolo distanze...
        /// </summary>
        public double[] prevPosAxis;

        /// <summary>
        /// direzione precedente assi per calcolo inversioni...
        /// </summary>
        public int[] prevDirAxis;

        /// <summary>
        /// blocco memoria BYTE x lettura TUTTI i dati di buffer M/S/T
        /// </summary>
        public byte[] MemBlock_MST;

        /// <summary>
        /// Indica se sia necessario il salto x array codici MST (OSAI = 1, FANUC/SIEMENS=0)
        /// </summary>
        public int saltoMST = 0;

        /// <summary>
        /// Determina se sia encessario convertire valori little/big endian (SIEMENS=true, OSAI=FALSE)
        /// </summary>
        public bool hasBigEndian = false;

        /// <summary>
        /// Verifica se siano stati già mostrati gli allarmi x debug...
        /// </summary>
        public bool alarmMsgDispl = true;

        /// <summary>
        /// dimensione massima vettore memorie UT
        /// </summary>
        public short numMemUt = 200;
        /// <summary>
        /// Processo selezionato
        /// </summary>
        public string procSel = "";
        /// <summary>
        /// Modo del processo selezionato
        /// </summary>
        public int procMode = 0;

        /// <summary>
        /// Form chiamante
        /// </summary>
        protected MainForm parentForm;

        /// <summary>
        /// Conf adapter corrente
        /// </summary>
        public AdapterConf currAdpConf;

        /// <summary>
        /// Obj gestione la comunicazione a valle (secondo standard LOGFILE / MTC / SOURS)
        /// </summary>
        public Gateway currGateway;

        #region altri oggetti

        /// <summary>
        /// 16 byte di strobe (4 word da 32 bit di flags...)
        /// </summary>
        public byte[] Strobes = new byte[16];
        /// <summary>
        /// 16 byte di strobe in risposta (4 word da 32 bit di flags...)
        /// </summary>
        public byte[] Acknowl = new byte[16];

        public Dictionary<string, string> elencoSubMode;

        /// <summary>
        /// Prima word di strobe da array flag completo
        /// </summary>
        public StFlag32 STRB_DW0
        {
            get
            {
                return (StFlag32)BitConverter.ToUInt32(Strobes, 0);
            }
        }

        /// <summary>
        /// Seconda word di strobe da array flag completo
        /// </summary>
        public StFlag32 STRB_DW1
        {
            get
            {
                return (StFlag32)BitConverter.ToUInt32(Strobes, 4);
            }
        }

        /// <summary>
        /// Terza word di strobe da array flag completo
        /// </summary>
        public StFlag32 STRB_DW2
        {
            get
            {
                return (StFlag32)BitConverter.ToUInt32(Strobes, 8);
            }
        }
        /// <summary>
        /// Valore statud x standard OPC-UA (da valorizzare in adapter specifico) 
        /// valore default a -1 --> SE NON VALORIZZATO NON LO USA:..
        /// </summary>
        public int ouStatus = -1;

        /// <summary>
        /// Quarta word di strobe da array flag completo
        /// </summary>
        public StFlag32 STRB_DW3
        {
            get
            {
                return (StFlag32)BitConverter.ToUInt32(Strobes, 12);
            }
        }
        /// <summary>
        /// PRIMO BYTE della Quarta word di strobe 
        /// </summary>
        public byte ACK_DW3_B0
        {
            get
            {
                return Acknowl[12];
            }
        }

        /// <summary>
        /// Quarta word di strobe da array flag completo
        /// </summary>
        public StFlag32 STRB_DW4
        {
            get
            {
                return (StFlag32)BitConverter.ToUInt32(Strobes, 16);
            }
        }

        /// <summary>
        /// Prima word di ACKnowledgment da array flag completo
        /// </summary>
        public StFlag32 ACK_DW0
        {
            get
            {
                return (StFlag32)BitConverter.ToUInt32(Acknowl, 0);
            }
        }

        /// <summary>
        /// Seconda word di ACKnowledgment da array flag completo
        /// </summary>
        public StFlag32 ACK_DW1
        {
            get
            {
                return (StFlag32)BitConverter.ToUInt32(Acknowl, 4);
            }
        }

        /// <summary>
        /// Terza word di ACKnowledgment da array flag completo
        /// </summary>
        public StFlag32 ACK_DW2
        {
            get
            {
                return (StFlag32)BitConverter.ToUInt32(Acknowl, 8);
            }
        }

        /// <summary>
        /// Quarta word di ACKnowledgment da array flag completo
        /// </summary>
        public StFlag32 ACK_DW3
        {
            get
            {
                return (StFlag32)BitConverter.ToUInt32(Acknowl, 12);
            }
        }

        /// <summary>
        /// Strobe mask PLC
        /// </summary>
        public Strobe STROBE_PLC = 0;

        /// <summary>
        /// Strobe mask adapter
        /// </summary>
        public Strobe STROBE_ADP = 0;

        /// <summary>
        /// Status flag
        /// </summary>
        public StatusBitMap STATUS_FLAG = 0;

        /// <summary>
        /// Variabili stato macchina principali
        /// </summary>
        public StFlag8 ST_MACCH = 0;

        public List<string>[] codaM;
        public List<string>[] codaS;
        public List<string>[] codaT;

        /// <summary>
        /// Verifica se los tatus sia recuperabile dal PLC ( oppure da calcolare)
        /// </summary>
        public bool ouStatusByPlc
        {
            get
            {
                return utils.CRB("ouStatusByPlc");
            }
        }

        #endregion altri oggetti

        #region Gestione contatori & obj specifici (Events & Samples)

        /// <summary>
        /// Vettore conters monotoni crescenti - EVENT
        /// </summary>
        public List<string> elCounter;

        /// <summary>
        /// Vettore conters realtime (liberi) - EVENT
        /// </summary>
        public List<string> elRTCounter;
        /// <summary>
        /// Vettore conters realtime value GENERICI comprensivo di indice - EVENT
        /// </summary>
        public Dictionary<string, int> elRTVCount;

        /// <summary>
        /// Vettore status (EVENT)
        /// </summary>
        public List<string> elStatus;

        /// <summary>
        /// Vettore analog data (SAMPLE)
        /// </summary>
        public List<string> elAnalogData;

        /// <summary>
        /// Vettore string data (SAMPLE)
        /// </summary>
        public List<string> elStringData;

        #endregion Gestione contatori & obj specifici (Events & Samples)

        #region oggetti complessi/completi

        public VacuumPump[] vettVacPump;
        public VacuumAct[] vettVacAct;
        public Lubro[] vettLubro;
        public SlittaMag[] vettSlittaMag;
        public ProtMag[] vettProtMag;
        public Cooler[] vettCooler;
        public Press[] vettPress;
        public Tempe[] vettTempe;
        public Path[] vettPath;
        public UnOp[] vettUnOp;
        public Axis[] vettAxis;
        public MemArea[] vettMemArea;
        public Dictionary<string, string> DirectMem = new Dictionary<string, string>();

        #endregion oggetti complessi/completi

        public event EventHandler eh_refreshed;

        /// <summary>
        /// caricamento allarmi da file
        /// </summary>
        protected void loadAllarmi()
        {
            if (utils.CRB("verbose"))
            {
                lg.Info("Inizio caricamento vettore allarmi");
            }

            int totRighe = 0;
            string fileName = string.Format(@"{0}\{1}", utils.confDir, utils.CRS("AlarmList"));
            string linea;
            totRighe = File.ReadLines(fileName).Count();
            // creo un vettore della dimensione corretta... conta anche commenti tanto poi riduco...
            currGateway.elencoAllarmi = new allarme[File.ReadLines(fileName).Count()];
            // carica da file...
            StreamReader file = new StreamReader(fileName);
            // leggo 1 linea alla volta...
            int numRiga = 0;
            while ((linea = file.ReadLine()) != null)
            {
                // SE non è un commento...
                if (linea.Substring(0, 1) != "#")
                {
                    //elencoAllarmi[rumRiga] = decodeAlarmLine(linea, ':');
                    currGateway.elencoAllarmi[numRiga] = decodeAlarmLine(linea, utils.CRC("testCharSep"));
                    numRiga++;
                }
            }
            // chiudo file
            file.Close();
            // ora trimmo vettore al solo numero VERO degli allarmi caricati...
            Array.Resize<allarme>(ref currGateway.elencoAllarmi, numRiga);

            // inizializzo a zero il vettore allarmi...
            int numByte = (int)Math.Ceiling(Convert.ToDecimal(numRiga) / 8);
            // 2016.07.20: dimensione AlarmFlags è la MAX tra quella del numero allarmi ed il numero allarmi standard dalla memoria...
            if (numByte < 32)
            {
                numByte = 32;
            }

            currGateway.AlarmFlags = new byte[numByte];
            if (utils.CRB("verbose"))
            {
                lg.Info(string.Format("Fine caricamento vettore allarmi: {0} allarmi caricati!", numRiga));
            }
        }
        /// <summary>
        /// Caricamento file rimappatura naming (per evitare uso improprio di "_" che porta a "split")
        /// impiega il file delle sostituzioni "inizio/fine/contenuto/tutto" (NameRepRolesList)
        /// </summary>
        protected void loadNameRepRoles()
        {
            if (utils.CRB("verbose"))
            {
                lg.Info("Inizio caricamento dizionario remapping nomi variabili");
            }
            try
            {
                // PRIMA leggo il file GENERATO di replacement... NON dando per scontato ci sia...
                if (File.Exists(utils.nameRepRoleFileSOUR))
                {
                    importFile(utils.nameRepRoleFileSOUR);
                }

                // processo file pre REPLACE parziale (con like) - file DI BASE ESPLICITO
                importFile(utils.nameRepRoleFile);
            }

            catch
            { }
        }

        private void importFile(string fileName)
        {
            // init variabili
            string linea;
            int rumRiga = 0;
            string valSost = "";
            string valTrad;
            string sMode = "";
            string sSearch = "";
            string[] dictSubst;
            subsMode modoSearch;
            substSearch tipoCerca;
            StreamReader file;
            replDict replacement;
            // carica da file...
            file = new StreamReader(fileName);
            // leggo 1 linea alla volta
            while ((linea = file.ReadLine()) != null)
            {
                linea = linea.Trim();
                // se HA CONTENUTO                   
                if (linea != "")
                {
                    // SE non è un commento...
                    if (linea.Substring(0, 1) != "#")
                    {
                        dictSubst = linea.Split(utils.CRC("testCharSep"));
                        // recupero valori inseriti 
                        sMode = dictSubst[0].Trim();
                        sSearch = dictSubst[1].Trim();
                        valSost = dictSubst[2].Trim();
                        valTrad = dictSubst[3].Trim();
                        switch (sMode)
                        {
                            case "X":
                                modoSearch = subsMode.X;
                                break;
                            default:
                            case "A":
                                modoSearch = subsMode.A;
                                break;
                        }
                        switch (sSearch)
                        {
                            case "B":
                                tipoCerca = substSearch.B;
                                break;
                            case "C":
                                tipoCerca = substSearch.C;
                                break;
                            case "E":
                                tipoCerca = substSearch.E;
                                break;
                            default:
                            case "I":
                                tipoCerca = substSearch.I;
                                break;
                        }
                        replacement = new replDict { modo = modoSearch, search = tipoCerca, tradz = valTrad };
                        // 3 oggetti: tipo ricerca | valOriginale | valTradotto
                        if (currGateway.nameRepRoles != null && currGateway.nameRepRoles.ContainsKey(valSost))
                        {
                            currGateway.nameRepRoles.Remove(valSost);
                        }
                        currGateway.nameRepRoles.Add(valSost, replacement);
                        rumRiga++;
                    }
                }
            }
            // chiudo file
            file.Close();

            // registro chiusura
            if (utils.CRB("verbose"))
            {
                lg.Info(string.Format("Fine caricamento file {0} con dizionario traduzioni nomi: {1} regole caricate", fileName, rumRiga));
            }
        }

        /// <summary>
        /// Caricamento file rimappatura naming (per evitare uso improprio di "_" che porta a "split")
        /// impiega il file delle sostituzioni "inizio/fine/contenuto/tutto" (NameRepRolesList)
        /// </summary>
        protected void loadMemCopyList()
        {
            if (utils.CRB("verbose"))
            {
                lg.Info("Inizio caricamento dizionario copia variabili REDIS");
            }
            string linea;
            string fileName = "";
            int rumRiga = 0;
            string valSost = "";
            string valTrad;
            string[] dictSubst;
            StreamReader file;
            try
            {
                // processo file pre REPLACE parziale (con like)
                fileName = string.Format(@"{0}\{1}", utils.confDir, utils.CRS("MemCopyList"));
                // carica da file...
                file = new StreamReader(fileName);
                // leggo 1 linea alla volta...
                while ((linea = file.ReadLine()) != null)
                {
                    linea = linea.Trim();
                    // se HA CONTENUTO                   
                    if (linea != "")
                    {
                        // SE non è un commento...
                        if (linea.Substring(0, 1) != "#")
                        {
                            dictSubst = linea.Split(utils.CRC("testCharSep"));
                            // recupero valori inseriti 
                            valSost = dictSubst[0].Trim();
                            valTrad = dictSubst[1].Trim();

                            // 3 oggetti: tipo ricerca | valOriginale | valTradotto
                            if (currGateway.memCopyList != null && currGateway.memCopyList.ContainsKey(valSost))
                            {
                                currGateway.nameRepRoles.Remove(valSost);
                            }
                            currGateway.memCopyList.Add(valSost, valTrad);
                            rumRiga++;
                        }
                    }
                }
                // chiudo file
                file.Close();

                // registro chiusura
                if (utils.CRB("verbose"))
                {
                    lg.Info(string.Format("Fine caricamento dizionario copia variabili MemCopy: {0} righe caricate", rumRiga));
                }
            }
            catch
            { }
        }
        /// <summary>
        /// Caricamento altri file necessari epr adapter all'avvio
        /// </summary>
        protected virtual void loadOtherFile()
        {
            // se è SOURS --> leggo datamodel...
            if (currGateway.protocollo == gwProtocol.SOURS)
            {
                if (utils.CRB("verbose"))
                {
                    lg.Info("Inizio caricamento DataModel per OPC-UA REDIS server");
                }
                string fileName = "";
                int rumRiga = 0;
                StreamReader file;
                // processo file pre REPLACE parziale (con like)
                fileName = string.Format(@"{0}\{1}", utils.confDir, utils.CRS("DataModel"));
                // carica da file...
                file = new StreamReader(fileName);
                // leggo file...
                string rawDataModel = file.ReadToEnd();

                // pre-processo datamodel...
                currGateway.DataModel = utils.xmlSanitize(rawDataModel);
                // chiudo file
                file.Close();


                // secondo metodo x deserializzare...
                DataModel dm = new DataModel();
                var currMachine2 = dm.Deserialize(currGateway.DataModel);

                // registro chiusura
                if (utils.CRB("verbose"))
                {
                    lg.Info(string.Format("Fine caricamento DataModel XML: {0} righe caricate", rumRiga));
                }
            }
        }

        /// <summary>
        /// Lettura file gestione dati manutenzione da PLC
        /// </summary>
        /// <param name="memPre"></param>
        /// <param name="baseAddr"></param>
        /// <param name="memSize"></param>
        public void loadMaintData(string memPre, int baseAddr, int memSize)
        {
            // carico dati x Maintenance
            if (utils.CRB("verbose"))
            {
                lg.Info("Inizio caricamento vettore variabili manutenzione gestite");
            }

            int totRighe = 0;
            int numCounters = 0;
            int numRTCounters = 0;
            int numRTVCount = 0;
            string fileName = utils.CounterListFile;
            if (currGateway.protocollo == gwProtocol.SOURS)
            {
                fileName = utils.CounterListFileSOUR;
            }
            string linea;
            totRighe = File.ReadLines(fileName).Count();
            // creo un vettore della dimensione corretta... conta anche commenti tanto poi riduco...
            maintData = new otherData[File.ReadLines(fileName).Count()];
            // carica da file...
            StreamReader file = new StreamReader(fileName);
            // leggo 1 linea alla volta...
            int numRiga = 0;
            while ((linea = file.ReadLine()) != null)
            {
                // se NON VUOTA...
                if (linea != "")
                {
                    // SE non è un commento...
                    if (linea.Substring(0, 1) != "#")
                    {
                        maintData[numRiga] = decodeOtherData(linea, utils.CRC("testCharSep"), memPre, baseAddr, memSize);
                        // se è un counter lo processo come tale..
                        if (maintData[numRiga].varName.StartsWith("Counter_"))
                        {
                            numCounters++;
                        }
                        else if (maintData[numRiga].varName.StartsWith("RTCounter_"))
                        {
                            numRTCounters++;
                        }
                        else if (maintData[numRiga].dataType == "RTV")
                        {
                            numRTVCount++;
                        }
                        numRiga++;
                    }
                }
            }
            // chiudo file
            file.Close();
            // ora trimmo vettore al solo numero VERO dei valori caricati...
            Array.Resize<otherData>(ref maintData, numRiga);

            if (utils.CRB("verbose"))
            {
                lg.Info(string.Format("Fine caricamento vettore di {0} variabili manutenzione gestite", numRiga));
            }
            // se log verboso 10+ --> scrivo tutti!
            if (utils.CRI("loglevel") > 9)
            {
                foreach (var item in maintData)
                {
                    lg.Info($"VarName: {item.varName} | dataType: {item.dataType} | codNum: {item.codNum} | memAddr: {item.memAddr}");
                }
            }

            elCounter = new List<string>();
            elRTCounter = new List<string>();
            elRTVCount = new Dictionary<string, int>();
            currCounters = new uint[numCounters];
            currRTCounters = new uint[numRTCounters];
            currRTVCount = new int[numRTVCount];
            istCounters = new sampleVect[numCounters];
            istRTCounters = new sampleVect[numRTCounters];
            istRTVCount = new sampleVect[numRTVCount];
            int idx = 0;
            int idxRT = 0;
            int idxRTV = 0;
            foreach (otherData item in maintData)
            {
                if (item.varName.StartsWith("Counter_"))
                {
                    elCounter.Add(item.varName);
                    currGateway.addItemNodeByType(item.varName, itemType.Event);
                    istCounters[idx] = new sampleVect();
                    idx++;
                }
                else if (item.varName.StartsWith("RTCounter_"))
                {
                    elRTCounter.Add(item.varName);
                    currGateway.addItemNodeByType(item.varName, itemType.Event);
                    istRTCounters[idxRT] = new sampleVect();
                    idxRT++;
                }
                else if (item.dataType == "RTV")
                {
                    elRTVCount.Add(item.varName, idxRTV);
                    currGateway.addItemNodeByType(item.varName, itemType.Event);
                    istRTVCount[idxRTV] = new sampleVect();
                    idxRTV++;
                }
                else
                {
                    currGateway.addItemNodeByType(item.varName, itemType.Event);
                }
            }
            if (utils.CRB("verbose"))
            {
                lg.Info(string.Format("inizializzato vettore di {0} MTC.EVENTS delle variabili CONTATORI generiche", numRiga));
            }
        }

        /// <summary>
        /// Lettura file gestione dati analogici da PLC
        /// </summary>
        /// <param name="memPre"></param>
        /// <param name="baseAddr"></param>
        /// <param name="memSize"></param>
        public void loadAnalogData(string memPre, int baseAddr, int memSize)
        {
            // carico dati x Maintenance
            if (utils.CRB("verbose"))
            {
                lg.Info("Inizio caricamento vettore variabili analogiche gestite");
            }

            int totRighe = 0;
            string fileName = utils.AnalogListFile;
            if (currGateway.protocollo == gwProtocol.SOURS)
            {
                fileName = utils.AnalogListFileSOUR;
            }
            string linea;
            totRighe = File.ReadLines(fileName).Count();
            // creo un vettore della dimensione corretta... conta anche commenti tanto poi riduco...
            analogData = new otherData[File.ReadLines(fileName).Count()];
            // carica da file...
            StreamReader file = new StreamReader(fileName);
            // leggo 1 linea alla volta...
            int numRiga = 0;
            while ((linea = file.ReadLine()) != null)
            {
                // se NON VUOTA...
                if (linea != "")
                {
                    // SE non è un commento...
                    if (linea.Substring(0, 1) != "#")
                    {
                        analogData[numRiga] = decodeOtherData(linea, utils.CRC("testCharSep"), memPre, baseAddr, memSize);
                        numRiga++;
                    }
                }
            }
            // chiudo file
            file.Close();
            // ora trimmo vettore al solo numero VERO dei valori caricati...
            Array.Resize<otherData>(ref analogData, numRiga);

            if (utils.CRB("verbose"))
            {
                lg.Info(string.Format("Fine caricamento vettore di {0} variabili analogiche gestite", numRiga));
            }

            // ora inizializzo l'insieme dei Samples delle var analogiche
            elAnalogData = new List<string>();
            string varName = "";
            for (int i = 0; i < numRiga; i++)
            {
                varName = analogData[i].varName;
                if (currGateway.protocollo != gwProtocol.SOURS)
                {
                    varName = string.Format("AV_" + analogData[i].varName);
                }
                elAnalogData.Add(varName);
                currGateway.addItemNodeByType(varName, itemType.Sample);
            }
            if (utils.CRB("verbose"))
            {
                lg.Info(string.Format("inizializzato vettore di {0} MTC.SAMPLES delle variabili analogiche", numRiga));
            }
        }

        /// <summary>
        /// Lettura file gestione dati status da PLC
        /// </summary>
        /// <param name="memPre"></param>
        /// <param name="baseAddr"></param>
        /// <param name="memSize"></param>
        public void loadStatusData(string memPre, int baseAddr, int memSize)
        {
            // carico dati x Maintenance
            if (utils.CRB("verbose"))
            {
                lg.Info("Inizio caricamento vettore variabili status gestite");
            }

            int totRighe = 0;
            // secondo protocollo scelgo quale file...
            string fileName = utils.StatusListFile;
            if (currGateway.protocollo == gwProtocol.SOURS)
            {
                fileName = utils.StatusListFileSOUR;
            }
            string linea;
            totRighe = File.ReadLines(fileName).Count();
            // creo un vettore della dimensione corretta... conta anche commenti tanto poi riduco...
            statusData = new otherData[File.ReadLines(fileName).Count()];
            // carica da file...
            StreamReader file = new StreamReader(fileName);
            // leggo 1 linea alla volta...
            int numRiga = 0;
            while ((linea = file.ReadLine()) != null)
            {
                // se NON VUOTA...
                if (linea != "")
                {
                    // SE non è un commento...
                    if (linea.Substring(0, 1) != "#")
                    {
                        statusData[numRiga] = decodeBitData(linea, utils.CRC("testCharSep"), memPre, baseAddr, memSize);
                        numRiga++;
                    }
                }
            }
            // chiudo file
            file.Close();
            // ora trimmo vettore al solo numero VERO dei valori caricati...
            Array.Resize<otherData>(ref statusData, numRiga);

            if (utils.CRB("verbose"))
            {
                lg.Info(string.Format("Fine caricamento vettore di {0} variabili status gestite", numRiga));
            }

            // ora inizializzo l'insieme degli Eventi di status
            elStatus = new List<string>();
            string varName = "";
            for (int i = 0; i < numRiga; i++)
            {
                varName = statusData[i].varName;
                if (currGateway.protocollo != gwProtocol.SOURS)
                {
                    varName = string.Format("ST_" + statusData[i].varName);
                }
                elStatus.Add(varName);
                currGateway.addItemNodeByType(varName, itemType.Event);
            }
            if (utils.CRB("verbose"))
            {
                lg.Info(string.Format("inizializzato vettore di {0} MTC.EVENTS di status", numRiga));
            }
        }

        /// <summary>
        /// Lettura file gestione dati stringa da PLC
        /// </summary>
        /// <param name="memPre"></param>
        /// <param name="baseAddr"></param>
        /// <param name="memSize"></param>
        public void loadStringData(string memPre, int baseAddr, int memSize)
        {
            // carico dati x Maintenance
            if (utils.CRB("verbose"))
            {
                lg.Info("Inizio caricamento vettore variabili stringa gestite");
            }

            int totRighe = 0;
            string fileName = utils.StringListFile;
            if (currGateway.protocollo == gwProtocol.SOURS)
            {
                fileName = utils.StringListFileSOUR;
            }
            string linea;
            totRighe = File.ReadLines(fileName).Count();
            // creo un vettore della dimensione corretta... conta anche commenti tanto poi riduco...
            stringData = new otherData[File.ReadLines(fileName).Count()];
            // carica da file...
            StreamReader file = new StreamReader(fileName);
            // leggo 1 linea alla volta...
            int numRiga = 0;
            while ((linea = file.ReadLine()) != null)
            {
                // se NON VUOTA...
                if (linea != "")
                {
                    // SE non è un commento...
                    if (linea.Substring(0, 1) != "#")
                    {
                        stringData[numRiga] = decodeOtherData(linea, utils.CRC("testCharSep"), memPre, baseAddr, memSize);
                        numRiga++;
                    }
                }
            }
            // chiudo file
            file.Close();
            // ora trimmo vettore al solo numero VERO dei valori caricati...
            Array.Resize<otherData>(ref stringData, numRiga);

            if (utils.CRB("verbose"))
            {
                lg.Info(string.Format("Fine caricamento vettore di {0} variabili stringa gestite", numRiga));
            }

            // ora inizializzo l'insieme dei Samples delle var analogiche
            elStringData = new List<string>();
            string varName = "";
            for (int i = 0; i < numRiga; i++)
            {
                varName = stringData[i].varName;
                if (currGateway.protocollo != gwProtocol.SOURS)
                {
                    varName = string.Format("STR_" + stringData[i].varName);
                }
                elStringData.Add(varName);
                currGateway.addItemNodeByType(varName, itemType.Sample);
            }
            if (utils.CRB("verbose"))
            {
                lg.Info(string.Format("inizializzato vettore di {0} MTC.SAMPLES delle variabili string", numRiga));
            }
        }

        /// <summary>
        /// caricamento allarmi da file
        /// </summary>
        protected void loadSubMode()
        {
            try
            {
                if (utils.CRB("verbose"))
                {
                    lg.Info("Inizio caricamento vettore SubMode");
                }

                int totRighe = 0;
                string fileName = string.Format(@"{0}\{1}", utils.confDir, utils.CRS("SubModeListFilePath"));
                string linea;
                totRighe = File.ReadLines(fileName).Count();
                // inizializzo
                elencoSubMode = new Dictionary<string, string>();
                // carica da file...
                StreamReader file = new StreamReader(fileName);
                // leggo 1 linea alla volta...
                string[] valori;
                while ((linea = file.ReadLine()) != null)
                {
                    // SE non è un commento...
                    if (linea.Substring(0, 1) != "#")
                    {
                        valori = linea.Split(':');
                        elencoSubMode.Add(valori[0], valori[1]);
                    }
                }
                // chiudo file
                file.Close();
                if (utils.CRB("verbose"))
                {
                    lg.Info("Fine caricamento vettore SubMode");
                }
            }
            catch (Exception exc)
            {
                lg.Error(exc, "Eccezione in caricamento SubMode");
            }
        }

        /// <summary>
        /// Decodifica file allarme, con linee allarme composte come di seguito
        /// LEGACY: CodAllarme | Gruppo | Livello | Descrizione (verrà poi replicata in IT e EN)
        /// v1811: CodAllarme | Gruppo | Livello | Descrizione (lingua corrente) | Descrizione IT (italiano) | Descrizione EN (inglese) 
        /// </summary>
        /// <param name="linea">Allarme in formato tutto su 1 linea</param>
        /// <param name="separator">Tipicamente |</param>
        /// <returns></returns>
        protected allarme decodeAlarmLine(string linea, char separator)
        {
            string[] valori = linea.Split(separator);
            allarme answ = new allarme();
            // in base a quanti oggetti ho uso tutti i valori indicati singolarmente
            if (valori.Length == 6)
            {
                answ = new allarme(valori[0], valori[1], valori[2], valori[3], valori[4], valori[5]);
            }
            else // oppure decido di replicare lingua corrente --> IT / EN
            {
                answ = new allarme(valori[0], valori[1], valori[2], valori[3]);
            }
            return answ;
        }

        /// <summary>
        /// Recupera il numero (iniziale) da una stringa prendendo la aprte sino al separatore...
        /// </summary>
        /// <param name="linea"></param>
        /// <param name="separator"></param>
        /// <returns></returns>
        protected int startNumb(string linea, char separator)
        {
            int answ = 0;
            try
            {
                answ = Convert.ToInt32(linea.Substring(0, linea.IndexOf(separator)));
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// Decodifica file datiProdSCM
        /// </summary>
        /// <param name="linea"></param>
        /// <param name="separator"></param>
        /// <returns></returns>
        protected datiProdSCM decodeScmProdLine(string linea, char separator)
        {
            string[] valori = linea.Split(separator);
            datiProdSCM answ = null;
            if (valori.Length == 23)
            {
                answ = new datiProdSCM(valori);
            }
            return answ;
        }

        /// <summary>
        /// Decodifica file allarme
        /// </summary>
        /// <param name="linea"></param>
        /// <param name="separator"></param>
        /// <param name="memPre">tipo memoria (R/D/...)</param>
        /// <param name="baseAddr">indirizzo di partenza memoria</param>
        /// <param name="memSize">dimensione singolo slot in byte</param>
        /// <returns></returns>
        protected otherData decodeOtherData(string linea, char separator, string memPre, int baseAddr, int memSize)
        {
            string[] valori = linea.Split(separator);
            int shift = 0;
            try
            {
                shift = Convert.ToInt32(valori[0]) - 1;
            }
            catch
            { }
            string memAddr = string.Format("{0}{1}", memPre, baseAddr + shift * memSize);
            int scale = 1;
            if (valori.Length > 3)
            {
                int.TryParse(valori[3].Trim(), out scale);
            }
            return new otherData(valori[0], memAddr, valori[1].Trim(), valori[2].Trim(), scale);
        }

        /// <summary>
        /// Decodifica file MAP (caso ESA/IOT)
        /// </summary>
        /// <param name="linea"></param>
        /// <param name="separator"></param>
        /// <param name="ByteNum">indirizzo Byte: indirizzo di partenza memoria</param>
        /// <param name="memSize">dimensione singolo slot in byte</param>
        /// <param name="BitNum">indirizzo bit: numero riga x calcolo indice bit</param>
        /// <returns></returns>
        protected otherData decodeBitData(string linea, char separator, int ByteNum, int memSize, int BitNum)
        {
            string[] valori = linea.Split(separator);
            int shift = 0;
            try
            {
                shift = Convert.ToInt32(valori[0]) - 1;
            }
            catch
            { }
            int resto = 0;
            Math.DivRem(BitNum, 8, out resto);
            string memAddr = string.Format("{0}.{1}", ByteNum + shift * memSize, resto);
            return new otherData(valori[0], memAddr, valori[1].Trim(), valori[2].Trim());
        }

        /// <summary>
        /// Decodifica file MAP (caso FANUC/OSAI/...)
        /// </summary>
        /// <param name="linea"></param>
        /// <param name="separator"></param>
        /// <param name="memPre">tipo memoria (R/D/...)</param>
        /// <param name="baseAddr">indirizzo Byte: indirizzo di partenza memoria</param>
        /// <param name="memSize">dimensione singolo slot in byte</param>
        /// <returns></returns>
        protected otherData decodeBitData(string linea, char separator, string memPre, int baseAddr, int memSize)
        {
            string[] valori = linea.Split(separator);
            int shift = 0;
            //indirizzo bit: numero riga x calcolo indice bit (base 0!!!)
            int numRiga = 0;
            int.TryParse(valori[0], out numRiga);
            numRiga--;
            try
            {
                shift = (numRiga) / (8 * memSize);
            }
            catch
            { }
            int resto = 0;
            Math.DivRem(numRiga, 8 * memSize, out resto);
            string memAddr = string.Format("{0}{1}.{2}", memPre, baseAddr + shift, resto);
            return new otherData(valori[0], memAddr, valori[1].Trim(), valori[2].Trim());
        }

        #region metodi adapter

        /// <summary>
        /// lettura file di persistenza
        /// </summary>
        public void loadPersData()
        {
            try
            {
                // nuova lettura valori da file persistenza...
                contOreMaccOn = getStoredValDouble("ACC_TIME");
                contOreMaccLav = getStoredValDouble("ACC_TIME_WORK");
                contSlittaTast = getStoredValDouble("SlittaTastatore_Count");

                for (int i = 0; i < currAdpConf.nUnOp; i++)
                {
                    contGiriElettrom[i] = getStoredValUInt(string.Format("UnOp_{0:00}_AccTime", i + 1));
                    contOreElettrom[i] = getStoredValUInt(string.Format("UnOp_{0:00}_KRev", i + 1));
                    currNumCambiUt[i] = getStoredValUInt(string.Format("UnOp_{0:00}_NumCU", i + 1));
                    currRepetitionUnOp[i] = getStoredValUInt(string.Format("UnOp_{0:00}_Count", i + 1));
                }

                for (int i = 0; i < currAdpConf.nAxis; i++)
                {
                    contDistMovAssi[i] = getStoredValUInt(string.Format("Axis_{0:00}_DistDone", i + 1));
                    contNumInvAssi[i] = getStoredValUInt(string.Format("Axis_{0:00}_InvDDone", i + 1));
                    contAccTimeAssi[i] = getStoredValDouble(string.Format("Axis_{0:00}_AccTime", i + 1));
                }

                for (int i = 0; i < currAdpConf.nVacuumPump; i++)
                {
                    currVacPumpWrkTime[i] = getStoredValUInt(string.Format("VacPump_{0:00}_WrkTime", i + 1));
                }

                for (int i = 0; i < currAdpConf.nVacuumAct; i++)
                {
                    currVacActCount[i] = getStoredValUInt(string.Format("VacAct_{0:00}_Count", i + 1));
                }

                for (int i = 0; i < currAdpConf.nLubro; i++)
                {
                    currLubroCount[i] = getStoredValUInt(string.Format("Lubro_{0:00}_Count", i + 1));
                }

                for (int i = 0; i < currAdpConf.nSlittaMag; i++)
                {
                    currSlittaMag[i] = getStoredValUInt(string.Format("SlittaMagazzino_{0:00}_Count", i + 1));
                }

                if (elCounter != null)
                {
                    for (int i = 0; i < elCounter.Count; i++)
                    {
                        currCounters[i] = getStoredValUInt(string.Format("Counter_{0:000}", i + 1));
                    }
                }

                for (int i = 0; i < currAdpConf.nProtMag; i++)
                {
                    currProtMag[i] = getStoredValUInt(string.Format("ProtMagazzino_{0:00}_Count", i + 1));
                }
            }
            catch (Exception exc)
            {
                lg.Error(string.Format("Eccezione in decodifica valori PersLayer: {0}{1}", Environment.NewLine, exc));
            }
        }

        /// <summary>
        /// Avvia l'adapter secondo parametri app.config
        /// </summary>
        public virtual void startAdapter()
        {
            lg.Info("Starting adapter...");
            // leggo parametri da app.config
            int port = 0;
            if (currGateway.protocollo == gwProtocol.MTC)
            {
                port = utils.CRI("MTC_port");
            }
            else if (currGateway.protocollo == gwProtocol.SOURS)
            {
                port = utils.CRI("SOURS_port");
            }
            // continuo
            parentForm.commPlcActive = false;
            adpRunning = true;

            dtAvvioAdp = DateTime.Now;
            TimingData.resetData();
            // inizializzo vettori di utility..
            loadAllarmi();
            loadNameRepRoles();
            loadSubMode();
            loadOtherFile();

            // salvo porta!
            adpPortNum = port;
            currGateway.port = port;
            // avvio
            currGateway.start();

            // setto status a ACTIV, SOLO SE è MTC
            if (currGateway.protocollo == gwProtocol.MTC)
            {
                currGateway.updateItemNodeValue("STATUS", actStatus.ACTIVE.ToString());
            }

            // resetto running flag...
            adpCommAct = false;

            // avvio i Sample vectors...
            istOreMaccOn = new sampleVect();
            istOreMaccLav = new sampleVect();
            istSlittaTast = new sampleVect();

            // carico valori da adapter x i conteggi
            contOreMaccOn = currAdpConf.ContOreMaccOn;
            contOreMaccLav = currAdpConf.ContOreMaccLav;
            contSlittaTast = currAdpConf.ContSlittaTast;

            // UnOp
            contGiriElettrom = new uint[currAdpConf.nUnOp];
            contOreElettrom = new uint[currAdpConf.nUnOp];
            istGiriElettrom = new sampleVect[currAdpConf.nUnOp];
            istRepetitionUnOp = new sampleVect[currAdpConf.nUnOp];
            istOreElettrom = new sampleVect[currAdpConf.nUnOp];
            currNumCambiUt = new uint[currAdpConf.nUnOp];
            currRepetitionUnOp = new uint[currAdpConf.nUnOp];

            istNumCambiUt = new sampleVect[currAdpConf.nUnOp];
            for (int i = 0; i < currAdpConf.nUnOp; i++)
            {
                // leggo tutti i dati...
                List<DataRefItem<string, string>> listaDR = currAdpConf.UnOp[i].dataRefList;
                // punto all'item
                DataRefItem<string, string> riContKRev = listaDR.Find(x => x.Key == string.Format("UnOp_{0:00}_KRev", i + 1));
                DataRefItem<string, string> riContOre = listaDR.Find(x => x.Key == string.Format("UnOp_{0:00}_AccTime", i + 1));
                DataRefItem<string, string> riContNumCU = listaDR.Find(x => x.Key == string.Format("UnOp_{0:00}_NumCU", i + 1));
                DataRefItem<string, string> riRepUO = listaDR.Find(x => x.Key == string.Format("UnOp_{0:00}_Count", i + 1));
                // recupero valore giri...
                UInt32 contTotGiri = Convert.ToUInt32(riContKRev.Value);
                // recupero valore ore...
                UInt32 contTotOre = Convert.ToUInt32(riContOre.Value);
                // recupero valore num cambi ut...
                UInt32 contNumCU = Convert.ToUInt32(riContNumCU.Value);
                UInt32 contRepUO = Convert.ToUInt32(riRepUO.Value);
                // salvo valore letto
                contGiriElettrom[i] = contTotGiri;
                contOreElettrom[i] = contTotOre;
                currNumCambiUt[i] = contNumCU;
                currRepetitionUnOp[i] = contRepUO;
                istGiriElettrom[i] = new sampleVect();
                istRepetitionUnOp[i] = new sampleVect();
                istOreElettrom[i] = new sampleVect();
                istNumCambiUt[i] = new sampleVect();
            }
            // imposto num assi e leggo valori salvati...
            contDistMovAssi = new double[currAdpConf.nAxis];
            istDistMovAssi = new sampleVect[currAdpConf.nAxis];
            istLoadAssi = new sampleVect[currAdpConf.nAxis];
            contNumInvAssi = new uint[currAdpConf.nAxis];
            istAccTimeAssi = new sampleVect[currAdpConf.nAxis];
            contAccTimeAssi = new double[currAdpConf.nAxis];
            istNumInvAssi = new sampleVect[currAdpConf.nAxis];
            lastChekAccumTimeAxis = DateTime.Now;
            for (int i = 0; i < currAdpConf.nAxis; i++)
            {
                // leggo tutti i dati...
                List<DataRefItem<string, string>> listaDR = currAdpConf.Axis[i].dataRefList;
                // punto all'item
                DataRefItem<string, string> riContDist = listaDR.Find(x => x.Key == string.Format("Axis_{0:00}_DistDone", i + 1));
                DataRefItem<string, string> riNumInv = listaDR.Find(x => x.Key == string.Format("Axis_{0:00}_Invers", i + 1));
                DataRefItem<string, string> riAccTime = listaDR.Find(x => x.Key == string.Format("Axis_{0:00}_AccTime", i + 1));
                // recupero valori...
                contDistMovAssi[i] = Convert.ToUInt32(riContDist.Value);
                contNumInvAssi[i] = Convert.ToUInt32(riNumInv.Value);
                contAccTimeAssi[i] = Convert.ToDouble(riAccTime.Value);

                // nons erve init generale allarmi finale
                istDistMovAssi[i] = new sampleVect();
                istLoadAssi[i] = new sampleVect();
                istAccTimeAssi[i] = new sampleVect();
                istNumInvAssi[i] = new sampleVect();
            }
            currPathPartId = new string[currAdpConf.nPath];
            istPathPartId = new string[currAdpConf.nPath];
            currPathProgrName = new string[currAdpConf.nPath];
            istPathProgrName = new string[currAdpConf.nPath];
            currPathPartCount = new uint[currAdpConf.nPath];
            istPathPartCount = new sampleVect[currAdpConf.nPath];
            for (int i = 0; i < currAdpConf.nPath; i++)
            {
                // leggo tutti i dati...
                List<DataRefItem<string, string>> listaDR = currAdpConf.Path[i].dataRefList;
                // punto all'item
                DataRefItem<string, string> riPathProgr = listaDR.Find(x => x.Key == string.Format("Path_{0:00}_PartId", i + 1));
                DataRefItem<string, string> riPathPzTot = listaDR.Find(x => x.Key == string.Format("Path_{0:00}_PZ_TOT", i + 1));
                // recupero valori...
                currPathPartId[i] = riPathProgr.Value;
                currPathPartCount[i] = Convert.ToUInt32(riPathPzTot.Value);
                currPathProgrName[i] = "";
                if (currGateway.protocollo != gwProtocol.SOURS)
                {
                    currGateway.initAlarm(currGateway.conditionNodes[vettPath[i].alarmCncKey]);
                    currGateway.initAlarm(currGateway.conditionNodes[vettPath[i].alarmPlcKey]);
                }
                istPathPartCount[i] = new sampleVect();
            }
            currVacPumpWrkTime = new uint[currAdpConf.nVacuumPump];
            istVacPumpWrkTime = new sampleVect[currAdpConf.nVacuumPump];
            for (int i = 0; i < currAdpConf.nVacuumPump; i++)
            {
                // leggo tutti i dati...
                List<DataRefItem<string, string>> listaDR = currAdpConf.VacuumPump[i].dataRefList;
                // punto all'item
                DataRefItem<string, string> riVacPumpWrk = listaDR.Find(x => x.Key == string.Format("VacPump_{0:00}_WrkTime", i + 1));
                // recupero valori...
                currVacPumpWrkTime[i] = Convert.ToUInt32(riVacPumpWrk.Value);
                istVacPumpWrkTime[i] = new sampleVect();
            }
            currVacActCount = new uint[currAdpConf.nVacuumAct];
            istVacActCount = new sampleVect[currAdpConf.nVacuumAct];
            for (int i = 0; i < currAdpConf.nVacuumAct; i++)
            {
                // leggo tutti i dati...
                List<DataRefItem<string, string>> listaDR = currAdpConf.VacuumAct[i].dataRefList;
                // punto all'item
                DataRefItem<string, string> riVacActCount = listaDR.Find(x => x.Key == string.Format("VacAct_{0:00}_Count", i + 1));
                // recupero valori...
                currVacActCount[i] = Convert.ToUInt32(riVacActCount.Value);
                istVacActCount[i] = new sampleVect();
            }
            currLubroCount = new uint[currAdpConf.nLubro];
            istLubroCount = new sampleVect[currAdpConf.nLubro];
            for (int i = 0; i < currAdpConf.nLubro; i++)
            {
                // leggo tutti i dati...
                List<DataRefItem<string, string>> listaDR = currAdpConf.Lubro[i].dataRefList;
                // punto all'item
                DataRefItem<string, string> riLubro = listaDR.Find(x => x.Key == string.Format("Lubro_{0:00}_Count", i + 1));
                // recupero valori...
                currLubroCount[i] = Convert.ToUInt32(riLubro.Value);
                istLubroCount[i] = new sampleVect();
            }
            currSlittaMag = new uint[currAdpConf.nSlittaMag];
            istSlittaMag = new sampleVect[currAdpConf.nSlittaMag];
            for (int i = 0; i < currAdpConf.nSlittaMag; i++)
            {
                // leggo tutti i dati...
                List<DataRefItem<string, string>> listaDR = currAdpConf.SlittaMag[i].dataRefList;
                // punto all'item
                DataRefItem<string, string> riSlittaMag = listaDR.Find(x => x.Key == string.Format("SlittaMagazzino_{0:00}_Count", i + 1));
                // recupero valori...
                currSlittaMag[i] = Convert.ToUInt32(riSlittaMag.Value);
                istSlittaMag[i] = new sampleVect();
            }
            currProtMag = new uint[currAdpConf.nProtMag];
            istProtMag = new sampleVect[currAdpConf.nProtMag];
            for (int i = 0; i < currAdpConf.nProtMag; i++)
            {
                // leggo tutti i dati...
                List<DataRefItem<string, string>> listaDR = currAdpConf.ProtMag[i].dataRefList;
                // punto all'item
                DataRefItem<string, string> riProtMag = listaDR.Find(x => x.Key == string.Format("ProtMagazzino_{0:00}_Count", i + 1));
                // recupero valori...
                currProtMag[i] = Convert.ToUInt32(riProtMag.Value);
                istProtMag[i] = new sampleVect();
            }
            // inizializzo TUTTI gli alarms
            currGateway.initAlarms();

            adpTryRestart = true;
            parentForm.displayTaskAndWait("Adapter Started!");
        }

        /// <summary>
        /// ferma l'adapter...
        /// </summary>
        /// <param name="tryRestart">indica se si debba tentare di riavviare l'adapter (con caduta connessione viene fermato in automatico)</param>
        public void stopAdapter(bool tryRestart)
        {
            parentForm.displayTaskAndWait("Stopping adapter...");
            adpTryRestart = false;

            if (currGateway.protocollo == gwProtocol.MTC)
            {
                currGateway.updateItemNodeValue("STATUS", actStatus.INACTIVE.ToString());
            }
            // faccio una chiamata extra ad ogni metodo di check...
            gaterAndSend(gatherCycle.HF);
            gaterAndSend(gatherCycle.MF);
            gaterAndSend(gatherCycle.LF);
            gaterAndSend(gatherCycle.VLF);
            parentForm.displayTaskAndWait("Stopping adapter - last periodic data read...");

            // chiudo la connessione all'adapter...
            tryDisconnect();
            // Stop everything...
            try
            {
                currGateway.stop();
            }
            catch (Exception exc)
            {
                lg.Error(exc, "Eccezione in chiusura Adapter:{0}{1}", Environment.NewLine, exc);
            }
            dtStopAdp = DateTime.Now;
            adpPortNum = currGateway.port;
            adpTryRestart = tryRestart;
            adpRunning = false;

            // chiudo!
            parentForm.resetProgBar();
            parentForm.dataMonitor_1 = "... not connected, waiting for data ...";
            parentForm.dataMonitor_2 = "";
            parentForm.dataMonitor_3 = "";
            parentForm.displayTaskAndWait("Adapter Stopped.");
            parentForm.commPlcActive = false;
        }

        /// <summary>
        ///  effettua recupero dati ed invio valori modificati...
        /// </summary>
        /// <param name="ciclo"></param>
        public void gaterAndSend(gatherCycle ciclo)
        {
            // controllo connessione/connettività
            if (connectionOk)
            {
                // controllo non sia già in esecuzione...
                if (!adpCommAct)
                {
                    // provo ad avviare
                    try
                    {
                        // avvio fase raccolta dati
                        currGateway.beginDataCollect();

                        // imposto flag adapter running..
                        adpCommAct = true;
                        adpStartRun = DateTime.Now;
                    }
                    catch (Exception exc)
                    {
                        parentForm.displayTaskAndWait(string.Format("Adapter NOT STARTED!!!{0}{1}", Environment.NewLine, exc));
                        adpCommAct = false;
                        adpStartRun = DateTime.Now;
                    }
                    if (adpCommAct)
                    {
                        // try / catch generale altrimenti segno che è disconnesso...
                        try
                        {
                            // processing degli strobes di allarme (da ULTIMA rappresentazione vettore dell'ADP)
                            processAlarm();
                            // se sono in debug testo invio vario dati che ho generalizzato da MTC...
#if DEBUG
                            testData();
#endif
                            bool showDebugData = false;

                            // verifico se processare tutto "in un colpo solo"
                            if (procIotMem)
                            {
                                processAllMemory();
                                // ciclo lento x log...
                                if (ciclo == gatherCycle.LF)
                                {
                                    // Eventuale log!
                                    if (utils.CRB("recTime"))
                                    {
                                        logTimeResults();
                                    }
                                }
                            }
                            // oppure in "modalità classica" con multistep...
                            else
                            {
                                // ciclo VHF x invii...
                                if (ciclo == gatherCycle.VHF)
                                {
                                    // processo e svuoto Eventuali code di invio per Codici M/S/T
                                    trySendCodMST();
                                }
                                // POI CONTROLLO cicli + lenti di lettura...
                                // ciclo HF: recupero update status & strobes vari
                                if (ciclo == gatherCycle.HF)
                                {
                                    // parte che eseguo SEMPRE: RECUPERO stato di tutti gli strobe/status e degli ack attualmente noti
                                    getStrobeAndAckStatus();

                                    // faccio refresh degli allarmi segnalati (da strobe su vettore locale)
                                    refreshAlarmState(STRB_DW0, true);
                                    // acquisizione degli status
                                    processStatus();
                                    // processing degli strobes
                                    processStrobe();
                                }
                                else if (ciclo == gatherCycle.MF)
                                {
                                    resetDebugConsole();
                                    // leggo parametri a media freq (dati globali, path, assi, Unità Operatrice)
                                    getGlobalData();
                                    getUnOp();
                                    getPath();
                                    getAxis();

                                    // se NON in modalità PROD eseguo chiamate "extra" x allarmi
                                    if (utils.CRS("mode") == "debug")
                                    {
                                        // SOLO in modalità testing forzo il controllo continuo allarmi...
                                        forceAlarmCheck();
                                    }
                                    // salva richiesta update x dati debug
                                    showDebugData = true;
                                }
                                // ciclo lento
                                else if (ciclo == gatherCycle.LF)
                                {
                                    // leggo EVENTUALI parametri da config file
                                    getConfigParam();
                                    ///acquisisco dati su programma in esecuzione e dati generali (stato, orologio, power...)
                                    getSlowChangingData();

                                    // Eventuale log!
                                    if (utils.CRB("recTime"))
                                    {
                                        logTimeResults();
                                    }
                                }
                                // ciclo lentissimo
                                else if (ciclo == gatherCycle.VLF)
                                {
                                    lg.Info("Richiesta lettura completa allarmi attivi");
                                    // faccio comunque rilettura completa allarmi...
                                    forceAlarmCheck();
                                }
                            }
                            if (showDebugData)
                            {
                                // verifica se debba salvare e mostrare dati
                                checkSavePersDataLayer();
                            }

                            // INVIO dati variati!
                            currGateway.sendChanged();
                        }
                        catch (Exception exc)
                        {
                            // segnalo eccezione e indico disconnesso...
                            lg.Error(exc, string.Format("Errore in gestione ciclo principale ADP, fermo adapter{0}{1}", Environment.NewLine, exc));
                            parentForm.fermaAdapter(true);
                        }
                        // tolgo flag running
                        adpCommAct = false;
                    }
                    else
                    {
                        lg.Info("ADP not running...");
                    }
                }
                else
                {
                    // log ADP running
                    lg.Error("Non eseguo chiamata: ADP ancora in running");
                    // se è bloccato da oltre maxSec lo sblocco...
                    if (DateTime.Now.Subtract(adpStartRun).TotalSeconds > utils.CRI("maxAdapterLockSec"))
                    {
                        // tolgo flag running
                        adpCommAct = false;
                        adpStartRun = DateTime.Now;
                    }
                }
            }
            else
            {
                // log connessione KO
                lg.Error("CicloMF - Connessione non disponibile, provo a riconnettere");
                // provo a riconnettere SE abilitato tryRestart...
                if (adpTryRestart && !connectionOk)
                {
                    lg.Info("ConnKO - tryConnect");
                    tryConnect();
                }
            }
            if (eh_refreshed != null)
            {
                eh_refreshed(this, new EventArgs());
            }
        }
        /// <summary>
        /// Effettua verifica direzione asse
        /// </summary>
        /// <param name="newDir"></param>
        /// <param name="i"></param>
        protected string calculateDirection(int newDir, int i)
        {
            string tipoAsse = "";
            string direzione = "";
            try
            {
                tipoAsse = currGateway.getItemNode(vettAxis[i].typeKey).ToString();
                if (tipoAsse.EndsWith("UNAVAILABLE"))
                {
                    tipoAsse = "LINEAR";
                }
            }
            catch
            { }
            if (tipoAsse == "" || tipoAsse == "OPC_UA_REDIS.DataItemRed")
            {
                // recupero info TIPO ASSE
                List<DataRefItem<string, string>> drl = vettAxis[i].dataRefList;
                foreach (var item in drl)
                {
                    if (item.Key == vettAxis[i].typeKey)
                    {
                        tipoAsse = item.Value;
                    }
                }
            }
            // verifico tipo direzione da tipo asse...   
            if (tipoAsse == "LINEAR")
            {
                if (currGateway.protocollo == gwProtocol.SOURS)
                {
                    direzione = (newDir > 0) ? "POS" : "NEG";
                }
                else
                {
                    // ?: conditional operator.  
                    direzione = (newDir > 0) ? "POSITIVE" : "NEGATIVE";
                }
            }
            else if (tipoAsse == "ROTATIONAL")
            {
                if (currGateway.protocollo == gwProtocol.SOURS)
                {
                    direzione = (newDir > 0) ? "CW" : "CCW";
                }
                else
                {
                    direzione = (newDir > 0) ? "CLOCKWISE" : "COUNTER_CLOCKWISE";
                }
            }
            return direzione;
        }
        /// <summary>
        /// Area per effettuazione test (tipicamente variabili scambiate da MTC --> generali...
        /// </summary>
        private void testData()
        {
            // imposto continuamente valore assetChange/removal x TESGING !!!FARE!!! togliere
            int sCount = DateTime.Now.Second;
        }

        public void resetDebugConsole()
        {
            // resetto console debug...
            parentForm.dataMonitor_1 = "";
            parentForm.dataMonitor_2 = "";
            parentForm.dataMonitor_3 = "";
            // indico msg allarme NON inviati
            alarmMsgDispl = false;
        }

        /// <summary>
        /// recupero dati globali (e comuni)
        /// </summary>
        public virtual void getGlobalData()
        {
            // accodo dati path in DataMonitor......
            StringBuilder sb1 = new StringBuilder();
            StringBuilder sb2 = new StringBuilder();

            // dati base...
            string currProc = "";
            // 2019.08.28 RIMETTO GESTIONE PROCESSO SEL!
            //if (currGateway.protocollo != gwProtocol.SOURS || currAdpConf.nPath > 1)
            //{
            try
            {
                currProc = currGateway.getItemNode("PROC_SEL").ToString();
            }
            catch (Exception exc)
            {
                lg.Error($"Eccezione in recupero PROC_SEL:{Environment.NewLine}{exc}");
            }
            //}
            sb1.AppendLine(string.Format("POWER {0}: | EmStop:{1} | ProcSel: {2}", currGateway.getItemNode("POWER"), currGateway.getItemNode("E_STOP"), currProc));

            try
            {
                // leggo dati globali...
                readGlobalData();
            }
            catch (Exception exc)
            {
                lg.Error($"Eccezione in readGlobalData:{Environment.NewLine}{exc}");
            }

            // legge overrides...
            try
            {
                readOverrides(ref sb1);
            }
            catch (Exception exc)
            {
                lg.Error($"Eccezione in readOverrides:{Environment.NewLine}{exc}");
            }
            // processo allarmi CNC
            try
            {
                procCncAlarm();
            }
            catch (Exception exc)
            {
                lg.Error($"Eccezione in procCncAlarm:{Environment.NewLine}{exc}");
            }
            // accodo dati base!
            try
            {
                parentForm.dataMonitor_1 += sb1.ToString();
                // accodo dati UT...
                for (int i = 0; i < currAdpConf.nUnOp; i++)
                {
                    sb2.AppendLine(string.Format("UT: ToolId {0} | VitaRes {1} | TipoVita {2} ", currGateway.getItemNode(vettUnOp[i].toolIdKey), currGateway.getItemNode(vettUnOp[i].vitaResKey), currGateway.getItemNode(vettUnOp[i].vitaResTypeKey)));
                }
                parentForm.dataMonitor_2 = sb2.ToString();
            }
            catch (Exception exc)
            {
                lg.Error($"Eccezione in accodamento a parentForm:{Environment.NewLine}{exc}");
            }
            // gestisco lettura dati manutenzione da PLC...
            try
            {
                getMtzDataFromPlc();
            }
            catch (Exception exc)
            {
                lg.Error($"Eccezione in getMtzDataFromPlc:{Environment.NewLine}{exc}");
            }
            // gestisco lettura dati status da PLC...
            try
            {
                getStatusDataFromPlc();
            }
            catch (Exception exc)
            {
                lg.Error($"Eccezione in getStatusDataFromPlc:{Environment.NewLine}{exc}");
            }
            // gestisco lettura dati analogici da PLC...
            try
            {
                getAnalogDataFromPlc();
            }
            catch (Exception exc)
            {
                lg.Error($"Eccezione in getAnalogDataFromPlc:{Environment.NewLine}{exc}");
            }
            // gestisco lettura dati stringa da PLC...
            try
            {
                getStringDataFromPlc();
            }
            catch (Exception exc)
            {
                lg.Error($"Eccezione in getStringDataFromPlc:{Environment.NewLine}{exc}");
            }
        }

        /// <summary>
        /// Legge dati globali...
        /// </summary>
        public virtual void readGlobalData()
        {
        }

        /// <summary>
        /// legge dati override...
        /// </summary>
        /// <param name="sb1"></param>
        /// <returns></returns>
        public virtual bool readOverrides(ref StringBuilder sb1)
        {
            bool fatto = false;
            return fatto;
        }

        /// <summary>
        /// processa allarmi CNC...
        /// </summary>
        public virtual bool procCncAlarm()
        {
            bool fatto = false;
            return fatto;
        }

        /// <summary>
        /// Gestione lettura dati manutenzione
        /// </summary>
        public virtual bool getMtzDataFromPlc()
        {
            bool fatto = false;
            return fatto;
        }

        /// <summary>
        /// Gestione lettura dati analogici
        /// </summary>
        public virtual bool getAnalogDataFromPlc()
        {
            bool fatto = false;
            return fatto;
        }

        /// <summary>
        /// Gestione lettura dati stringa
        /// </summary>
        public virtual bool getStringDataFromPlc()
        {
            bool fatto = false;
            return fatto;
        }

        /// <summary>
        /// Gestione lettura dati status da PLC
        /// </summary>
        public virtual bool getStatusDataFromPlc()
        {
            bool fatto = false;
            return fatto;
        }

        /// <summary>
        /// Processa i dati di override di un path
        /// </summary>
        /// <param name="currIdx">idx path (zero based)</param>
        /// <param name="dataVector">vettore 7 valori dei dati (valori int16 jog/feed/rapid/spindle[1..4])</param>
        /// <param name="sb">StringBuilder da aggiornare</param>
        public bool procPathOverride(int currIdx, ushort[] dataVector, ref StringBuilder sb)
        {
            bool fatto = false;
            // 2019.09.20: provo a salvare i 3 override... 
            try
            {
                FeedRateOverPath[currIdx] = dataVector[1];
                RapidOverPath[currIdx] = dataVector[2];
                SpeedRateOverPath[currIdx] = dataVector[3];
            }
            catch (Exception exc)
            {
                lg.Error(exc, $"Errore in processing override per path {currIdx}");
            }
            // altro processing
            try
            {
                // SOLO SE NON sono SOUR...
                if (currGateway.protocollo != gwProtocol.SOURS)
                {
                    currGateway.updateItemNodeValue(vettPath[currIdx].jogOverKey, dataVector[0] / 100);
                }

                // se ho + di 1 path prendo la sua...
                if (FeedRatePath.Length > 1)
                {
                    currGateway.updateItemNodeValue(vettPath[currIdx].feedKey, FeedRatePath[currIdx]);
                }
                else
                {
                    // prendo quella GLOBALE...                                                                      
                    currGateway.updateItemNodeValue(vettPath[currIdx].feedKey, FeedRate);
                }

                // leggo da vettore... CABLATO DIVISO PER 100!!!                                     
                currGateway.updateItemNodeValue(vettPath[currIdx].feedOverKey, dataVector[1] / 100);
                currGateway.updateItemNodeValue(vettPath[currIdx].rapidOverKey, dataVector[2] / 100);
                if (currGateway.protocollo != gwProtocol.SOURS)
                {
                    currGateway.updateItemNodeValue(vettPath[currIdx].spindleOver_01_Key, dataVector[3] / 100);
                    currGateway.updateItemNodeValue(vettPath[currIdx].spindleOver_02_Key, dataVector[4] / 100);
                    currGateway.updateItemNodeValue(vettPath[currIdx].spindleOver_03_Key, dataVector[5] / 100);
                    currGateway.updateItemNodeValue(vettPath[currIdx].spindleOver_04_Key, dataVector[6] / 100);
                }

                // SE il processo è quello corrente...
                string processo = string.Format("P{0}", currIdx + 1);
                bool doProc = false;
                if (currGateway.protocollo != gwProtocol.SOURS)
                {
                    doProc = currGateway.getItemNode("PROC_SEL").ToString() == processo;
                }
                else
                {
                    doProc = (((DataItemRed)currGateway.getItemNode("PROC_SEL")).Value.ToString() == processo);
                }
                if (doProc)
                {
                    // se da conf richeisto salvo override globale come max tra i 4 letti...
                    if (utils.CRB("getMaxSpOver"))
                    {
                        int maxSpeedOver = 0;
                        maxSpeedOver = ((dataVector[3] / 100) > maxSpeedOver) ? dataVector[3] / 100 : maxSpeedOver;
                        maxSpeedOver = ((dataVector[4] / 100) > maxSpeedOver) ? dataVector[4] / 100 : maxSpeedOver;
                        maxSpeedOver = ((dataVector[5] / 100) > maxSpeedOver) ? dataVector[5] / 100 : maxSpeedOver;
                        maxSpeedOver = ((dataVector[6] / 100) > maxSpeedOver) ? dataVector[6] / 100 : maxSpeedOver;

                        // includo lettura override spindle... è la massima tra quelle che ho letto (dai path)
                        SpeedRateOver = maxSpeedOver;
                    }
                }

                // salvo stringa!
                sb.AppendLine(string.Format("P{0} - Override % Jog | Feed | Rapid: {1} | {2} | {3}", currIdx + 1, dataVector[0] / 100, dataVector[1] / 100, dataVector[2] / 100));
                sb.AppendLine(string.Format("P{0} - Override % Spindle 1 | 2 | 3 | 4: {1} | {2} | {3} | {4}", currIdx + 1, dataVector[3] / 100, dataVector[4] / 100, dataVector[5] / 100, dataVector[6] / 100));
                fatto = true;
            }
            catch
            { }
            return fatto;
        }

        /// <summary>
        /// riporta il log di tutti i dati di results temporali registrati
        /// </summary>
        public void logTimeResults()
        {
            if (TimingData.results.Count > 0)
            {
                lg.Info("{0}--------------- START TIMING DATA ---------------", Environment.NewLine);
                int globNumCall = 0;
                TimeSpan globAvgMsec = new TimeSpan(0);
                foreach (TimeRec item in TimingData.results)
                {
                    lg.Info("Chiamate {0}: effettuate {1}, tempo medio {2:N2} msec | impegno canale {3:P3}", item.codCall, item.numCall, item.avgMsec, item.totMsec.TotalSeconds / DateTime.Now.Subtract(dtAvvioAdp).TotalSeconds);
                    globNumCall += item.numCall;
                    globAvgMsec += item.totMsec;
                }
                // riporto conteggio medio al secondo...
                lg.Info("Chiamate GLOBALI: {0}, periodo: {1:N2} minuti.cent, tempo medio {2:N2} msec | impegno canale {3:P3}", globNumCall, DateTime.Now.Subtract(dtAvvioAdp).TotalMinutes, globAvgMsec.TotalMilliseconds / globNumCall, globAvgMsec.TotalSeconds / DateTime.Now.Subtract(dtAvvioAdp).TotalSeconds);
                lg.Info("{0}--------------- STOP TIMING DATA ---------------{0}", Environment.NewLine);
                // mostro in form statistiche globali!
                parentForm.updateComStats(string.Format("Periodo: {0:N2}min | {1} x {2:N2}ms | canale {3:P3}", DateTime.Now.Subtract(dtAvvioAdp).TotalMinutes, globNumCall, globAvgMsec.TotalMilliseconds / globNumCall, globAvgMsec.TotalSeconds / DateTime.Now.Subtract(dtAvvioAdp).TotalSeconds));
            }
        }

        /// <summary>
        /// verifico se ho dati M/S/T e li invio nel caso
        /// </summary>
        public virtual void trySendCodMST()
        {
            // ciclo su + path
            for (int i = 0; i < currAdpConf.nPath; i++)
            {
                // verifico SE ho codici M/S/T da inviare...
                string codiceM = getNextMCode(i);
                string codiceS = getNextSCode(i);
                string codiceT = getNextTCode(i);
                if (codiceM != "")
                {
                    currGateway.updateItemNodeValue(vettPath[i].pathCodMKey, string.Format("[M{0}]", codiceM));
                }
                if (codiceS != "")
                {
                    currGateway.updateItemNodeValue(vettPath[i].pathCodSKey, string.Format("[S{0}]", codiceS));
                }
                if (codiceT != "")
                {
                    currGateway.updateItemNodeValue(vettPath[i].pathCodTKey, string.Format("[T{0}]", codiceT));
                }
            }
        }

        /// <summary>
        /// Metodo base connessione...
        /// </summary>
        public virtual void tryConnect()
        {
        }

        /// <summary>
        /// Metodo base disconnessione...
        /// </summary>
        public virtual void tryDisconnect()
        {
        }

        protected bool _connOk = false;

        /// <summary>
        /// Salva verifica stato connessione OK
        /// </summary>
        /// <returns></returns>
        public virtual bool connectionOk
        {
            get
            {
                return _connOk;
            }
            set
            {
                _connOk = value;
            }
        }

        #region gestione allarmi

        /// <summary>
        /// effettua ogni log period una rilettura di TUTTI gli allarmi...
        /// </summary>
        public virtual void forceAlarmCheck()
        {
            // carico status allarmi (completo)
            StFlag32 forceAlarm = (StFlag32)unchecked((int)UInt32.MaxValue);
            try
            {
                refreshAlarmState(forceAlarm, false);
            }
            catch
            {
                lg.Error("Errore in fase di esecuzione di forceAlarmCheck");
            }
            if (utils.CRB("recTime"))
            {
                logTimeResults();
            }
        }

        /// <summary>
        /// Effettua refresh del vettore privato degli allarmi attivi
        /// </summary>
        /// <param name="Alarm2Refresh">flag mask degli allarmi da aggiornare</param>
        /// <param name="giveAck">boolean: se si debba tornare ACK</param>
        public virtual void refreshAlarmState(StFlag32 Alarm2Refresh, bool giveAck)
        {
            // log bitmap se verboso attivo + ho allarmi da refreshare
            if ((Alarm2Refresh != StFlag32.NONE) && utils.CRB("verbose"))
            {
                lg.Info("AG-RAS | Richiesto refresh allarmi x bitmask: {0}", utils.binaryForm((int)Alarm2Refresh));
            }

            bool ackReturned = false;
            // byte di acknowledge...
            byte[] retACK_DW0 = new byte[4];
            // inizio impostando una bitmap x ACK che abbia i bit abbassati se lo strobe è disattivo: AND logico tra STR e ACK
            retACK_DW0 = BitConverter.GetBytes(Convert.ToUInt32(STRB_DW0 & ACK_DW0));

            inizio = DateTime.Now;
            uint[] MemBlock;
            // controllo, SE devo leggere tutto uso un unico accesso ai 128byte, altrimenti leggo a blocchi di 32bit...
            if (Alarm2Refresh == (StFlag32)unchecked((int)UInt32.MaxValue))
            {
                // blocco memoria x lettura dati COMPLETO (4Byte*32 = 128Byte)
                MemBlock = new uint[32];
                // recupero tutti i 32 bit del blocco
                inizio = DateTime.Now;
                readAllAlarms(ref MemBlock);
                if (utils.CRB("recTime"))
                {
                    TimingData.addResult(string.Format("R{0}-STRB_DW0", MemBlock.Length * 4), DateTime.Now.Subtract(inizio).Ticks);
                }

                if (currGateway.AlarmFlags != null)
                {
                    try
                    {
                        // aggiorno vettore allarmi x intero! size del vettore di destinazione (in byte!!!!)
                        Buffer.BlockCopy(MemBlock, 0, currGateway.AlarmFlags, 0, currGateway.AlarmFlags.Length);
                    }
                    catch (Exception exc)
                    {
                        lg.Error(string.Format("Errore in BLOCKCOPY{0}{1}", Environment.NewLine, exc));
                    }
                }
            }
            else
            {
                if (Alarm2Refresh != StFlag32.NONE)
                {
                    // blocco memoria x lettura dati
                    MemBlock = new uint[1];
                    // verifico gli allarmi di tutti i bit alzati...
                    for (int i = 0; i < 32; i++)
                    {
                        if (Alarm2Refresh.HasFlag((StFlag32)Math.Pow(2, i)))
                        {
                            // recupero tutti i 32 bit del blocco
                            inizio = DateTime.Now;
                            readAlarmBlock(ref MemBlock, i);
                            if (utils.CRB("recTime"))
                            {
                                TimingData.addResult(string.Format("R{0}-STRB_DW0", MemBlock.Length * 4), DateTime.Now.Subtract(inizio).Ticks);
                            }

                            try
                            {
                                // aggiorno vettore allarmi x intero!
                                Buffer.BlockCopy(MemBlock, 0, currGateway.AlarmFlags, i * 4, 4);
                            }
                            catch (Exception exc)
                            {
                                lg.Error(string.Format("Errore in BLOCKCOPY per indice i = {2},{0}{1}", Environment.NewLine, exc, i));
                            }
                            if (utils.CRI("loglevel") > 5)
                            {
                                lg.Info("Bit {0}, MemBlock: {1}", i, MemBlock[0]);
                            }
                            // segnalo allarme letto! memorizzo allarme nel vettore ack....
                            retACK_DW0 = utils.setBitOnStFlag(retACK_DW0, true, i);
                        }
                    }
                    // scrivo ack se richiesto!!!
                    if (giveAck)
                    {
                        // scrivo update ad ack!!!
                        inizio = DateTime.Now;
                        writeAlarmAck(ref retACK_DW0);
                        if (utils.CRB("recTime"))
                        {
                            TimingData.addResult(string.Format("W{0}-ACK_DW0", retACK_DW0.Length), DateTime.Now.Subtract(inizio).Ticks);
                        }

                        ackReturned = true;
                    }
                }
            }

            // SE non ho già tornato un ACK...
            if (!ackReturned)
            {
                // se è diverso il vettori degli ACK in memoria da quello PLC...
                if (ACK_DW0 != (StFlag32)BitConverter.ToUInt32(retACK_DW0, 0))
                {
                    // invio INTERO set ACK_DW0 con bit abbassati...
                    retACK_DW0 = BitConverter.GetBytes(Convert.ToUInt32(STRB_DW0 & ACK_DW0));
                    inizio = DateTime.Now;
                    writeAlarmAck(ref retACK_DW0);
                    if (utils.CRB("recTime"))
                    {
                        TimingData.addResult(string.Format("W{0}-ACK_DW0", retACK_DW0.Length), DateTime.Now.Subtract(inizio).Ticks);
                    }
                }
            }
        }

        /// <summary>
        /// Scrive vettore ACK degli allarmi
        /// </summary>
        /// <param name="retACK_DW0"></param>
        /// <returns></returns>
        public virtual bool writeAlarmAck(ref byte[] retACK_DW0)
        {
            return false;
        }

        /// <summary>
        /// Legge vettore di TUTTE memorie tipo DWord dato vettore memorie (completo)
        /// </summary>
        /// <param name="MemBlock"></param>
        /// <returns></returns>
        public virtual bool readAllAlarms(ref uint[] MemBlock)
        {
            return false;
        }

        /// <summary>
        /// Legge vettore di TUTTE memorie tipo DWord dato indice di partenza e vettore memorie
        /// </summary>
        /// <param name="MemBlock"></param>
        /// <param name="blockIndex"></param>
        /// <returns></returns>
        public virtual bool readAlarmBlock(ref uint[] MemBlock, int blockIndex)
        {
            return false;
        }

        #endregion gestione allarmi

        #region gestione altri strobe/ack

        /// <summary>
        /// Invia (se necessario) il watchdog di stato in vita... blink 0/1 ogni secondo
        /// </summary>
        public void sendWatchDog()
        {
            bool setFlag = false;
            // 2017.07.24 gestisco 32 bit perché c'è la parte finale del doppio watchdog incrociato...
            byte[] retACK_DW = new byte[4];
            // gestione su ultimi 2 bit della DW2 STR/ACK: il PRIMO bit è gestito in master da ADAPTER, il secondo da PLC; in primis io COPIO il valore del bit finale (di cui è slave...)
            retACK_DW = utils.setBitOnStFlag(retACK_DW, STRB_DW2.HasFlag(StFlag32.B31), 31);
            // ...poi gestisco il penultimo bit di cui è master... ogni 2 secondi...

            int restoB30 = 0;
            Math.DivRem(DateTime.Now.Second, 2, out restoB30);
            // i secondi dispari controllo...
            if (restoB30 > 0)
            {
                if (STRB_DW2.HasFlag(StFlag32.B30) == ACK_DW2.HasFlag(StFlag32.B30))
                {
                    // ... SE in ingresso ho strobe uguale lo cambio!!!
                    retACK_DW = utils.setBitOnStFlag(retACK_DW, !ACK_DW2.HasFlag(StFlag32.B30), 30);
                }
                else
                {
                    retACK_DW = utils.setBitOnStFlag(retACK_DW, ACK_DW2.HasFlag(StFlag32.B30), 30);
                }
            }

            // 2018.10.01 gestione bit status dei check ULTERIORI...  SE abilitato
            if (utils.CRB("stChkEnabled"))
            {
                if (currGateway.protocollo == gwProtocol.SOURS)
                {
                    bool rOK = false;
                    // imposto bit controllo servizio REDIS attivo
                    rOK = currGateway.checkStatus(1);
                    retACK_DW = utils.setBitOnStFlag(retACK_DW, rOK, 16);


                    // controllo catena REDIS | OPC-UA | Gateway | Internet 
                    // !!!FARE!!!
                    // verifico se ci siano messaggi da recapitare (MConnect --> GateWay --> macchina)  
                    // !!!FARE!!!
                }
                else if (currGateway.protocollo == gwProtocol.MTC)
                {
                    bool agentOk = false;
                    // imposto bit controllo AGENT attivo
                    agentOk = currGateway.checkStatus(1);
                    retACK_DW = utils.setBitOnStFlag(retACK_DW, agentOk, 24);
                    // imposto bit controllo AGENT valido
                    agentOk = currGateway.checkStatus(2);
                    retACK_DW = utils.setBitOnStFlag(retACK_DW, agentOk, 25);
                    // imposto bit controllo CURRENT valido
                    agentOk = currGateway.checkStatus(3);
                    retACK_DW = utils.setBitOnStFlag(retACK_DW, agentOk, 26);
                }
            }

            // 2016.10.18 aggiungo scrittura del bit di "watchdog" al primo bit della DW2... come resto tra secondi / 2
            if (utils.CRB("sendWatchDog"))
            {
                int resto = 0;
                Math.DivRem(DateTime.Now.Second / utils.CRI("cycleWatchDog"), 2, out resto);
                setFlag = resto != 0;
                // se watchdog è cambiato lo invio, altrimenti lascio come è...
                if (setFlag != lastWatchDog)
                {
                    lastWatchDog = setFlag;
                }
                retACK_DW = utils.setBitOnStFlag(retACK_DW, setFlag, 0); // imposto primo bit!!!
                                                                         // scrivo su area PLC SE variato
                if (ACK_DW2 != (StFlag32)BitConverter.ToUInt32(retACK_DW, 0))
                {
                    inizio = DateTime.Now;
                    writeWatchDog(ref retACK_DW);
                    if (utils.CRB("recTime"))
                    {
                        TimingData.addResult(string.Format("W{0}-WatchDog", retACK_DW.Length), DateTime.Now.Subtract(inizio).Ticks);
                    }
                }
            }
        }

        /// <summary>
        /// Scrive watchdog
        /// </summary>
        /// <param name="retACK_DW"></param>
        /// <returns></returns>
        public virtual bool writeWatchDog(ref byte[] retACK_DW)
        {
            return false;
        }

        #endregion gestione altri strobe/ack

        /// <summary>
        /// recupero dati PATH
        /// </summary>
        public virtual void getPath()
        {
            // SE presente recupero dati path
            checkPath();

            // dati BASE, ciclando su path
            for (int i = 0; i < currAdpConf.nPath; i++)
            {
                // se ho + di 1 path prendo la sua...
                if (FeedRatePath.Length > 1)
                {
                    currGateway.updateItemNodeValue(vettPath[i].feedKey, FeedRatePath[i]);
                }
                else
                {
                    currGateway.updateItemNodeValue(vettPath[i].feedKey, FeedRate);
                }
            }
        }

        /// <summary>
        /// Recupero dati Unità Operatrici / Mandrini
        /// </summary>
        public virtual void getUnOp()
        {
        }

        /// <summary>
        /// Processing dati UnOp
        /// </summary>
        /// <param name="unOpSpeedMem"></param>
        public void procUnOp(byte[] unOpSpeedMem)
        {
            StringBuilder sb = new StringBuilder();

            int numUnOp = currAdpConf.nUnOp;
            int locSpeedRate = 0;
            // cicl su path x leggere le velocità dell'UnOp
            for (int i = 0; i < numUnOp; i++)
            {
                // leggo valore Codice
                locSpeedRate = BitConverter.ToUInt16(unOpSpeedMem, 2 * i);
                // leggo 41° byte = indice 40 + 2*i x le var del carico UnOp
                UnOpLoad = unOpSpeedMem[40 + i];

                // Eventuale fix bigEndian...
                if (hasBigEndian)
                {
                    locSpeedRate = Endian.SwapUInt16((ushort)locSpeedRate);
                }
                currGateway.updateItemNodeValue(vettUnOp[i].speedKey, locSpeedRate);
                currGateway.updateItemNodeValue(vettUnOp[i].loadKey, UnOpLoad);
                currGateway.updateItemNodeValue(vettUnOp[i].speedOverKey, SpeedRateOver);

                sb.AppendLine(string.Format("UnOp_{0}: SpeedRate {1} rpm | Load {2} | SpOv: {3}", i + 1, locSpeedRate, UnOpLoad, SpeedRateOver));
            }

            parentForm.dataMonitor_2 += sb.ToString();
        }

        /// <summary>
        /// recupero dati ASSI
        /// </summary>
        public virtual void getAxis()
        {
        }

        /// <summary>
        /// Gestione STROBE --> ACK per codici M/S/T
        /// </summary>
        /// <param name="currStrobe">byte di strobe corrente</param>
        /// <param name="bitNum">0/1/2</param>
        /// <param name="retACK_DW1">vettore da restituire di ACK</param>
        /// <param name="memShift">shift memoria x buffer dati da leggere</param>
        /// <param name="MemBlock">Vettore completo dei valori + buffer code M/S/T</param>
        /// <param name="Coda">Quale coda: M/S/T</param>
        /// <param name="idxPath">Path (0,1,...)</param>
        public void gestStrobeCodMST(StFlag8 currStrobe, int bitNum, ref byte[] retACK_DW1, int memShift, byte[] MemBlock, string Coda, int idxPath)
        {
            UInt16 numEv = 0;
            UInt16 codEv = 0;
            if (currStrobe.HasFlag((StFlag8)Math.Pow(2, bitNum)))
            {
                try
                {
                    // verifico sia > 0 il numero di valori da leggere - indice 0 sull'area...
                    numEv = BitConverter.ToUInt16(MemBlock, 2 * memShift);
                }
                catch (Exception exc)
                {
                    lg.Error(exc, "Errore in gestStrobeCodMST --> BitConverter 01");
                }
                // se è bigEndian devo swappare!
                if (hasBigEndian)
                {
                    numEv = Endian.SwapUInt16(numEv);
                }

                if (numEv > 0)
                {
                    // il num ev rappresenta quanti slot 16bit (da 2 byte) sono stati valorizzati, VA FATTO CICLO E LETTI TUTTI
                    for (int i = 0; i < numEv; i++)
                    {
                        try
                        {
                            // leggo valore Codice
                            codEv = BitConverter.ToUInt16(MemBlock, 2 * (1 + saltoMST + i + memShift));
                        }
                        catch (Exception exc)
                        {
                            lg.Error(exc, "Errore in gestStrobeCodMST --> BitConverter 02");
                        }
                        if (hasBigEndian)
                        {
                            codEv = Endian.SwapUInt16(codEv);
                        }
                        // accodo Evento Codice
                        appendCodeMST(Coda, codEv.ToString(), idxPath);
                    }
                }
                // memorizzo allarme nel vettore ack....
                retACK_DW1 = utils.setBitOnStFlag(retACK_DW1, true, bitNum);
            }
        }

        /// <summary>
        /// Gestione strobe UserAction: salva dati e gestione ACK
        /// </summary>
        /// <param name="idxPath"></param>
        /// <param name="bitNum"></param>
        /// <param name="retACK_DW1"></param>
        /// <param name="UserAction"></param>
        /// <param name="azione"></param>
        public void gestStrobeUserAction(int idxPath, int bitNum, ref byte[] retACK_DW1, ref string UserAction, string azione)
        {
            if (STRB_DW1.HasFlag((StFlag32)Math.Pow(2, bitNum + 16 * idxPath)))
            {
                // salvo Evento UserAction in variabile...
                UserAction += azione;
                // memorizzo allarme nel vettore ack....
                retACK_DW1 = utils.setBitOnStFlag(retACK_DW1, true, bitNum);
            }
        }

        /// <summary>
        /// Ricarica dati da file di scambio con CMSConnect
        /// </summary>
        public void reloadDataFromFile()
        {
            if (currGateway.protocollo == gwProtocol.MTC)
            {
                if (utils.CRB("verbose"))
                {
                    lg.Info("Inizio lettura dati da file");
                }

                int totRighe = 0;
                // da rivedere: se sono N+1 file (N=path + generale) deve essere ad esempio nomeComune_*.mtc --> ciclo per leggerne N
                string fileName = string.Format(@"{0}\{1}", utils.dataDir, utils.CRS("GeneralStatusFilePath"));
                string linea;
                // creo un vettore della dimensione corretta... conta anche commenti tanto poi riduco...
                generalStatus = new Dictionary<string, string>();
                try
                {
                    totRighe = File.ReadLines(fileName).Count();
                    // carica da file...
                    System.IO.StreamReader file = new System.IO.StreamReader(fileName);
                    if (file != null)
                    {
                        // leggo 1 linea alla volta...
                        string[] valori;
                        while ((linea = file.ReadLine()) != null)
                        {
                            // SE non è un commento...
                            if (linea.Substring(0, 1) != "#")
                            {
                                valori = linea.Split(utils.CRC("testCharSep"));
                                generalStatus.Add(valori[0], valori[1]);
                            }
                        }
                        // chiudo file
                        file.Close();
                        if (utils.CRB("verbose"))
                        {
                            lg.Info("Fine lettura dati da file scambio CMS");
                        }
                    }
                }
                catch (Exception exc)
                {
                    lg.Error(exc, "Errore in lettura dati da file scambio CMS");
                }

                // ora salvo valori letti...
                foreach (KeyValuePair<string, string> item in generalStatus)
                {
                    // verifico la chiave e nel caso aggiorno...
                    switch (item.Key)
                    {
                        case "OperatorId":
                            currGateway.updateItemNodeValue("OperatorId", item.Value);
                            break;

                        case "Path_01_CurrProg":
                            istPathProgrName[0] = item.Value;
                            break;

                        case "Path_02_CurrProg":
                            istPathProgrName[1] = item.Value;
                            break;

                        case "Path_03_CurrProg":
                            istPathProgrName[2] = item.Value;
                            break;

                        case "Path_04_CurrProg":
                            istPathProgrName[3] = item.Value;
                            break;

                        case "Path_05_CurrProg":
                            istPathProgrName[4] = item.Value;
                            break;

                        case "Path_06_CurrProg":
                            istPathProgrName[5] = item.Value;
                            break;

                        case "Path_01_PartId":
                            istPathPartId[0] = item.Value;
                            break;

                        case "Path_02_PartId":
                            istPathPartId[1] = item.Value;
                            break;

                        case "Path_03_PartId":
                            istPathPartId[2] = item.Value;
                            break;

                        case "Path_04_PartId":
                            istPathPartId[3] = item.Value;
                            break;

                        case "Path_05_PartId":
                            istPathPartId[4] = item.Value;
                            break;

                        case "Path_06_PartId":
                            istPathPartId[5] = item.Value;
                            break;

                        default:
                            break;
                    }
                }
            }
        }

        /// <summary>
        /// verifica gli status attivi
        /// </summary>
        public virtual void processStatus()
        {
            // status macchina (SOUR)
            string sourStatus = "UNDEFINED";
            if (currGateway.protocollo == gwProtocol.SOURS)
            {
                // recupero byte dello status!
                ouStatus = ACK_DW3_B0;

                // recupero valore PUNTUALE status da apposita area memoria... se ha valore >=0...
                if (ouStatusByPlc && ouStatus >= 0)
                {
                    sourStatus = ((macState)ouStatus).ToString();
                }
                // calcolo status da ALTRE info (vs leggo variabile...)
                else
                {
                    // calcolo lo status...
                    if (!STRB_DW2.HasFlag(StFlag32.B01))
                    {
                        sourStatus = macState.POWER_OFF.ToString();
                    }
                    else if (STRB_DW2.HasFlag(StFlag32.B11))
                    {
                        sourStatus = macState.FAIL.ToString();
                    }
                    else if (STRB_DW2.HasFlag(StFlag32.B04) && STRB_DW2.HasFlag(StFlag32.B09))
                    {
                        sourStatus = macState.EXE.ToString();
                    }
                    else
                    {
                        sourStatus = macState.READY.ToString();
                    }
                }

                currGateway.updateItemNodeValue("STATUS", sourStatus);
            }


            // update status da DW2/ DW3

            // EMstop: verifico BIT e di conseguenza imposto
            if (STRB_DW2.HasFlag(StFlag32.B00))
            {
                if (currGateway.protocollo == gwProtocol.SOURS)
                {
                    currGateway.updateItemNodeValue("E_STOP", true);
                }
                else
                {
                    currGateway.updateItemNodeValue("E_STOP", emStatus.TRIGGERED.ToString());
                }
            }
            else
            {
                if (currGateway.protocollo == gwProtocol.SOURS)
                {
                    currGateway.updateItemNodeValue("E_STOP", false);
                }
                else
                {
                    currGateway.updateItemNodeValue("E_STOP", emStatus.ARMED.ToString());
                }
            }

            // verifico POWER ON...
            if (STRB_DW2.HasFlag(StFlag32.B01))
            {
                if (currGateway.protocollo == gwProtocol.SOURS)
                {
                    currGateway.updateItemNodeValue("POWER", true);
                }
                else
                {
                    currGateway.updateItemNodeValue("POWER", onOffStatus.ON.ToString());
                }
            }
            else
            {
                if (currGateway.protocollo == gwProtocol.SOURS)
                {
                    currGateway.updateItemNodeValue("POWER", false);
                }
                else
                {
                    currGateway.updateItemNodeValue("POWER", onOffStatus.OFF.ToString());
                }
            }

            // Processo selezionato 0=P1, 1=P2

            if (STRB_DW2.HasFlag(StFlag32.B02))
            {
                procSel = "P2";
            }
            else
            {
                procSel = "P1";
            }

            // 2019.08.28 RIMETTO GESTIONE PROCESSO SEL!
            //// lo riporto SOLO SE HO almeno 2 processi oppure protocollo NON OPC-UA
            //if (currGateway.protocollo != gwProtocol.SOURS || currAdpConf.nPath > 1)
            //{
            if (currGateway.getItemNode("PROC_SEL").ToString() != procSel)
            {
                currGateway.updateItemNodeValue("PROC_SEL", procSel);
            }
            //}

            // processo ora i dai dei path... di sicuro il primo
            procPath01_Status();
            //...e se c'è pure il secondo...
            if (currAdpConf.nPath > 1)
            {
                // anche il secondo!
                procPath02_Status();
            }

            // cerco status allarmi presenti 
            if (STRB_DW2.HasFlag(StFlag32.B29))
            {
                currGateway.alarmPresent = true;
            }
            else
            {
                currGateway.alarmPresent = false;
            }
        }

        /// <summary>
        /// Processa status del path 01...
        /// </summary>
        public void procPath01_Status()
        {
            // HARD CODE: forzo path 1 (indice 0...) x iniziare...
            int idxPath = 0;
            string pathType = "";
            // verifico tipo processo path...
            if (STRB_DW2.HasFlag(StFlag32.B03))
            {
                if (currGateway.protocollo == gwProtocol.SOURS)
                {
                    pathType = "LAV";
                }
                else
                {
                    pathType = "LAVORO";
                }
            }
            else
            {
                if (currGateway.protocollo == gwProtocol.SOURS)
                {
                    pathType = "ASS";
                }
                else
                {
                    pathType = "ASSERV";
                }
            }

            // switch su RUN mode...
            string runMode = "";
            int currRunMode = 0;
            if (STRB_DW2.HasFlag(StFlag32.B04))
            {
                currRunMode = (int)MtcRunMode.AUTOMATIC;
            }
            else if (STRB_DW2.HasFlag(StFlag32.B05))
            {
                currRunMode = (int)MtcRunMode.EDIT;
            }
            else if (STRB_DW2.HasFlag(StFlag32.B06))
            {
                currRunMode = (int)MtcRunMode.MANUAL_DATA_INPUT;
            }
            else if (STRB_DW2.HasFlag(StFlag32.B07))
            {
                currRunMode = (int)MtcRunMode.MANUAL;
            }
            else if (STRB_DW2.HasFlag(StFlag32.B08))
            {
                currRunMode = (int)MtcRunMode.SEMI_AUTO;
            }
            // traduco...
            if (currGateway.protocollo == gwProtocol.SOURS)
            {
                runMode = ((OpcUaPathMode)currRunMode).ToString();
            }
            else
            {
                runMode = ((MtcRunMode)currRunMode).ToString();
            }
            // se proc corrente --> salvo
            if (procSel == "P1")
            {
                procMode = currRunMode;
            }

            // switch su EXE mode...
            string exeMode = "";
            int currExeMode = 0;
            if (STRB_DW2.HasFlag(StFlag32.B09))
            {
                currExeMode = (int)MtcExeMode.ACTIVE;
            }
            else if (STRB_DW2.HasFlag(StFlag32.B10))
            {
                currExeMode = (int)MtcExeMode.READY;
            }
            else if (STRB_DW2.HasFlag(StFlag32.B11))
            {
                currExeMode = (int)MtcExeMode.STOPPED;
            }
            else if (STRB_DW2.HasFlag(StFlag32.B12))
            {
                currExeMode = (int)MtcExeMode.FEED_HOLD;
            }
            else if (STRB_DW2.HasFlag(StFlag32.B13))
            {
                currExeMode = (int)MtcExeMode.OPTIONAL_STOP;
            }
            else if (STRB_DW2.HasFlag(StFlag32.B14))
            {
                currExeMode = (int)MtcExeMode.PROGRAM_STOPPED;
            }
            else if (STRB_DW2.HasFlag(StFlag32.B15))
            {
                currExeMode = (int)MtcExeMode.PROGRAM_COMPLETED;
            }
            // traduco...
            if (currGateway.protocollo == gwProtocol.SOURS)
            {
                exeMode = ((OpcUaPathStatus)currExeMode).ToString();
            }
            else
            {
                exeMode = ((MtcExeMode)currExeMode).ToString();
            }

            // inizializzo SEMPRE a vuoto...
            string SubMode = "";
            // verifico sulla STRB_DW3 i submode che POTREBBERO tutti sovrapposti...
            if (STRB_DW3 != StFlag32.NONE)
            {
                // cerco i bit alzati --> aggiungo relativo submode!
                for (int i = 0; i < 32; i++)
                {
                    // converto! e aggiungo allarmi sollevati al corretto controller allarmi...
                    if (STRB_DW3.HasFlag((StFlag32)Math.Pow(2, i)))
                    {
                        SubMode += string.Format(" [P{0:00}_{1}]", idxPath + 1, elencoSubMode[i.ToString()]);
                    }
                }
            }

            // salvo in blocco le info ricostruite x path!
            savePathData(idxPath, pathType, runMode, exeMode, SubMode.Trim());
        }

        /// <summary>
        /// Processa status del path 02...
        /// </summary>
        public void procPath02_Status()
        {
            // HARD CODE: forzo path 2 (indice 1)...
            int idxPath = 1;
            string pathType = "";
            // verifico tipo processo path...
            if (STRB_DW1.HasFlag(StFlag32.B16))
            {
                if (currGateway.protocollo == gwProtocol.SOURS)
                {
                    pathType = "LAV";
                }
                else
                {
                    pathType = "LAVORO";
                }
            }
            else
            {
                if (currGateway.protocollo == gwProtocol.SOURS)
                {
                    pathType = "ASS";
                }
                else
                {
                    pathType = "ASSERV";
                }
            }

            // switch su RUN mode...
            string runMode = "";
            int currRunMode = 0;
            if (STRB_DW2.HasFlag(StFlag32.B17))
            {
                currRunMode = (int)MtcRunMode.AUTOMATIC;
            }
            else if (STRB_DW2.HasFlag(StFlag32.B18))
            {
                currRunMode = (int)MtcRunMode.EDIT;
            }
            else if (STRB_DW2.HasFlag(StFlag32.B19))
            {
                currRunMode = (int)MtcRunMode.MANUAL_DATA_INPUT;
            }
            else if (STRB_DW2.HasFlag(StFlag32.B20))
            {
                currRunMode = (int)MtcRunMode.MANUAL;
            }
            else if (STRB_DW2.HasFlag(StFlag32.B21))
            {
                currRunMode = (int)MtcRunMode.SEMI_AUTO;
            }
            // traduco...
            if (currGateway.protocollo == gwProtocol.SOURS)
            {
                runMode = ((OpcUaPathMode)currRunMode).ToString();
            }
            else
            {
                runMode = ((MtcRunMode)currRunMode).ToString();
            }
            // se proc corrente --> salvo
            if (procSel == "P2")
            {
                procMode = currRunMode;
            }

            // switch su EXE mode...
            string exeMode = "";
            int currExeMode = 0;
            if (STRB_DW2.HasFlag(StFlag32.B22))
            {
                currExeMode = (int)MtcExeMode.ACTIVE;
            }
            else if (STRB_DW2.HasFlag(StFlag32.B23))
            {
                currExeMode = (int)MtcExeMode.READY;
            }
            else if (STRB_DW2.HasFlag(StFlag32.B24))
            {
                currExeMode = (int)MtcExeMode.STOPPED;
            }
            else if (STRB_DW2.HasFlag(StFlag32.B25))
            {
                currExeMode = (int)MtcExeMode.FEED_HOLD;
            }
            else if (STRB_DW2.HasFlag(StFlag32.B26))
            {
                currExeMode = (int)MtcExeMode.OPTIONAL_STOP;
            }
            else if (STRB_DW2.HasFlag(StFlag32.B27))
            {
                currExeMode = (int)MtcExeMode.PROGRAM_STOPPED;
            }
            else if (STRB_DW2.HasFlag(StFlag32.B28))
            {
                currExeMode = (int)MtcExeMode.PROGRAM_COMPLETED;
            }
            // traduco...
            if (currGateway.protocollo == gwProtocol.SOURS)
            {
                exeMode = ((OpcUaPathStatus)currExeMode).ToString();
            }
            else
            {
                exeMode = ((MtcExeMode)currExeMode).ToString();
            }

            // inizializzo SEMPRE a vuoto...
            string SubMode = "";
            // verifico sulla STRB_DW3 i submode che POTREBBERO tutti sovrapposti...
            if (STRB_DW4 != StFlag32.NONE)
            {
                // cerco i bit alzati --> aggiungo relativo submode!
                for (int i = 0; i < 32; i++)
                {
                    // converto! e aggiungo allarmi sollevati al corretto controller allarmi...
                    if (STRB_DW4.HasFlag((StFlag32)Math.Pow(2, i)))
                    {
                        SubMode += string.Format(" [P{0:00}_{1}]", idxPath + 1, elencoSubMode[i.ToString()]);
                    }
                }
            }

            // salvo in blocco le info ricostruite x path!
            savePathData(idxPath, pathType, runMode, exeMode, SubMode.Trim());

        }

        /// <summary>
        /// Salva i valori per il path indicato SE variati...
        /// </summary>
        /// <param name="idxPath"></param>
        /// <param name="pathType"></param>
        /// <param name="pathRunMode"></param>
        /// <param name="pathExeMode"></param>
        /// <param name="pathSubMode"></param>
        public void savePathData(int idxPath, string pathType, string pathRunMode, string pathExeMode, string pathSubMode)
        {
            // salvo type      
            if (currGateway.getItemNode(vettPath[idxPath].pathTypeKey).ToString() != pathType)
            {
                currGateway.updateItemNodeValue(vettPath[idxPath].pathTypeKey, pathType);
            }
            // salvo RUN mode
            if (currGateway.getItemNode(vettPath[idxPath].runModeKey).ToString() != pathRunMode)
            {
                currGateway.updateItemNodeValue(vettPath[idxPath].runModeKey, pathRunMode);
            }
            // salvo EXE mode
            if (currGateway.getItemNode(vettPath[idxPath].exeModeKey).ToString() != pathExeMode)
            {
                currGateway.updateItemNodeValue(vettPath[idxPath].exeModeKey, pathExeMode);
            }
            // salvo i submode..
            if (currGateway.getItemNode(vettPath[idxPath].subModeKey).ToString() != pathSubMode)
            {
                currGateway.updateItemNodeValue(vettPath[idxPath].subModeKey, pathSubMode);
            }
        }

        /// <summary>
        /// processo tutti gli strobe attivi
        /// </summary>
        public virtual void processStrobe()
        {
            // ...da gestire su ogni adapter...
        }

        /// <summary>
        /// Processa strobe x un dato path
        /// </summary>
        /// <param name="idxPath">path corrente</param>
        /// <param name="currStrobe">Byte di strobe del path corrente</param>
        /// <param name="currAck">Byte di strobe del path corrente</param>
        /// <param name="memIndexMST">indice x lettura memoria MST del path</param>
        /// <param name="memIndexAck">indice x scrittura ACK x path</param>
        /// <param name="UserAction">stringa COMPLESSIVA azioni utente</param>
        public void procPathStrobes(int idxPath, StFlag8 currStrobe, StFlag8 currAck, int memIndexMST, int memIndexAck, ref string UserAction)
        {
            // byte di strobe e di acknowledge... inizializzo!!!
            byte[] currACK_DW = new byte[1];
            // altre variabili
            int bitNum = 0;
            inizio = DateTime.Now;
            // incomincio vera e propria gestione...
            try
            {
                // controllo TUTTI i flag: se ce ne sono di alzati DEVO processare...
                if (currStrobe != StFlag8.NONE)
                {
                    // se ho un M/S/T leggo area...
                    if (currStrobe.HasFlag(StFlag8.B0) || currStrobe.HasFlag(StFlag8.B1) || currStrobe.HasFlag(StFlag8.B2))
                    {
                        // leggo memoria (direttamente a Byte...)!
                        readMST_data(idxPath, memIndexMST, ref MemBlock_MST);

                        // check COD_M
                        bitNum = 0;
                        gestStrobeCodMST(currStrobe, bitNum, ref currACK_DW, 0, MemBlock_MST, "M", idxPath);

                        // check COD_S
                        bitNum = 1;
                        gestStrobeCodMST(currStrobe, bitNum, ref currACK_DW, 11 + saltoMST, MemBlock_MST, "S", idxPath);

                        // check COD_T
                        bitNum = 2;
                        gestStrobeCodMST(currStrobe, bitNum, ref currACK_DW, 17 + 2 * saltoMST, MemBlock_MST, "T", idxPath);
                    }

                    // check FILE DATI MODIFICATO: ricaricare...
                    bitNum = 3;
                    if (STRB_DW1.HasFlag((StFlag32)Math.Pow(2, bitNum)))
                    {
                        lg.Info("Notifica file modificato");
                        try
                        {
                            // reload dati da file...
                            reloadDataFromFile();

                            // memorizzo allarme nel vettore ack....
                            currACK_DW = utils.setBitOnStFlag(currACK_DW, true, bitNum);
                        }
                        catch
                        {
                            lg.Info("Errore lettura dati da file");
                        }
                    }

                    // AREA strobe USER ACTION
                    // chiamato Start...
                    bitNum = 4;
                    gestStrobeUserAction(idxPath, bitNum, ref currACK_DW, ref UserAction, string.Format(" (P{0:00} START) ", idxPath + 1));
                    // chiamato Stop...
                    bitNum = 5;
                    gestStrobeUserAction(idxPath, bitNum, ref currACK_DW, ref UserAction, string.Format(" (P{0:00} STOP) ", idxPath + 1));
                    // chiamato Reset...
                    bitNum = 6;
                    gestStrobeUserAction(idxPath, bitNum, ref currACK_DW, ref UserAction, string.Format(" (P{0:00} RESET) ", idxPath + 1));
                }
                else
                {
                    // inizializzo 4 byte a zero!!!
                    currACK_DW = new byte[1];
                }
            }
            catch (Exception exc)
            {
                lg.Error(string.Format("Errore in strobe:{0}{1}", Environment.NewLine, exc));
            }

            // scrivo update ad ack SE VARIATO!!!
            if (currAck != (StFlag8)currACK_DW[0])
            {
                writeMST_ACK(memIndexAck, ref currACK_DW);
            }
        }

        /// <summary>
        /// Verifica strobe autotest
        /// </summary>
        /// <param name="currStrobe"></param>
        /// <param name="currAck"></param>
        /// <param name="memIndexAck"></param>
        /// <param name="memOrderStart"></param>
        public void processTestStrobe(StFlag8 currStrobe, StFlag8 currAck, int memIndexAck, int memOrderStart)
        {
            // byte di strobe e di acknowledge... inizializzo!!!
            byte[] currACK_DW = new byte[1];
            string TestingData = "";
            // INIZIO TEST...
            int bitNum = 6;
            if (currStrobe.HasFlag((StFlag8)Math.Pow(2, bitNum)))
            {
                // formatto stringa risultato
                TestingData = string.Format("START TEST{0}", getTestData(utils.CRS("testCharSep")));

                // memorizzo allarme nel vettore ack....
                currACK_DW = utils.setBitOnStFlag(currACK_DW, true, bitNum);
            }
            // FINE TEST...
            bitNum = 7;
            if (currStrobe.HasFlag((StFlag8)Math.Pow(2, bitNum)))
            {
                // formatto stringa risultato
                TestingData = string.Format("STOP TEST{0}", getTestData(utils.CRS("testCharSep")));

                // memorizzo allarme nel vettore ack....
                currACK_DW = utils.setBitOnStFlag(currACK_DW, true, bitNum);
            }

            // INVIO stato test...
            if (currGateway.getItemNode("TESTING_DATA").ToString() != TestingData.Trim())
            {
                currGateway.updateItemNodeValue("TESTING_DATA", TestingData.Trim());
            }

            // scrivo update ad ack SE VARIATO!!!
            if (currAck != (StFlag8)currACK_DW[0])
            {
                writeMST_ACK(memIndexAck, ref currACK_DW);
            }
        }

        /// <summary>
        /// Recupero info su test: numero + elenco parametri IN/OUT
        /// </summary>
        /// <param name="charSep"></param>
        /// <returns></returns>
        public string getTestData(string charSep)
        {
            string answ = "";
            // Area di memoria x test... (64 DWord) (la prima va splittata)
            UInt32[] MemBlockTestData = new UInt32[64];
            // variabili numero test e num parametri impiegati
            int testNum = 0;
            int numPar = 0;
            // variabile dove parcheggiare conversione codici dei parametri del test (IN o OUT)
            UInt32 testParam = 0;
            readTestData(ref MemBlockTestData);

            // recupero cod univoco test e numero parametri impiegati
            testNum = BitConverter.ToUInt16(BitConverter.GetBytes(MemBlockTestData[0]), 0);
            numPar = BitConverter.ToUInt16(BitConverter.GetBytes(MemBlockTestData[0]), 2);

            // riporto separatore + numero test + num parametri
            answ = string.Format("{0}TN:{1}{0}NP:{2}", charSep, testNum, numPar);
            // se ci sono parametri da accodare li recupero!
            if (numPar > 0)
            {
                for (int i = 0; i < numPar; i++)
                {
                    testParam = MemBlockTestData[1 + i];
                    answ += string.Format("{0}{1}", charSep, testParam);
                }
            }
            return answ;
        }

        /// <summary>
        /// Effettua lettura dati TESTING
        /// </summary>
        /// <param name="MemBlockTestData"></param>
        /// <returns></returns>
        public virtual bool readTestData(ref uint[] MemBlockTestData)
        {
            bool fatto = false;
            return fatto;
        }

        /// <summary>
        /// Legge area memoria dati MST
        /// </summary>
        /// <param name="idxPath"></param>
        /// <param name="memIndexMST"></param>
        /// <param name="MemBlock_MST"></param>
        /// <returns></returns>
        public virtual bool readMST_data(int idxPath, int memIndexMST, ref byte[] MemBlock_MST)
        {
            bool fatto = false;
            return fatto;
        }

        /// <summary>
        /// Scrive ACK x dati MST
        /// </summary>
        /// <param name="idxPath"></param>
        /// <param name="memIndexMST"></param>
        /// <param name="MemBlock_W"></param>
        /// <returns></returns>
        public virtual bool writeMST_ACK(int memIndexAck, ref byte[] currACK_DW)
        {
            bool fatto = false;
            return fatto;
        }

        /// <summary>
        /// processo il vettore LOCALE degli allarmi
        /// </summary>
        public virtual void processAlarm()
        {
            currGateway.processAlarm();
        }

        /// <summary>
        /// Classe fittizia in caso di processing GLOBALE di tutto in 1 solo colpo...
        /// </summary>
        public virtual void processAllMemory()
        { }

        /// <summary>
        /// metodo di recupero dei dati di identificativo macchina - DA CONF!!!
        /// </summary>
        public virtual void getConfigParam()
        {
        }

        /// <summary>
        /// dati "lenti" relativi al device
        /// </summary>
        public virtual void getSlowChangingData()
        {
            if (currGateway.protocollo == gwProtocol.MTC)
            {
                // dati da PC
                currGateway.updateItemNodeValue("CLOCK", DateTime.Now);

                // reload dati da file...
                reloadDataFromFile();
            }

            // area gestione dati utensili... in base al num max di UnOp recupero i dati utensile... PROCEDURA AD HOC!!!
            getDatiUt(currAdpConf.nUnOp);
        }

        /// <summary>
        /// recupero di TUTTI gli strobes/status attivi
        /// </summary>
        public virtual void getStrobeAndAckStatus()
        {
            // da gestire su ogni adapter... legge tutto array STROBE!!!
        }
        /// <summary>
        /// Effettua decodifica a ritroso della key SOUR
        /// </summary>
        /// <param name="varName"></param>
        /// <param name="tgtName"></param>
        /// <returns></returns>
        protected string getOrigName(string varName)
        {
            string answ = varName;
            // se il gateway è sour DEVO FARE CONTROLLO con fix...
            if (utils.CRS("adpProto") == "SOURS")
            {
                GatewaySOURS gSour = (GatewaySOURS)currGateway;
                answ = gSour.mAdapter.getOrigKey(varName);
            }
            // return!
            return answ;
        }
        /// <summary>
        /// Numero massimo (indice) valori maintData (privato)
        /// </summary>
        protected int _maintDataMaxNum = 0;
        /// <summary>
        /// Numero massimo (indice) valori maintData (calcolato)
        /// </summary>
        public int maintDataMaxNum
        {
            get
            {
                if (_maintDataMaxNum == 0)
                {
                    if (maintData != null)
                    {
                        // prima stima
                        int idx = maintData.Length;
                        // ora ciclo...
                        foreach (var item in maintData)
                        {
                            int.TryParse(item.codNum, out idx);
                            _maintDataMaxNum = idx > _maintDataMaxNum ? idx : _maintDataMaxNum;
                        }
                    }
                }
                return _maintDataMaxNum;
            }
        }

        /// <summary>
        /// Processa la tabella di memoria dei dati di manutenzione
        /// </summary>
        /// <param name="tabDatiMtz"></param>
        /// <param name="maintData"></param>
        public void processMaintData(uint[] tabDatiMtz, otherData[] maintData)
        {
            // uno ad uno vado a inserirli nella mappa dei dati dell'adapter...
            int numero = 0;
            int idxTab = 0;
            int valRead = 0;
            string origName = "";
            for (int i = 0; i < maintData.Length; i++)
            {
                numero = 0;
                valRead = 0;
                // calcolo idx a indice 0...
                int.TryParse(maintData[i].codNum, out idxTab);
                idxTab--;
                origName = getOrigName(maintData[i].varName);

                // 2020.04.30: inizio TENTANDO di calcolare valRead con suo fattore di scala
                try
                {
                    valRead = (int) (tabDatiMtz[idxTab]);
                    // se c'è fatt scala --> divido
                    if (maintData[i].scale != 0 && maintData[i].scale != 1)
                    {
                        // scalo!
                        valRead = valRead / maintData[i].scale;
                    }
                }
                catch
                { }
                // decodifico...
                if (origName == "ACC_TIME")
                {
                    istOreMaccOn.addValue(DateTime.Now, (int)valRead);
                    //istOreMaccOn.addValue(DateTime.Now, Convert.ToInt32(tabDatiMtz[idxTab]));
                }
                else if (origName == "ACC_TIME_WORK")
                {
                    istOreMaccLav.addValue(DateTime.Now, (int)valRead);
                }
                else if (origName == "SlittaTastatore_Count")
                {
                    istSlittaTast.addValue(DateTime.Now, (int)valRead);
                }
                // DA RIVEDERE x check traduzione...
                else if (origName.StartsWith("Counter_"))
                {
                    try
                    {
                        numero = Convert.ToInt32(origName.Replace("Counter_", ""));
                    }
                    catch
                    {
                    }
                    if (numero > 0 && istCounters.Length >= numero)
                    {
                        istCounters[numero - 1].addValue(DateTime.Now, (int)valRead);
                    }
                }
                else if (origName.StartsWith("RTCounter_"))
                {
                    try
                    {
                        numero = Convert.ToInt32(origName.Replace("RTCounter_", ""));
                    }
                    catch
                    {
                    }
                    if (numero > 0 && istRTCounters.Length >= numero)
                    {
                        istRTCounters[numero - 1].addValue(DateTime.Now, (int)valRead);
                    }
                }
                else if (elRTVCount.ContainsKey(origName))
                {
                    // recupero da dictionary!
                    try
                    {
                        // numero base 0 --> +1!!!
                        numero = elRTVCount[origName] + 1;
                    }
                    catch
                    {
                        numero = 0;
                    }
                    if (numero > 0 && istRTVCount.Length >= numero)
                    {
                        istRTVCount[numero - 1].addValue(DateTime.Now, (int)valRead);
                    }
                }
                else if (origName.StartsWith("Path_"))
                {
                    if (origName.EndsWith("_PZ_TOT"))
                    {
                        try
                        {
                            numero = Convert.ToInt32(origName.Replace("Path_", "").Replace("_PZ_TOT", ""));
                        }
                        catch
                        { }
                        if (numero > 0 && vettPath.Length >= numero)
                        {
                            // SE NON E' SOUR...
                            if (currGateway.protocollo != gwProtocol.SOURS)
                            {
                                currGateway.updateItemNodeValue(vettPath[numero - 1].partCountKey, valRead);
                            }
                        }
                    }
                }
                else if (origName.StartsWith("Axis_"))
                {
                    if (origName.EndsWith("_DistDone"))
                    {
                        try
                        {
                            numero = Convert.ToInt32(origName.Replace("Axis_", "").Replace("_DistDone", ""));
                        }
                        catch
                        { }
                        if (numero > 0 && istDistMovAssi.Length >= numero)
                        {
                            istDistMovAssi[numero - 1].addValue(DateTime.Now, (int)valRead);
                        }
                    }
                    else if (origName.EndsWith("_InvDDone") || origName.EndsWith("_Invers"))
                    {
                        try
                        {
                            numero = Convert.ToInt32(origName.Replace("Axis_", "").Replace("_InvDDone", "").Replace("_Invers", ""));
                        }
                        catch
                        { }
                        if (numero > 0 && istNumInvAssi.Length >= numero)
                        {
                            // 2016.07.06 debug di valori che potrebbero essere nulli...
                            try
                            {
                                valRead = (int) tabDatiMtz[idxTab];
                            }
                            catch (Exception exc)
                            {
                                valRead = 0;
                                lg.Error(string.Format("Errore in recupero num inversioni:{0}parametro: {1}{0}i: {2}{0}Exc: {3}", Environment.NewLine, maintData[i].varName, i, exc));
                            }
                            istNumInvAssi[numero - 1].addValue(DateTime.Now, Convert.ToInt32(valRead));
                        }
                    }
                    else if (origName.EndsWith("_AccTime"))
                    {
                        try
                        {
                            numero = Convert.ToInt32(origName.Replace("Axis_", "").Replace("_AccTime", ""));
                        }
                        catch
                        { }
                        if (numero > 0 && istAccTimeAssi.Length >= numero)
                        {
                            // 2016.07.06 debug di valori che potrebbero essere nulli...
                            try
                            {
                                valRead = (int) tabDatiMtz[idxTab];
                            }
                            catch (Exception exc)
                            {
                                valRead = 0;
                                lg.Error(string.Format("Errore in recupero num AccTime:{0}parametro: {1}{0}i: {2}{0}Exc: {3}", Environment.NewLine, maintData[i].varName, i, exc));
                            }
                            istAccTimeAssi[numero - 1].addValue(DateTime.Now, Convert.ToInt32(valRead));
                        }
                    }
                }
                else if (origName.StartsWith("UnOp_") || origName.StartsWith("OperatingGroups:"))
                {
                    if (origName.EndsWith("_AccTime") || origName.EndsWith("ActiveTime"))
                    {
                        try
                        {
                            numero = Convert.ToInt32(origName.Replace("UnOp_", "").Replace("_AccTime", ""));
                        }
                        catch
                        { }
                        if (numero > 0 && istOreElettrom.Length >= numero)
                        {
                            istOreElettrom[numero - 1].addValue(DateTime.Now, (int)valRead);
                        }
                    }
                    else if (origName.EndsWith("_KRev") || origName.EndsWith("Distance"))
                    {
                        try
                        {
                            numero = Convert.ToInt32(origName.Replace("UnOp_", "").Replace("_KRev", ""));
                        }
                        catch
                        { }
                        if (numero > 0 && istGiriElettrom.Length >= numero)
                        {
                            istGiriElettrom[numero - 1].addValue(DateTime.Now, (int)valRead);
                        }
                    }
                    else if (origName.EndsWith("_NumCambiUT"))
                    {
                        try
                        {
                            numero = Convert.ToInt32(origName.Replace("UnOp_", "").Replace("_NumCambiUT", ""));
                        }
                        catch
                        { }
                        if (numero > 0 && istNumCambiUt.Length >= numero)
                        {
                            istNumCambiUt[numero - 1].addValue(DateTime.Now, (int)valRead);
                        }
                    }
                    else if (origName.EndsWith("_NumCU"))
                    {
                        try
                        {
                            numero = Convert.ToInt32(origName.Replace("UnOp_", "").Replace("_NumCU", ""));
                        }
                        catch
                        { }
                        if (numero > 0 && istNumCambiUt.Length >= numero)
                        {
                            istNumCambiUt[numero - 1].addValue(DateTime.Now, (int)valRead);
                        }
                    }
                    else if (origName.EndsWith("_Count"))
                    {
                        try
                        {
                            numero = Convert.ToInt32(origName.Replace("UnOp_", "").Replace("_Count", ""));
                        }
                        catch
                        { }
                        if (numero > 0 && istRepetitionUnOp.Length >= numero)
                        {
                            istRepetitionUnOp[numero - 1].addValue(DateTime.Now, (int)valRead);
                        }
                    }
                }
                else if (origName.StartsWith("VacPump_"))
                {
                    if (origName.EndsWith("_WrkTime"))
                    {
                        try
                        {
                            numero = Convert.ToInt32(origName.Replace("VacPump_", "").Replace("_WrkTime", ""));
                        }
                        catch
                        { }
                        if (numero > 0 && istVacPumpWrkTime.Length >= numero)
                        {
                            istVacPumpWrkTime[numero - 1].addValue(DateTime.Now, (int)valRead);
                        }
                    }
                }
                else if (origName.StartsWith("VacAct_"))
                {
                    if (origName.EndsWith("_Count"))
                    {
                        try
                        {
                            numero = Convert.ToInt32(origName.Replace("VacAct_", "").Replace("_Count", ""));
                        }
                        catch
                        { }
                        if (numero > 0 && istVacActCount.Length >= numero)
                        {
                            istVacActCount[numero - 1].addValue(DateTime.Now, (int)valRead);
                        }
                    }
                }
                else if (origName.StartsWith("Lubro_"))
                {
                    if (origName.EndsWith("_Num") || origName.EndsWith("_Count"))
                    {
                        try
                        {
                            numero = Convert.ToInt32(origName.Replace("Lubro_", "").Replace("_Num", "").Replace("_Count", ""));
                        }
                        catch
                        { }
                        if (numero > 0 && istLubroCount.Length >= numero)
                        {
                            istLubroCount[numero - 1].addValue(DateTime.Now, (int)valRead);
                        }
                    }
                }
                else if (origName.StartsWith("SlittaMagazzino_"))
                {
                    if (origName.EndsWith("_Count"))
                    {
                        try
                        {
                            numero = Convert.ToInt32(origName.Replace("SlittaMagazzino_", "").Replace("_Count", ""));
                        }
                        catch
                        { }
                        if (numero > 0 && istSlittaMag.Length >= numero)
                        {
                            istSlittaMag[numero - 1].addValue(DateTime.Now, (int)valRead);
                        }
                    }
                }
                else if (origName.StartsWith("ProtMagazzino_"))
                {
                    if (origName.EndsWith("_Count"))
                    {
                        try
                        {
                            numero = Convert.ToInt32(origName.Replace("ProtMagazzino_", "").Replace("_Count", ""));
                        }
                        catch
                        { }
                        if (numero > 0 && istProtMag.Length >= numero)
                        {
                            istProtMag[numero - 1].addValue(DateTime.Now, (int)valRead);
                        }
                    }
                }
                else if (origName.StartsWith("AuxiliaryGroups"))
                {
                    try
                    {
                        currGateway.updateItemNodeValue(origName, valRead);
                    }
                    catch (Exception exc)
                    { }
                }
                else //if (origName.StartsWith("ProtMagazzino_"))
                {
                    try
                    {
                        currGateway.updateItemNodeValue(origName, valRead);
                    }
                    catch (Exception exc)
                    { }
                }
                // !!!FIXME!!! verificare SE si vuole reinserire gestione contapezzi e/o variabili "freepass" qui...
            }
        }
        /// <summary>
        /// Numero massimo (indice) valori analogData (privato)
        /// </summary>
        protected int _analogDataMaxNum = 0;
        /// <summary>
        /// Numero massimo (indice) valori analogData (calcolato)
        /// </summary>
        public int analogDataMaxNum
        {
            get
            {
                if (_analogDataMaxNum == 0)
                {
                    if (analogData != null)
                    {
                        // prima stima
                        int idx = analogData.Length;
                        // ora ciclo...
                        foreach (var item in analogData)
                        {
                            int.TryParse(item.codNum, out idx);
                            _analogDataMaxNum = idx > _analogDataMaxNum ? idx : _analogDataMaxNum;
                        }
                    }
                }
                return _analogDataMaxNum;
            }
        }

        /// <summary>
        /// Numero massimo (indice) valori string (privato)
        /// </summary>
        protected int _stringDataMaxNum = 0;
        /// <summary>
        /// Numero massimo (indice) valori string (calcolato)
        /// </summary>
        public int stringDataMaxNum
        {
            get
            {
                if (_stringDataMaxNum == 0)
                {
                    if (stringData != null)
                    {
                        // prima stima
                        int idx = stringData.Length;
                        // ora ciclo...
                        foreach (var item in stringData)
                        {
                            int.TryParse(item.codNum, out idx);
                            _stringDataMaxNum = idx > _stringDataMaxNum ? idx : _stringDataMaxNum;
                        }
                    }
                }
                return _stringDataMaxNum;
            }
        }

        /// <summary>
        /// Processa la tabella di memoria dei dati analogici
        /// </summary>
        /// <param name="tabDatiAnag"></param>
        /// <param name="analogData"></param>
        public void processAnalogData(int[] tabDatiAnag, otherData[] analogData)
        {
            // uno ad uno vado a inserirli nella mappa dei dati dell'adapter...
            StringBuilder sb = new StringBuilder();
            double analogVal = 0;
            int idxTab = 0;
            string origName = "";
            for (int i = 0; i < analogData.Length; i++)
            {
                // calcolo idx a indice 0...
                int.TryParse(analogData[i].codNum, out idxTab);
                idxTab--;
                origName = getOrigName(analogData[i].varName);
                // gestisco in modalità "lazy" qualsiasi variabile (dividendo x opportuno fattore conversione...)
                try
                {
                    analogVal = (double)tabDatiAnag[idxTab] / (double)utils.CRI("fattDecVA");
                }
                catch (Exception exc)
                {
                    analogVal = 0;
                    lg.Error(string.Format("Errore in recupero valore analogico:{0}parametro: {1}{0}i: {2}{0}Exc: {3}", Environment.NewLine, analogData[i].varName, i, exc));
                }
                // salvo vettore Eventi...
                currGateway.updateItemNodeValue(elAnalogData[i], analogVal);
                //currGateway.updateItemNodeValue(elAnalogData[idxTab], analogVal);
                // accodo ultimi codici in visualizzazione...
                sb.AppendLine(currGateway.getItemNode(elAnalogData[i]).ToString().Replace("|", " | "));
            }
            // aggiungo i vari analogici rilevati
            parentForm.dataMonitor_3 += sb.ToString();
        }

        /// <summary>
        /// Processa la tabella di memoria dei dati analogici
        /// </summary>
        /// <param name="tabDatiAnag"></param>
        /// <param name="analogData"></param>
        public void processAnalogData(uint[] tabDatiAnag, otherData[] analogData)
        {
            // uno ad uno vado a inserirli nella mappa dei dati dell'adapter...
            StringBuilder sb = new StringBuilder();
            double analogVal = 0;
            int idxTab = 0;
            string origName = "";
            for (int i = 0; i < analogData.Length; i++)
            {
                // calcolo idx a indice 0...
                int.TryParse(analogData[i].codNum, out idxTab);
                idxTab--;
                origName = getOrigName(analogData[i].varName);
                // gestisco in modalità "lazy" qualsiasi variabile (dividendo x opportuno fattore conversione...)
                try
                {
                    analogVal = (double)tabDatiAnag[idxTab] / (double)utils.CRI("fattDecVA");
                }
                catch (Exception exc)
                {
                    analogVal = 0;
                    lg.Error(string.Format("Errore in recupero valore analogico:{0}parametro: {1}{0}i: {2}{0}Exc: {3}", Environment.NewLine, analogData[i].varName, i, exc));
                }
                // salvo vettore Eventi...
                currGateway.updateItemNodeValue(elAnalogData[idxTab], analogVal);
                // accodo ultimi codici in visualizzazione...
                sb.AppendLine(currGateway.getItemNode(elAnalogData[idxTab]).ToString().Replace("|", " | "));
            }
            // aggiungo i vari analogici rilevati
            parentForm.dataMonitor_3 += sb.ToString();
        }
        /// <summary>
        /// Processa la tabella di memoria dei dati stringa
        /// </summary>
        /// <param name="tabDatiString"></param>
        /// <param name="stringData"></param>
        public void processStringData(string[] tabDatiString, otherData[] stringData)
        {
            // uno ad uno vado a inserirli nella mappa dei dati dell'adapter...
            StringBuilder sb = new StringBuilder();
            int idxTab = 0;
            string origName = "";
            for (int i = 0; i < stringData.Length; i++)
            {
                // calcolo idx a indice 0...
                int.TryParse(stringData[i].codNum, out idxTab);
                idxTab--;
                origName = getOrigName(stringData[i].varName);

                // salvo vettore...
                currGateway.updateItemNodeValue(elStringData[idxTab], tabDatiString[idxTab]);
                // accodo ultimi codici in visualizzazione...
                sb.AppendLine(currGateway.getItemNode(elStringData[idxTab]).ToString().Replace("|", " | "));
            }
            // aggiungo i vari analogici rilevati
            parentForm.dataMonitor_3 += sb.ToString();
        }

        /// <summary>
        /// processa dataLayer e se necessario salva/mostra
        /// </summary>
        public void checkSavePersDataLayer()
        {
            // aggiungo dettaglio valori ultimi codici MST
            StringBuilder sb = new StringBuilder();
            string codM = "";
            string codS = "";
            string codT = "";
            for (int i = 0; i < currAdpConf.nPath; i++)
            {
                codM = currGateway.getItemNode(vettPath[i].pathCodMKey).ToString().Replace("NULL", "n.d.").Replace("UNAVAILABLE", "n.d.");
                codS = currGateway.getItemNode(vettPath[i].pathCodSKey).ToString().Replace("NULL", "n.d.").Replace("UNAVAILABLE", "n.d.");
                codT = currGateway.getItemNode(vettPath[i].pathCodTKey).ToString().Replace("NULL", "n.d.").Replace("UNAVAILABLE", "n.d.");
                // accodo ultimi codici in visualizzazione...
                sb.AppendLine(string.Format("P{0} last MST: {1} | {2} | {3}", i + 1, codM, codS, codT));
            }
            parentForm.dataMonitor_1 += sb.ToString();

            if (persistenceLayer != null)
            {
                bool needSave = false;
                // verifica se si debba aggiornare XML (e salva in adapter dati vari)
                needSave = procOreMaccOn(needSave);
                needSave = procOreMaccLav(needSave);
                needSave = procProgrName(needSave);
                needSave = procPartId(needSave);
                needSave = procPzProd(needSave);
                needSave = procGiriTotUnOp(needSave);
                needSave = procNumCU(needSave);
                needSave = procRepetitions(needSave);
                needSave = procCounters(needSave);
                needSave = procMovTotAssi(needSave);
                needSave = procAccTimeAssi(needSave);
                needSave = procNumInvAssi(needSave);
                needSave = procVacPump(needSave);
                needSave = procVacAct(needSave);
                needSave = procLubro(needSave);
                needSave = procSlittaMag(needSave);
                needSave = procProtMag(needSave);

                // salvo se necessario!
                if (needSave)
                {
                    parentForm.persistData();
                }
                // -------------------------------------------
            }
        }

        /// <summary>
        /// Numero massimo (indice) valori analogData (privato)
        /// </summary>
        protected int _statusDataMaxNum = 0;
        /// <summary>
        /// Numero massimo (indice) valori analogData (calcolato)
        /// </summary>
        public int statusDataMaxNum
        {
            get
            {
                if (_statusDataMaxNum == 0)
                {
                    if (statusData != null)
                    {
                        // prima stima
                        int idx = statusData.Length;
                        // ora ciclo...
                        foreach (var item in statusData)
                        {
                            int.TryParse(item.codNum, out idx);
                            _statusDataMaxNum = idx > _statusDataMaxNum ? idx : _statusDataMaxNum;
                        }
                    }
                }
                return _statusDataMaxNum;
            }
        }
        /// <summary>
        /// Processa la tabella di memoria degli status di manutenzione
        /// </summary>
        /// <param name="tabDatiStatus"></param>
        /// <param name="statusData"></param>
        public void processStatusData(byte[] tabDatiStatus, otherData[] statusData)
        {
            int bitNum = 0;
            int byteNum = 0;
            byte byteVal;
            StringBuilder sb = new StringBuilder();
            // uno ad uno vado a inserirli nella mappa dei dati dell'adapter...
            int numero = 0;
            string status = "";
            int idxTab = 0;
            string origName = "";
            for (int i = 0; i < statusData.Length; i++)
            {
                numero = 0;
                status = "";
                // calcolo idx a indice 0...
                int.TryParse(statusData[i].codNum, out idxTab);
                idxTab--;

                origName = getOrigName(statusData[i].varName);
                // calcolo quale byte e quale bit devo leggere..
                byteNum = idxTab / 8;
                // indice zero dei bit nel byte ( da cui -1 )
                bitNum = idxTab - (8 * byteNum);
                // faccio vera lettura
                byteVal = tabDatiStatus[byteNum];
                // leggo bit come ACTIVE/INACTIVE
                if (((StFlag8)byteVal).HasFlag((StFlag8)Math.Pow(2, bitNum)))
                {
                    if (currGateway.protocollo == gwProtocol.SOURS)
                    {
                        status = "EXE";
                    }
                    else
                    {
                        status = "ACTIVE";
                    }
                }
                else
                {
                    if (currGateway.protocollo == gwProtocol.SOURS)
                    {
                        status = "READY";
                    }
                    else
                    {
                        status = "INACTIVE";
                    }
                }

                // gestione AGGIUNTIVA vettori memorie "vecchie" per retrocompatibilità...
                if (origName.StartsWith("VacPump_"))
                {
                    if (origName.EndsWith("_Status"))
                    {
                        try
                        {
                            numero = Convert.ToInt32(origName.Replace("VacPump_", "").Replace("_Status", ""));
                        }
                        catch
                        {
                        }
                        if (numero > 0)
                        {
                            currGateway.updateItemNodeValue(vettVacPump[numero - 1].statusKey, status);
                        }
                    }
                }
                else if (origName.StartsWith("Cooler_"))
                {
                    if (origName.EndsWith("_Status"))
                    {
                        try
                        {
                            numero = Convert.ToInt32(origName.Replace("Cooler_", "").Replace("_Status", ""));
                        }
                        catch
                        { }
                        if (numero > 0)
                        {
                            currGateway.updateItemNodeValue(vettCooler[numero - 1].statusKey, status);
                        }
                    }
                }
                else if (origName.StartsWith("UnOp_"))
                {
                    if (origName.EndsWith("_Status"))
                    {
                        try
                        {
                            numero = Convert.ToInt32(origName.Replace("UnOp_", "").Replace("_Status", ""));
                        }
                        catch
                        { }
                        if (numero > 0)
                        {
                            currGateway.updateItemNodeValue(vettUnOp[numero - 1].statusKey, status);
                        }
                    }
                }

                // salvo vettore Eventi...
                currGateway.updateItemNodeValue(elStatus[i], status);
                // accodo ultimi codici in visualizzazione...
                if (currGateway.protocollo == gwProtocol.MTC)
                {
                    sb.AppendLine(currGateway.getItemNode(elStatus[i]).ToString().Replace("|", " | "));
                }
                else if (currGateway.protocollo == gwProtocol.SOURS)
                {
                    DataItemRed redDI = (DataItemRed)currGateway.getItemNode(elStatus[i]);
                    sb.AppendLine(string.Format("{0} | {1}", redDI.Name, redDI.Value));
                }
            }
            // aggiungo i vari status rilevati
            parentForm.dataMonitor_2 += sb.ToString();
        }

        /// <summary>
        /// procedura di lettura (multistep) dati da memoria x caricare dati utensile
        /// </summary>
        /// <param name="maxNumOp">num max di teste da recuperare</param>
        public virtual void getDatiUt(int maxNumOp)
        {
            // variabili "Indice" utensile e famiglia da decodificare + utils
            int maxMemAddr = numMemUt;
            byte[] elencoUtMem = new byte[2 * 20];
            byte[] tabUt_UT = new byte[2 * maxMemAddr];
            byte[] tabFam_FamUt = new byte[2 * maxMemAddr];

            // altre variabili
            ushort[] idUtMontato = new ushort[maxNumOp];
            ushort[] idFamUt = new ushort[maxNumOp];
            int[] idTipoVitaUt = new int[maxNumOp];
            uint[] valVitaUtRes = new uint[maxNumOp];
            ushort[] tabUt = new ushort[maxMemAddr];
            ushort[] tabFamUt = new ushort[maxMemAddr];
            int memIndex = 0;
            byte[] int32Mem = new byte[4];
            byte[] int16Mem = new byte[2];
            byte int8Mem = new byte();
            bool found = false;

            // step 1: lettura ID dell'utensile x ogni testa... leggo area memoria degli UT montati
            memIndex = getDatiUt_step1(ref elencoUtMem);
            // decodifica da byte a int16 dell'ID Utensile
            for (int i = 0; i < maxNumOp; i++)
            {
                idUtMontato[i] = BitConverter.ToUInt16(elencoUtMem, 2 * i);
            }

            // step 2a: leggo vettore memoria dei maxMemAddr(200) UT in Tabella Utensili
            memIndex = getDatiUt_step2a(ref tabUt_UT);
            // decodifico TUTTI i maxMemAddr utensili
            for (int i = 0; i < maxMemAddr; i++)
            {
                tabUt[i] = BitConverter.ToUInt16(tabUt_UT, 2 * i);
            }
            // step 2b: devo cercare l'UT di ogni UnOp nella Tabella Utensili
            for (int i = 0; i < maxNumOp; i++)
            {
                // poiché potrei trovarlo replicato dopo la prima volta che lo trovo evito di ricontrollare...
                found = false;
                // spazzo la tab Utensili x cercare quelli delle UnOp...
                for (int j = 0; j < maxMemAddr; j++)
                {
                    // controllo, se l'id utensile è quello dell'attuale UnOp...
                    if (tabUt[j] == idUtMontato[i] && !found)
                    {
                        // leggo FamUt puntuale..
                        memIndex = getDatiUt_step2b(ref int16Mem, j);
                        // step 2b: leggo puntualmente la FamUt dal suo indice...
                        idFamUt[i] = BitConverter.ToUInt16(int16Mem, 0);
                        found = true;
                    }
                }
            }

            // step 3a: leggo vettore memoria dei maxMemAddr(200) FamUT in Tabella Famiglie Utensili (x ricavare unità misura vita)
            memIndex = getDatiUt_step3a(ref tabFam_FamUt);
            // decodifico TUTTI i maxMemAddr utensili
            for (int i = 0; i < maxMemAddr; i++)
            {
                tabFamUt[i] = BitConverter.ToUInt16(tabFam_FamUt, 2 * i);
            }
            // step 3b: devo cercare la famiglia dell'UT di ogni UnOp nella Tabella Famiglie
            for (int i = 0; i < maxNumOp; i++)
            {
                // poiché potrei trovarlo replicato dopo la prima volta che lo trovo evito di ricontrollare...
                found = false;
                // spazzo la tab Utensili x cercare quelli delle UnOp...
                for (int j = 0; j < maxMemAddr; j++)
                {
                    // controllo, se l'id utensile è quello dell'attuale UnOp...
                    if (tabFamUt[j] == idFamUt[i] && !found)
                    {
                        // leggo FamUt puntuale..
                        memIndex = getDatiUt_step3b(ref int8Mem, j);
                        // step 3b: leggo puntualmente il TIPO DI vita UT dal suo indice...
                        idTipoVitaUt[i] = int8Mem;
                        found = true;
                    }
                }
            }

            // step 4: recupero la vita residua dell'utensile
            for (int i = 0; i < maxNumOp; i++)
            {
                // poiché potrei trovarlo replicato dopo la prima volta che lo trovo evito di ricontrollare...
                found = false;
                // spazzo la tab Utensili x cercare quelli delle UnOp...
                for (int j = 0; j < maxMemAddr; j++)
                {
                    // controllo, se l'id utensile è quello dell'attuale UnOp...
                    if (tabUt[j] == idUtMontato[i] && !found)
                    {
                        // leggo FamUt puntuale..
                        memIndex = getDatiUt_step4(ref int32Mem, j);
                        // leggo puntualmente valore della vita ut residua da indice utensile...
                        valVitaUtRes[i] = BitConverter.ToUInt32(int32Mem, 0);
                        found = true;
                    }
                }
            }

            // salvo in adapter vita UT residua...
            for (int i = 0; i < maxNumOp; i++)
            {
                currGateway.updateItemNodeValue(vettUnOp[i].toolIdKey, idUtMontato[i]);
                currGateway.updateItemNodeValue(vettUnOp[i].vitaResKey, valVitaUtRes[i]);
                // decodifico valore tipo VitaRes...
                string tipoVitaRes = "ND";
                switch (idTipoVitaUt[i])
                {
                    case 1:
                        tipoVitaRes = "Time";
                        break;

                    case 2:
                        tipoVitaRes = "Stroke";
                        break;

                    case 3:
                        tipoVitaRes = "Distance";
                        break;

                    default: break;
                }
                currGateway.updateItemNodeValue(vettUnOp[i].vitaResTypeKey, tipoVitaRes);
            }
        }

        /// <summary>
        /// Procedura di processing lettura memoria x DatiUt - Step 4
        /// </summary>
        /// <param name="int32Mem"></param>
        /// <param name="j"></param>
        /// <returns></returns>
        public virtual int getDatiUt_step4(ref byte[] int32Mem, int j)
        {
            int memIndex = 13100 + 4 * j;
            //inizio = DateTime.Now;
            //OsaiMemRW(R, FANUC.MemType.D, memIndex, ref int32Mem);
            //if (utils.CRB("recTime")) TimingData.addResult(string.Format("R{0}-TabUT-VitaRes", int32Mem.Length), DateTime.Now.Subtract(inizio).Ticks);
            return memIndex;
        }

        /// <summary>
        /// Procedura di processing lettura memoria x DatiUt - Step 3b
        /// </summary>
        /// <param name="int8Mem"></param>
        /// <param name="j"></param>
        /// <returns></returns>
        public virtual int getDatiUt_step3b(ref byte int8Mem, int j)
        {
            int memIndex = 10700 + 1 * j;
            //inizio = DateTime.Now;
            //OsaiMemRW(R, FANUC.MemType.D, memIndex, ref int8Mem);
            //if (utils.CRB("recTime")) TimingData.addResult(string.Format("R{0}-TabUT-FamUT", 8), DateTime.Now.Subtract(inizio).Ticks);
            return memIndex;
        }

        /// <summary>
        /// Procedura di processing lettura memoria x DatiUt - Step 3a
        /// </summary>
        /// <param name="tabFam_FamUt"></param>
        /// <returns></returns>
        public virtual int getDatiUt_step3a(ref byte[] tabFam_FamUt)
        {
            int memIndex = 8900;
            //inizio = DateTime.Now;
            //OsaiMemRW(R, FANUC.MemType.D, memIndex, ref tabFam_FamUt);
            //if (utils.CRB("recTime")) TimingData.addResult(string.Format("R{0}-TabFamUT-FamUT", tabFam_FamUt.Length), DateTime.Now.Subtract(inizio).Ticks);
            return memIndex;
        }

        /// <summary>
        /// Procedura di processing lettura memoria x DatiUt - Step 2b
        /// </summary>
        /// <param name="int16Mem"></param>
        /// <param name="j"></param>
        /// <returns></returns>
        public virtual int getDatiUt_step2b(ref byte[] int16Mem, int j)
        {
            int memIndex = 11700 + 2 * j;
            //inizio = DateTime.Now;
            //OsaiMemRW(R, FANUC.MemType.D, memIndex, ref int16Mem);
            //if (utils.CRB("recTime")) TimingData.addResult(string.Format("R{0}-TabUT-FamUT", int16Mem.Length), DateTime.Now.Subtract(inizio).Ticks);
            return memIndex;
        }

        /// <summary>
        /// Procedura di processing lettura memoria x DatiUt - Step 2a
        /// </summary>
        /// <param name="tabUt_UT"></param>
        /// <returns></returns>
        public virtual int getDatiUt_step2a(ref byte[] tabUt_UT)
        {
            int memIndex = 11300;
            //inizio = DateTime.Now;
            //OsaiMemRW(R, FANUC.MemType.D, memIndex, ref tabUt_UT);
            //if (utils.CRB("recTime")) TimingData.addResult(string.Format("R{0}-TabUT-UT", tabUt_UT.Length), DateTime.Now.Subtract(inizio).Ticks);
            return memIndex;
        }

        /// <summary>
        /// Procedura di processing lettura memoria x DatiUt - Step 1
        /// </summary>
        /// <param name="elencoUtMem"></param>
        /// <returns></returns>
        public virtual int getDatiUt_step1(ref byte[] elencoUtMem)
        {
            int memIndex = 2960;
            //inizio = DateTime.Now;
            //OsaiMemRW(R, FANUC.MemType.D, memIndex, ref elencoUtMem);
            //if (utils.CRB("recTime")) TimingData.addResult(string.Format("R{0}-NUMUT", elencoUtMem.Length), DateTime.Now.Subtract(inizio).Ticks);
            return memIndex;
        }

        #endregion metodi adapter

        #region area metodi comunicazione con PLC/CNC

        public void checkPath()
        {
        }

        /// <summary>
        /// FeedRate globale
        /// </summary>
        public int FeedRate { get; set; }
        /// <summary>
        /// FeedRate per singolo PATH
        /// </summary>
        public int[] FeedRatePath { get; set; }

        /// <summary>
        /// FeedRate di gruppo  MAX 20!!!
        /// </summary>
        public int[] FeedRateGrp { get; set; }

        /// <summary>
        /// SpeedRate mandrino globale
        /// </summary>
        public int SpeedRate { get; set; }

        /// <summary>
        /// OVERRIDE FeedRate globale
        /// </summary>
        public int FeedRateOver { get; set; }
        /// <summary>
        /// OVERRIDE FeedRate per singolo PATH
        /// </summary>
        public int[] FeedRateOverPath { get; set; }

        /// <summary>
        /// OVERRIDE dei rapidi
        /// </summary>
        public int RapidOver { get; set; }
        /// <summary>
        /// OVERRIDE Rapid per singolo PATH
        /// </summary>
        public int[] RapidOverPath { get; set; }

        /// <summary>
        /// OVERRIDE SpeedRate mandrino globale
        /// </summary>
        public int SpeedRateOver { get; set; }
        /// <summary>
        /// OVERRIDE SpeedRate per singolo PATH
        /// </summary>
        public int[] SpeedRateOverPath { get; set; }

        /// <summary>
        /// LOAD mandrino globale
        /// </summary>
        public int UnOpLoad { get; set; }

        /// <summary>
        /// recupera Vettore completo PosAct (fare override!)
        /// </summary>
        public virtual position PosAct
        {
            get
            {
                position answ = new position();
                return answ;
            }
        }

        /// <summary>
        ///  recupera pezzi OK (fare override!)
        /// </summary>
        public virtual int getNumPzOk
        {
            get
            {
                int answ = 0;
                return answ;
            }
        }

        /// <summary>
        /// recupera pezzi KO (fare override!)
        /// </summary>
        public virtual int getNumPzKo
        {
            get
            {
                int answ = 0;
                return answ;
            }
        }

        /// <summary>
        /// Aggiunge nel vettore coda codici M
        /// </summary>
        /// <param name="Coda"></param>
        /// <param name="Codice">Codice da accodare</param>
        /// <param name="idxPath">Path (0,1,...)</param>
        public void appendCodeMST(string Coda, string Codice, int idxPath)
        {
            switch (Coda)
            {
                case "S":
                    codaS[idxPath].Add(Codice);
                    break;

                case "T":
                    codaT[idxPath].Add(Codice);
                    break;

                case "M":
                default:
                    codaM[idxPath].Add(Codice);
                    break;
            }
        }

        /// <summary>
        /// recupera primo elemento coda M
        /// </summary>
        /// <param name="idxPath">Path (0,1,...)</param>
        /// <returns></returns>
        protected string getNextMCode(int idxPath)
        {
            string answ = "";
            if (codaM[idxPath].Count > 0)
            {
                // recupero codice M...
                answ = codaM[idxPath].First();
                // tolgo elemento
                codaM[idxPath].RemoveAt(0);
            }
            return answ;
        }

        /// <summary>
        /// recupera primo elemento coda S
        /// </summary>
        /// <param name="idxPath">Path (0,1,...)</param>
        /// <returns></returns>
        protected string getNextSCode(int idxPath)
        {
            string answ = "";
            if (codaS[idxPath].Count > 0)
            {
                // recupero codice S...
                answ = codaS[idxPath].First();
                // tolgo elemento
                codaS[idxPath].RemoveAt(0);
            }
            return answ;
        }

        /// <summary>
        /// recupera primo elemento coda T
        /// </summary>
        /// <param name="idxPath">Path (0,1,...)</param>
        /// <returns></returns>
        protected string getNextTCode(int idxPath)
        {
            string answ = "";
            if (codaT[idxPath].Count > 0)
            {
                // recupero codice T...
                answ = codaT[idxPath].First();
                // tolgo elemento
                codaT[idxPath].RemoveAt(0);
            }
            return answ;
        }

        #endregion area metodi comunicazione con PLC/CNC

        #region metodi che prevedono salvataggio valori su file XML/BIN

        /// <summary>
        /// Processing delle variabili generiche Counters
        /// </summary>
        /// <param name="needSave"></param>
        /// <returns></returns>
        public bool procCounters(bool needSave)
        {
            uint delta = 0;
            uint valore = 0;
            int valoreInt = 0;
            StringBuilder sb = new StringBuilder();
            string cKey = "";
            if (elCounter != null)
            {
                // processo i counter MONOTONI CRESCENTI
                for (int i = 0; i < elCounter.Count; i++)
                {
                    // nome counter
                    cKey = string.Format("Counter_{0:000}", i + 1);
                    // procedo solo SE HO FINESTRA VALIDA...
                    if (istCounters[i].vcValid)
                    {
                        valore = Convert.ToUInt32(istCounters[i].vcMedian);
                        if (valore >= currCounters[i])
                        {
                            delta = valore - currCounters[i];
                            // controllo delta < 50% max...
                            if (delta < uint.MaxValue / 2)
                            {
                                //processo comunque sempre...
                                uint contTot = updateValUIntByIncr(i, delta, "Counter_{0:000}");
                                // passo valore totale all'adapter
                                currGateway.updateItemNodeValue(cKey, contTot);
                                // controllo valore riferimento...
                                if (delta > 0)
                                {
                                    // segnalo necessità salvataggio!
                                    needSave = true;
                                }
                            }
                        }
                        // ...aggiorno valore riferimento...
                        currCounters[i] = valore;
                    }
                    sb.AppendLine(currGateway.getItemNode(cKey).ToString().Replace("|", " | "));
                }
            }
            if (elRTCounter != null)
            {
                // processo i counter ASSOLUTI
                for (int i = 0; i < elRTCounter.Count; i++)
                {
                    // nome counter
                    cKey = string.Format("RTCounter_{0:000}", i + 1);
                    // procedo solo SE HO FINESTRA VALIDA...
                    if (istRTCounters[i].vcValid)
                    {
                        valore = Convert.ToUInt32(istRTCounters[i].vcMedian);
                        if (valore != currRTCounters[i])
                        {
                            delta = valore - currRTCounters[i];
                            // controllo delta < 50% max...
                            if (delta < uint.MaxValue / 2)
                            {
                                //processo comunque sempre...
                                updateValUInt(i, valore, "RTCounter_{0:000}");
                                // passo valore totale all'adapter
                                currGateway.updateItemNodeValue(cKey, valore);
                                // controllo valore riferimento...
                                if (delta > 0)
                                {
                                    // segnalo necessità salvataggio!
                                    needSave = true;
                                }
                            }
                        }
                        // ...aggiorno valore riferimento...
                        currRTCounters[i] = valore;
                    }
                    sb.AppendLine(currGateway.getItemNode(cKey).ToString().Replace("|", " | "));
                }
            }
            if (elRTVCount != null)
            {
                // processo i counter VALORI RTV
                foreach (var item in elRTVCount)
                {
                    // nome counter
                    cKey = item.Key;
                    // procedo solo SE HO FINESTRA VALIDA...
                    if (istRTVCount[item.Value].vcValid)
                    {
                        valoreInt = Convert.ToInt32(istRTVCount[item.Value].vcMedian);
                        // passo valore totale all'adapter
                        currGateway.updateItemNodeValue(cKey, valoreInt);
                        // ...aggiorno valore riferimento...
                        currRTVCount[item.Value] = valoreInt;
                    }
                    sb.AppendLine(currGateway.getItemNode(cKey).ToString().Replace("|", " | "));
                }
            }
            // salvo su maschera...
            parentForm.dataMonitor_2 += sb.ToString();
            return needSave;
        }

        /// <summary>
        /// Processing delle ore macchina ACCESA
        /// </summary>
        /// <param name="needSave"></param>
        /// <returns></returns>
        public bool procOreMaccOn(bool needSave)
        {
            double delta = 0;
            double valore = 0;
            StringBuilder sb = new StringBuilder();
            if (istOreMaccOn.vcValid)
            {
                valore = istOreMaccOn.vcMedian;
                if (valore >= contOreMaccOn)
                {
                    delta = valore - contOreMaccOn;
                    // controllo delta < 50% max...
                    if (delta < double.MaxValue / 2)
                    {
                        // processo comunque sempre...
                        double contatore = updateValDoubleByIncr(0, delta, "ACC_TIME");
                        currAdpConf.ContOreMaccOn += delta;
                        // salvo valore
                        string newAccTime = contatore.ToString("0.000", CultureInfo.InvariantCulture);
                        currGateway.updateItemNodeValue("ACC_TIME", newAccTime);
                        // controllo incremento...
                        if (delta > 0)
                        {
                            // segnalo necessità salvataggio!
                            needSave = true;
                        }
                    }
                }
                // ...aggiorno valore riferimento...
                contOreMaccOn = valore;
            }
            // salvo su maschera...
            sb.AppendLine(string.Format("ACC_TIME: {0}", currGateway.getItemNode("ACC_TIME")));
            parentForm.dataMonitor_1 += sb.ToString();
            return needSave;
        }

        /// <summary>
        /// Processing delle ore macchina IN LAVORO
        /// </summary>
        /// <param name="needSave"></param>
        /// <returns></returns>
        public bool procOreMaccLav(bool needSave)
        {
            double delta = 0;
            double valore = 0;
            StringBuilder sb = new StringBuilder();
            if (istOreMaccLav.vcValid)
            {
                valore = istOreMaccLav.vcMedian;
                if (valore >= contOreMaccLav)
                {
                    delta = valore - contOreMaccLav;
                    // controllo delta < 50% max...
                    if (delta < double.MaxValue / 2)
                    {
                        double contatore = updateValDoubleByIncr(0, delta, "ACC_TIME_WORK");
                        currAdpConf.ContOreMaccLav += delta;
                        // salvo valore
                        string newAccTimeWork = contatore.ToString("0.000", CultureInfo.InvariantCulture);
                        currGateway.updateItemNodeValue("ACC_TIME_WORK", newAccTimeWork);
                        // controllo valore riferimento...
                        if (delta > 0)
                        {
                            // segnalo necessità salvataggio!
                            needSave = true;
                        }
                    }
                }
                // ...aggiorno valore riferimento...
                contOreMaccLav = valore;
            }
            // salvo su maschera...
            sb.AppendLine(string.Format("ACC_TIME_WORK: {0}", currGateway.getItemNode("ACC_TIME_WORK")));
            parentForm.dataMonitor_1 += sb.ToString();
            return needSave;
        }

        /// <summary>
        /// Processing contatore Slitta Tastatore
        /// </summary>
        /// <param name="needSave"></param>
        /// <returns></returns>
        public bool procSlittaTast(bool needSave)
        {
            double delta = 0;
            double valore = 0;
            StringBuilder sb = new StringBuilder();
            if (istSlittaTast.vcValid)
            {
                valore = istSlittaTast.vcMedian;
                if (valore >= contSlittaTast)
                {
                    delta = valore - contSlittaTast;
                    // controllo delta < 50% max...
                    if (delta < double.MaxValue / 2)
                    {
                        double contatore = updateValDoubleByIncr(0, delta, "SlittaTastatore_Count");
                        currAdpConf.ContSlittaTast += delta;
                        // salvo valore
                        currGateway.updateItemNodeValue("SlittaTastatore_Count", contatore.ToString("0", CultureInfo.InvariantCulture));
                        // controllo valore riferimento...
                        if (delta > 0)
                        {
                            // segnalo necessità salvataggio!
                            needSave = true;
                        }
                    }
                }
                // ...aggiorno valore riferimento...
                contSlittaTast = valore;
            }
            // salvo su maschera...
            sb.AppendLine(string.Format("SlittaTastatore_Count: {0}", currGateway.getItemNode("SlittaTastatore_Count")));// mSlittaTast.Value));
            parentForm.dataMonitor_1 += sb.ToString();
            return needSave;
        }

        /// <summary>
        /// Processing del program name
        /// </summary>
        /// <param name="needSave"></param>
        /// <returns></returns>
        public bool procProgrName(bool needSave)
        {
            // SOLO SE NON sono SOUR...
            if (currGateway.protocollo != gwProtocol.SOURS)
            {
                // controllo valore riferimento x tutti i path se sia cambiato programma...
                for (int i = 0; i < currAdpConf.nPath; i++)
                {
                    if (istPathProgrName[i] != null)
                    {
                        if (istPathProgrName[i] != currPathProgrName[i])
                        {
                            // prendo nuovo valore programma x path!
                            currGateway.updateItemNodeValue(vettPath[i].currProgKey, istPathProgrName[i]);
                            // segnalo necessità salvataggio!
                            needSave = true;
                            // ...aggiorno valore riferimento...
                            currPathProgrName[i] = istPathProgrName[i];
                        }
                    }
                }
            }
            return needSave;
        }

        /// <summary>
        /// Processing del particolare
        /// </summary>
        /// <param name="needSave"></param>
        /// <returns></returns>
        public bool procPartId(bool needSave)
        {
            if (currGateway.protocollo != gwProtocol.SOURS)
            {
                // controllo valore riferimento x tutti i path se sia cambiato num pz...
                for (int i = 0; i < currAdpConf.nPath; i++)
                {
                    if (istPathPartId[i] != null)
                    {
                        if (istPathPartId[i] != currPathPartId[i])
                        {
                            // aggiorno valore in Path RefList
                            updateValString(i, istPathPartId[i], "Path_{0:00}_PartId");
                            // prendo nuovo valore programma x path!                
                            currGateway.updateItemNodeValue(vettPath[i].partIdKey, istPathPartId[i]);
                            // imposto a ZERO i pezzi del nuovo articolo    
                            currGateway.updateItemNodeValue(vettPath[i].partCountKey, 0);
                            // segnalo necessità salvataggio!
                            needSave = true;
                            // ...aggiorno valore riferimento...
                            currPathPartId[i] = istPathPartId[i];
                        }
                    }
                }
            }
            return needSave;
        }

        /// <summary>
        /// Processing del num pz prodotti
        /// </summary>
        /// <param name="needSave"></param>
        /// <returns></returns>
        public bool procPzProd(bool needSave)
        {
            if (currGateway.protocollo != gwProtocol.SOURS)
            {
                string outString = string.Format("Path_[1-{0}]_PZ_TOT: ", currAdpConf.nPath);
                // controllo valore riferimento x tutti i path se sia cambiato qta pezzi...
                for (int i = 0; i < currAdpConf.nPath; i++)
                {
                    // controllo valore riferimento variato...
                    if (istPathPartCount[i].vcMedian != currPathPartCount[i])
                    {
                        if (istPathPartCount[i].vcMedian > currPathPartCount[i])
                        {
                            uint delta = Convert.ToUInt32(istPathPartCount[i].vcMedian) - currPathPartCount[i];
                            uint contatore = updateValUIntByIncr(i, delta, "Path_{0:00}_PZ_TOT");
                            // passo valore num pz all'adapter         
                            currGateway.updateItemNodeValue(vettPath[i].partCountKey, contatore);
                        }
                        else // variato x difetto... azzero!!!
                        {
                            uint newVal = Convert.ToUInt32(istPathPartCount[i].vcMedian);
                            updateValUInt(i, newVal, "Path_{0:00}_PZ_TOT");
                            // passo valore num pz all'adapter    
                            currGateway.updateItemNodeValue(vettPath[i].partCountKey, newVal);
                        }

                        // segnalo necessità salvataggio!
                        needSave = true;
                        // ...aggiorno valore riferimento...
                        currPathPartCount[i] = Convert.ToUInt32(istPathPartCount[i].vcMedian);
                    }
                    outString += string.Format("{0} | ", currGateway.getItemNode(vettPath[i].partCountKey));
                }
                // salvo su maschera...
                parentForm.dataMonitor_2 += string.Format("{0}{1}", outString.Substring(0, outString.Length - 3), Environment.NewLine);
            }
            return needSave;
        }

        /// <summary>
        /// Processing delle variabili sul numero giri mandrino (totali) + tempo attività...
        /// </summary>
        /// <param name="needSave"></param>
        /// <returns></returns>
        public bool procGiriTotUnOp(bool needSave)
        {
            uint delta = 0;
            uint valore = 0;
            // Contatore giri mandrino
            string outString = string.Format("UnOp_[1-{0}]_KRev: ", currAdpConf.nUnOp);
            for (int i = 0; i < currAdpConf.nUnOp; i++)
            {
                // procedo solo SE HO FINESTRA VALIDA...
                if (istGiriElettrom[i].vcValid)
                {
                    valore = Convert.ToUInt32(istGiriElettrom[i].vcMedian);
                    if (valore >= contGiriElettrom[i])
                    {
                        delta = valore - contGiriElettrom[i];
                        // controllo delta < 50% max...
                        if (delta < uint.MaxValue / 2)
                        {
                            // processo comunque sempre...
                            uint contatore = updateValUIntByIncr(i, delta, "UnOp_{0:00}_KRev");
                            // passo valore num giri (migliaia) all'adapter  
                            currGateway.updateItemNodeValue(vettUnOp[i].kRevKey, contatore);
                            // controllo valore riferimento...
                            if (delta > 0)
                            {
                                // segnalo necessità salvataggio!
                                needSave = true;
                            }
                        }
                    }
                    // ...aggiorno valore riferimento...
                    contGiriElettrom[i] = valore;
                }
                //outString += string.Format("{0} | ", currGateway.getItemNode(vettUnOp[i].kRevKey));
            }
            // salvo su maschera...
            parentForm.dataMonitor_2 += string.Format("{0}{1}", outString.Substring(0, outString.Length - 3), Environment.NewLine);

            // Contatore ORE ATTIVE mandrino
            outString = string.Format("UnOp_[1-{0}]_AccTime: ", currAdpConf.nUnOp);
            for (int i = 0; i < currAdpConf.nUnOp; i++)
            {
                // procedo solo SE HO FINESTRA VALIDA...
                if (istOreElettrom[i].vcValid)
                {
                    valore = Convert.ToUInt32(istOreElettrom[i].vcMedian);
                    if (valore >= contOreElettrom[i])
                    {
                        delta = valore - contOreElettrom[i];
                        // controllo delta < 50% max...
                        if (delta < uint.MaxValue / 2)
                        {
                            // processo comunque sempre...
                            uint contatore = updateValUIntByIncr(i, delta, "UnOp_{0:00}_AccTime");
                            // passo valore num giri (migliaia) all'adapter  
                            currGateway.updateItemNodeValue(vettUnOp[i].accTimeKey, contatore);
                            // controllo valore riferimento...
                            if (delta > 0)
                            {
                                // segnalo necessità salvataggio!
                                needSave = true;
                            }
                        }
                    }
                    // ...aggiorno valore riferimento...
                    contOreElettrom[i] = valore;
                }
                //outString += string.Format("{0} | ", currGateway.getItemNode(vettUnOp[i].accTimeKey));
            }
            return needSave;
        }

        /// <summary>
        /// Processing delle variabili sul numero cambi utensile (totali)
        /// </summary>
        /// <param name="needSave"></param>
        /// <returns></returns>
        public bool procNumCU(bool needSave)
        {
            uint delta = 0;
            uint valore = 0;
            string outString = string.Format("UnOp_[1-{0}]_NumCU: ", currAdpConf.nUnOp);
            for (int i = 0; i < currAdpConf.nUnOp; i++)
            {
                // procedo solo SE HO FINESTRA VALIDA...
                if (istNumCambiUt[i].vcValid)
                {
                    valore = Convert.ToUInt32(istNumCambiUt[i].vcMedian);
                    if (valore >= currNumCambiUt[i])
                    {
                        delta = valore - currNumCambiUt[i];
                        // controllo delta < 50% max...
                        if (delta < uint.MaxValue / 2)
                        {
                            // processo comunque sempre...
                            uint contatore = updateValUIntByIncr(i, delta, "UnOp_{0:00}_NumCU");
                            // passo valore num CU all'adapter
                            currGateway.updateItemNodeValue(vettUnOp[i].numCUKey, contatore);
                            // controllo valore riferimento...
                            if (delta > 0)
                            {
                                // segnalo necessità salvataggio!
                                needSave = true;
                            }
                        }
                    }
                    // ...aggiorno valore riferimento...
                    currNumCambiUt[i] = valore;
                }
                outString += string.Format("{0} | ", currGateway.getItemNode(vettUnOp[i].numCUKey));
            }
            // salvo su maschera...
            parentForm.dataMonitor_2 += string.Format("{0}{1}", outString.Substring(0, outString.Length - 3), Environment.NewLine);
            return needSave;
        }



        /// <summary>
        /// Processing delle variabili sul numero di ripetizioni
        /// </summary>
        /// <param name="needSave"></param>
        /// <returns></returns>
        public bool procRepetitions(bool needSave)
        {
            uint delta = 0;
            uint valore = 0;
            string outString = string.Format("UnOp_[1-{0}]_Count: ", currAdpConf.nUnOp);
            for (int i = 0; i < currAdpConf.nUnOp; i++)
            {
                // procedo solo SE HO FINESTRA VALIDA...
                if (istRepetitionUnOp[i].vcValid)
                {
                    valore = Convert.ToUInt32(istRepetitionUnOp[i].vcMedian);
                    if (valore >= currRepetitionUnOp[i])
                    {
                        delta = valore - currRepetitionUnOp[i];
                        // controllo delta < 50% max...
                        if (delta < uint.MaxValue / 2)
                        {
                            // processo comunque sempre...
                            uint contatore = updateValUIntByIncr(i, delta, "UnOp_{0:00}_Count");
                            // passo valore num CU all'adapter
                            currGateway.updateItemNodeValue(vettUnOp[i].countKey, contatore);
                            // controllo valore riferimento...
                            if (delta > 0)
                            {
                                // segnalo necessità salvataggio!
                                needSave = true;
                            }
                        }
                    }
                    // ...aggiorno valore riferimento...
                    currRepetitionUnOp[i] = valore;
                }
                outString += string.Format("{0} | ", currGateway.getItemNode(vettUnOp[i].countKey));
            }
            // salvo su maschera...
            parentForm.dataMonitor_2 += string.Format("{0}{1}", outString.Substring(0, outString.Length - 3), Environment.NewLine);
            return needSave;
        }


        /// <summary>
        /// Processing delle variabili sul totale m percorsi dagli assi
        /// </summary>
        /// <param name="needSave"></param>
        /// <returns></returns>
        public bool procMovTotAssi(bool needSave)
        {
            double delta = 0;
            uint valore = 0;
            string outString = string.Format("Axis_[1-{0}]_DistDone: ", currAdpConf.nAxis);
            for (int i = 0; i < currAdpConf.nAxis; i++)
            {
                // procedo solo SE HO FINESTRA VALIDA...
                if (istDistMovAssi[i].vcValid)
                {
                    valore = Convert.ToUInt32(istDistMovAssi[i].vcMedian);
                    if (valore >= contDistMovAssi[i])
                    {
                        delta = valore - contDistMovAssi[i];
                        // controllo delta < 50% max...
                        if (delta < double.MaxValue / 2)
                        {
                            // processo comunque sempre...
                            double contTot = updateValDoubleByIncr(i, delta, "Axis_{0:00}_DistDone");
                            // passo valore totale all'adapter                                     
                            currGateway.updateItemNodeValue(vettAxis[i].distDoneKey, contTot.ToString("0.000", CultureInfo.InvariantCulture));
                            // controllo valore riferimento...
                            if (delta > 0)
                            {
                                // segnalo necessità salvataggio!
                                needSave = true;
                            }
                        }
                    }
                    // ...aggiorno valore riferimento...
                    contDistMovAssi[i] = valore;
                }
                outString += string.Format("{0} | ", currGateway.getItemNode(vettAxis[i].distDoneKey));
            }
            // salvo su maschera...
            parentForm.dataMonitor_3 += string.Format("{0}{1}", outString.Substring(0, outString.Length - 3), Environment.NewLine);
            return needSave;
        }

        /// <summary>
        /// Processing delle variabili sul totale tempo lavoro degli assi
        /// </summary>
        /// <param name="needSave"></param>
        /// <returns></returns>
        public bool procAccTimeAssi(bool needSave)
        {
            double delta = 0;
            uint valore = 0;
            string outString = string.Format("Axis_[1-{0}]_AccTime: ", currAdpConf.nAxis);
            for (int i = 0; i < currAdpConf.nAxis; i++)
            {
                // procedo solo SE HO FINESTRA VALIDA...
                if (istAccTimeAssi[i].vcValid)
                {
                    valore = Convert.ToUInt32(istAccTimeAssi[i].vcMedian);
                    if (valore >= contAccTimeAssi[i])
                    {
                        delta = valore - contAccTimeAssi[i];
                        // controllo delta < 50% max...
                        if (delta < double.MaxValue / 2)
                        {
                            // salvo valore aggiuntivo x ore lavoro assi...
                            double oreTot = updateValDoubleByIncr(i, delta, "Axis_{0:00}_AccTime");
                            currGateway.updateItemNodeValue(vettAxis[i].accTimeKey, oreTot.ToString("0.000", CultureInfo.InvariantCulture));
                            // controllo valore riferimento...
                            if (delta > 0)
                            {
                                // segnalo necessità salvataggio!
                                needSave = true;
                            }
                        }
                    }
                    // ...aggiorno valore riferimento...
                    contAccTimeAssi[i] = valore;
                }
                outString += string.Format("{0} | ", currGateway.getItemNode(vettAxis[i].accTimeKey));
            }
            // salvo su maschera...
            parentForm.dataMonitor_3 += string.Format("{0}{1}", outString.Substring(0, outString.Length - 3), Environment.NewLine);
            return needSave;
        }

        /// <summary>
        /// Processing delle variabili sul totale num inversioni degli assi
        /// </summary>
        /// <param name="needSave"></param>
        /// <returns></returns>
        public bool procNumInvAssi(bool needSave)
        {
            long delta = 0;
            uint valore = 0;
            string outString = string.Format("Axis_[1-{0}]_InvDDone: ", currAdpConf.nAxis);
            for (int i = 0; i < currAdpConf.nAxis; i++)
            {
                // procedo solo SE HO FINESTRA VALIDA...
                if (istNumInvAssi[i].vcValid)
                {
                    valore = Convert.ToUInt32(istNumInvAssi[i].vcMedian);
                    if (valore >= contNumInvAssi[i])
                    {
                        delta = valore - contNumInvAssi[i];
                        // controllo delta < 50% max...
                        if (delta < long.MaxValue / 2)
                        {
                            // processo comunque sempre...
                            long contTot = updateValLongByIncr(i, delta, "Axis_{0:00}_InvDDone");
                            // passo valore totale all'adapter  
                            currGateway.updateItemNodeValue(vettAxis[i].invDDoneKey, contTot);
                            // controllo valore riferimento...
                            if (delta > 0)
                            {
                                // segnalo necessità salvataggio!
                                needSave = true;
                            }
                        }
                    }
                    // ...aggiorno valore riferimento...
                    contNumInvAssi[i] = valore;
                }
                outString += string.Format("{0} | ", currGateway.getItemNode(vettAxis[i].invDDoneKey));
            }
            // salvo su maschera...
            parentForm.dataMonitor_3 += string.Format("{0}{1}", outString.Substring(0, outString.Length - 3), Environment.NewLine);
            return needSave;
        }

        /// <summary>
        /// Processing delle variabili sulle VacPump
        /// </summary>
        /// <param name="needSave"></param>
        /// <returns></returns>
        public bool procVacPump(bool needSave)
        {
            uint delta = 0;
            uint valore = 0;
            string outString = string.Format("VacPump_[1-{0}]_WrkTime: ", currAdpConf.nVacuumPump);
            for (int i = 0; i < currAdpConf.nVacuumPump; i++)
            {
                // procedo solo SE HO FINESTRA VALIDA...
                if (istVacPumpWrkTime[i].vcValid)
                {
                    valore = Convert.ToUInt32(istVacPumpWrkTime[i].vcMedian);
                    if (valore >= currVacPumpWrkTime[i])
                    {
                        delta = valore - currVacPumpWrkTime[i];
                        // controllo delta < 50% max...
                        if (delta < uint.MaxValue / 2)
                        {
                            // processo comunque sempre...
                            uint contTot = updateValUIntByIncr(i, delta, "VacPump_{0:00}_WrkTime");
                            // passo valore totale all'adapter
                            currGateway.updateItemNodeValue(vettVacPump[i].workTimeKey, contTot);
                            // controllo valore riferimento...
                            if (delta > 0)
                            {
                                // segnalo necessità salvataggio!
                                needSave = true;
                            }
                        }
                    }
                    // ...aggiorno valore riferimento...
                    currVacPumpWrkTime[i] = valore;
                }
                outString += string.Format("{0} | ", currGateway.getItemNode(vettVacPump[i].workTimeKey));
            }
            // salvo su maschera...
            parentForm.dataMonitor_2 += string.Format("{0}{1}", outString.Substring(0, outString.Length - 3), Environment.NewLine);
            return needSave;
        }

        /// <summary>
        /// Processing delle variabili sulle VacAct
        /// </summary>
        /// <param name="needSave"></param>
        /// <returns></returns>
        public bool procVacAct(bool needSave)
        {
            uint delta = 0;
            uint valore = 0;
            string outString = string.Format("VacPump_[1-{0}]_Count: ", currAdpConf.nVacuumPump);
            for (int i = 0; i < currAdpConf.nVacuumAct; i++)
            {
                // procedo solo SE HO FINESTRA VALIDA...
                if (istVacActCount[i].vcValid)
                {
                    valore = Convert.ToUInt32(istVacActCount[i].vcMedian);
                    if (valore >= currVacActCount[i])
                    {
                        delta = valore - currVacActCount[i];
                        // controllo delta < 50% max...
                        if (delta < uint.MaxValue / 2)
                        {
                            // processo comunque sempre...
                            uint contTot = updateValUIntByIncr(i, delta, "VacAct_{0:00}_Count");
                            // passo valore totale all'adapter
                            currGateway.updateItemNodeValue(vettVacAct[i].countKey, contTot);
                            // controllo valore riferimento...
                            if (delta > 0)
                            {
                                // segnalo necessità salvataggio!
                                needSave = true;
                            }
                        }
                    }
                    // ...aggiorno valore riferimento...
                    currVacActCount[i] = valore;
                }
                outString += string.Format("{0} | ", currGateway.getItemNode(vettVacAct[i].countKey));
            }
            // salvo su maschera...
            parentForm.dataMonitor_2 += string.Format("{0}{1}", outString.Substring(0, outString.Length - 3), Environment.NewLine);
            return needSave;
        }

        /// <summary>
        /// Processing delle variabili sui componenti Lubro
        /// </summary>
        /// <param name="needSave"></param>
        /// <returns></returns>
        public bool procLubro(bool needSave)
        {
            uint delta = 0;
            uint valore = 0;
            string outString = string.Format("Lubro_[1-{0}]_Count: ", currAdpConf.nLubro);
            for (int i = 0; i < currAdpConf.nLubro; i++)
            {
                valore = Convert.ToUInt32(istLubroCount[i].vcMedian);
                if (valore > currLubroCount[i])
                {
                    delta = valore - currLubroCount[i];
                    // controllo delta < 50% max...
                    if (delta < uint.MaxValue / 2)
                    {
                        //processo comunque sempre...
                        uint contTot = updateValUIntByIncr(i, delta, "Lubro_{0:00}_Count");
                        // passo valore totale all'adapter
                        currGateway.updateItemNodeValue(vettLubro[i].countKey, contTot);
                        // controllo valore riferimento...
                        if (delta > 0)
                        {
                            // segnalo necessità salvataggio!
                            needSave = true;
                        }
                    }
                    // ...aggiorno valore riferimento...
                    currLubroCount[i] = valore;
                }
                else
                {
                    currGateway.updateItemNodeValue(vettLubro[i].countKey, currLubroCount[i]);
                }
                outString += string.Format("{0} | ", currGateway.getItemNode(vettLubro[i].countKey));
            }
            // salvo su maschera...
            parentForm.dataMonitor_2 += string.Format("{0}{1}", outString.Substring(0, outString.Length - 3), Environment.NewLine);
            return needSave;
        }

        /// <summary>
        /// Processing delle variabili sui componenti SlittaMag
        /// </summary>
        /// <param name="needSave"></param>
        /// <returns></returns>
        public bool procSlittaMag(bool needSave)
        {
            uint delta = 0;
            uint valore = 0;
            string outString = string.Format("SlittaMagazzino_[1-{0}]_Count: ", currAdpConf.nSlittaMag);
            for (int i = 0; i < currAdpConf.nSlittaMag; i++)
            {
                // procedo solo SE HO FINESTRA VALIDA...
                if (istSlittaMag[i].vcValid)
                {
                    valore = Convert.ToUInt32(istSlittaMag[i].vcMedian);
                    if (valore >= currSlittaMag[i])
                    {
                        delta = valore - currSlittaMag[i];
                        // controllo delta < 50% max...
                        if (delta < uint.MaxValue / 2)
                        {
                            //processo comunque sempre...
                            uint contTot = updateValUIntByIncr(i, delta, "SlittaMagazzino_{0:00}_Count");
                            // passo valore totale all'adapter
                            currGateway.updateItemNodeValue(vettSlittaMag[i].countKey, contTot);
                            // controllo valore riferimento...
                            if (delta > 0)
                            {
                                // segnalo necessità salvataggio!
                                needSave = true;
                            }
                        }
                    }
                    // ...aggiorno valore riferimento...
                    currSlittaMag[i] = valore;
                }
                outString += string.Format("{0} | ", currGateway.getItemNode(vettSlittaMag[i].countKey));
            }
            // salvo su maschera...
            parentForm.dataMonitor_2 += string.Format("{0}{1}", outString.Substring(0, outString.Length - 3), Environment.NewLine);
            return needSave;
        }

        /// <summary>
        /// Processing delle variabili sui componenti ProtMag
        /// </summary>
        /// <param name="needSave"></param>
        /// <returns></returns>
        public bool procProtMag(bool needSave)
        {
            uint delta = 0;
            uint valore = 0;
            string outString = string.Format("ProtMagazzino_[1-{0}]_Count: ", currAdpConf.nProtMag);
            for (int i = 0; i < currAdpConf.nProtMag; i++)
            {// procedo solo SE HO FINESTRA VALIDA...
                if (istProtMag[i].vcValid)
                {
                    valore = Convert.ToUInt32(istProtMag[i].vcMedian);
                    if (valore >= currProtMag[i])
                    {
                        delta = valore - currProtMag[i];
                        // controllo delta < 50% max...
                        if (delta < uint.MaxValue / 2)
                        {
                            //processo comunque sempre...
                            uint contTot = updateValUIntByIncr(i, delta, "ProtMagazzino_{0:00}_Count");
                            // passo valore totale all'adapter
                            currGateway.updateItemNodeValue(vettProtMag[i].countKey, contTot);
                            // controllo valore riferimento...
                            if (delta > 0)
                            {
                                // segnalo necessità salvataggio!
                                needSave = true;
                            }
                        }
                    }
                    // ...aggiorno valore riferimento...
                    currProtMag[i] = valore;
                }
                outString += string.Format("{0} | ", currGateway.getItemNode(vettProtMag[i].countKey));
            }
            // salvo su maschera...
            parentForm.dataMonitor_2 += string.Format("{0}{1}", outString.Substring(0, outString.Length - 3), Environment.NewLine);
            return needSave;
        }

        #endregion metodi che prevedono salvataggio valori su file XML/BIN

        #region layer persistenza dati

        /// <summary>
        /// Dizionario di persistenza per i valori da salvare da/su file
        /// </summary>
        public Dictionary<string, string> persistenceLayer;

        /// <summary>
        /// recupera valore salvato in persistence layer (se non c'è crea...)
        /// </summary>
        /// <param name="keyVal"></param>
        /// <returns></returns>
        private string getStoredVal(string keyVal)
        {
            string value = "";
            try
            {
                if (persistenceLayer != null)
                {
                    if (!persistenceLayer.TryGetValue(keyVal, out value))
                    {
                        persistenceLayer.Add(keyVal, "0");
                    }
                }
            }
            catch (Exception exc)
            {
                lg.Error(string.Format("Eccezione in getStoredVal: {0}{1}", Environment.NewLine, exc));
            }
            return value;
        }

        /// <summary>
        /// recupera valore salvato in persistence layer (se non c'è crea...) come UINT
        /// </summary>
        /// <param name="keyVal"></param>
        /// <returns></returns>
        private uint getStoredValUInt(string keyVal)
        {
            uint answ = 0;
            try
            {
                answ = Convert.ToUInt32(getStoredVal(keyVal));
            }
            catch (Exception exc)
            {
                lg.Error(string.Format("Eccezione in getStoredValUInt: {0}{1}", Environment.NewLine, exc));
            }
            // verifico che il valore sia minore di 9/10 del valore massimo...
            answ = (answ < (uint.MaxValue / 10 * 9)) ? answ : 0;
            return answ;
        }

        /// <summary>
        /// recupera valore salvato in persistence layer (se non c'è crea...) come INT
        /// </summary>
        /// <param name="keyVal"></param>
        /// <returns></returns>
        private long getStoredValLong(string keyVal)
        {
            long answ = 0;
            try
            {
                answ = Convert.ToInt64(getStoredVal(keyVal));
            }
            catch
            { }
            // verifico che il valore sia minore di 9/10 del valore massimo...
            answ = (answ < (long.MaxValue / 10 * 9)) ? answ : 0;
            return answ;
        }

        /// <summary>
        /// recupera valore salvato in persistence layer (se non c'è crea...) come double
        /// </summary>
        /// <param name="keyVal"></param>
        /// <returns></returns>
        private double getStoredValDouble(string keyVal)
        {
            double answ = 0;
            try
            {
                answ = Convert.ToDouble(getStoredVal(keyVal));
            }
            catch (Exception exc)
            {
                lg.Error(string.Format("Eccezione in getStoredValDouble: {0}{1}", Environment.NewLine, exc));
            }
            answ = (answ < (double.MaxValue / 10 * 9)) ? answ : 0;
            return answ;
        }

        /// <summary>
        /// Aggiorna un valore del dizionario in SOSTITUZIONE
        /// </summary>
        /// <param name="i"></param>
        /// <param name="newVal"></param>
        /// <param name="searchString"></param>
        /// <returns>Nuovo valore incrementato</returns>
        private void updateValString(int i, string newVal, string searchString)
        {
            // stringa da cercare..
            string keyVal = string.Format(searchString, i + 1);
            // salvo in ram!
            persistenceLayer[keyVal] = newVal;
        }

        /// <summary>
        /// Aggiorna un valore del dizionario in SOSTITUZIONE e lo restituisce
        /// </summary>
        /// <param name="i"></param>
        /// <param name="newVal"></param>
        /// <param name="searchString"></param>
        /// <returns>Nuovo valore incrementato</returns>
        private void updateValUInt(int i, uint newVal, string searchString)
        {
            // stringa da cercare..
            string keyVal = string.Format(searchString, i + 1);
            // salvo in ram!
            persistenceLayer[keyVal] = newVal.ToString();
        }

        /// <summary>
        /// Aggiorna un valore del dizionario in INCREMENTO e lo restituisce
        /// </summary>
        /// <param name="i"></param>
        /// <param name="delta"></param>
        /// <param name="searchString"></param>
        /// <returns>Nuovo valore incrementato</returns>
        private uint updateValUIntByIncr(int i, uint delta, string searchString)
        {
            // stringa da cercare..
            string keyVal = string.Format(searchString, i + 1);
            // recupero valore precedente...
            uint contAct = getStoredValUInt(keyVal);
            // nuovo valore...
            contAct += delta;
            // salvo in ram!
            persistenceLayer[keyVal] = contAct.ToString();
            // rendo il valore!
            return contAct;
        }

        /// <summary>
        /// Aggiorna un valore del dizionario in INCREMENTO e lo restituisce
        /// </summary>
        /// <param name="i"></param>
        /// <param name="delta"></param>
        /// <param name="searchString"></param>
        /// <returns>Nuovo valore incrementato</returns>
        private long updateValLongByIncr(int i, long delta, string searchString)
        {
            // stringa da cercare..
            string keyVal = string.Format(searchString, i + 1);
            // recupero valore precedente...
            long contAct = getStoredValLong(keyVal);
            // nuovo valore...
            contAct += delta;
            // salvo in ram!
            persistenceLayer[keyVal] = contAct.ToString();
            // rendo il valore!
            return contAct;
        }

        /// <summary>
        /// Aggiorna un valore del dizionario in INCREMENTO e lo restituisce
        /// </summary>
        /// <param name="i"></param>
        /// <param name="delta"></param>
        /// <param name="searchString"></param>
        /// <returns>Nuovo valore incrementato</returns>
        private double updateValDoubleByIncr(int i, double delta, string searchString)
        {
            // stringa da cercare..
            string keyVal = string.Format(searchString, i + 1);
            // recupero valore precedente...
            double contAct = getStoredValDouble(keyVal);
            // nuovo valore...
            contAct += delta;
            // salvo in ram!
            persistenceLayer[keyVal] = contAct.ToString();
            // rendo il valore!
            return contAct;
        }

        #endregion layer persistenza dati

        #region metodi helper


        /// <summary>
        /// Effettua accodamento messaggio sullo string builder indicato (con try/catch e eventuale log...)
        /// </summary>
        /// <param name="strBuild"></param>
        /// <param name="newLine"></param>
        public void tryLogMessage(StringBuilder strBuild, string newLine)
        {
            try
            {
                strBuild.AppendLine(newLine);
            }
            catch (Exception exc)
            {
                lg.Error(exc, "Eccezione in accodamento messaggio su stringBuilder");
            }
        }

        #endregion
    }
}