using EgwProxy.MultiCncLib.CNC;
using IOB_UT;
using MapoSDK;
using System;
using System.Collections.Generic;
using System.Net;
using System.Net.NetworkInformation;

namespace IOB_WIN
{
    public class IobFanuc : IobGeneric
    {
        #region Private Fields

        /// <summary>
        /// LookUpTable di decodifica da CNC a segnali tipo bitmap MAPO
        /// </summary>
        private Dictionary<string, string> signLUT = new Dictionary<string, string>();

        #endregion Private Fields

        #region Protected Fields

        /// <summary>
        /// Dati dell'area D
        /// </summary>
        protected memAreaFanuc areaD;

        /// <summary>
        /// Dati dell'area PARameters
        /// </summary>
        protected memAreaFanuc areaPAR;

        /// <summary>
        /// Dati dell'area R
        /// </summary>
        protected memAreaFanuc areaR;

        /// <summary>
        /// Dati dell'area X
        /// </summary>
        protected memAreaFanuc areaX;

        /// <summary>
        /// Dati dell'area Y
        /// </summary>
        protected memAreaFanuc areaY;

        /// <summary>
        /// Oggetto MAIN x connessione FANUC
        /// </summary>
        protected FANUC FANUC_ref;

        /// <summary>
        /// Area memoria G (copia)
        /// </summary>
        protected byte[] MemBlockG = new byte[2];

        /// <summary>
        /// Area memoria R (copia)
        /// </summary>
        protected byte[] MemBlockR = new byte[2];

        /// <summary>
        /// Area memoria X (copia)
        /// </summary>
        protected byte[] MemBlockX = new byte[2];

        /// <summary>
        /// Area memoria Y (copia)
        /// </summary>
        protected byte[] MemBlockY = new byte[2];

        #endregion Protected Fields

        #region Public Constructors

        /// <summary>
        /// estende l'init della classe base...
        /// </summary>
        /// <param name="caller"></param>
        /// <param name="adpConf"></param>
        public IobFanuc(AdapterForm caller, IobConfiguration IOBConf) : base(caller, IOBConf)
        {
            // i dati RAW principali sono 6 byte...
            RawInput = new byte[6];

            // gestione invio ritardato contapezzi
            pzCountDelay = utils.CRI("pzCountDelay");
            lastPzCountSend = DateTime.Now;
            lastWarnODL = DateTime.Now;

            // inizializzo correttamente aree memoria secondo CONF - iniFileName
            IniFile fIni = new IniFile(IOBConf.iniFileName);
            // inizializzo aree di memoria correnti...
            MemBlockG = new byte[fIni.ReadInteger("MEMORY", "AREAG_SIZE", 8)];
            MemBlockR = new byte[fIni.ReadInteger("MEMORY", "AREAR_SIZE", 8)];
            MemBlockX = new byte[fIni.ReadInteger("MEMORY", "AREAX_SIZE", 8)];
            MemBlockY = new byte[fIni.ReadInteger("MEMORY", "AREAY_SIZE", 8)];
            // loggo aree di memoria avviate...
            lgInfo(string.Format("Avviare area di memoria MemBlockG: {0} byte", MemBlockG.Length));
            lgInfo(string.Format("Avviare area di memoria MemBlockR: {0} byte", MemBlockR.Length));
            lgInfo(string.Format("Avviare area di memoria MemBlockX: {0} byte", MemBlockX.Length));
            lgInfo(string.Format("Avviare area di memoria MemBlockY: {0} byte", MemBlockY.Length));

            // fix enable prgName
            enablePrgName = fIni.ReadBoolean("CNC", "GETPRGNAME", true);

            // salvo le aree X-Y-D (per dump/sample/ottimizzazione lettura)
            areaD = new memAreaFanuc
            {
                areaName = "AreaD",
                startIdx = fIni.ReadInteger("MEMORY", "AREAD_START", 0),
                arraySize = fIni.ReadInteger("MEMORY", "AREAD_SIZE", 0)
            };
            areaPAR = new memAreaFanuc
            {
                areaName = "AreaPARR",
                startIdx = fIni.ReadInteger("MEMORY", "PAR_START", 0),
                arraySize = fIni.ReadInteger("MEMORY", "PAR_SIZE", 0)
            };
            areaR = new memAreaFanuc
            {
                areaName = "AreaR",
                startIdx = fIni.ReadInteger("MEMORY", "AREAR_START", 0),
                arraySize = fIni.ReadInteger("MEMORY", "AREAR_SIZE", 0)
            };
            areaX = new memAreaFanuc
            {
                areaName = "AreaX",
                startIdx = fIni.ReadInteger("MEMORY", "AREAX_START", 0),
                arraySize = fIni.ReadInteger("MEMORY", "AREAX_SIZE", 0)
            };
            areaY = new memAreaFanuc
            {
                areaName = "AreaY",
                startIdx = fIni.ReadInteger("MEMORY", "AREAY_START", 0),
                arraySize = fIni.ReadInteger("MEMORY", "AREAY_SIZE", 0)
            };
            lgInfo(string.Format("Salvata area di memoria: {0}, da {1} per {2} byte", areaD.areaName, areaD.startIdx, areaD.arraySize));
            lgInfo(string.Format("Salvata area di memoria: {0}, da {1} per {2} byte", areaR.areaName, areaR.startIdx, areaR.arraySize));
            lgInfo(string.Format("Salvata area di memoria: {0}, da {1} per {2} byte", areaX.areaName, areaX.startIdx, areaX.arraySize));
            lgInfo(string.Format("Salvata area di memoria: {0}, da {1} per {2} byte", areaY.areaName, areaY.startIdx, areaY.arraySize));

            // effettuo lettura della conf sigLUT... cercando 1:1 i bit...
            string currBit = "";
            string memArea = "";
            for (int i = 0; i < 8; i++)
            {
                currBit = string.Format("BIT{0}", i);
                memArea = fIni.ReadString("MEMORY", currBit, "");
                // se trovo un valore...
                if (!string.IsNullOrEmpty(memArea))
                {
                    signLUT.Add(currBit, memArea);
                }
            }

            // è little endian (NON serve conversione)
            hasBigEndian = false;
            lgInfo("Start init Adapter FANUC all'IP {0}:{1} per IOB {2}", IOBConf.cncIpAddr, IOBConf.cncPort, IOBConf.codIOB);

            // Creo oggetto connessione NC
            parentForm.commPlcActive = true;
            Runtime.CreateNC(CNC.NcType.FANUC, IOBConf.cncIpAddr, IOBConf.cncPort);
            parentForm.commPlcActive = false;

            // aggiungo referenza obj FANUC
            FANUC_ref = (FANUC)Runtime.NC;
            if (isVerboseLog)
            {
                lgInfo("FANUC_ref da EgwProxy.MultiCncLib");
            }

            // disconnetto e connetto...
            if (isVerboseLog)
            {
                lgInfo("FANUC: tryDisconnect");
            }

            tryDisconnect();
            lgInfo("FANUC: tryConnect");
            tryConnect();
            if (utils.CRB("enableContapezzi"))
            {
                lgInfo("FANUC: inizio gestione contapezzi");
                try
                {
                    // verifico quale modalità sia richiesta: STD (6711) oppure BIT (Custom, con indicazione area)
                    if (cIobConf.optPar.Count > 0 && !string.IsNullOrEmpty(getOptPar("PZCOUNT_MODE")))
                    {
                        if (getOptPar("PZCOUNT_MODE").StartsWith("STD"))
                        {
                            lgInfo("Init contapezzi FANUC: pzCntReload(true)");
                            pzCntReload(true);
                            // refresh associazione Macchina - IOB
                            sendM2IOB();
                            // per adesso imposto lettura fanuc == contapezzi (poi farà vera lettura...)
                            contapezziPLC = contapezziIOB;
                        }
                        else
                        {
                            contapezziIOB = 0;
                            lgInfo("Contapezzi STD disabilitato: modalità {0}", getOptPar("PZCOUNT_MODE"));
                        }
                    }
                    else
                    {
                        contapezziIOB = 0;
                        lgInfo("Parametro mancante PZCOUNT_MODE");
                    }
                }
                catch (Exception exc)
                {
                    lgError(exc, "Errore in contapezzi FANUC");
                }
            }
            // finisco INIT ADAPTER
            lgInfo("End init Adapter FANUC");
        }

        #endregion Public Constructors

        #region Private Methods

        /// <summary>
        /// Effettua decodifica aree memoria alla bitmap usata x MAPO
        /// </summary>
        private void decodeToBitmap()
        {
            // init a zero...
            B_input = 0;
            if (connectionOk)
            {
                // SE SI E' CONNESSO al FANUC allora è 1=powerON...
                if (FANUC_ref.Connected)
                {
                    B_input += 1 << 0;
                }

                // decodifico impiegando dictionary... cercando il TIPO di memoria & co...
                string bKey = "";
                string bVal = "";
                char area;
                // valore INVERTED (default è false)
                bool invSignal = false;
                string memArea = "";
                string[] memIdx;
                int bitNum = 0;
                int byteNum = 0;
                int byte2check = 0;
                for (int i = 0; i < 8; i++)
                {
                    bKey = string.Format("BIT{0}", i);
                    // cerco se ci sia in LUT
                    if (signLUT.ContainsKey(bKey))
                    {
                        // recupero nome variabile...
                        bVal = signLUT[bKey];
                        // se l'area è PZCOUNT... processo PUNTUALMENTE il CONTAPEZZI...
                        if (bVal.StartsWith("PZCOUNT"))
                        {
                            // procedo SOLO SE è enabled IOB
                            if (IobOnline)
                            {
                                try
                                {
                                    currODL = utils.callUrl(urlGetCurrODL);
                                    // solo SE HO un ODL...
                                    if (string.IsNullOrEmpty(currODL) || currODL == "0")
                                    {
                                        if (periodicLog)
                                        {
                                            lgInfo(string.Format("Fanuc | Lettura ODL andata a vuoto: currODL: {0}", currODL));
                                        }
                                    }
                                    else
                                    {
                                        // se variato o scaduto timeout log...
                                        if (periodicLog || ($"{currIdxODL}" != currODL))
                                        {
                                            lgInfo(string.Format("Fanuc | Lettura ODL, currODL: {0} --> currIdxODL prec: {1}", currODL, currIdxODL));
                                        }
                                        // provo a salvare nuovo ODL
                                        int.TryParse(currODL, out currIdxODL);
                                    }
                                }
                                catch (Exception exc)
                                {
                                    if (DateTime.Now.Subtract(lastWarnODL).TotalSeconds > 15)
                                    {
                                        lgError(exc, "Errore in fase di chiamata URL x ODL corrente | URL chiamato: {0}", urlGetCurrODL);
                                        lastWarnODL = DateTime.Now;
                                    }
                                }
                            }
                            else
                            {
                                // imposto currODL a vuoto!
                                currODL = "";
                                if (periodicLog)
                                {
                                    lgInfo($"Fanuc | Lettura ODL non effettuata: IobOnline: {IobOnline} | currODL impostato a vuoto");
                                }
                            }
                            if (!string.IsNullOrEmpty(currODL) && currODL != "0")
                            {
                                // controllo se è passato intervallo minimo tra 2 controlli/elaborazioni x distanziare invio e ridurre letture
                                if (DateTime.Now >= lastPzCountSend.AddMilliseconds(pzCountDelay))
                                {
                                    // se sono differenti MOSTRO...
                                    if (contapezziPLC != contapezziIOB)
                                    {
                                        // registro contapezzi
                                        lgInfo($"Differenza Contapezzi: contapezziPLC: {contapezziPLC} | contapezziIOB {contapezziIOB}");
                                    }
                                    // verifico se variato contapezzi...
                                    if (contapezziPLC > contapezziIOB)
                                    {
                                        // salvo nuovo contapezzi (incremento di 1...) + richiesta refresh conteggio
                                        contapezziIOB++;
                                        needRefreshPzCount = true;
                                        // salvo in semaforo!
                                        B_input += 1 << 2;
                                        // registro contapezzi
                                        lgInfo($"contapezziPLC FANUC: {contapezziPLC} | contapezziIOB {contapezziIOB}");
                                    }
                                    // invio a server contapezzi (aggiornato)
                                    string retVal = utils.callUrl(urlSetPzCount + contapezziIOB.ToString());
                                    // verifica se tutto OK
                                    if (retVal != contapezziIOB.ToString())
                                    {
                                        // errore salvataggio contapezzi
                                        lgInfo($"Errore salvataggio Contapezzi FANUC: contapezziPLC {contapezziPLC} | contapezziIOB {contapezziIOB} | risposta: {retVal}");
                                        // rileggo il counter pezzi da server
                                        pzCntReload(true);
                                    }
                                    // resetto timer...
                                    lastPzCountSend = DateTime.Now;
                                }
                            }
                            else
                            {
                                if (DateTime.Now >= lastPzCountSend.AddMilliseconds(pzCountDelay))
                                {
                                    lgInfo($"Attenzione: mancanza ODL non procedo con gestione contapezzi. contapezziPLC FANUC: {contapezziPLC} | contapezziIOB {contapezziIOB}");
                                    // resetto timer...
                                    lastPzCountSend = DateTime.Now;
                                }
                            }
                        }
                        else // area "normale" byte.bit
                        {
                            // di norma è segnale normale => 1, altrimenti inverse => 0...
                            invSignal = false;
                            // cerco se sia inverse (ultimo char "!") --> registro e elimino char...
                            invSignal = bVal.StartsWith("!");
                            // tolgo comunque inversione...
                            bVal = bVal.Replace("!", "");
                            // recupero area...
                            area = bVal[0];
                            // altrimenti decodifico area...
                            memArea = bVal.Substring(1, bVal.Length - 1);
                            memIdx = memArea.Split('.');
                            // calcolo bit e byte number...
                            int.TryParse(memIdx[0], out byteNum);
                            if (memIdx.Length > 1)
                            {
                                int.TryParse(memIdx[1], out bitNum);
                            }
                            // in base al nome cerco in una delle aree.. e prendo solo solo quel bit di quel byte...
                            switch (area)
                            {
                                case 'G':
                                    byte2check = MemBlockG[byteNum];
                                    break;

                                case 'R':
                                    byte2check = MemBlockR[byteNum];
                                    break;

                                case 'X':
                                    byte2check = MemBlockX[byteNum];
                                    break;

                                case 'Y':
                                    byte2check = MemBlockY[byteNum];
                                    break;

                                default:
                                    break;
                            }
                            // a secondo che sia segnale normale o inverso...
                            if (invSignal)
                            {
                                // controllo se il bit sia NON attivo (basso)... == 0...
                                if ((byte2check & (1 << bitNum)) == 0)
                                {
                                    B_input += 1 << i;
                                }
                            }
                            else
                            {
                                // controllo se il bit sia attivo (alto)... != 0
                                if ((byte2check & (1 << bitNum)) != 0)
                                {
                                    B_input += 1 << i;
                                }
                            }
                        }
                    }
                }
            }
            // log opzionale!
            if (verboseLog)
            {
                lgInfo(string.Format("Trasformazione B_input: {0}", B_input));
            }
        }

        /// <summary>
        /// Dump area D della memoria
        /// </summary>
        /// <param name="tipo">tipo di DUMP: START (sovrascrivendo) / SAMPLE (salva tanti campionamenti)</param>
        /// <param name="tipoMem">tipo memoria</param>
        /// <param name="memIndex">area memoria di partenza</param>
        /// <param name="memSizeByte">dimensione memoria</param>
        private void dump_MemArea(dumpType tipo, FANUC.MemType tipoMem, int memIndex, int memSizeByte)
        {
            DateTime adesso = DateTime.Now;
            string nomeFileB = "";
            string nomeFileW = "";
            string nomeFileDW = "";
            Dictionary<string, string> mappaValori = new Dictionary<string, string>();
            // per sicurezza verifico < 9999 byte
            if (memSizeByte > 9999)
            {
                memSizeByte = 9999;
            }
            // leggo TUTTI i (MAX 9999) byte della memoria D...
            byte[] MemBlockCurr = new byte[memSizeByte];
            if (verboseLog)
            {
                lgInfo("START MemDump", tipoMem);
            }

            stopwatch.Restart();
            FanucMemRW(R, tipoMem, memIndex, ref MemBlockCurr);
            if (utils.CRB("recTime"))
            {
                TimingData.addResult(cIobConf.codIOB, string.Format("R{0}-{1}", MemBlockCurr.Length, tipoMem), stopwatch.ElapsedTicks);
            }

            if (verboseLog)
            {
                lgInfo("END MemDump", tipoMem);
            }

            // seconda del tipo di lettura definisco i nomi delle variabili...
            if (tipo == dumpType.SAMPLE)
            {
                nomeFileB = string.Format(@"{0}\SAMPLES\{1}_{2}_Byte_{3:yyyyMMdd_HHmmss}.dat", utils.dataDatDir, cIobConf.codIOB, tipoMem, adesso);
                nomeFileW = string.Format(@"{0}\SAMPLES\{1}_{2}_W_{3:yyyyMMdd_HHmmss}.dat", utils.dataDatDir, cIobConf.codIOB, tipoMem, adesso);
                nomeFileDW = string.Format(@"{0}\SAMPLES\{1}_{2}_DW_{3:yyyyMMdd_HHmmss}.dat", utils.dataDatDir, cIobConf.codIOB, tipoMem, adesso);
            }
            else
            {
                // salvo in file i dati letti come BYTE
                nomeFileB = string.Format(@"{0}\{1}_{2}_Byte.dat", utils.dataDatDir, cIobConf.codIOB, tipoMem);
                nomeFileW = string.Format(@"{0}\{1}_{2}_W.dat", utils.dataDatDir, cIobConf.codIOB, tipoMem);
                nomeFileDW = string.Format(@"{0}\{1}_{2}_DW.dat", utils.dataDatDir, cIobConf.codIOB, tipoMem);
            }

            // salvo in file i dati letti come BYTE
            mappaValori = new Dictionary<string, string>();
            for (int i = 0; i < MemBlockCurr.Length; i++)
            {
                mappaValori.Add(i.ToString("0000"), MemBlockCurr[i].ToString());
            }
            utils.WritePlain(mappaValori, nomeFileB);

            // salvo in file i dati letti come Word (2byte)
            mappaValori = new Dictionary<string, string>();
            for (int i = 0; i < MemBlockCurr.Length / 2; i++)
            {
                mappaValori.Add(i.ToString("0000"), BitConverter.ToUInt16(MemBlockCurr, i * 2).ToString());
            }
            utils.WritePlain(mappaValori, nomeFileW);

            // salvo in file i dati letti come DWord (4byte)
            mappaValori = new Dictionary<string, string>();
            for (int i = 0; i < MemBlockCurr.Length / 4; i++)
            {
                mappaValori.Add(i.ToString("0000"), BitConverter.ToUInt32(MemBlockCurr, i * 4).ToString());
            }
            utils.WritePlain(mappaValori, nomeFileDW);
        }

        /// <summary>
        /// Dump area PARAMETRI
        /// </summary>
        /// <param name="tipo">tipo di DUMP: START (sovrascrivendo) / SAMPLE (salva tanti campionamenti)</param>
        /// <param name="memIndex">Parametro di partenza</param>
        /// <param name="numPar">Numero parametri da esportare... memoria</param>
        private void dump_ParArea(dumpType tipo, int memIndex, int numPar)
        {
            DateTime adesso = DateTime.Now;
            string nomeFile = "";
            Dictionary<string, string> mappaValori = new Dictionary<string, string>();
            // per sicurezza verifico < 9999 parametri
            if (numPar > 9999)
            {
                numPar = 9999;
            }

            // leggo TUTTI i (MAX 9999) byte della memoria D...
            object[] paramsArray = new object[numPar];
            if (verboseLog)
            {
                lgInfo("START ParamDump");
            }

            stopwatch.Restart();
            for (int i = 0; i < numPar; i++)
            {
                FANUC_ref.F_RW_Param_Integer(false, memIndex + i, 3, ref paramsArray[i]);
            }

            if (utils.CRB("recTime"))
            {
                TimingData.addResult(cIobConf.codIOB, string.Format("R{0}-PAR", 4 * numPar), stopwatch.ElapsedTicks);
            }

            if (verboseLog)
            {
                lgInfo("END ParamDump");
            }

            // seconda del tipo di lettura definisco i nomi delle variabili...
            if (tipo == dumpType.SAMPLE)
            {
                nomeFile = string.Format(@"{0}\SAMPLES\{1}_{2}_{3:yyyyMMdd_HHmmss}.dat", utils.dataDatDir, cIobConf.codIOB, "PAR", adesso);
            }
            else
            {
                nomeFile = string.Format(@"{0}\{1}_{2}.dat", utils.dataDatDir, cIobConf.codIOB, "PAR");
            }

            // salvo in file i dati letti
            mappaValori = new Dictionary<string, string>();
            for (int i = 0; i < paramsArray.Length; i++)
            {
                mappaValori.Add(i.ToString("0000"), paramsArray[i].ToString());
            }
            utils.WritePlain(mappaValori, nomeFile);
        }

        /// <summary>
        /// Recupera il valore INT dal nome del parametro per successivo processing
        /// </summary>
        /// <param name="varName"></param>
        /// <returns></returns>
        private string getValByParam(string varName)
        {
            string answ = "";
            // verifico quale modalità sia richiesta: STD (6711) oppure BIT (Custom, con indicazione area)
            string memAddr = getOptPar(varName);
            if (memAddr.StartsWith("STD"))
            {
                // inizio verifica area memoria/parametro levando prima parte codice
                memAddr = memAddr.Replace("STD.", "");
                // var di appoggio
                int cntAddr = 0;
                object outputVal = new object();
                // verifico se si tratta di lettura parametro... formato tipo STD.PAR.6711
                if (memAddr.StartsWith("PAR."))
                {
                    // recupero parametro...
                    int.TryParse(memAddr.Replace("PAR.", ""), out cntAddr);
                    // processo parametro
                    stopwatch.Restart();
                    FANUC_ref.F_RW_Param_Integer(false, cntAddr, 3, ref outputVal);
                    if (utils.CRB("recTime"))
                    {
                        TimingData.addResult(cIobConf.codIOB, string.Format("R{0}-PAR", 4), stopwatch.ElapsedTicks);
                    }
                    // salvo valore
                    answ = outputVal.ToString();
                }
                // altrimenti se legge da area memoria specifica leggo da li... formto tipo STD.D.1604.DW
                else
                {
                    memAddressFanuc areaCounter = new memAddressFanuc(memAddr);

                    if (isVerboseLog)
                    {
                        lgInfo("[0] area memoria: {0}.{1}.{2}", areaCounter.mType, areaCounter.mPos, areaCounter.vType);
                    }

                    // leggo!
                    stopwatch.Restart();
                    // switch x tipo dati --> tipo lettura... e salvo ultimo conteggio rilevato
                    switch (areaCounter.vType)
                    {
                        case "B":
                            byte valB = 0;
                            FANUC_ref.F_RW_Byte(false, areaCounter.mType, areaCounter.mPos, ref valB);
                            outputVal = valB;
                            break;

                        case "D":
                            ushort valW = 0;
                            FANUC_ref.F_RW_Word(false, areaCounter.mType, areaCounter.mPos, ref valW);
                            outputVal = valW;
                            break;

                        case "DW":
                            uint valDW = 0;
                            FANUC_ref.F_RW_DWord(false, areaCounter.mType, areaCounter.mPos, ref valDW);
                            if (isVerboseLog)
                            {
                                lgInfo("[1] valDW PAR: {0}", valDW);
                            }

                            outputVal = valDW;
                            if (isVerboseLog)
                            {
                                lgInfo("[2] outputVal PAR: {0}", outputVal);
                            }

                            break;

                        default:
                            break;
                    }
                    if (utils.CRB("recTime"))
                    {
                        TimingData.addResult(cIobConf.codIOB, string.Format("R-{0}.{1}.{2}", areaCounter.mType, areaCounter.mPos, areaCounter.vType), stopwatch.ElapsedTicks);
                    }

                    // salvo...
                    answ = outputVal.ToString();
                    if (isVerboseLog)
                    {
                        lgInfo("[3] PAR letto: {0} | {1}", varName, answ);
                    }
                }
                stopwatch.Stop();
            }
            return answ;
        }

        #endregion Private Methods

        #region Protected Methods

        /// <summary>
        /// decodifica il modo dai valori del byte G43
        /// </summary>
        /// <param name="currVal"></param>
        /// <returns></returns>
        protected static CNC_MODE decodeG43(byte currVal)
        {
            // hard coded da valori tabellari a MODI definiti in CNC_MODE...
            CNC_MODE answ = CNC_MODE.ND;
            switch (currVal)
            {
                case 0:
                    answ = CNC_MODE.MDI;
                    break;

                case 1:
                    answ = CNC_MODE.MEN;
                    break;

                case 3:
                    answ = CNC_MODE.EDIT;
                    break;

                case 4:
                    answ = CNC_MODE.HANDLE_INC;
                    break;

                case 5:
                    answ = CNC_MODE.JOG;
                    break;

                case 6:
                    answ = CNC_MODE.TJOG;
                    break;

                case 7:
                    answ = CNC_MODE.THND;
                    break;

                case 33:
                    answ = CNC_MODE.RMT;
                    break;

                case 133:
                    answ = CNC_MODE.REF;
                    break;

                default:
                    answ = CNC_MODE.ND;
                    break;
            }
            return answ;
        }

        #endregion Protected Methods

        #region Public Methods

        /// <summary>
        /// Processo i task richiesti e li elimino dalla coda 1:1
        /// </summary>
        /// <param name="task2exe"></param>
        public override Dictionary<string, string> executeTasks(Dictionary<string, string> task2exe)
        {
            // Verificare il protocollo: dovrebbe togliere SOLO i task eseguiti...
            Dictionary<string, string> taskDone = new Dictionary<string, string>();
            if (task2exe != null)
            {
                bool taskOk = false;
                string taskVal = "";
                // cerco task specifici: se ho startSetup --> imposto bit DBB701.DBB0.4
                foreach (var item in task2exe)
                {
                    taskOk = false;
                    taskVal = "";
                    // converto richiesta in enum...
                    taskType tName = taskType.nihil;
                    Enum.TryParse(item.Key, out tName);
                    switch (tName)
                    {
                        case taskType.nihil:
                        case taskType.fixStopSetup:
                        case taskType.forceResetPzCount:
                        case taskType.forceSetPzCount:
                        case taskType.setArt:
                        case taskType.setComm:
                        case taskType.setProg:
                        case taskType.sendWatchDogMes2Plc:
                            taskVal = $"taskReq: {tName} | key: {item.Key} | val: {item.Value} | SKIPPED | NO EXEC";
                            lgInfo($"Chiamata senza processing: taskOk: {taskOk} | taskVal: {taskVal}");
                            break;

                        case taskType.startSetup:
                            // reset contapezzi inizio setup
                            taskOk = resetcontapezziPLC();
                            taskVal = taskOk ? "RESET: SETUP START" : "PZ RESET DISABLED | NO EXEC";
                            lgInfo($"Chiamata startSetup: taskOk: {taskOk} | taskVal: {taskVal}");
                            break;

                        case taskType.stopSetup:
                            // reset contapezzi fine setup SE ESPLICITAMENTE IMPOSTATO
                            if (cIobConf.optPar.Count > 0 && getOptPar("ENABLE_PZ_RESET_stopSetup") == "TRUE")
                            {
                                taskOk = resetcontapezziPLC();
                            }
                            taskVal = taskOk ? "RESET: SETUP END" : "PZ RESET DISABLED | NO EXEC";
                            lgInfo($"Chiamata stopSetup: taskOk: {taskOk} | taskVal: {taskVal}");
                            break;

                        default:
                            taskVal = "SKIPPED | NO EXEC";
                            lgInfo($"Chiamata default senza processing: taskOk: {taskOk} | taskVal: {taskVal}");
                            break;
                    }
                    // aggiungo task!
                    taskDone.Add(item.Key, taskVal);
                }
            }
            return taskDone;
        }

        /// <summary>
        /// wrapper chiamata lettura/scrittura SINGOLO BYTE...
        /// </summary>
        /// <param name="bWrite"></param>
        /// <param name="MemType"></param>
        /// <param name="memIndex"></param>
        /// <param name="Value"></param>
        /// <returns></returns>
        public bool FanucMemRW(bool bWrite, FANUC.MemType MemType, Int32 memIndex, ref byte Value)
        {
            bool answ = false;
            if (connectionOk)
            {
                if (FANUC_ref.Connected)
                {
                    try
                    {
                        parentForm.commPlcActive = true;
                        answ = FANUC_ref.F_RW_Byte(bWrite, MemType, memIndex, ref Value);
                    }
                    catch
                    { }
                }
            }
            parentForm.commPlcActive = false;
            return answ;
        }

        /// <summary>
        /// wrapper chiamata lettura/scrittura MULTI BYTE...
        /// </summary>
        /// <param name="bWrite"></param>
        /// <param name="MemType"></param>
        /// <param name="memIndex"></param>
        /// <param name="MATRICE Value"></param>
        /// <returns></returns>
        public bool FanucMemRW(bool bWrite, FANUC.MemType MemType, Int32 memIndex, ref byte[] Value)
        {
            bool answ = false;
            if (connectionOk)
            {
                if (FANUC_ref.Connected)
                {
                    try
                    {
                        parentForm.commPlcActive = true;
                        answ = FANUC_ref.F_RW_Byte(bWrite, MemType, memIndex, ref Value);
                    }
                    catch
                    { }
                }
            }
            parentForm.commPlcActive = false;
            return answ;
        }

        /// <summary>
        /// Recupero dati dinamici...
        /// </summary>
        public override Dictionary<string, string> getDynData()
        {
            Dictionary<string, string> outVal = new Dictionary<string, string>();
            // processo SOLO SE connected...
            if (connectionOk)
            {
                if (FANUC_ref.Connected)
                {
                    stopwatch.Restart();
                    EgwProxy.MultiCncLib.Focas1.ODBDY2_1 answ = FANUC_ref.getAllDynData();
                    if (utils.CRB("recTime"))
                    {
                        TimingData.addResult(cIobConf.codIOB, string.Format("PROC-DYN-DATA"), stopwatch.ElapsedTicks);
                    }

                    try
                    {
                        string actf = answ.actf.ToString();
                        string acts = answ.acts.ToString();
                        //string numAlarm = answ.alarm.ToString();
                        // preparo i singoli valori dell'array...
                        //outVal.Add("DYNDATA", string.Format("{0}#{1}#{2}", actf, acts, numAlarm));
                        outVal.Add("DYNDATA", string.Format("FEED {0}#SPEED_RPM {1}", actf, acts));
                        if (utils.CRB("SendFeedSpeed"))
                        {
                            outVal.Add("FEED", actf);
                            outVal.Add("SPEED_RPM", acts);
                            //outVal.Add("NUM_ALARM", numAlarm);
                        }
                        if (utils.CRB("SendAxPos"))
                        {
                            // salvo le posizioni...
                            EgwProxy.MultiCncLib.Focas1.FAXIS posAx = answ.pos;
                            int[] currPosAbs = posAx.absolute;
                            int i = 0;
                            foreach (var item in currPosAbs)
                            {
                                i++;
                                outVal.Add(string.Format("POS_{0:00}", i), item.ToString());
                            }
                        }
                    }
                    catch (Exception exc)
                    {
                        lgError(exc, "Errore in getDynData");
                    }
                    stopwatch.Stop();
                }
            }
            return outVal;
        }

        /// <summary>
        /// Recupero dati override (da area G che è già stata letta...)
        /// </summary>
        /// <returns></returns>
        public override Dictionary<string, string> getOverrides()
        {
            Dictionary<string, string> outVal = new Dictionary<string, string>();
            // processo SOLO SE connected...
            if (connectionOk)
            {
                if (FANUC_ref.Connected)
                {
                    if (utils.CRB("enableMode") && MemBlockG != null && MemBlockG.Length > 0)
                    {
                        outVal.Add("FEED_OVER", MemBlockG[30].ToString());
                        outVal.Add("RAPID_OVER", MemBlockG[12].ToString());
                    }
                }
            }
            return outVal;
        }

        /// <summary>
        /// Recupero programma in lavorazione
        /// </summary>
        /// <returns></returns>
        public override string getPrgName()
        {
            string prgName = "";
            // recupero NUOVO prgName...
            try
            {
                // recupero nome programma MAIN
                prgName = utils.purgedChar2String(FANUC_ref.getPrgNameMain());
                // trimmo path del programma, ovvero "CNCMEMUSERPATH1"
                prgName = prgName.Replace(utils.CRS("basePrgMemPath"), "");
                lgInfo("Current PROG: {0}", prgName);
            }
            catch (Exception exc)
            {
                lgError(string.Format("Eccezione in recupero PRG NAME MAIN:{0}{1}", Environment.NewLine, exc));
                connectionOk = false;
            }
            return prgName;
        }

        /// <summary>
        /// Recupero programma in lavorazione come Dictionary FANUC...
        /// - SYSINFO: (prima KEY globale) TUTTI i valori separati da # (x fare check modifica)
        /// - altre stringhe: ogni singolo parametro / valore
        /// </summary>
        /// <returns></returns>
        public override Dictionary<string, string> getSysInfo()
        {
            Dictionary<string, string> outVal = new Dictionary<string, string>();
            stopwatch.Restart();
            EgwProxy.MultiCncLib.Focas1.ODBSYS answ = FANUC_ref.getSysInfo();
            if (utils.CRB("recTime"))
            {
                TimingData.addResult(cIobConf.codIOB, string.Format("SYS-INFO"), stopwatch.ElapsedTicks);
            }

            try
            {
                string cnc_type = new string(answ.cnc_type);
                string mt_type = new string(answ.mt_type);
                string series = new string(answ.series);
                string version = new string(answ.version);
                string axes = new string(answ.axes);
                //short addInfo = answ.addinfo;
                short max_axis = answ.max_axis;
                // preparo i singoli valori dell'array...
                outVal.Add("SYSINFO", string.Format("{0}#{1}#{2}#{3}#{4}#{5}", cnc_type, mt_type, series, version, axes, max_axis));
                outVal.Add("CNC", cnc_type);
                outVal.Add("MTT", mt_type);
                outVal.Add("SER", series);
                outVal.Add("VER", version);
                outVal.Add("AXS", string.Format("{0}|{1}", axes, max_axis));
            }
            catch (Exception exc)
            {
                lgError(exc, "Errore in getSysInfo");
                connectionOk = false;
            }
            return outVal;
        }

        /// <summary>
        /// Effettua vero processing contapezzi:
        /// 6711: pezzi lavorati
        /// 6712: pezzi lavorati totali
        /// 6713: pezzi richiesti
        /// </summary>
        public override void processContapezzi()
        {
            if (utils.CRB("enableContapezzi"))
            {
                // procedo SOLO SE ho connessione...
                if (connectionOk)
                {
                    try
                    {
                        // controllo di AVERE parametri opzionali x conteggi vari
                        if (cIobConf.optPar.Count > 0)
                        {
                            // contapezzi ATTUALE
                            if (!string.IsNullOrEmpty(getOptPar("PZCOUNT_MODE")))
                            {
                                // verifico quale modalità sia richiesta: STD (6711) oppure BIT (Custom, con indicazione area)
                                string memAddr = getOptPar("PZCOUNT_MODE");
                                if (memAddr.StartsWith("STD"))
                                {
                                    // inizio verifica area memoria/parametro levando prima parte codice
                                    memAddr = memAddr.Replace("STD.", "");
                                    // var di appoggio
                                    int cntAddr = 0;
                                    object outputVal = new object();
                                    // verifico se si tratta di lettura parametro... formato tipo STD.PAR.6711
                                    if (memAddr.StartsWith("PAR."))
                                    {
                                        // recupero parametro...
                                        int.TryParse(memAddr.Replace("PAR.", ""), out cntAddr);
                                        if (cntAddr == 0)
                                        {
                                            cntAddr = 6711;
                                        }

                                        // processo parametro contapezzi (lavorati)
                                        stopwatch.Restart();
                                        FANUC_ref.F_RW_Param_Integer(false, cntAddr, 3, ref outputVal);
                                        if (utils.CRB("recTime"))
                                        {
                                            TimingData.addResult(cIobConf.codIOB, string.Format("R{0}-PAR", 4), stopwatch.ElapsedTicks);
                                        }

                                        // salvo ultimo conteggio rilevato
                                        int newVal = -1;
                                        Int32.TryParse(outputVal.ToString(), out newVal);
                                        contapezziPLC = newVal > -1 ? newVal : contapezziPLC;
                                    }
                                    // altrimenti se legge da area memoria specifica leggo da li... formto tipo STD.D.1604.DW
                                    else
                                    {
                                        memAddressFanuc areaCounter = new memAddressFanuc(memAddr);

                                        if (isVerboseLog)
                                        {
                                            lgInfo("[0] area memoria: {0}.{1}.{2}", areaCounter.mType, areaCounter.mPos, areaCounter.vType);
                                        }

                                        // leggo!
                                        stopwatch.Restart();
                                        // switch x tipo dati --> tipo lettura... e salvo ultimo conteggio rilevato
                                        switch (areaCounter.vType)
                                        {
                                            case "B":
                                                byte valB = 0;
                                                FANUC_ref.F_RW_Byte(false, areaCounter.mType, areaCounter.mPos, ref valB);
                                                outputVal = valB;
                                                break;

                                            case "D":
                                                ushort valW = 0;
                                                FANUC_ref.F_RW_Word(false, areaCounter.mType, areaCounter.mPos, ref valW);
                                                outputVal = valW;
                                                break;

                                            case "DW":
                                                uint valDW = 0;
                                                FANUC_ref.F_RW_DWord(false, areaCounter.mType, areaCounter.mPos, ref valDW);
                                                if (isVerboseLog)
                                                {
                                                    lgInfo("[1] valDW contapezzi: {0}", valDW);
                                                }

                                                outputVal = valDW;
                                                if (isVerboseLog)
                                                {
                                                    lgInfo("[2] outputVal contapezzi: {0}", outputVal);
                                                }

                                                break;

                                            default:
                                                break;
                                        }
                                        if (utils.CRB("recTime"))
                                        {
                                            TimingData.addResult(cIobConf.codIOB, string.Format("R-{0}.{1}.{2}", areaCounter.mType, areaCounter.mPos, areaCounter.vType), stopwatch.ElapsedTicks);
                                        }

                                        // salvo...
                                        int newVal = -1;
                                        Int32.TryParse(outputVal.ToString(), out newVal);
                                        contapezziPLC = newVal > -1 ? newVal : contapezziPLC;
                                        if (isVerboseLog)
                                        {
                                            lgInfo("[3] contapezziPLC contapezzi: {0}", contapezziPLC);
                                        }
                                    }
                                    stopwatch.Stop();
                                }
                            }
                        }
                    }
                    catch (Exception exc)
                    {
                        lgError(exc, "Errore in contapezzi FANUC");
                        connectionOk = false;
                    }
                }
                else
                {
                    lgError("Errore: manca connessione in contapezzi FANUC");
                }
            }
        }

        /// <summary>
        /// Esegue processing MODE (e nel contempo recupera altri dati dell'area G)
        /// </summary>
        public override void processMode()
        {
            // processo SOLO SE connected...
            if (connectionOk)
            {
                if (FANUC_ref.Connected)
                {
                    if (utils.CRB("enableMode") && MemBlockG != null && MemBlockG.Length > 0)
                    {
                        try
                        {
                            // leggo tutto da 0 a 43...
                            int memIndex = 0;
                            // controllo modalità lettura memoria
                            stopwatch.Restart();
                            FanucMemRW(R, FANUC.MemType.G, memIndex, ref MemBlockG);
                            if (utils.CRB("recTime"))
                            {
                                TimingData.addResult(cIobConf.codIOB, string.Format("R{0}-G-AREA", MemBlockG.Length), stopwatch.ElapsedTicks);
                            }

                            stopwatch.Stop();
                            // verifico modo con valore corrente, se cambia aggiorno...
                            CNC_MODE newMode = decodeG43(MemBlockG[43]);
                            if (newMode != currMode)
                            {
                                // aggiorno!
                                currMode = newMode;
                                // conversione NUM MODE in descrizione da ENUM
                                string descrMode = Enum.GetName(typeof(CNC_MODE), currMode);
                                // accodo x invio
                                string sVal = string.Format("[CNC_MODE]{0}", descrMode);
                                // chiamo accodamento...
                                accodaFLog(sVal, qEncodeFLog("CNC_MODE", descrMode));
                            }
                        }
                        catch (Exception exc)
                        {
                            lgError(exc, string.Format("Errore in process Mode G43: {0}{1}", Environment.NewLine, exc));
                            connectionOk = false;
                            stopwatch.Stop();
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Recupero altri counters se ci sono
        /// </summary>
        public override void processOtherCounters()
        {
            try
            {
                // controllo di AVERE parametri opzionali x conteggi vari
                if (cIobConf.optPar.Count > 0)
                {
                    string newVal = "";
#if false
          // controllo SE salvare contapezzo
          if (getOptPar("PZCOUNT_MODE") != "")
          {
            sendOptVal("PZ_COUNT", contapezziPLC);
          }
#endif
                    // controllo SE devo gestire contatore pezzi REQUESTED (lanciati)
                    if (!string.IsNullOrEmpty(getOptPar("PZREQ_MODE")))
                    {
                        newVal = getValByParam("PZREQ_MODE");
                        sendOptVal("PZ_REQ", newVal);
                    }
                    // controllo SE devo gestire contatore PEZZI TOTALI
                    if (!string.IsNullOrEmpty(getOptPar("PZGTOT_MODE")))
                    {
                        newVal = getValByParam("PZGTOT_MODE");
                        sendOptVal("PZ_GTOT", newVal);
                    }
                    // controllo SE devo gestire contatore CADENZA (secondi ciclo rilevati)
                    if (!string.IsNullOrEmpty(getOptPar("PZCAD_MODE")))
                    {
                        newVal = getValByParam("PZCAD_MODE");
                        sendOptVal("CICLE_CAD", newVal);
                    }
                }
            }
            catch (Exception exc)
            {
                lgError(exc, "Eccezione in processOtherCounters");
            }
        }

        /// <summary>
        /// Effettua lettura semafori principale
        /// <paramref name="currDispData">Parametri da aggiornare x display in form</paramref>
        /// </summary>
        public override void readSemafori(ref newDisplayData currDispData)
        {
            base.readSemafori(ref currDispData);
            try
            {
                if (verboseLog)
                {
                    lgInfo("inizio read semafori");
                }

                currDispData.semIn = Semaforo.SV;
                // inizio letture, SEMPRE DA ZERO (possibile ottimizzazione...)
                int memIndex = 0;
                // controllo area R: se ha dati (> 0 byte) --> leggo!
                if (MemBlockR.Length > 0)
                {
                    stopwatch.Restart();
                    FanucMemRW(R, FANUC.MemType.R, memIndex, ref MemBlockR);
                    if (utils.CRB("recTime"))
                    {
                        TimingData.addResult(cIobConf.codIOB, string.Format("R{0}-R", MemBlockR.Length), stopwatch.ElapsedTicks);
                    }
                    // log
                    if (verboseLog)
                    {
                        for (int i = 0; i < MemBlockR.Length; i++)
                        {
                            lgInfo(string.Format("MemBlockR{0}: {1}", i, utils.binaryForm(MemBlockR[i])));
                        }
                    }
                }
                // controllo area X: se ha dati (> 0 byte) --> leggo!
                if (MemBlockX.Length > 0)
                {
                    stopwatch.Restart();
                    FanucMemRW(R, FANUC.MemType.X, memIndex, ref MemBlockX);
                    if (utils.CRB("recTime"))
                    {
                        TimingData.addResult(cIobConf.codIOB, string.Format("R{0}-X", MemBlockX.Length), stopwatch.ElapsedTicks);
                    }
                    // log
                    if (verboseLog)
                    {
                        for (int i = 0; i < MemBlockX.Length; i++)
                        {
                            lgInfo(string.Format("MemBlockX{0}: {1}", i, utils.binaryForm(MemBlockX[i])));
                        }
                    }
                }
                // controllo area Y: se ha dati (> 0 byte) --> leggo!
                if (MemBlockY.Length > 0)
                {
                    stopwatch.Restart();
                    FanucMemRW(R, FANUC.MemType.Y, memIndex, ref MemBlockY);
                    if (utils.CRB("recTime"))
                    {
                        TimingData.addResult(cIobConf.codIOB, string.Format("R{0}-Y", MemBlockY.Length), stopwatch.ElapsedTicks);
                    }
                    // log
                    if (verboseLog)
                    {
                        for (int i = 0; i < MemBlockY.Length; i++)
                        {
                            lgInfo(string.Format("MemBlockY{0}: {1}", i, utils.binaryForm(MemBlockY[i])));
                        }
                    }
                }
                stopwatch.Stop();
                // salvo il solo BYTE dell'input decifrando il semaforo...
                decodeToBitmap();
                reportRawInput(ref currDispData);
            }
            catch (Exception exc)
            {
                lgError(string.Format("Eccezione in readSemafori:{0}{1}", Environment.NewLine, exc));
                connectionOk = false;
                currDispData.semIn = Semaforo.SR;
            }
        }

        /// <summary>
        /// Effettua reset del contapezzi
        /// </summary>
        /// <returns></returns>
        public override bool resetcontapezziPLC()
        {
            bool answ = false;
            // ...SE abilitato da conf IOB
            if (cIobConf.optPar.Count > 0 && getOptPar("ENABLE_PZ_RESET") == "TRUE")
            {
                // scrivo valore 0 x il contapezzi
                try
                {
                    // contapezzi ATTUALE
                    if (!string.IsNullOrEmpty(getOptPar("PZCOUNT_MODE")))
                    {
                        // verifico quale modalità sia richiesta: STD (6711) oppure BIT (Custom, con indicazione area)
                        string memAddr = getOptPar("PZCOUNT_MODE");
                        if (memAddr.StartsWith("STD"))
                        {
                            // inizio verifica area memoria/parametro levando prima parte codice
                            memAddr = memAddr.Replace("STD.", "");
                            // var di appoggio
                            int cntAddr = 0;
                            // var contapezzi a zero....
                            object newVal = new object();
                            newVal = 0;
                            // verifico se si tratta di lettura parametro... formato tipo STD.PAR.6711
                            if (memAddr.StartsWith("PAR."))
                            {
                                // recupero parametro...
                                int.TryParse(memAddr.Replace("PAR.", ""), out cntAddr);
                                if (cntAddr == 0)
                                {
                                    cntAddr = 6711;
                                }

                                // processo RESET contapezzi (lavorati)
                                stopwatch.Restart();
                                FANUC_ref.F_RW_Param_Integer(true, cntAddr, 3, ref newVal);
                                if (utils.CRB("recTime"))
                                {
                                    TimingData.addResult(cIobConf.codIOB, string.Format("W{0}-PAR", 4), stopwatch.ElapsedTicks);
                                }
                            }
                            // altrimenti se legge da area memoria specifica leggo da li... formto tipo STD.D.1604.DW
                            else
                            {
                                memAddressFanuc areaCounter = new memAddressFanuc(memAddr);

                                if (isVerboseLog)
                                {
                                    lgInfo("[0] area memoria: {0}.{1}.{2}", areaCounter.mType, areaCounter.mPos, areaCounter.vType);
                                }
                                // leggo!
                                stopwatch.Restart();
                                // switch x tipo dati --> tipo lettura... e salvo ultimo conteggio rilevato
                                switch (areaCounter.vType)
                                {
                                    case "B":
                                        byte valB = 0;
                                        FANUC_ref.F_RW_Byte(true, areaCounter.mType, areaCounter.mPos, ref valB);
                                        newVal = valB;
                                        break;

                                    case "D":
                                        ushort valW = 0;
                                        FANUC_ref.F_RW_Word(true, areaCounter.mType, areaCounter.mPos, ref valW);
                                        newVal = valW;
                                        break;

                                    case "DW":
                                        uint valDW = 0;
                                        FANUC_ref.F_RW_DWord(true, areaCounter.mType, areaCounter.mPos, ref valDW);
                                        break;

                                    default:
                                        break;
                                }
                                if (utils.CRB("recTime"))
                                {
                                    TimingData.addResult(cIobConf.codIOB, string.Format("W-{0}.{1}.{2}", areaCounter.mType, areaCounter.mPos, areaCounter.vType), stopwatch.ElapsedTicks);
                                }
                            }
                            stopwatch.Stop();
                        }
                    }
                }
                catch (Exception exc)
                {
                    lgError(exc, "Errore in RESET contapezzi FANUC");
                    connectionOk = false;
                }
                answ = true;
            }
            return answ;
        }

        /// <summary>
        /// Override salvataggio valori in memoria...
        /// </summary>
        /// <param name="tipo">tipo di DUMP</param>
        public override void saveMemDump(dumpType tipo)
        {
            // se l'area ha una size > 0...
            if (areaD.arraySize > 0)
            {
                dump_MemArea(tipo, FANUC.MemType.D, areaD.startIdx, areaD.arraySize);
            }
            // se l'area ha una size > 0...
            if (areaR.arraySize > 0)
            {
                dump_MemArea(tipo, FANUC.MemType.R, areaR.startIdx, areaR.arraySize);
            }
            // se l'area ha una size > 0...
            if (areaX.arraySize > 0)
            {
                dump_MemArea(tipo, FANUC.MemType.X, areaX.startIdx, areaX.arraySize);
            }
            // se l'area ha una size > 0...
            if (areaY.arraySize > 0)
            {
                dump_MemArea(tipo, FANUC.MemType.Y, areaY.startIdx, areaY.arraySize);
            }
            // se l'area ha una size > 0...
            if (areaPAR.arraySize > 0)
            {
                dump_ParArea(tipo, areaPAR.startIdx, areaPAR.arraySize);
            }
        }

        /// <summary>
        /// Override connessione
        /// </summary>
        public override void tryConnect()
        {
            if (!connectionOk)
            {
                // controllo che il ping sia stato tentato almeno pingTestSec fa...
                if (DateTime.Now.Subtract(lastPING).TotalSeconds > utils.CRI("pingTestSec"))
                {
                    if (verboseLog || periodicLog)
                    {
                        lgInfo("FANUC: ConnKO - tryConnect");
                    }
                    // in primis salvo data ping...
                    lastPING = DateTime.Now;
                    // ora PING!!!
                    Ping pingSender = new Ping();
                    IPAddress address = IPAddress.Loopback;
                    IPAddress.TryParse(cIobConf.cncIpAddr, out address);
                    PingReply reply = pingSender.Send(address, 100);
                    // se passa il ping faccio il resto...
                    if (reply.Status == IPStatus.Success)
                    {
                        string szStatusConnection = "";
                        try
                        {
                            // ora provo connessione...
                            parentForm.commPlcActive = true;
                            FANUC_ref.Connect(ref szStatusConnection);
                            parentForm.commPlcActive = false;
                            lgInfo("szStatusConnection: " + szStatusConnection);
                            connectionOk = true;
                            // refresh stato allarmi!!!
                            if (connectionOk)
                            {
                                dtAvvioAdp = DateTime.Now;
                                if (adpRunning)
                                {
                                    lgInfo("Connessione OK");
                                }
                            }
                            else
                            {
                                lgError("Impossibile procedere, connessione mancante...");
                            }
                        }
                        catch (Exception exc)
                        {
                            lgFatal(string.Format("Errore nella connessione all'adapter FANUC: {0}{1}{2}", szStatusConnection, Environment.NewLine, exc));
                            connectionOk = false;
                            lgInfo(string.Format("Eccezione in TryConnect, Adapter NON running, pausa di {0} msec prima di ulteriori tentativi di riconnessione", utils.CRI("waitRecMSec")));
                        }
                    }
                    else
                    {
                        // loggo no risposta ping ...
                        connectionOk = false;
                        if (verboseLog || periodicLog)
                        {
                            lgInfo(string.Format("Attenzione: controllo PING fallito per IP {0} - {1}", cIobConf.cncIpAddr, reply.Status));
                        }
                    }
                }
            }
            // se non è ancora connesso faccio procesisng memoria caso disconnesso...
            if (!connectionOk)
            {
                // processo semafori ed invio...
                processMemoryDiscon();
            }
        }

        /// <summary>
        /// Override disconnessione
        /// </summary>
        public override void tryDisconnect()
        {
            if (connectionOk)
            {
                string szStatusConnection = "";
                try
                {
                    FANUC_ref.Disconnect(ref szStatusConnection);
                    connectionOk = false;
                    // resetto timing!
                    TimingData.resetData();
                    lgInfo(szStatusConnection);
                    lgInfo("Effettuata disconnessione adapter FANUC!");
                }
                catch (Exception exc)
                {
                    lgFatal(exc, "Errore nella disconnessione dall'adapter FANUC");
                }
            }
            else
            {
                lgError("IMPOSSIBILE effettuare disconnessione: Connessione non disponibile...");
            }
        }

        #endregion Public Methods
    }
}