using CMS_CORE_Library.Models;
using S7.Net;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.NetworkInformation;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Xml.Linq;
using static CMS_CORE_Library.Models.DataStructures;
using static CMS_CORE_Library.NcThermo;
using static CMS_CORE_Library.Nc.MEMORY_TYPE;
using static CMS_CORE_Library.S7Net.MEMORY_ADDRESS;
using static CMS_CORE_Library.Utils.Nc_Utils;
using static CMS_CORE_Library.Nc;

namespace CMS_CORE_Library.S7Net
{
    public class Nc_S7Net : NcThermo
    {

        #region costanti ed oggetti
        // Global Constants

        private const string NcNotFound = "Missing response";
        private const string NcNotFound2 = "networking error";
        private const string NcNotFound3 = "Nc not Connected";

        // Global Variables
        private static DateTime Last_Static_Read;

        private byte S7Language;
        private static string Cnc_name;
        private static string Cnc_SftVersion;
        private static string Cnc_SeriesNum;
        private static string Cms_MachNumber;
        private static string PlcFirmware_SerialNum;
        private static uint ConfChannelNo;
        private static string UnitOfMeasure;

        // Alarms data
        private static Dictionary<int, string> PlcMessages;

        private static ushort SelectedProcess = 1;

        private bool EnableAlarms;
        private bool EnableHeaters;
        private bool EnableModules;
        private bool EnableParameters;
        private bool EnableProd;

        private bool EnableAxes;


        // Dizionario parametri specifici per THERMO
        private static Dictionary<int, RecipeParam> ThermoParamList;
        private static Dictionary<int, ModuleBlock> ThermoModuleList;
        private static Dictionary<int, WarmerChannel> ThermoWarmChannels;
        private static ProdInfo ThermoProdInfo;
        private static ProdCycle ThermoProdCycle;

        // connessione S7
        private CpuType tipoCpu = CpuType.S71500;
        private short rack = 0;
        private short slot = 1;

        /// <summary>
        /// Oggetto PLC da ri-utilizzare...
        /// </summary>
        protected Plc currPLC;

        #endregion

        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

        #region Constructor & global methods

        ///<summary>
        ///Instantiate The NC-S7Net Class
        ///</summary>
        ///<param name = "IpAddress" > Remote Ip-Address of the Nc</param>
        ///<param name = "RemotePort" > Remote Port of the Nc</param>
        ///<param name="ConnectionTimeOut">Send/Recieve timeout connection [mS]</param>
        public Nc_S7Net(string IpAddress, ushort RemotePort, ushort ConnectionTimeOut)
        {
            initObjects(IpAddress, RemotePort, false, true, true, true, true, true);
        }
        /// <summary>
        /// Instantiate The NC-Siemens Class
        /// </summary>
        ///<param name = "IpAddress" > Remote Ip-Address of the Nc</param>
        ///<param name = "RemotePort" > Remote Port of the Nc</param>
        /// <param name="ConnectionTimeOut">Send/Recieve timeout connection [mS]</param>
        /// <param name="EnableAxes">Enable Axes Svc</param>
        /// <param name="EnableAlarms">Enable Alarms Svc</param>
        /// <param name="EnableHeaters">Enable Heaters Svc</param>
        /// <param name="EnableModules">Enable Modules Svc</param>
        /// <param name="EnableParameters">Enable Parameters Svc</param>
        /// <param name="EnableProd">Enable Prod Svc</param>
        public Nc_S7Net(string IpAddress, ushort RemotePort, ushort ConnectionTimeOut, bool EnableAxes, bool EnableAlarms, bool EnableHeaters, bool EnableModules, bool EnableParameters, bool EnableProd)
        {
            initObjects(IpAddress, RemotePort, EnableAxes, EnableAlarms, EnableHeaters, EnableModules, EnableParameters, EnableProd);
        }
        /// <summary>
        /// /Inizializzazione effettiva parametri classe
        /// </summary>
        /// <param name="IpAddress"></param>
        /// <param name="RemotePort"></param>
        /// <param name="EnableAxes"></param>
        /// <param name="EnableAlarms"></param>
        /// <param name="EnableHeaters"></param>
        /// <param name="EnableModules"></param>
        /// <param name="EnableParameters"></param>
        /// <param name="EnableProd"></param>
        private void initObjects(string IpAddress, ushort RemotePort, bool EnableAxes, bool EnableAlarms, bool EnableHeaters, bool EnableModules, bool EnableParameters, bool EnableProd)
        {
            // Setup options
            this.EnableAlarms = EnableAlarms;
            this.EnableAxes = EnableAxes;
            this.EnableHeaters = EnableHeaters;
            this.EnableModules = EnableModules;
            this.EnableParameters = EnableParameters;
            this.EnableProd = EnableProd;

            // Setup parametri
            Ip = IpAddress;
            Port = RemotePort;
            // mesasggi generici PLC
            PlcMessages = new Dictionary<int, string>();
            // Init dati specifici Themo
            ThermoParamList = new Dictionary<int, RecipeParam>();
            ThermoModuleList = new Dictionary<int, ModuleBlock>();
            ThermoWarmChannels = new Dictionary<int, WarmerChannel>();
            ThermoProdCycle = new ProdCycle();
            ThermoProdInfo = new ProdInfo();
        }
        /// <summary>
        /// Connessione al PLC
        /// </summary>
        /// <returns></returns>
        public override CmsError NC_Connect()
        {
            // Try to get information
            try
            {
                // Check if Siemens Environment is started
                CmsError cmsError = CheckS7Ping();
                if (cmsError.IsError())
                    return cmsError;

                // Check connection
                currPLC = new Plc(tipoCpu, this.Ip, this.rack, this.slot);
                currPLC.Open();
                if (currPLC.IsConnected)
                    Connected = true;

                // FARE TODO FIXME
                // Setup the alarms (with DB bitmap) --> PlcMessages

                if (this.EnableAlarms)
                {
                    // PlcMessages
#if false
                    SiemensAlarms = new Alarm[] { };
                    SiemensAlmSvc = new AlarmSvc(ConvertToSTEPLanguage(SiemensLanguage).ThreeLetterISOLanguageName);
                    SiemensAlmSvc.Subscribe(AlarmsChanged);
                    Infrastructure.SubscribeLanguageChanged(NcLanguageChanged); 
#endif
                }

            }
            catch (Exception ex)
            {
                return ManageException(ex);
            }

            return NO_ERROR;
        }
        /// <summary>
        /// Disconnect Method
        /// </summary>
        /// <returns></returns>
        public override CmsError NC_Disconnect()
        {
            // Set Connected to FALSE and close the sessions
            Connected = false;
            if (currPLC != null)
            {
                try
                {
                    currPLC.Close();
                }
                catch
                { }
            }
            return NO_ERROR;
        }
        /// <summary>
        /// Compilazione dizionario allarmi x lingua
        /// </summary>
        /// <param name="language"></param>
        /// <param name="messages"></param>
        /// <returns></returns>
        public override CmsError NC_GetTranslatedPlcMessages(string language, ref Dictionary<int, string> messages)
        {
            // FIXME TODO 
#if false
            string filePath;
            try
            {
                PlcMessages = new Dictionary<int, string>();
                CultureInfo cultureInfo = CultureInfo.CreateSpecificCulture(language);
                string langName = "";
                if (cultureInfo.IsNeutralCulture)
                    langName = cultureInfo.EnglishName;
                else
                    langName = cultureInfo.Parent.EnglishName;

                //Setup the Path
                filePath = PLC_MESSAGE_PATH + @"Messaggi_" + langName + @".txt";

                //Read From Files
                messages = File.ReadAllLines(filePath, Encoding.Default)
                    .Select(line => line.Split(','))
                    .Where(line => line.Count() == 2)
                    .ToDictionary(line => Convert.ToInt32(line[0]), line => line[1].Trim());

                return NO_ERROR;
            }
            catch (Exception ex)
            {
                return ManageException(ex);
            }
#endif
            return FUNCTION_NOT_ALLOWED_ERROR;
        }
        /// <summary>
        /// Elenco lingue disponibili
        /// </summary>
        /// <param name="languages"></param>
        /// <returns></returns>
        public override CmsError NC_GetAvailableLanguages(ref ICollection<CultureInfo> languages)
        {
            // FIXME TODO 
#if false
            try
            {
                foreach (string file in Directory.GetFiles(PLC_MESSAGES_FILE_PATH))
                {
                    if (Path.GetExtension(file) == ".ts")
                    {
                        string fileName = Path.GetFileNameWithoutExtension(file);

                        var splittedFileName = fileName.Split('_');
                        if (splittedFileName.Count() == 2)
                        {
                            if (splittedFileName[0].ToLower() == "cmsalarm")
                            {
                                // Get lang from threeletter
                                var lang = GetCultureFromThreeLetter(splittedFileName[1]);

                                if (lang != null)
                                    languages.Add(lang);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                return ManageException(ex);
            } 
#endif

            var lang = GetCultureFromThreeLetter("eng");
            if (lang != null)
                languages.Add(lang);
            lang = GetCultureFromThreeLetter("ita");
            if (lang != null)
                languages.Add(lang);

            return NO_ERROR;
        }

        #endregion Contructor & global methods

        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

        #region High level methods

        /// <summary>
        /// Get the processes-count configurated
        /// </summary>
        /// <param name="ProcNumber"></param>
        /// <returns></returns>
        public override CmsError NC_RProcessesNum(ref ushort ProcNumber)
        {
            CmsError cmsError = ReadStaticNCData();
            if (cmsError.IsError())
                return cmsError;

            ProcNumber = (ushort)ConfChannelNo;

            return NO_ERROR;
        }

        /// <summary>
        /// Get the NC model Name
        /// </summary>
        /// <param name="ModelName"></param>
        /// <returns></returns>
        public override CmsError NC_RModelName(ref string ModelName)
        {
            CmsError cmsError = ReadStaticNCData();
            if (cmsError.IsError())
                return cmsError;

            ModelName = Cnc_name;

            return NO_ERROR;
        }

        /// <summary>
        /// Get the NC Software Version
        /// </summary>
        /// <param name="SWV"></param>
        /// <returns></returns>
        public override CmsError NC_RSoftwareVersion(ref string SWV)
        {
            CmsError cmsError = ReadStaticNCData();
            if (cmsError.IsError())
                return cmsError;

            SWV = Cnc_SftVersion;

            return NO_ERROR;
        }

        /// <summary>
        /// Get the NC Language
        /// </summary>
        /// <param name="Language"></param>
        /// <returns></returns>
        public override CmsError NC_RLanguage(ref CultureInfo Language)
        {
            // Read static data
            CmsError cmsError = ReadStaticNCData();
            if (cmsError.IsError())
                return cmsError;

            Language = ConvertToSTEPLanguage(S7Language);

            return NO_ERROR;
        }

        /// <summary>
        /// Set the NC Language
        /// </summary>
        /// <param name="Language"></param>
        /// <returns></returns>
        public override CmsError NC_WLanguage(CultureInfo Language)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        /// <summary>
        /// Get the NC Serial number
        /// </summary>
        /// <param name="serialNumber"></param>
        /// <returns></returns>
        public override CmsError NC_RSerialNumber(ref string serialNumber)
        {
            CmsError cmsError = ReadStaticNCData();
            if (cmsError.IsError())
                return cmsError;

            serialNumber = Cnc_SeriesNum;

            return NO_ERROR;
        }

        /// <summary>
        /// Get CMS Machine number
        /// </summary>
        /// <param name="hasLetters"></param>
        /// <param name="MachNumber"></param>
        /// <returns></returns>
        public override CmsError NC_RMachineNumber(bool hasLetters, ref string MachNumber)
        {
            if (!hasLetters)
            {
                CmsError cmsError = ReadStaticNCData();
                if (cmsError.IsError())
                    return cmsError;

                MachNumber = Cms_MachNumber;
            }
            else
            {
                // New method to read machine number
                List<byte> lists = new List<byte>();
                CmsError cmsError = MEM_RWByteList(R, 0, NEW_MATR_MACC.MemType, NEW_MATR_MACC.Address, NEW_MATR_MACC.SubAddress, 0, 4, ref lists);
                if (cmsError.IsError())
                    return cmsError;

                lists.Reverse();

                MachNumber = Encoding.ASCII.GetString(lists.ToArray());
            }

            return NO_ERROR;
        }

        /// <summary>
        /// Get the Date-Time of the NC
        /// </summary>
        /// <param name="ActualTime"></param>
        /// <returns></returns>
        public override CmsError NC_RDateTime(ref DateTime ActualTime)
        {
            ActualTime = DateTime.Now;
            return NO_ERROR;
        }

        /// <summary>
        /// Check if the NC is in running state
        /// </summary>
        /// <param name="running"></param>
        /// <returns></returns>
        public override CmsError NC_RIsRunning(ref bool running)
        {
            ushort nProcess = 0;
            // Get the number of processes
            CmsError cmsError = NC_RProcessesNum(ref nProcess);
            if (cmsError.IsError())
                return cmsError;

            ushort i = 1;
            running = false;
            do
            {
                PROC_STATUS procStatus = PROC_STATUS.IDLE;

                // Read process status
                cmsError = PROC_RStatus(i, ref procStatus);
                if (cmsError.IsError())
                    return cmsError;

                if (procStatus == PROC_STATUS.RUN)
                    running = true;
                i++;
            } while (!running || i <= nProcess);

            return NO_ERROR;
        }

        /// <summary>
        /// Get NC unit of measure
        /// </summary>
        /// <param name="unitOfMeasure"></param>
        /// <returns></returns>
        public override CmsError NC_RUnitOfMeasure(ref string unitOfMeasure)
        {
            CmsError cmsError = ReadStaticNCData();
            if (cmsError.IsError())
                return cmsError;

            unitOfMeasure = UnitOfMeasure;

            return NO_ERROR;
        }

        /// <summary>
        /// Get the Nc Active Alarms
        /// </summary>
        /// <param name="alarms"></param>
        /// <returns></returns>
        public override CmsError NC_RActiveAlarms(ref List<AlarmModel> alarms)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        /// <summary>
        /// Set the Nc Active Page of the NC
        /// </summary>
        /// <param name="screen"></param>
        /// <returns></returns>
        public override CmsError NC_SetScreenVisible(SCREEN_PAGE screen)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError NC_WMDICommand(int processId, string mdiString)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        #endregion High level methods

        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

        #region PLC High-level data

        public override CmsError PLC_RWManageWatchdog()
        {
            bool plcWatchdog = false;
            CmsError cmsError = MEM_RWBoolean(R, 0, NC_WATCHDOG.MemType, NC_WATCHDOG.Address, NC_WATCHDOG.SubAddress, 0, ref plcWatchdog);
            if (cmsError.IsError())
                return cmsError;

            if (plcWatchdog)
                return PLC_NOT_RUNNING_ERROR;

            plcWatchdog = true;
            return MEM_RWBoolean(W, 0, NC_WATCHDOG.MemType, NC_WATCHDOG.Address, NC_WATCHDOG.SubAddress, 0, ref plcWatchdog);
        }
        /// <summary>
        /// Active message list
        /// </summary>
        /// <param name="alarms"></param>
        /// <returns></returns>
        public override CmsError PLC_RActiveMessages(ref List<PlcAlarmModel> alarms)
        {
            // FIXME TODO controllare
            bool[] statusBits;
            int i = 0;
            List<int> readValues = new List<int>();
            CmsError cmsError;
            try
            {
                alarms.Clear();

                // Read on data from memory
                cmsError = MEM_RWIntegerList(R, 0,
                    ALARMS_STATUS.MemType,
                    ALARMS_STATUS.Address,
                    ALARMS_STATUS.SubAddress,
                    (ALARMS_STATUS.Size / 4) + (ALARMS_DATA.Size / 2), // status_bytes / 4 + data_word / 2
                    ref readValues);

                if (cmsError.IsError())
                    return cmsError;

                alarms.Clear();

                // Convert integer array into bit array
                statusBits = IntToBits(readValues.ToArray());

                for (i = 0; i < ALARMS_STATUS.Size * 8; i++)
                {
                    // If alarm is active
                    if (statusBits[i])
                    {
                        // Calculate matching alarm byte info address
                        int dataByteAddress = (i * 16) + ALARMS_NUMBER;

                        var processList = new List<int>();

                        // Get processes on which alarm is active
                        for (int j = dataByteAddress; j < dataByteAddress + 6; j++)
                        {
                            if (statusBits[j])
                                processList.Add(j + 1 - dataByteAddress);
                        }
                        // Add alarm info into active alarms list
                        alarms.Add(new PlcAlarmModel()
                        {
                            Id = (uint)i + 1,
                            IsWarning = statusBits[dataByteAddress + 7],
                            RestorationIsActive = statusBits[dataByteAddress + 6],
                            Process = processList
                        });
                    }
                }
            }
            catch (Exception ex)
            {
                return ManageException(ex);
            }

            return NO_ERROR;
        }

        public override CmsError PLC_WRestoreMessage(uint id)
        {
            // Check id range
            if (id > ALARMS_NUMBER)
                return INCORRECT_PARAMETERS_ERROR;

            // Call restore message
            CmsError cmsError = PLC_WStrobe(ALARM_ACK, ALARM_RESTORATION_STROBE, id);
            if (cmsError.IsError())
                return cmsError;

            return NO_ERROR;
        }

        public override CmsError PLC_WRefreshMessage(uint id)
        {
            // Check id range
            if (id > ALARMS_NUMBER)
                return INCORRECT_PARAMETERS_ERROR;

            // Call restore message
            CmsError cmsError = PLC_WStrobe(ALARM_ACK, ALARM_REFRESH_STROBE, id);
            if (cmsError.IsError())
                return cmsError;

            return NO_ERROR;
        }

        public override CmsError PLC_WRefreshAllMessages()
        {
            return PLC_WNcSoftKey(REFRESH_ALL_ALARMS_SFKEY_INDEX);
        }

        public override CmsError PLC_RPowerOnData(ref PreAndPostPowerOnModel powerOnModel)
        {
            int readValue = 0;
            // Read pre power on and post power on data from memory
            CmsError cmsError = MEM_RWInteger(R, 0, PRE_POST_POWER_ON.MemType, PRE_POST_POWER_ON.Address, PRE_POST_POWER_ON.SubAddress, ref readValue);
            if (cmsError.IsError())
                return cmsError;

            bool[] bits = new bool[32];

            // Convert int into to true/false array
            bits = IntToBits(readValue);
            // Create adn set pre power on object
            PrePowerOnModel prePowerOn = new PrePowerOnModel()
            {
                PowerOn = new PowerOnDataModel() { Id = 1, Active = bits[0], Clickable = bits[16] }, // id = N, bits = N, Clickable = N + 8 (Second bit)
                AirPressure = new PowerOnDataModel() { Id = 2, Active = bits[1], Clickable = bits[17] },
                ProtectionStatus = new PowerOnDataModel() { Id = 3, Active = bits[2], Clickable = bits[18] },
                EmergencyButtons = new PowerOnDataModel() { Id = 4, Active = bits[3], Clickable = bits[19] },
                SettingMode = new PowerOnDataModel() { Id = 5, Active = bits[4], Clickable = bits[20] },
                StartingKey = new PowerOnDataModel() { Id = 6, Active = bits[5], Clickable = bits[21] }
            };

            // Create and set post power on object
            PostPowerOnModel postPowerOn = new PostPowerOnModel()
            {
                AxisReset = new PowerOnDataModel() { Id = 9, Active = bits[8], Clickable = bits[24] }, // id = N - 8, bits = N, Clickable = N + 8 (Second bit)
                WaterjetPump = new PowerOnDataModel() { Id = 10, Active = bits[9], Clickable = bits[25] }
            };

            powerOnModel = new PreAndPostPowerOnModel()
            {
                PostPowerOn = postPowerOn,
                PrePowerOn = prePowerOn
            };

            return NO_ERROR;
        }

        public override CmsError PLC_WPowerOnData(uint id, bool value)
        {
            // Check bit range
            if (id > 16)
                return INCORRECT_PARAMETERS_ERROR;

            // Call restore message
            CmsError cmsError = PLC_WStrobe(PRE_POST_POWER_ON_ACK, PRE_POST_POWER_ON_CLICKED, id);
            if (cmsError.IsError())
                return cmsError;

            return NO_ERROR;
        }

        public override CmsError PLC_RFunctionAccess(ref List<FunctionalityModel> functions)
        {
            List<int> readValues = new List<int>();
            int numberOfIntegers = FUNCTION_ACCESS.Size / 4;
            // Read functions access data from memory
            CmsError cmsError = MEM_RWIntegerList(R, 0, FUNCTION_ACCESS.MemType, FUNCTION_ACCESS.Address, FUNCTION_ACCESS.SubAddress, numberOfIntegers, ref readValues);
            if (cmsError.IsError())
                return cmsError;

            functions = new List<FunctionalityModel>();
            // Convert int into to true/false array
            bool[] bits = IntToBits(readValues.ToArray());
            // Convert array into structured data
            for (int i = 0; i < bits.Count(); i++)
            {
                functions.Add(new FunctionalityModel()
                {
                    Id = (uint)i + 1,
                    IsActive = bits[i]
                });
            }

            return NO_ERROR;
        }

        public override CmsError PLC_RAxesResetData(ref AxisResetDataModel axisResetData)
        {
            byte value = 0;
            // Read byte from memory
            CmsError cmsError = MEM_RWByte(R, 0, AXIS_RESET_PROCEDURE.MemType, AXIS_RESET_PROCEDURE.Address, AXIS_RESET_PROCEDURE.SubAddress, 0, ref value);
            if (cmsError.IsError())
                return cmsError;

            // Check last bit if is active
            if ((value & 128) == 128)
            {
                // Set to 0 last bit( isActive bit x - 128 )
                // From 0 to 6 bit represents percentage
                // If higher than 100 then value = 100
                byte percentage = value - 128 > 100 ? (byte)100 : (byte)(value - 128);
                axisResetData = new AxisResetDataModel()
                {
                    IsActive = true,
                    Percentage = percentage
                };
            }

            return NO_ERROR;
        }

        public override CmsError PLC_RNcSoftKeys(ref List<SoftKeysModel> ncSoftKeys)
        {
            CmsError cmsError = PLC_RSoftKeys(NC_SOFTKEYS_VALUE, NC_SOFTKEYS_CLICKABLE, ref ncSoftKeys);
            if (cmsError.IsError())
                return cmsError;

            return NO_ERROR;
        }

        public override CmsError PLC_RUserSoftKeys(ref List<SoftKeysModel> softKeys)
        {
            CmsError cmsError = PLC_RSoftKeys(USER_SOFTKEYS_VALUE, USER_SOFTKEYS_CLICKABLE, ref softKeys);
            if (cmsError.IsError())
                return cmsError;

            return NO_ERROR;
        }

        private CmsError PLC_RSoftKeys(MEMORY_CELL softKeyStatusMemory, MEMORY_CELL softKeysClickableMemory, ref List<SoftKeysModel> softKeys)
        {
            softKeys = new List<SoftKeysModel>();
            List<int> readValues = new List<int>();

            int memorySizeToRead = (softKeyStatusMemory.Size + softKeysClickableMemory.Size);
            // Offset between status and clickable data
            int offset = softKeyStatusMemory.Size * 8;

            // Read  on data from memory
            CmsError cmsError = MEM_RWIntegerList(R, 0,
                softKeyStatusMemory.MemType,
                softKeyStatusMemory.Address,
                softKeyStatusMemory.SubAddress,
                memorySizeToRead / 4,
                ref readValues);

            if (cmsError.IsError())
                return cmsError;
            // Convert ints into an array of bools
            bool[] bits = IntToBits(readValues.ToArray());

            // Convert array into structured data
            for (ushort i = 0; i < bits.Count() / 2; i++)
            {
                softKeys.Add(new SoftKeysModel()
                {
                    Id = (uint)i + 1,
                    Value = bits[i],
                    Active = bits[i + offset]
                });
            }

            return NO_ERROR;
        }

        public override CmsError PLC_WNcSoftKey(uint id)
        {
            // Check id range
            if (id > NC_SOFTKEYS_NUMBER)
                return INCORRECT_PARAMETERS_ERROR;

            // Write strobe into memory
            CmsError cmsError = PLC_WStrobe(NC_SOFT_KEYS_ACK, NC_SOFT_KEYS_CLICKED, id);
            if (cmsError.IsError())
                return cmsError;

            return NO_ERROR;
        }

        public override CmsError PLC_WUserSoftKey(uint id)
        {
            // Check id range
            if (id > USER_SOFTKEYS_NUMBER)
                return INCORRECT_PARAMETERS_ERROR;

            // Write strobe into memory
            CmsError cmsError = PLC_WStrobe(USER_SOFT_KEYS_ACK, USER_SOFT_KEYS_CLICKED, id);
            if (cmsError.IsError())
                return cmsError;

            return NO_ERROR;
        }

        public override CmsError PLC_RHeadsData(List<HeadDataModel> heads, int number)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError PLC_RWorkedTimeHead(int head, ref uint time)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError PLC_WResetWorkedTimeHead(int head)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError PLC_RWorkedTimeMachine(ref uint time)
        {
            // Read Worked time 
            CmsError cmsError = MEM_RWDWord(R, 0, MACHINE_WORKED_TIME.MemType, MACHINE_WORKED_TIME.Address, MACHINE_WORKED_TIME.SubAddress, ref time);
            if (cmsError.IsError())
                return cmsError;

            return NO_ERROR;
        }

        public override CmsError PLC_WResetWorkedTimeMachine(uint time)
        {
            uint actTime = 0;

            // Read actual Value
            CmsError cmsError = MEM_RWDWord(R, 0, MACHINE_WORKED_TIME.MemType, MACHINE_WORKED_TIME.Address, MACHINE_WORKED_TIME.SubAddress, ref actTime);
            if (cmsError.IsError())
                return cmsError;

            // Per richiedere l'azzeramento del timer invio 4 volte il segnale velocemente al PLC
            // Il PLC resetta il bit e aspetta quello successivo entro 500ms, se no abortisce
            // Sfrutto così la velocità dei sw, cosa che un "nemico" a mano se provasse a forzare il bit non avrebbe
            bool bitValue = true;
            int nTry = 0;

            for (int i = 0; i <= 4; i++)
            {
                //Scrivo il bit
                bitValue = true;
                nTry = 0;
                cmsError = MEM_RWBoolean(W, 0, MACHINE_RESET_WORKED_TIME.MemType, MACHINE_RESET_WORKED_TIME.Address, MACHINE_RESET_WORKED_TIME.SubAddress, 0, ref bitValue);
                if (cmsError.IsError())
                    return cmsError;

                //Aspetto che venga abbassato
                do
                {
                    Thread.Sleep(50);
                    nTry += 1;
                    cmsError = MEM_RWBoolean(R, 0, MACHINE_RESET_WORKED_TIME.MemType, MACHINE_RESET_WORKED_TIME.Address, MACHINE_RESET_WORKED_TIME.SubAddress, 0, ref bitValue);
                    if (cmsError.IsError())
                        return cmsError;

                } while (bitValue && nTry <= 10);

                //se il valore è rimasto a 1 il plc non l'ha preso in carico, e abortisco
                if (bitValue)
                {
                    bitValue = true;
                    cmsError = MEM_RWBoolean(W, 0, MACHINE_RESET_WORKED_TIME.MemType, MACHINE_RESET_WORKED_TIME.Address, MACHINE_RESET_WORKED_TIME.SubAddress, 0, ref bitValue);
                    if (cmsError.IsError())
                        return cmsError;

                    return PLC_NOT_RUNNING_ERROR;
                }
                else
                {
                    //Se l'ha abbassato scrivo il nuovo dato
                    cmsError = MEM_RWDWord(W, 0, MACHINE_WORKED_TIME.MemType, MACHINE_WORKED_TIME.Address, MACHINE_WORKED_TIME.SubAddress, ref time);
                }

            }

            return NO_ERROR;
        }

        public override CmsError PLC_WHeadOverride(uint id, HEAD_OVERRIDE_SIGN sign)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        // MACHINE COUNTERS
        public override CmsError PLC_RMachineCounters(ref List<CounterModel> counters)
        {
            List<uint> val = new List<uint>();
            // Read ints
            CmsError cmsError = MEM_RWDWordList(R, 0, COUNTERS_DATA.MemType, COUNTERS_DATA.Address, COUNTERS_DATA.SubAddress, COUNTERS_DATA.Size / 4, ref val);
            if (cmsError.IsError())
                return cmsError;

            // Set return value
            uint i = 0;
            counters = val.Select(x => new CounterModel()
            {
                Id = i++,
                Value = x
            })
            .ToList();

            return NO_ERROR;
        }

        public override CmsError PLC_WResetMachineCounters(uint counter)
        {
            bool isResettable = false;
            CmsError cmsError = MEM_RWBoolean(R, 0, COUNTER_IS_RESETTABLE.MemType, COUNTER_IS_RESETTABLE.Address, COUNTER_IS_RESETTABLE.SubAddress, (int)(counter - 1), ref isResettable);
            if (cmsError.IsError())
                return cmsError;

            if (!isResettable)
                return FUNCTION_NOT_ALLOWED_ERROR;

            cmsError = PLC_WStrobe(COUNTER_IS_RESETTABLE_ACK, COUNTER_IS_RESETTABLE_STROBE, counter);
            if (cmsError.IsError())
                return cmsError;

            return NO_ERROR;
        }

        public override CmsError PLC_ROperatorInputIsNeeded(ref List<M155InputIsNeededModel> value)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError PLC_WOperatorInputResponse(int process, double responseVal)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError PLC_RM154Data(ref List<M154DataModel> data, ref bool MTCOnOff)
        {
            MTCOnOff = false;
            CmsError cmsError = MEM_RWBoolean(R, 0, M154_SWITCH_ONOFF.MemType, M154_SWITCH_ONOFF.Address, M154_SWITCH_ONOFF.SubAddress, 1, ref MTCOnOff);

            if (cmsError.IsError())
                return cmsError;

            byte val = 0;
            cmsError = MEM_RWByte(R, 0, M154_STROBE.MemType, M154_STROBE.Address, M154_STROBE.SubAddress, 0, ref val);
            if (cmsError.IsError())
                return cmsError;

            // Convert a byte to an array of booleans
            bool[] bits = ByteToBits(val);
            string[] parameters;
            string tmpStr = "";

            for (uint processId = 1; processId <= MAX_PROCESS_NUMBER; processId++)
            {
                if (bits[processId - 1])
                {
                    // Read active program line
                    cmsError = PROC_ReadActiveLine(processId, ref tmpStr);
                    if (cmsError.IsError())
                        return cmsError;

                    // Parse parameters
                    parameters = ExtractM154ParametersFromNcCodeLine(tmpStr);
                    data.Add(new M154DataModel()
                    {
                        Process = processId,
                        IsNeeded = bits[processId - 1],
                        Parameters = parameters
                    });
                }
            }

            return NO_ERROR;
        }

        public override CmsError PLC_W154ManageAck(int processId)
        {
            return PLC_ManageActiveAck(M154_STROBE.Address, M154_STROBE.SubAddress, processId - 1, M154_ACK.Address, M154_ACK.SubAddress, processId - 1, M154_STROBE.MemType);
        }


        public override CmsError PLC_RM156Data(ref List<M156InputIsNeededModel> value)
        {
            byte val = 0;
            List<byte> vals = new List<byte>();
            CmsError cmsError = MEM_RWByte(R, 0, M156_INPUT_NEEDED.MemType, M156_INPUT_NEEDED.Address, M156_INPUT_NEEDED.SubAddress, 0, ref val);
            if (cmsError.IsError())
                return cmsError;

            cmsError = MEM_RWByteList(R, 0, M156_INPUT_ID_LIST.MemType, M156_INPUT_ID_LIST.Address, M156_INPUT_ID_LIST.SubAddress, 0, M156_INPUT_ID_LIST.Size, ref vals);
            if (cmsError.IsError())
                return cmsError;

            bool[] bits = ByteToBits(val);

            for (int processId = 1; processId <= MAX_PROCESS_NUMBER; processId++)
            {
                if (bits[processId - 1])
                {
#if false
                    Item item = new Item()
                    {
                        Path = string.Format("/channel/parameter/r[c{0} , 154]", processId),
                    };
                    try
                    {
                        DataSvc dataSvc = new DataSvc();
                        dataSvc.Read(item);
                    }
                    catch (Exception ex)
                    {
                        return ManageException(ex);
                    }

                    // Parse line & get parameters
                    value.Add(new M156InputIsNeededModel()
                    {
                        Process = (uint)processId,
                        Id = vals.ElementAt(processId - 1),
                        Value = Convert.ToDouble(item.Value)
                    }); 
#endif
                }
            }

            return NO_ERROR;
        }

        public override CmsError PLC_WM156Response(int process, double responseVal)
        {
            //CmsError cmsError = MEM_RWDouble(W, 0, MEMORY_TYPE.Osai_GD, 900 + (process - 1), ref responseVal);
            //if (cmsError.IsError())
            //    return cmsError;

            return PLC_WStrobe(M156_INPUT_ACK, M156_INPUT_STROBE, (uint)process);
        }

        public override CmsError PLC_RScadaValue(string memIndex, SCADA_MEM_TYPE memType, ref object value)
        {
            if (memType == SCADA_MEM_TYPE.BOOL)
            {
                if (memIndex.ToUpper() == "FALSE")
                {
                    value = false;
                    return NO_ERROR;
                }
                else if (memIndex.ToUpper() == "TRUE")
                {
                    value = true;
                    return NO_ERROR;
                }
            }

            string[] index = memIndex.Split('.');
            CmsError cmsError = NO_ERROR;
            try
            {
                if (index.Count() == 0 || index.Count() == 1)
                    return INCORRECT_PARAMETERS_ERROR;
                else if (index.Count() == 2)
                {
                    if (memType == SCADA_MEM_TYPE.INT)
                    {
                        // read INT
                        int val = 0;
                        cmsError = MEM_RWInteger(R, 0, MEMORY_TYPE.Siemens_DB, Convert.ToInt32(index[0]), Convert.ToInt32(index[1]), ref val);

                        value = val;
                    }
                    else if (memType == SCADA_MEM_TYPE.WORD)
                    {   // read WORD
                        short val = 0;
                        cmsError = MEM_RWShort(R, 0, MEMORY_TYPE.Siemens_DB, Convert.ToInt32(index[0]), Convert.ToInt32(index[1]), ref val);

                        value = val;
                    }
                    else if (memType == SCADA_MEM_TYPE.REAL)
                    {   // read DOUBLE
                        double val = 0;
                        cmsError = MEM_RWDouble(R, 0, MEMORY_TYPE.Siemens_DB, Convert.ToInt32(index[0]), Convert.ToInt32(index[1]), ref val);

                        value = val;
                    }
                    else
                    {   // read BYTE
                        byte val = 0;
                        cmsError = MEM_RWByte(R, 0, MEMORY_TYPE.Siemens_DB, Convert.ToInt32(index[0]), Convert.ToInt32(index[1]), 0, ref val);

                        value = val;
                    }
                }
                else if (index.Count() == 3 && memType == SCADA_MEM_TYPE.BOOL)
                {   // read BOOL
                    bool val = false;
                    cmsError = MEM_RWBoolean(R, 0, MEMORY_TYPE.Siemens_DB, Convert.ToInt32(index[0]), Convert.ToInt32(index[1]), Convert.ToInt32(index[2]), ref val);

                    value = val;
                }
            }
            catch (Exception ex)
            {
                return ManageException(ex);
            }

            return cmsError;
        }

        public override CmsError PLC_RScadaSiemens(ref List<ScadaObjectModel> objects)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError PLC_WScadaValue(string memIndex, SCADA_MEM_TYPE memType, object value)
        {
            string[] index = memIndex.Split('.');
            CmsError cmsError = NO_ERROR;
            if (index.Count() == 0)
                return INCORRECT_PARAMETERS_ERROR;

            else if (index.Count() == 2)
            {
                if (memType == SCADA_MEM_TYPE.INT)
                {
                    // write INT
                    int val = Convert.ToInt32(value);
                    cmsError = MEM_RWInteger(W, 0, MEMORY_TYPE.Siemens_DB, Convert.ToInt32(index[0]), Convert.ToInt32(index[1]), ref val);
                }
                else if (memType == SCADA_MEM_TYPE.WORD)
                {   // write WORD
                    short val = Convert.ToInt16(value);
                    cmsError = MEM_RWShort(W, 0, MEMORY_TYPE.Siemens_DB, Convert.ToInt32(index[0]), Convert.ToInt32(index[1]), ref val);
                }
                else if (memType == SCADA_MEM_TYPE.REAL)
                {   // write DOUBLE
                    double val = Convert.ToDouble(value);
                    cmsError = MEM_RWDouble(W, 0, MEMORY_TYPE.Siemens_DB, Convert.ToInt32(index[0]), Convert.ToInt32(index[1]), ref val);
                }
                else
                {   // write byte
                    byte val = Convert.ToByte(value);
                    cmsError = MEM_RWByte(W, 0, MEMORY_TYPE.Siemens_DB, Convert.ToInt32(index[0]), Convert.ToInt32(index[1]), 0, ref val);
                }
            }
            else if (index.Count() == 3 && memType == SCADA_MEM_TYPE.BOOL)
            {   // write BOOL
                bool val = Convert.ToBoolean(value);
                cmsError = MEM_RWBoolean(W, 0, MEMORY_TYPE.Siemens_DB, Convert.ToInt32(index[0]), Convert.ToInt32(index[1]), Convert.ToInt32(index[2]), ref val);
            }

            return cmsError;
        }

        public override CmsError PLC_WAssistedToolingCmd(ushort toolId, ushort familyId, ushort shankId, ushort magazineId, ushort positionId, ASSISTED_TOOLING_ACTION action)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError PLC_RAssistedToolingData(ref AssistedToolingModel data)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError PLC_WTerminateAssistedToolingProcedure()
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        private CmsError PLC_WStrobe(MEMORY_CELL ackCell, MEMORY_CELL strobeCell, uint id)
        {
            CmsError cmsError;
            bool readValue = false;
            bool writeValue = true;

            SetupAckStrobeAddresses(ackCell.SubAddress, strobeCell.SubAddress, id, out int ackByte, out int strobeByte, out int alarmBitId);

            // Check Strobe
            cmsError = MEM_RWBoolean(R, 0, strobeCell.MemType, strobeCell.Address, strobeByte, alarmBitId, ref readValue);
            if (cmsError.IsError())
                return cmsError;

            // If PLC it's performing another request then return
            if (readValue)
                return NO_ERROR;

            // Check ACK
            cmsError = MEM_RWBoolean(R, 0, ackCell.MemType, ackCell.Address, ackByte, alarmBitId, ref readValue);
            if (cmsError.IsError())
                return cmsError;

            // If PLC it's performing another request then return
            if (readValue)
                return NO_ERROR;

            // Write strobe into memory
            cmsError = MEM_RWBoolean(W, 0, strobeCell.MemType, strobeCell.Address, strobeByte, alarmBitId, ref writeValue);
            if (cmsError.IsError())
                return cmsError;

            // Reset wait ack = 1 and reset the strobe
            cmsError = ResetStrobe(alarmBitId, strobeByte, ackByte, ackCell.MemType);
            if (cmsError.IsError())
                return cmsError;

            return NO_ERROR;
        }

        private void SetupAckStrobeAddresses(int ackAddress, int strobeAddress, uint id, out int ackByte, out int strobeByte, out int bit)
        {
            ackByte = ackAddress + (((int)id - 1) / 8);
            strobeByte = strobeAddress + (((int)id - 1) / 8);
            bit = (((int)id - 1) % 8);
        }

        private CmsError ResetStrobe(int bitId, int strobeByte, int ackByte, MEMORY_TYPE memType)
        {
            int n = 600;
            bool readValue = false;
            bool writeValue = false;
            bool ok = false;

            CmsError cmsError;
            do
            {
                // Check ACK
                cmsError = MEM_RWBoolean(R, 0, memType, TABLE, ackByte, bitId, ref readValue);
                if (cmsError.IsError())
                    return cmsError;

                // If true reset strobe
                if (readValue == true)
                {
                    // Reset strobe
                    cmsError = MEM_RWBoolean(W, 0, memType, TABLE, strobeByte, bitId, ref writeValue);
                    if (cmsError.IsError())
                        return cmsError;
                    // Exit from cycle
                    n = 0;
                    ok = true;
                }
                else
                {
                    // Decrement
                    n--;
                    // Wait befor next cycle
                    Thread.Sleep(20);
                }
            } while (n > 0);

            if (!ok)
            {
                // Reset strobe
                cmsError = MEM_RWBoolean(W, 0, memType, TABLE, strobeByte, bitId, ref writeValue);
                if (cmsError.IsError())
                    return cmsError;
            }

            return cmsError;
        }

        private CmsError PLC_ManageActiveAck(int strobeByte, int strobeSubByte, int strobeBit, int ackByte, int ackSubByte, int ackBit, MEMORY_TYPE memType)
        {
            int n = 1200; // 30 seconds
            bool readValue = false;
            bool writeValue = true;
            bool ok = false;
            // Set ack to 1
            CmsError cmsError = MEM_RWBoolean(W, 0, memType, ackByte, ackSubByte, ackBit, ref writeValue);
            if (cmsError.IsError())
                return cmsError;

            do
            {
                // Check strobe
                cmsError = MEM_RWBoolean(R, 0, memType, strobeByte, strobeSubByte, strobeBit, ref readValue);
                if (cmsError.IsError())
                    return cmsError;

                // If true reset acknowledge
                if (!readValue)
                {
                    writeValue = false;
                    // Reset acknowledge
                    cmsError = MEM_RWBoolean(W, 0, memType, ackByte, ackSubByte, ackBit, ref writeValue);
                    if (cmsError.IsError())
                        return cmsError;
                    // Exit from cycle
                    n = 0;
                    ok = true;
                }
                else
                {
                    // Decrement
                    n--;
                    // Wait befor next cycle
                    Thread.Sleep(25);
                }
            } while (n > 0);

            // If loop timeout goes in timeout
            if (!ok)
            {
                // Reset acknowledge
                writeValue = false;
                cmsError = MEM_RWBoolean(W, 0, memType, ackByte, ackSubByte, ackBit, ref writeValue);
                if (cmsError.IsError())
                    return cmsError;
            }

            return cmsError;
        }

        public override CmsError PLC_WExpiredCandy(bool value)
        {
            bool newVal = false;

            //Scrivo il dato
            CmsError cmsError = MEM_RWBoolean(W, 0, EXP_CANDY_MEM.MemType, EXP_CANDY_MEM.Address, EXP_CANDY_MEM.SubAddress, 5, ref value);
            if (cmsError.IsError())
                return cmsError;
            else
            {
                //Leggo il dato
                cmsError = PLC_RExpiredCandy(ref newVal);
                if (cmsError.IsError())
                    return cmsError;

                //Se i 2 dati coincidono ritorno OK
                if (value == newVal)
                    return NO_ERROR;
                else
                    return PLC_NOT_RUNNING_ERROR;

            }
        }

        public override CmsError PLC_RExpiredCandy(ref bool value)
        {
            CmsError cmsError = MEM_RWBoolean(R, 0, EXP_CANDY_MEM.MemType, EXP_CANDY_MEM.Address, EXP_CANDY_MEM.SubAddress, 5, ref value);
            if (cmsError.IsError())
                return cmsError;
            return NO_ERROR;
        }

        public override CmsError PLC_WCandy(long value)
        {
            // Long is formed by a integer + word
            // Write Word
            ushort word = (ushort)((value & 0xFFFF));
            CmsError cmsError = MEM_RWWord(W, 0, CANDY_MEM.MemType, CANDY_MEM.Address, CANDY_MEM.SubAddress, ref word);
            if (cmsError.IsError())
                return cmsError;

            int integer = (int)((value & 0xFFFFFFFF0000) >> 16);
            // Write Integer (+1 is used because osai uses word)   
            cmsError = MEM_RWInteger(W, 0, CANDY_MEM.MemType, CANDY_MEM.Address, CANDY_MEM.SubAddress + 2, ref integer);
            if (cmsError.IsError())
                return cmsError;

            // Rieggo il dato
            long newVal = 0;
            cmsError = PLC_RCandy(ref newVal);
            if (cmsError.IsError())
                return cmsError;

            // Se i 2 dati coincidono ritorno OK
            if (value == newVal)
                return NO_ERROR;
            else
                return PLC_NOT_RUNNING_ERROR;
        }

        public override CmsError PLC_RCandy(ref long value)
        {
            // Long is formed by a integer + word
            // Read word
            ushort word = 0;
            CmsError cmsError = MEM_RWWord(R, 0, CANDY_MEM.MemType, CANDY_MEM.Address, CANDY_MEM.SubAddress, ref word);
            if (cmsError.IsError())
                return cmsError;

            // Read first int
            uint firtInt = 0;
            cmsError = MEM_RWDWord(R, 0, CANDY_MEM.MemType, CANDY_MEM.Address, CANDY_MEM.SubAddress + 2, ref firtInt);
            if (cmsError.IsError())
                return cmsError;



            // Build Long value
            value = ((long)firtInt << 16) + word;

            return NO_ERROR;
        }

        public override CmsError PLC_RActiveClient(ref int clientId)
        {
            CmsError cmsError = CheckConnection();
            if (cmsError.IsError())
                return cmsError;

            byte readValues = 0;
            cmsError = MEM_RWByte(R, 0, ACTIVE_CLIENT.MemType, ACTIVE_CLIENT.Address, ACTIVE_CLIENT.SubAddress, 0, ref readValues);
            if (cmsError.IsError())
                return cmsError;

            // Convert integer array into bit array
            bool[] statusBits = ByteToBits(readValues);
            // check which bit is set
            for (int i = 0; i < 8; i++)
            {
                if (statusBits[i])
                    clientId = i + 1;
            }

            return NO_ERROR;
        }

        public override CmsError PLC_RToolMovement(ref MovementBetweenMagazinesModel toolMovement)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError PLC_WTerminateMovementProcedure(MOVEMENT_RESPONSE resp)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        #endregion PLC High-level data

        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

        #region PROCESS (PATH) High-level data

        // Get the process Mode
        public override CmsError PROC_RMode(ushort ProcNumber, ref PROC_MODE Mode)
        {
            //Check if the NC is Connected
            CmsError cmsError = CheckConnection();
            if (cmsError.IsError())
                return cmsError;

            // FIXME

            // fare guardando mappatura memoria stsato processo

#if false
            // Try to get information
            try
            {
                // Setup variables
                DataSvc Data = HighPriorityDataSvc();
                Item itemRead = new Item(NC_GENERIC_MODE_PATH + "[u" + ProcNumber + "]");
                Item itemReadIncr = new Item(JOG_INCR_PATH + "[u" + ProcNumber + "]");
                Item itemReadAdv = new Item(ADVANCED_JOG_PATH + "[u" + ProcNumber + "]");

                // Read Data
                Data.Read(itemRead);
                Data.Read(itemReadIncr);
                Data.Read(itemReadAdv);

                // Save Data
                Mode = ConvertToSTEPMode((uint)itemRead.Value, (uint)itemReadIncr.Value, (uint)itemReadAdv.Value);
            }
            catch (Exception ex)
            {
                return ManageException(ex);
            } 
#endif

            return NO_ERROR;
        }

        // Get the process status
        public override CmsError PROC_RStatus(ushort ProcNumber, ref PROC_STATUS Status)
        {
            // Check if the NC is Connected
            CmsError cmsError = CheckConnection();
            if (cmsError.IsError())
                return cmsError;


            // FIXME

            // fare guardando amppatura variabili status

#if false
            // Try to get information
            try
            {
                // Setup variables
                DataSvc Data = HighPriorityDataSvc();
                Item itemRead = new Item(NC_GENERIC_STATE_PATH + "[u" + ProcNumber + "]");

                // Read Data
                Data.Read(itemRead);

                // Save Data
                Status = ConvertToSTEPStatus((uint)itemRead.Value);
            }
            catch (Exception ex)
            {
                return ManageException(ex);
            } 
#endif

            return NO_ERROR;
        }

        // Get PP Lines
        public override CmsError PROC_RPPLines(ushort ProcNumber, ref List<string> Lines)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        // Get PP Name
        public override CmsError PROC_RSelectedPPName(ushort ProcNumber, ref string Name)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        // Get the process Active Alarms
        public override CmsError PROC_RActiveAlarms(ushort procNumber, ref List<AlarmModel> alarms)
        {
            // fare guardando bitmap allarmi attivi

#if false
            alarms = SiemensAlarms
                    .Where(x => x.Id >= IDMinChannel && x.Id <= IDMaxChannel && x.Parameters[0].Equals(procNumber.ToString()))
                    .Select(x =>
                    {
                        uint id = x.Instance == 1 ? (uint)x.Id : Convert.ToUInt32((x.Id & 0xffff) | (x.Instance << 24));
                        return new AlarmModel()
                        {
                            Id = id,
                            Message = x.Message,
                            IsWarning = false,
                            Process = procNumber,
                            DateTime = x.TimeStamp
                        };
                    })
                    .ToList(); 
#endif

            return NO_ERROR;
        }

        // Get process part program data
        public override CmsError PROC_RStatusAndData(ushort procNumber, ref ProcessDataModel processData)
        {
            processData.Id = procNumber;
            // Read part program name
            CmsError cmsError = PROC_RSelectedPPName(procNumber, ref processData.PartProgramName);
            if (cmsError.IsError())
                return cmsError;

            int readValue = 0;
            // Read processes status from memory
            cmsError = MEM_RWInteger(R, 0, PROCESS_STATUS.MemType, PROCESS_STATUS.Address, PROCESS_STATUS.SubAddress + ((procNumber - 1) * 2), ref readValue);
            if (cmsError.IsError())
                return cmsError;

            byte[] bytes = BitConverter.GetBytes(readValue);

            // Convert Byte into true/false array
            BitArray bits = new BitArray(new byte[] { bytes[0] }); // 1st byte -> 0 : Proccess type (AUX-WORK), 1: Process in alarm status, 2: Run, 3: Hold, 4: Read, 5: PartProgramVisible

            // Get part program info visibility
            processData.Visible = bits[0];

            // Populate response structure
            processData.Type = bits[1] ? "WORK" : "AUX";
            processData.IsSelected = bits[2];
            processData.IsInAlarm = bits[3];
            processData.CanLoadProgram = bits[4];

            // Choose process status
            if (bytes[1] == 1)
                processData.Status = "HOLD";
            else
            {
                if (bytes[1] == 2)
                    processData.Status = "RUN";
                else
                    processData.Status = "READY";
            }

            // Get Reps from 3nd-4th byte
            processData.Reps = BitConverter.ToUInt16(bytes, 2);

            return NO_ERROR;
        }

        public override CmsError PROC_RSelectedProcess(ref ushort procNumber)
        {
            if (SelectedProcess == 0)
                return SELECTED_PROCESS_ERROR;

            procNumber = SelectedProcess;
            //CmsError cmsError;
            //bool readValue = false;

            //for (int i = 0; i < PROCESS_NUMBER; i++)
            //{
            //    // Calculate bit address = ProcessBase + processId * 2
            //    int memoryAddress = SELECTED_PROCESS.SubAddress + i * (2);
            //    // Read memory from plc
            //    cmsError = MEM_RWBoolean(R, 0, SELECTED_PROCESS.MemType, SELECTED_PROCESS.Address, memoryAddress, 2, ref readValue);
            //    if (cmsError.IsError())
            //        return cmsError;

            //    if (readValue)
            //    {
            //        procNumber = (ushort)(i + 1);
            //        return NO_ERROR;
            //    }
            //}

            return NO_ERROR;
        }

        public override CmsError PROC_WSelectProcess(ushort procNumber)
        {
            CmsError cmsError;
            byte processNum = (byte)procNumber;

            // Check parameter
            if (processNum > MAX_PROCESS_NUMBER)
                return INCORRECT_PARAMETERS_ERROR;

            // Write process number
            cmsError = MEM_RWByte(W, 0, SELECT_PROCESS.MemType, SELECT_PROCESS.Address, SELECT_PROCESS.SubAddress, 0, ref processNum);
            if (cmsError.IsError())
                return cmsError;

            return NO_ERROR;
        }

        public override CmsError PROC_RSelectedProcessData(int processId, ref SelectedProcessData processData)
        {
            if (processId <= 0)
                return PROC_NOT_FOUND_ERROR;

            // FIXME
            // ha senso?

#if false
            try
            {
                Item[] items = new Item[7]
                {
                    new Item { Path = "/Channel/State/actTNumber[u" + processId + ",1]" }, // ActiveToolId
                    new Item { Path = "/Channel/State/actDNumber[u" + processId + ",1]" }, // OffsetId
                    new Item { Path = "/Channel/State/actFrameIndex[u" + processId + "]" }, // Origin
                    new Item { Path = "DB21.DBB4"}, // Work override
                    new Item { Path = "DB21.DBB5"}, // Rapid override,
                    new Item { Path = "/Channel/State/actFeedRateIpo[u" + processId + ", 1]"},
                    new Item { Path = "/Nck/Configuration/numCuttEdgeParams[1]"}, // Cutt Edge Params                    
                };

                // Read data
                DataSvc dataSvc = new DataSvc();
                dataSvc.Read(items);

                short origin = 0;
                // Convert SIEMENS enumerable to G(N) format es: G54
                if (Convert.ToInt16(items[2].Value) > 0)
                {
                    if (Convert.ToInt16(items[1].Value) >= 5)
                        origin = (short)(Convert.ToInt16(items[2].Value) + 500);
                    else
                        origin = (short)(Convert.ToInt16(items[2].Value) + 53);
                }

                OffsetModel offset = new OffsetModel();

                //Read the ID of the Tool & Edge
                short actualToolId = Convert.ToInt16(items[0].Value);
                short actualEdgeId = Convert.ToInt16(items[1].Value);
                short numCuttEdgeParams = Convert.ToInt16(items[6].Value);
                int offsetEdge = (actualEdgeId - 1) * numCuttEdgeParams;

                if (actualToolId != 0 && actualEdgeId != 0)
                {
                    //Setup the items for the tools. Must be read only this value
                    Item[] itemsToolEdge = new Item[4]
                    {
                        new Item { Path = "/Tool/Compensation/edgeData[u1,c"+ actualToolId +","+ (offsetEdge + 3) + "]" },  // $TC_DP3
                        new Item { Path = "/Tool/Compensation/edgeData[u1,c"+ actualToolId +","+ (offsetEdge + 6) + "]" },  // $TC_DP6
                        new Item { Path = "/Tool/Compensation/edgeData[u1,c"+ actualToolId +","+ (offsetEdge + 12) + "]" }, // $TC_DP12
                        new Item { Path = "/Tool/Compensation/edgeData[u1,c"+ actualToolId +","+ (offsetEdge + 15) + "]" }  // $TC_DP15
                    };

                    dataSvc.Read(itemsToolEdge);

                    offset = new OffsetModel()
                    {
                        Id = actualEdgeId,
                        Length = Convert.ToDouble(itemsToolEdge[0].Value),
                        Radius = Convert.ToDouble(itemsToolEdge[1].Value),
                        WearLength = Convert.ToDouble(itemsToolEdge[2].Value),
                        WearRadius = Convert.ToDouble(itemsToolEdge[3].Value),
                        RealLength = Convert.ToDouble(itemsToolEdge[0].Value) + Convert.ToDouble(itemsToolEdge[2].Value),
                        RealRadius = Convert.ToDouble(itemsToolEdge[1].Value) + Convert.ToDouble(itemsToolEdge[3].Value)
                    };

                    /* Other Method. Find it in the Database of the Tools... Too SLow? (Nicola Carminati 08/08/19)
                    // Find edge
                    EdgeModel edge = ToolTableData.Where(x => x.Id == Convert.ToInt16(items[0].Value))
                        .FirstOrDefault()
                        .EdgesData.Where(x => x.Id == Convert.ToInt16(items[1].Value))
                        .FirstOrDefault();


                    //Find the Type of the Tool
                    SiemensEdgesConfiguration toolEdgesConfig = new SiemensEdgesConfiguration();
                    List<EdgeConfigModel> toolTypeConfig = toolEdgesConfig.EdgesConfig[
                            ToolTableData.Where(x => x.Id == Convert.ToInt16(items[0].Value)).FirstOrDefault().ToolType
                        ];

                    if(toolTypeConfig != null && toolTypeConfig.Count > 0)
                    {
                        //Read Names of the parameters
                        String lenghtName = toolTypeConfig.Where(x => x.Path == "$TC_DP3[").FirstOrDefault().Name;
                        String radiusName = toolTypeConfig.Where(x => x.Path == "$TC_DP6[").FirstOrDefault().Name;
                        String wearLenghtName = toolTypeConfig.Where(x => x.Path == "$TC_DP12[").FirstOrDefault().Name;
                        String wearRadiusName = toolTypeConfig.Where(x => x.Path == "$TC_DP15[").FirstOrDefault().Name;

                        if(!String.IsNullOrEmpty(wearLenghtName) && !String.IsNullOrEmpty(wearRadiusName) && !String.IsNullOrEmpty(lenghtName) && !String.IsNullOrEmpty(radiusName))
                        {
                            // Convert edgeModel to offsetModel
                            offset = new OffsetModel()
                            {
                                Id = (short)edge.Id,
                                Length = edge.EdgeAdditionalParams[lenghtName],
                                Radius = edge.EdgeAdditionalParams[radiusName],
                                WearLength = edge.EdgeAdditionalParams[wearLenghtName],
                                WearRadius = edge.EdgeAdditionalParams[wearRadiusName],
                                RealLength = edge.EdgeAdditionalParams[lenghtName] + edge.EdgeAdditionalParams[wearLenghtName],
                                RealRadius = edge.EdgeAdditionalParams[radiusName] + edge.EdgeAdditionalParams[wearRadiusName]
                            };

                        }

                    }*/

                }

                // Creata return model
                processData = new SelectedProcessData
                {
                    ActiveOffsetId = Convert.ToInt16(items[1].Value),
                    Origin = origin,
                    ProcessMessage = "",
                    WorkOverride = Convert.ToByte(items[3].Value),
                    RapidOverride = Convert.ToByte(items[4].Value),
                    OffsetData = offset,
                    FeedOverride = Convert.ToDouble(items[5].Value)
                };
            }
            catch (Exception ex)
            {
                return ManageException(ex);
            } 
#endif

            return NO_ERROR;
        }

        private CmsError PROC_ReadActiveLine(uint processId, ref string line)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;

#if false
            try
            {
                Item item = new Item();
                if (processId == 0)
                    item.Path = "/Channel/ProgramInfo/actBlock[u1,1]"; // Default
                else
                    item.Path = "/Channel/ProgramInfo/actBlock[u" + processId + ",1]";

                DataSvc dataSvc = new DataSvc();
                dataSvc.Read(item);

                line = item.Value.ToString();
            }
            catch (Exception ex)
            {
                return ManageException(ex);
            }

            return NO_ERROR; 
#endif
        }

        #endregion PROCESS (PATH) High-level data

        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

        #region THERMO high level data

        /// <summary>
        /// Get gauge data
        /// </summary>
        /// <param name="gaugeData"></param>
        /// <returns></returns>
        public override CmsError PLC_RGaugeData(ref GaugeModel gaugeData)
        {
            List<int> Values = new List<int>();
            CmsError cmsError = MEM_RWIntegerList(R, 1, MACHINE_GAUGE_DATA.MemType, MACHINE_GAUGE_DATA.Address, MACHINE_GAUGE_DATA.SubAddress, MACHINE_GAUGE_DATA.Size / 4, ref Values);

            if (cmsError.IsError())
                return cmsError;

            gaugeData = new GaugeModel()
            {
                TimeAdv = Convert.ToUInt32(Values[0]),
                Power = Values[1],
                Vacuum = Values[2],
                Air = Values[3],
            };

            return NO_ERROR;
        }
        /// <summary>
        /// read current recipe parameter list
        /// </summary>
        /// <param name="onlyRT">updates only RT parameters (false = update all)</param>
        /// <param name="currParamList"></param>
        /// <returns></returns>
        public override CmsError PLC_RRecipeParamList(bool onlyRT, ref Dictionary<int, RecipeParam> currParamList)
        {
            // se richiesto NON SOLO RT faccio refresh anche dati "lenti"
            if (!onlyRT)
            {
                refreshMemRecipeParameter();
            }
            // refresh dati veloci / RT
            refreshMemRecipeParameterRT();

            // copio lista act in output...
            currParamList = ThermoParamList;
            return NO_ERROR;
        }
        /// <summary>
        /// Write recipe updated parameter
        /// </summary>
        /// <param name="updtParam"></param>
        /// <returns></returns>
        public override CmsError PLC_WRecipeParam(RecipeParam updtParam)
        {
            // init variabili accessorie
            List<byte> currMem = new List<byte>();
            int packSize = 20;
            int memIndex = PARAMETER_DATA.SubAddress + (updtParam.Id - 1) * packSize;
            // leggo in primis il parametro che mi richiedono
            CmsError cmsError = MEM_RWByteList(R, 0, PARAMETER_DATA.MemType, PARAMETER_DATA.Address, memIndex, 0, packSize, ref currMem);
            if (cmsError.IsError())
                return cmsError;

            // converto in parametro...
            PlcParam currParam = new PlcParam(currMem.ToArray());
            // aggiorno SetpointHMI...
            currParam.SetpointHMI = (int)updtParam.SetpointHMI;
            // converto a NUOVA lista byte
            List<byte> newMem = currParam.convertToByte().ToList();
            cmsError = MEM_RWByteList(W, 0, PARAMETER_DATA.MemType, PARAMETER_DATA.Address, memIndex, 0, packSize, ref newMem);
            if (cmsError.IsError())
                return cmsError;

            return NO_ERROR;
        }
        /// <summary>
        /// Get current Modules Block list
        /// </summary>
        /// <param name="onlyRT">updates only RT parameters (false = update all)</param>
        /// <param name="currModulesBlockList"></param>
        /// <returns></returns>
        public override CmsError PLC_RModulesBlockList(bool onlyRT, ref Dictionary<int, ModuleBlock> currModulesBlockList)
        {
            return NO_ERROR;
        }
        /// <summary>
        /// Get current Warmers Channels list
        /// </summary>
        /// <param name="currWarmerChannelList"></param>
        /// <returns></returns>
        public override CmsError PLC_RWarmerChannelList(ref Dictionary<int, ModuleBlock> currWarmerChannelList)
        {
            return NO_ERROR;
        }
        /// <summary>
        /// Get current Production Info data
        /// </summary>
        /// <param name="currProdInfo"></param>
        /// <returns></returns>
        public override CmsError PLC_RProdInfo(ref ProdInfo currProdInfo)
        {
            return NO_ERROR;
        }
        /// <summary>
        /// Get current Production Cycle data
        /// </summary>
        /// <param name="currProdCycle"></param>
        /// <returns></returns>
        public override CmsError PLC_RProdCycle(ref ProdCycle currProdCycle)
        {
            return NO_ERROR;
        }

        protected void refreshMemRecipeParameterRT()
        {
            List<byte> currMem = new List<byte>();
            int packSize = 8;

            // leggo da PLC a array di byte di appoggio...
            CmsError cmsError = MEM_RWByteList(R, 0, PARAMETER_RT_DATA.MemType, PARAMETER_RT_DATA.Address, PARAMETER_RT_DATA.SubAddress, 0, PARAMETER_RT_DATA.Size, ref currMem);

            // controllo SE ho dati...
            if (currMem.Count > 0)
            {
                // converto a blocchi di 8 byte...
                byte[] memArray = currMem.ToArray();
                for (int i = 0; i < PARAMETER_RT_DATA.Size / packSize; i++)
                {
                    PlcParamRT currParam = new PlcParamRT(memArray.Skip(i * packSize).Take(packSize).ToArray());
                    // solo se ID > 0...
                    if (currParam.Id > 0)
                    {
                        // update oggetto thermoParamList...
                        if (ThermoParamList.ContainsKey(currParam.Id))
                        {
                            ThermoParamList[currParam.Id].Enabled = currParam.Enabled;
                            ThermoParamList[currParam.Id].HasError = currParam.HasError;
                            ThermoParamList[currParam.Id].Visible = currParam.Visible;
                            ThermoParamList[currParam.Id].ValueAct = currParam.ValueAct;
                        }
                        else
                        {
                            ThermoParamList.Add(currParam.Id, new RecipeParam() { Id = currParam.Id, Enabled = currParam.Enabled, HasError = currParam.HasError, Visible = currParam.Visible, ValueAct = currParam.ValueAct });
                        }
                    }
                }
            }
        }
        protected void refreshMemRecipeParameter()
        {
            List<byte> currMem = new List<byte>();
            int packSize = 20;

            // leggo da PLC a array di byte di appoggio...
            CmsError cmsError = MEM_RWByteList(R, 0, PARAMETER_DATA.MemType, PARAMETER_DATA.Address, PARAMETER_DATA.SubAddress, 0, PARAMETER_DATA.Size, ref currMem);


            // controllo SE ho dati...
            if (currMem.Count > 0)
            {
                // converto a blocchi di 8 byte...
                byte[] memArray = currMem.ToArray();
                for (int i = 0; i < PARAMETER_DATA.Size / packSize; i++)
                {
                    PlcParam currParam = new PlcParam(memArray.Skip(i * packSize).Take(packSize).ToArray());
                    // solo se ID > 0...
                    if (currParam.Id > 0)
                    {
                        // update oggetto thermoParamList...
                        if (ThermoParamList.ContainsKey(currParam.Id))
                        {
                            ThermoParamList[currParam.Id].SetpointHMI = currParam.SetpointHMI;
                            ThermoParamList[currParam.Id].SetpointPLC = currParam.SetpointPLC;
                            ThermoParamList[currParam.Id].ValMax = currParam.ValMax;
                            ThermoParamList[currParam.Id].ValMin = currParam.ValMin;
                            ThermoParamList[currParam.Id].UnitMeasure = currParam.UnitMeasure;
                        }
                        else
                        {
                            ThermoParamList.Add(currParam.Id, new RecipeParam() { Id = currParam.Id, SetpointHMI = currParam.SetpointHMI, SetpointPLC = currParam.SetpointPLC, ValMax = currParam.ValMax, ValMin = currParam.ValMin, UnitMeasure = currParam.UnitMeasure });
                        }
                    }
                }
            }
        }
        /// <summary>
        /// Oggetto Parametro RT da PLC
        /// </summary>
        protected class PlcParamRT
        {
            public short Id { get; set; } = 0;
            private ushort Stato { get; set; } = 0;
            public bool Visible { get; set; }
            public bool Enabled { get; set; }
            public bool HasError { get; set; }
            public int ValueAct { get; set; } = 0;
            /// <summary>
            /// Deserializzazione da byte ad oggetto ParamRT
            /// </summary>
            /// <param name="rawData"></param>
            public PlcParamRT(byte[] rawData)
            {
                // converto i dati da byte grezzi ai 3 componenti...
                Id = S7.Net.Types.Int.FromByteArray(rawData.Skip(0).Take(2).ToArray());
                Stato = S7.Net.Types.Word.FromByteArray(rawData.Skip(2).Take(2).ToArray());
                ValueAct = S7.Net.Types.DInt.FromByteArray(rawData.Skip(4).Take(4).ToArray());
                // calcolo bit...
                Visible = (Stato & 1) == 1;
                Enabled = (Stato & 2) == 2;
                HasError = (Stato & 4) == 4;
            }
            /// <summary>
            /// Converte un singolo item in un array di byte per scrittura su PLC S7
            /// </summary>
            /// <returns></returns>
            public byte[] convertToByte()
            {
                // convero stato dai bit...
                Stato = 0;
                Stato += (ushort)(Visible ? 1 : 0);
                Stato += (ushort)(Enabled ? 2 : 0);
                Stato += (ushort)(HasError ? 4 : 0);
                byte[] answ = new byte[8];
                Buffer.BlockCopy(S7.Net.Types.Int.ToByteArray(Id), 0, answ, 0, 2);
                Buffer.BlockCopy(S7.Net.Types.Word.ToByteArray(Stato), 0, answ, 2, 2);
                Buffer.BlockCopy(S7.Net.Types.DInt.ToByteArray(ValueAct), 0, answ, 4, 4);
                return answ;
            }
        }
        /// <summary>
        /// Oggetto Parametro da PLC
        /// </summary>
        protected class PlcParam
        {
            public short Id { get; set; } = 0;
            public int SetpointHMI { get; set; } = 0;
            public int SetpointPLC { get; set; } = 0;
            public int ValMax { get; set; } = 0;
            public int ValMin { get; set; } = 0;
            public ushort UnitMeasure { get; set; } = 0;
            /// <summary>
            /// Deserializzazione da byte ad oggetto Param
            /// </summary>
            /// <param name="rawData"></param>
            public PlcParam(byte[] rawData)
            {
                // converto i dati da byte grezzi ai 3 componenti...
                Id = S7.Net.Types.Int.FromByteArray(rawData.Skip(0).Take(2).ToArray());
                SetpointHMI = S7.Net.Types.DInt.FromByteArray(rawData.Skip(2).Take(4).ToArray());
                SetpointPLC = S7.Net.Types.DInt.FromByteArray(rawData.Skip(6).Take(4).ToArray());
                ValMax = S7.Net.Types.DInt.FromByteArray(rawData.Skip(10).Take(4).ToArray());
                ValMin = S7.Net.Types.DInt.FromByteArray(rawData.Skip(14).Take(4).ToArray());
                UnitMeasure = S7.Net.Types.Word.FromByteArray(rawData.Skip(18).Take(2).ToArray());
            }
            /// <summary>
            /// Converte un singolo item in un array di byte per scrittura su PLC S7
            /// </summary>
            /// <returns></returns>
            public byte[] convertToByte()
            {
                byte[] answ = new byte[20];
                Buffer.BlockCopy(S7.Net.Types.Int.ToByteArray(Id), 0, answ, 0, 2);
                Buffer.BlockCopy(S7.Net.Types.DInt.ToByteArray(SetpointHMI), 0, answ, 2, 4);
                Buffer.BlockCopy(S7.Net.Types.DInt.ToByteArray(SetpointPLC), 0, answ, 6, 4);
                Buffer.BlockCopy(S7.Net.Types.DInt.ToByteArray(ValMax), 0, answ, 10, 4);
                Buffer.BlockCopy(S7.Net.Types.DInt.ToByteArray(ValMin), 0, answ, 14, 4);
                Buffer.BlockCopy(S7.Net.Types.Word.ToByteArray(UnitMeasure), 0, answ, 18, 2);
                return answ;
            }
        }

        #endregion

        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

        #region PROCESS-AXES (PATH) High-level data

        public override CmsError AXES_RInterpPosition(ushort channel, ref Dictionary<string, double> axes)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
#if false
            try
            {
                axes = new Dictionary<string, double>();
                // Cycle between axes
                // The dictionary is written asynchronously so i have to create a copy of the dictionary with .ToList() to avoid exceptions
                // axes = InterpAxesPosition.ToDictionary(x => x.Key, x => x.Value); This code throws exceptions
                lock (InterpAxesPosition)
                {
                    foreach (var axis in InterpAxesPosition.ToList())
                    {
                        axes.Add(axis.Key, axis.Value);
                    }
                }
            }
            catch (Exception ex)
            {
                return ManageException(ex);
            }

            return NO_ERROR; 
#endif
        }

        public override CmsError AXES_RMachinePosition(ushort channel, ref Dictionary<string, double> axes)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
#if false
            try
            {
                axes = new Dictionary<string, double>();

                lock (MachineAxesPosition)
                {
                    // Cycle between axes
                    // The dictionary is written asynchronously so i have to create a copy of the dictionary with .ToList() to avoid exceptions
                    foreach (var axis in MachineAxesPosition.ToList())
                    {
                        axes.Add(axis.Key, axis.Value);
                    }
                }
            }
            catch (Exception ex)
            {
                return ManageException(ex);
            }

            return NO_ERROR; 
#endif
        }

        public override CmsError AXES_RProgrPosition(ushort channel, ref Dictionary<string, double> axes)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
#if false
            try
            {
                axes = new Dictionary<string, double>();
                lock (ProgrammedAxisPosition)
                {
                    // Cycle between axes
                    // The dictionary is written asynchronously so i have to create a copy of the dictionary with .ToList() to avoid exceptions
                    foreach (var axis in ProgrammedAxisPosition.ToList())
                    {
                        axes.Add(axis.Key, axis.Value);
                    }
                }
            }
            catch (Exception ex)
            {
                return ManageException(ex);
            }

            return NO_ERROR; 
#endif
        }

        public override CmsError AXES_RFollowingError(ushort channel, ref Dictionary<string, double> axes)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
#if false
            try
            {
                axes = new Dictionary<string, double>();
                lock (InterpAxesPosition)
                {
                    // Cycle between axes
                    // The dictionary is written asynchronously so i have to create a copy of the dictionary with .ToList() to avoid exceptions
                    foreach (var axis in InterpAxesPosition.ToList())
                    {
                        axes.Add(axis.Key, axis.Value);
                    }
                }
            }
            catch (Exception ex)
            {
                return ManageException(ex);
            }

            return NO_ERROR; 
#endif
        }

        public override CmsError AXES_RDistanceToGo(ushort channel, ref Dictionary<string, double> axes)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
#if false
            try
            {
                axes = new Dictionary<string, double>();
                lock (ToGoAxesPosition)
                {
                    // Cycle between axes
                    // The dictionary is written asynchronously so i have to create a copy of the dictionary with .ToList() to avoid exceptions
                    foreach (var axis in ToGoAxesPosition.ToList())
                    {
                        axes.Add(axis.Key, axis.Value);
                    }
                }
            }
            catch (Exception ex)
            {
                return ManageException(ex);
            }
            return NO_ERROR; 
#endif
        }

        private Dictionary<string, double> AXES_RAxesPos(ushort channel, string positionType)
        {
            Dictionary<string, double> axes = new Dictionary<string, double>();
#if false
            List<AxisModel> axesConf = new List<AxisModel>();

            CmsError cmsError = AXES_RAxesNames(channel, ref axesConf);

            List<Item> items = new List<Item>();
            foreach (var conf in axesConf)
            {
                // Setup the items to be readed
                items.Add(new Item() { Path = string.Format("/Channel/{0}[u{1},{2}]", positionType, channel, conf.Id) });
            }

            DataSvc dataSvc = new DataSvc();
            // Read all the items
            dataSvc.Read(items.ToArray());

            int i = 0;
            foreach (var conf in axesConf)
            {
                axes.Add(conf.Id.ToString(), Convert.ToDouble(items[i].Value));
                i++;
            } 
#endif

            return axes;
        }

        public override CmsError AXES_RAxesNames(ushort channel, ref List<AxisModel> axesData)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
#if false
            if (!File.Exists(AXES_FILE_PATH))
                return CmsError.InternalError("File" + AXES_FILE_PATH + " not found", new Exception("File" + AXES_FILE_PATH + " not found"));

            // Check if the NC is Connected
            CmsError cmsError = CheckConnection();
            if (cmsError.IsError())
                return cmsError;
            List<AxisModel> configuredAxes = new List<AxisModel>();

            Item[] ncAxes = new Item[MAX_AXES_FOR_PROCESS * 3];
            try
            {
                // Check if the static object is already populated
                if (AxesData.Count == 0)
                {
                    XDocument xmlAxesFile = XDocument.Load(AXES_FILE_PATH);
                    // Read data from file
                    configuredAxes = xmlAxesFile
                        .Root
                        .Elements()
                        .Select(x => new AxisModel()
                        {
                            Id = Convert.ToInt32(x.Attribute("id").Value),
                            Name = x.Value,
                            IsSelectable = false
                        })
                        .Where(x => x.Id != 0) // Parse only active axes
                        .ToList();
                }

                // Object used for reading data from NC
                DataSvc svcData = new DataSvc();

                bool[] axesAreVisible = new bool[MAX_AXES_FOR_PROCESS];
                // Read from Nc
                for (int i = 1; i <= MAX_AXES_FOR_PROCESS; i++)
                {
                    // Set the path to read on which process is the axis
                    ncAxes[i - 1] = new Item("/Nck/MachineAxis/chanNoAxisIsActive[" + i + "]");
                    // Set the path in order to find which axes are visible
                    ncAxes[i - 1 + MAX_AXES_FOR_PROCESS] = new Item("/NC/_N_CH_TEA_ACX/$MC_DISPLAY_AXIS[u" + channel + "," + i + "]");
                    // Set the path of the axes type
                    ncAxes[i - 1 + (MAX_AXES_FOR_PROCESS * 2)] = new Item("/Nck/Configuration/axisType[" + i + "]");
                }

                svcData.Read(ncAxes);

                for (int i = 0; i < MAX_AXES_FOR_PROCESS; i++)
                {
                    // Set visible field
                    axesAreVisible[i] = (Convert.ToInt32(ncAxes[i + MAX_AXES_FOR_PROCESS].Value) & 1) == 1;
                    int processAxes = Convert.ToInt32(ncAxes[i].Value);
                    // If axis is visible, add it to the output
                    if (processAxes == channel && axesAreVisible[i])
                    {
                        // Check if axes is configurated axes
                        var axis = configuredAxes.Where(x => x.Id == (i + 1)).FirstOrDefault();
                        if (axis != null)
                        {
                            axis.Type = (AXIS_TYPE)Convert.ToInt32(ncAxes[i + (MAX_AXES_FOR_PROCESS * 2)].Value);
                            AxesData.Add(axis);
                        }
                    }
                }

                // Get from PLC which axis can be selected
                List<byte> ids = new List<byte>();
                cmsError = MEM_RWByteList(R, 0, AXES_BUTTON_VISIBLE.MemType, AXES_BUTTON_VISIBLE.Address, AXES_BUTTON_VISIBLE.SubAddress, 0, AXES_BUTTON_VISIBLE.Size, ref ids);
                if (cmsError.IsError())
                    return cmsError;

                // Parse the data readed from PLC
                foreach (byte id in ids)
                {
                    if (id != 0)
                    {
                        // If axis exists, set it as selectable
                        var tmpAxis = AxesData.Where(x => x.Id == id).FirstOrDefault();
                        if (tmpAxis != null)
                            tmpAxis.IsSelectable = true;
                    }
                }

                axesData = AxesData;
            }
            catch (Exception ex)
            {
                return ManageException(ex);
            }

            return NO_ERROR; 
#endif
        }

        public override CmsError AXES_RSelectedAxis(ref byte axisId)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
#if false
            // Read byte from memory
            CmsError cmsError = MEM_RWByte(R, 0, SELECTED_AXIS.MemType, SELECTED_AXIS.Address, SELECTED_AXIS.SubAddress, 1, ref axisId);
            if (cmsError.IsError())
                return cmsError;

            return NO_ERROR; 
#endif
        }

        public override CmsError AXES_WSelectAxis(byte axisId)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
#if false
            // Write byte from memory
            CmsError cmsError = MEM_RWByte(W, 0, SELECT_AXIS.MemType, SELECT_AXIS.Address, SELECT_AXIS.SubAddress, 1, ref axisId);
            if (cmsError.IsError())
                return cmsError;

            return NO_ERROR; 
#endif
        }

        public override CmsError AXES_ROrigin(int numberOfAxes)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
#if false
            DataSvc dataSvc = new DataSvc();
            List<Item> ncAxes = new List<Item>();

            List<AxisModel> axes = new List<AxisModel>();
            CmsError cmsError = AXES_RAxesNames(1, ref axes);


            for (int i = 1; i <= 4; i++)
            {
                foreach (var axis in axes)
                {
                    var num = axis.Id + (axes.Last().Id * i);
                    ncAxes.Add(new Item()
                    {
                        Path = "/Channel/UserFrame/linShift[u1, " + num + "]"
                    });
                }
            }

            dataSvc.Read(ncAxes.ToArray());

            return NO_ERROR; 
#endif
        }

        #endregion PROCESS-AXES (PATH) High-level data

        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

        #region NC Low-level function: single valiable in memory

        //Read-Write a Boolean-Value inside the NC.
        public override CmsError MEM_RWBoolean(bool bWrite, int Process, MEMORY_TYPE MemType, int MemTable, int MemIndex, int MemBit, ref bool Value)
        {
            //Check if the NC is Connected
            CmsError cmsError = CheckConnection();
            if (cmsError.IsError())
                return cmsError;

            //Check if the Bit Number is Correct
            cmsError = CheckBitRange(MemBit);
            if (cmsError.IsError())
                return cmsError;

            byte bValue = 0;
            ushort pow = (ushort)Math.Pow(2, MemBit);

            //Read the Byte where is the bit
            cmsError = MEM_RWByte(R, Process, MemType, MemTable, MemIndex, 0, ref bValue);
            if (cmsError.IsError())
                return cmsError;

            //If i have to Write -> Write the Bit
            if (bWrite)
            {
                if (Value)
                    bValue = (byte)(bValue | (1 << MemBit));
                else
                    bValue = (byte)(bValue & ~(1 << MemBit));

                cmsError = MEM_RWByte(W, Process, MemType, MemTable, MemIndex, 0, ref bValue);
                if (cmsError.IsError())
                    return cmsError;
            }
            //If i have to read -> Read the Bit
            else
            {
                Value = (bValue & pow) == pow;
            }

            return NO_ERROR;
        }

        //Read-Write a Byte-Value-List inside the NC. In writing-mode the field "Number" is not required
        public override CmsError MEM_RWByte(bool bWrite, int Process, MEMORY_TYPE MemType, int MemTable, int MemIndex, int MemByte, ref byte Value)
        {
            List<byte> ListValue = new List<byte>() { Value };

            //uses the List method with one-element list
            CmsError cmsError = MEM_RWByteList(bWrite, Process, MemType, MemTable, MemIndex, MemByte, 1, ref ListValue);
            if (cmsError.IsError())
                return cmsError;
            if (ListValue.Count > 0)
            {
                Value = ListValue.First();
            }

            return NO_ERROR;
        }

        //Write a Word-Value inside the NC. In writing-mode the field "Number" is not required
        public override CmsError MEM_RWWord(bool bWrite, int Process, MEMORY_TYPE MemType, int MemTable, int MemIndex, ref ushort Value)
        {
            List<ushort> ListValue = new List<ushort>() { Value };

            //uses the List method with one-element list
            CmsError cmsError = MEM_RWWordList(bWrite, Process, MemType, MemTable, MemIndex, 1, ref ListValue);
            if (cmsError.IsError())
                return cmsError;

            Value = ListValue.First();

            return NO_ERROR;
        }

        public override CmsError MEM_RWShort(bool bWrite, int Process, MEMORY_TYPE MemType, int MemTable, int MemIndex, ref short Value)
        {
            List<short> ListValue = new List<short>() { Value };

            //uses the List method with one-element list
            CmsError cmsError = MEM_RWShortList(bWrite, Process, MemType, MemTable, MemIndex, 1, ref ListValue);
            if (cmsError.IsError())
                return cmsError;

            Value = ListValue.First();

            return NO_ERROR;
        }

        //Write a Word-Value inside the NC. In writing-mode the field "Number" is not required
        public override CmsError MEM_RWDWord(bool bWrite, int Process, MEMORY_TYPE MemType, int MemTable, int MemIndex, ref uint Value)
        {
            List<uint> ListValue = new List<uint>() { Value };

            //uses the List method with one-element list
            CmsError cmsError = MEM_RWDWordList(bWrite, Process, MemType, MemTable, MemIndex, 1, ref ListValue);
            if (cmsError.IsError())
                return cmsError;

            Value = ListValue.First();

            return NO_ERROR;
        }

        public override CmsError MEM_RWDouble(bool bWrite, int Process, MEMORY_TYPE MemType, int MemTable, int MemIndex, ref double Value)
        {
            List<double> ListValue = new List<double>() { Value };

            //uses the List method with one-element list
            CmsError cmsError = MEM_RWDoubleList(bWrite, Process, MemType, MemTable, MemIndex, 1, ref ListValue);
            if (cmsError.IsError())
                return cmsError;

            Value = ListValue.First();

            return NO_ERROR;
        }

        //Write a Int-Value inside the NC. In writing-mode the field "Number" is not required
        public override CmsError MEM_RWInteger(bool bWrite, int Process, MEMORY_TYPE MemType, int MemTable, int MemIndex, ref int Value)
        {
            List<int> ListValue = new List<int>() { Value };

            // uses the List method with one-element list, reading int32 (4byte) data...
            CmsError cmsError = MEM_RWIntegerList(bWrite, Process, MemType, MemTable, MemIndex, 1, ref ListValue);
            if (cmsError.IsError())
                return cmsError;
            if (ListValue.Count > 0)
            {
                Value = ListValue.First();
            }

            return NO_ERROR;
        }


        #endregion NC Low-level function: single valiable in memory

        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

        #region Low level methods

        public override CmsError MEM_RWByteList(bool bWrite, int Process, MEMORY_TYPE MemType, int MemTable, int MemIndex, int MemByteStart, int Number, ref List<byte> Values)
        {
            //Check if the NC is Connected
            CmsError cmsError = CheckConnection();
            if (cmsError.IsError())
                return cmsError;

            if (MemType != MEMORY_TYPE.Siemens_DB)
            {
                return INCORRECT_PARAMETERS_ERROR;
            }

            cmsError = null;

            if (bWrite)
            {
                //Prevent some exceptions
                if (Values.Count == 0)
                    return NO_ERROR;
                // try/catch
                try
                {
                    currPLC.WriteBytes(DataType.DataBlock, MemTable, MemIndex, Values.ToArray());
                }
                catch
                {
                    return PLC_MEM_CONF_ERROR;
                }
            }
            else
            {
                // Prevent some exceptions
                if (Number == 0)
                    return NO_ERROR;

                Values.Clear();
                try
                {
                    var memByteRead = currPLC.ReadBytes(DataType.DataBlock, MemTable, MemIndex, Number);
                    Values = memByteRead.ToList();
                }
                catch
                {
                    return PLC_MEM_CONF_ERROR;
                }
            }

            return NO_ERROR;
        }

        public override CmsError MEM_RWWordList(bool bWrite, int Process, MEMORY_TYPE MemType, int MemTable, int MemIndex, int Number, ref List<ushort> Values)
        {
            ////Check if the NC is Connected
            CmsError cmsError = CheckConnection();
            if (cmsError.IsError())
                return cmsError;


            if (MemType != MEMORY_TYPE.Siemens_DB)
            {
                return INCORRECT_PARAMETERS_ERROR;
            }


            cmsError = null;

            if (bWrite)
            {
                //Prevent some exceptions
                if (Values.Count == 0)
                    return NO_ERROR;

                byte[] singleItem = new byte[2];
                List<Byte> memByteList = new List<byte>();

                foreach (var Item in Values)
                {
                    singleItem = S7.Net.Types.Word.ToByteArray(Item);
                    memByteList.AddRange(singleItem);
                }

                currPLC.WriteBytes(DataType.DataBlock, MemTable, MemIndex, memByteList.ToArray());
            }
            else
            {
                // Prevent some exceptions
                if (Number == 0)
                    return NO_ERROR;

                Values.Clear();

                byte[] memByteRead = currPLC.ReadBytes(DataType.DataBlock, MemTable, MemIndex, Number);
                // converto a word!
                ushort shortVal = 0;
                for (int i = 0; i < memByteRead.Length / 2; i++)
                {
                    shortVal = S7.Net.Types.Word.FromByteArray(memByteRead.Skip(2 * i).Take(2).ToArray());
                    Values.Add(shortVal);
                }
            }

            return NO_ERROR;
        }

        public override CmsError MEM_RWShortList(bool bWrite, int Process, MEMORY_TYPE MemType, int MemTable, int MemIndex, int Number, ref List<short> Values)
        {
            //Check if the NC is Connected
            CmsError cmsError = CheckConnection();
            if (cmsError.IsError())
                return cmsError;

            if (MemType != MEMORY_TYPE.Siemens_DB)
            {
                return INCORRECT_PARAMETERS_ERROR;
            }


            cmsError = null;

            if (bWrite)
            {
                //Prevent some exceptions
                if (Values.Count == 0)
                    return NO_ERROR;

                byte[] singleItem = new byte[2];
                List<Byte> memByteList = new List<byte>();

                foreach (var Item in Values)
                {
                    singleItem = S7.Net.Types.Int.ToByteArray(Item);
                    memByteList.AddRange(singleItem);
                }

                currPLC.WriteBytes(DataType.DataBlock, MemTable, MemIndex, memByteList.ToArray());
            }
            else
            {
                // Prevent some exceptions
                if (Number == 0)
                    return NO_ERROR;

                Values.Clear();

                byte[] memByteRead = currPLC.ReadBytes(DataType.DataBlock, MemTable, MemIndex, Number);
                // converto a word!
                short shortVal = 0;
                for (int i = 0; i < memByteRead.Length / 2; i++)
                {
                    shortVal = S7.Net.Types.Int.FromByteArray(memByteRead.Skip(2 * i).Take(2).ToArray());
                    Values.Add(shortVal);
                }
            }

            return NO_ERROR;
        }

        public override CmsError MEM_RWDWordList(bool bWrite, int Process, MEMORY_TYPE MemType, int MemTable, int MemIndex, int Number, ref List<uint> Values)
        {
            //Check if the NC is Connected
            CmsError cmsError = CheckConnection();
            if (cmsError.IsError())
                return cmsError;

            if (MemType != MEMORY_TYPE.Siemens_DB)
            {
                return INCORRECT_PARAMETERS_ERROR;
            }

            cmsError = null;

            if (bWrite)
            {
                //Prevent some exceptions
                if (Values.Count == 0)
                    return NO_ERROR;

                byte[] singleItem = new byte[4];
                List<Byte> memByteList = new List<byte>();

                foreach (var Item in Values)
                {
                    singleItem = S7.Net.Types.DWord.ToByteArray(Item);
                    memByteList.AddRange(singleItem);
                }

                currPLC.WriteBytes(DataType.DataBlock, MemTable, MemIndex, memByteList.ToArray());
            }
            else
            {
                // Prevent some exceptions
                if (Number == 0)
                    return NO_ERROR;

                Values.Clear();

                byte[] memByteRead = currPLC.ReadBytes(DataType.DataBlock, MemTable, MemIndex, Number);
                // converto a word!
                uint shortVal = 0;
                for (int i = 0; i < memByteRead.Length / 4; i++)
                {
                    shortVal = S7.Net.Types.DWord.FromByteArray(memByteRead.Skip(4 * i).Take(4).ToArray());
                    Values.Add(shortVal);
                }
            }

            return NO_ERROR;
        }


        /// <summary>
        /// Lettura lista di interi
        /// </summary>
        /// <param name="bWrite"></param>
        /// <param name="Process"></param>
        /// <param name="MemType"></param>
        /// <param name="MemTable"></param>
        /// <param name="MemIndex"></param>
        /// <param name="Number">numero di INT 32 da leggere (byte/4)</param>
        /// <param name="Values"></param>
        /// <returns></returns>
        public override CmsError MEM_RWIntegerList(bool bWrite, int Process, MEMORY_TYPE MemType, int MemTable, int MemIndex, int Number, ref List<int> Values)
        {
            //Check if the NC is Connected
            CmsError cmsError = CheckConnection();
            if (cmsError.IsError())
                return cmsError;

            if (MemType != MEMORY_TYPE.Siemens_DB)
            {
                return INCORRECT_PARAMETERS_ERROR;
            }

            cmsError = null;

            if (bWrite)
            {
                //Prevent some exceptions
                if (Values.Count == 0)
                    return NO_ERROR;

                byte[] singleItem = new byte[4];
                List<Byte> memByteList = new List<byte>();

                foreach (var Item in Values)
                {
                    singleItem = S7.Net.Types.DInt.ToByteArray(Item);
                    memByteList.AddRange(singleItem);
                }

                currPLC.WriteBytes(DataType.DataBlock, MemTable, MemIndex, memByteList.ToArray());
            }
            else
            {
                // Prevent some exceptions
                if (Number == 0)
                    return NO_ERROR;

                Values.Clear();
                byte[] memByteRead = null;
                try
                {
                    memByteRead = currPLC.ReadBytes(DataType.DataBlock, MemTable, MemIndex, Number * 4);
                }
                catch
                {
                    return PLC_MEM_CONF_ERROR;
                }
                // converto a word!
                int intVal = 0;
                for (int i = 0; i < memByteRead.Length / 4; i++)
                {
                    intVal = S7.Net.Types.DInt.FromByteArray(memByteRead.Skip(4 * i).Take(4).ToArray());
                    Values.Add(intVal);
                }
            }

            if (Values.Count == 0)
            {
                return NOT_CONNECTED_ERROR;
            }

            return NO_ERROR;
        }

        public override CmsError MEM_RWDoubleList(bool bWrite, int Process, MEMORY_TYPE MemType, int MemTable, int MemIndex, int Number, ref List<double> Values)
        {
            //Check if the NC is Connected
            CmsError cmsError = CheckConnection();
            if (cmsError.IsError())
                return cmsError;

            if (MemType != MEMORY_TYPE.Siemens_DB)
            {
                return INCORRECT_PARAMETERS_ERROR;
            }

            cmsError = null;

            if (bWrite)
            {
                //Prevent some exceptions
                if (Values.Count == 0)
                    return NO_ERROR;

                byte[] singleItem = new byte[4];
                List<Byte> memByteList = new List<byte>();

                foreach (var Item in Values)
                {
                    singleItem = S7.Net.Types.Double.ToByteArray(Item);
                    memByteList.AddRange(singleItem);
                }

                currPLC.WriteBytes(DataType.DataBlock, MemTable, MemIndex, memByteList.ToArray());
            }
            else
            {
                // Prevent some exceptions
                if (Number == 0)
                    return NO_ERROR;

                Values.Clear();

                byte[] memByteRead = currPLC.ReadBytes(DataType.DataBlock, MemTable, MemIndex, Number);
                // converto a word!
                double shortVal = 0;
                for (int i = 0; i < memByteRead.Length / 4; i++)
                {
                    shortVal = S7.Net.Types.Double.FromByteArray(memByteRead.Skip(4 * i).Take(4).ToArray());
                    Values.Add(shortVal);
                }
            }

            return NO_ERROR;
        }

        #endregion Low level methods

        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

        #region NC Low-level function: Parameters

        public override CmsError NC_RParam(short Index, short Bit, ref bool Value)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError NC_RParam(short Index, ref byte Value)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError NC_RParam(short Index, ref short Value)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError NC_RParam(short Index, ref int Value)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError NC_RParam(short Index, ref double Value)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        #endregion NC Low-level function: Parameters

        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

        #region File Management

        /// <summary>
        /// Get list of recipe (from local PC area)
        /// </summary>
        /// <param name="path"></param>
        /// <param name="file"></param>
        /// <returns></returns>
        public CmsError FILES_RecipeList(string path, ref List<PreviewFileModel> file)
        {
            return NO_ERROR;

        }

        /// <summary>
        /// Load selected recipe, convert and save to PLC memory area
        /// </summary>
        /// <param name="path"></param>
        /// <param name="name"></param>
        /// <returns></returns>
        public CmsError FILES_LoadRecipe(string path, string name)
        {
            return NO_ERROR;
        }
        /// <summary>
        /// Save current recipe from  PLC memory area to file
        /// </summary>
        /// <param name="path"></param>
        /// <param name="name"></param>
        /// <returns></returns>
        public CmsError FILES_SaveRecipe(string path, string name)
        {
            return NO_ERROR;
        }

        public override CmsError FILES_RGetFileList(string path, ref List<PreviewFileModel> files)
        {

#if false
            string[] rootFolders = { "WKS.DIR", "MPF.DIR", "SPF.DIR" };
            try
            {
                string tmpPath = FormatPath(path);

                FileSvc fileSvc = new FileSvc();
                // Preapare folder node
                Node folderNode = new Node(BASE_FILE_PATH + tmpPath);
                // Read files in the folder
                List<Node> nodeArray = fileSvc.List(folderNode).ToList();

                // Go through the array of file nodes
                foreach (Node element in nodeArray)
                {
                    PreviewFileModel file = new PreviewFileModel();
                    if (path == "\\\\")
                    {
                        if (rootFolders.Contains(element.Name))
                        {
                            file = new PreviewFileModel()
                            {
                                Path = path + "\\" + element.Name,
                                IsDirectory = element.IsDirNode,
                                Name = GetStringUntilOrEmpty(element.Name, "."),
                                AbsolutePath = element.LogicalPath
                            };
                            files.Add(file);
                        }
                    }
                    else
                    {
                        file = new PreviewFileModel()
                        {
                            Path = path + "\\" + element.Name,
                            IsDirectory = element.IsDirNode,
                            Name = element.IsDirNode ? GetStringUntilOrEmpty(element.Name, ".") : element.Name,
                            AbsolutePath = element.LogicalPath
                        };
                        files.Add(file);
                    }

                    // ACCESS LEVEL CHECK (REMOVED TEMPORARILY)
                    //if (element.AccessRights.List == AccessLevel.KEY_0)
                    //{
                    //    var file = new PreviewFileModel()
                    //    {
                    //        Path = path + "\\" + element.Name,
                    //        IsDirectory = element.IsDirNode,
                    //        Name = element.Name,
                    //        AbsolutePath = element.LogicalPath
                    //    };

                    //    files.Add(file);
                    //}
                }
            }
            catch (Exception ex)
            {
                return ManageException(ex);
            }
#endif
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError FILES_RGetFileInfo(string path, ref InfoFile fileInfo)
        {
#if false
            try
            {
                FileSvc fileSvc = new FileSvc();
                // Preapare folder node
                Node fileNode = new Node(path);

                if (fileNode != null)
                {
                    string filePath = "C://CMS//Active//TMP//" + fileNode.Name;
                    FileStream str = new FileStream(filePath, FileMode.Create);
                    CmsError cmsError = FILES_RProgramToFile(path, str);
                    if (cmsError.IsError())
                        return cmsError;
                    fileInfo = new InfoFile()
                    {
                        CreationDate = fileNode.Attributes.LastAccess,
                        LastModDate = fileNode.Attributes.LastAccess,
                        Name = fileNode.Name,
                        Content = File.ReadAllLines(filePath).ToList(),
                        // PreviewBase64 = FindImageBase64String(IMAGES_PATH, fileNode.Name),
                        AbsolutePath = fileNode.LogicalPath
                    };

                    str.Close();
                    File.Delete(filePath);
                }
            }
            catch (Exception ex)
            {
                return ManageException(ex);
            }

            return NO_ERROR; 
#endif

            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError FILES_WSetActiveProgram(int processId, string filePath, ref ActiveProgramDataModel data)
        {
#if false
            try
            {
                // string ncPath = FormatPath(filePath);

                FileSvc fileSvc = new FileSvc();

                // Preapare folder node
                Node selectedNode = new Node(filePath);

                if (!selectedNode.Exists)
                    return FILE_NOT_FOUND_ERROR;

                // Check if file is stored on NC
                if (filePath.StartsWith(BASE_FILE_PATH))
                    fileSvc.Select(selectedNode, processId);
                else
                    fileSvc.SelectExtern(selectedNode, processId);

                return FILES_RActiveProgramData(processId, ref data);
            }
            catch (Exception ex)
            {
                return ManageException(ex);
            } 
#endif

            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError FILES_WDeactivateProgram(int processId)
        {
#if false
            try
            {
                string[] piArgs = new string[4];
                piArgs[0] = "/NC";
                piArgs[1] = (200 + processId).ToString();
                piArgs[2] = "/MPF0";
                piArgs[3] = "_N_SELECT";

                PiSvc pi = new PiSvc(piArgs);
                pi.Start();
            }
            catch (Exception ex)
            {
                return ManageException(ex);
            }
            return NO_ERROR; 
#endif

            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError FILES_RActiveProgramData(int processId, ref ActiveProgramDataModel programData)
        {
#if false
            try
            {
                //Setup variables
                DataSvc dataSvc = new DataSvc();

                // Read position and tool data
                List<Item> itemRead = new List<Item>()
                            {
                                new Item($"/Channel/ProgramInfo/workPandProgName[u{processId}]"),
                                new Item($"/Channel/ProgramInfo/actPartProgram[u{processId}]")
                            };

                //Read Data
                dataSvc.Read(itemRead.ToArray());

                // Elaborate String
                string trimString = ((string)itemRead[0].Value);
                trimString = trimString.Replace("_N_", "");
                int lastUnderscore = trimString.LastIndexOf("_");
                if (lastUnderscore >= 0)
                    trimString = trimString.Remove(lastUnderscore, 1).Insert(lastUnderscore, ".");

                // check if is the NULL Program
                if (trimString == "/MPF0")
                {
                    programData = new ActiveProgramDataModel()
                    {
                        Path = "",
                        IsoLines = new List<string>(),
                        TimeLeft = new DateTime()
                    };
                    return NO_ERROR;
                }

                // Separate string into list of lines
                List<string> isoLines = itemRead[1]
                    .Value
                    .ToString()
                    .Split('\n') // Line separator
                    .Skip(1) // The actPartProgram read starting with the line before the current
                    .ToList();

                programData = new ActiveProgramDataModel()
                {
                    Path = trimString,
                    IsoLines = isoLines,
                    TimeLeft = new DateTime()
                };
            }
            catch (Exception ex)
            {
                return ManageException(ex);
            }

            return NO_ERROR; 
#endif

            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError FILES_UploadPartProgram(string localPath, string name, ref string newFilePath)
        {
#if false
            File.Copy(localPath + name, PART_PRG_PATH + name, true);

            newFilePath = PART_PRG_PATH + name;

            return NO_ERROR; 
#endif

            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError FILES_CopyProgram(string partProgramPath, string newPartProgramPath, bool failIfExist)
        {
#if false
            //Check if the NC is Connected
            CmsError cmsError = CheckConnection();
            if (cmsError.IsError())
                return cmsError;
            try
            {
                //Setup variables
                FileSvc FileData = new FileSvc();
                Node sourceNode = new Node(partProgramPath);
                Node destNode = new Node(newPartProgramPath);

                //Execute Function
                FileData.Copy(sourceNode, destNode, failIfExist);
            }
            catch (Exception ex)
            {
                return ManageException(ex);
            }

            return NO_ERROR; 
#endif

            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError FILES_DeleteProgram(string partProgramPath, string partProgramName)
        {
#if false
            //Check if the NC is Connected
            CmsError cmsError = CheckConnection();
            if (cmsError.IsError())
                return cmsError;

            try
            {
                // Setup variables
                FileSvc FileData = new FileSvc();
                Node sourceNode = new Node(partProgramPath);

                //Execute Function
                FileData.Delete(sourceNode);
            }
            catch (Exception ex)
            {
                return ManageException(ex);
            }

            return NO_ERROR; 
#endif

            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError FILES_RProgramToFile(string partProgramPath, FileStream localFile)
        {
#if false
            // Check if the NC is Connected
            CmsError cmsError = CheckConnection();
            if (cmsError.IsError())
                return cmsError;

            try
            {
                // Setup variables
                string tmpFile = Path.GetTempFileName();
                FileSvc FileData = new FileSvc();
                Node sourceNode = new Node(partProgramPath);
                Node destNode = new Node(tmpFile);

                // Execute Function
                FileData.Copy(sourceNode, destNode, true);

                FileStream tmpFileStream = new FileStream(tmpFile, FileMode.Open);

                // Write to local file
                WriteLocalFile(ReadLocalFile(tmpFileStream), ref localFile);

                tmpFileStream.Close();
                // Delete temporary file
                File.Delete(tmpFile);
            }
            catch (Exception ex)
            {
                return ManageException(ex);
            }

            return NO_ERROR; 
#endif

            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError FILES_WProgramFromFile(string partProgramPath, FileStream localFile)
        {
#if false
            //Check if the NC is Connected
            CmsError cmsError = CheckConnection();
            if (cmsError.IsError())
                return cmsError;

            try
            {
                // Setup variables
                FileSvc FileData = new FileSvc();
                Node sourceNode = new Node(localFile.Name);
                Node destNode = new Node(partProgramPath);

                //Execute Function
                FileData.Copy(sourceNode, destNode, true);
            }
            catch (Exception ex)
            {
                return ManageException(ex);
            }

            return NO_ERROR; 
#endif

            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError FILES_RQueueData(ref List<QueueStatusModel> statusList)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError FILES_RQueueDataByProcess(ref QueueStatusModel status, int processId)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError FILES_WStartQueue()
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError FILES_WStopQueue()
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError FILES_WLoadNextPartProgram(string localPath, string ncFileName)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError FILES_WUploadJobFilesAndActivate(int processId, string jobExtractedPath, string fileToActivate)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError FILES_RGetProgramType(ref PROGRAM_TYPE_ENUM programType)
        {
            programType = PROGRAM_TYPE_ENUM.PART_PROGRAM;

            return NO_ERROR;
        }

        public override CmsError FILES_WCleanUploadFolder()
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError FILES_WUploadCustomMainProgramAndActivate(int processId, string customPartProgramContent, ref ActiveProgramDataModel activeData)
        {
#if false
            string customMainName = string.Format(CUSTOM_MAIN_PROGRAM, processId);

            string newFilePath = "";
            CmsError cmsError = FILES_UploadPartProgram(customPartProgramContent, customMainName, ref newFilePath);
            if (cmsError.IsError())
                return cmsError;

            cmsError = FILES_WSetActiveProgram(processId, newFilePath, ref activeData);
            if (cmsError.IsError())
                return cmsError;

            return NO_ERROR; 
#endif

            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        private IEnumerable<string> GetLinesFromString(string text)
        {
            string line;
            using (StringReader reader = new StringReader(text))
            {
                while ((line = reader.ReadLine()) != null)
                {
                    yield return line;
                }
            }
        }

        private string FormatPath(string path)
        {
            path = path.TrimStart('\\');
            path = path.TrimStart('/');
            path = path.TrimEnd('\\');

            return path.Replace('\\', '/');
        }

        #endregion File Management

        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

        #region Siemens Tools Management

        public override CmsError TOOLS_RConfiguration(ref ToolTableConfiguration config)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_RToolsData(ref List<SiemensToolModel> toolTable)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_RShanksData(ref List<ShankModel> shanksData)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_RFamilyData(ref List<FamilyModel> families)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_RMagazinePositions(ref List<PositionModel> positions)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WAddTool(ref SiemensToolModel tool)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WAddFamily(ref FamilyModel family)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WAddShank(ref ShankModel shank)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WUpdateFamilyData(string oldName, string newName)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WUpdatePosition(PositionModel position)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WUpdateTool(ref SiemensToolModel tool)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WDeleteTool(int id)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WDeleteShank(int id)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WDeleteFamily(string name)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WDeleteEdge(int toolId, int edgeId)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WAddEdge(int toolId, ref EdgeModel edge)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WUpdateEdge(int toolId, ref EdgeModel newEdge)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WUpdateShank(ref ShankModel shank)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_RMountedTools(int magazineId, ref List<MountedToolModel> magazinePos)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_RAvailableTools(ref List<ShankModel> multiTools, ref List<SiemensToolModel> tools)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WLoadToolInMagazine(int magazine, NewToolInMagazineModel newMagazineTool, ref MountedToolModel newMountedTool)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WUnloadToolFromMagazine(int magazineId, int positionId)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WLoadToolIntoShank(int shankId, int positionId, int toolId)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WUnloadToolFromShank(int shankId, int positionId)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_RMagazineAction(ref MagazineActionModel magazineAction)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WStartTDILoading(ushort magazineId, ushort positionId)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WStartTDIUnloading(ushort magazineId, ushort positionId, ushort toolId)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WEmptyBallufTablet(SiemensToolModel tool)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WAbortBallufTablet()
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        #endregion Siemens Tools Management

        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

        #region Nc Tool Manager

        public override CmsError TOOLS_RMagazineConfig(ref List<NcMagazineConfigModel> config)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WOptions(ToolManagerOptionsModel options)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_ROffset(short offsetId, ref OffsetModel offset)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WOffset(short offsetId, ref OffsetModel offset)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WStartEditData()
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WStopEditData()
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WUpdateTools(List<NcToolModel> list)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WUpdateFamilies(List<NcFamilyModel> list)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WUpdateShanks(List<NcShankModel> list)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WUpdateMagazinePositions(List<NcMagazinePositionModel> list)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WStartEditTooling(int magazineId)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WStopEditTooling(int magazineId)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WRestoreBackup()
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_RUpdatedToolsData(ref Dictionary<int, byte> updatedStatus, ref Dictionary<int, uint> updatedLives)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_RStoredData(ref List<NcToolModel> tools, ref List<NcFamilyModel> families, ref List<NcShankModel> shanks)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_RMagazineBlock(ref List<int> ids)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WFreeMagazines()
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_RMagazineStatus(ref Dictionary<int, bool> magazineStatus)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_RAdatpivePathStep(ref Byte step)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        public override CmsError TOOLS_WAdatpivePathStep(Byte step)
        {
            return FUNCTION_NOT_ALLOWED_ERROR;
        }

        #endregion Nc Tool Manager

        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

        #region Subordinate Private Functions

#if false
        // Manage the Alarms - Called automatically on changes
        private void AlarmsChanged(Guid guid, Alarm[] alarms)
        {
            try
            {
                if (alarms != null)
                    SiemensAlarms = alarms.ToArray();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            } 
        } 
#endif

        private void NcLanguageChanged(string language)
        {
#if false
            SiemensAlmSvc.UnSubscribe(AlarmsChanged);
            // SiemensAlmSvc.Dispose();
            SiemensAlmSvc = new AlarmSvc(language);
            SiemensAlmSvc.Subscribe(AlarmsChanged); 
#endif
        }

        private int SetBitValue(int intVal, bool val, int bitIndex)
        {
            if (val)
                return intVal | (1 << (bitIndex - 1));
            else
                return intVal & ~(1 << (bitIndex - 1));
        }

        //Manage the Mode
        private PROC_MODE ConvertToSTEPMode(uint mode, uint JogMode, uint AdvMode)
        {
            if (mode == 0)
            {
                if (AdvMode == 0)
                    return (JogMode < 6) ? PROC_MODE.JOGINC : PROC_MODE.JOG;
                else if (AdvMode == 1)
                    return PROC_MODE.RETPROF;
                else if (AdvMode == 2)
                    return PROC_MODE.TEACH;
                else if (AdvMode == 3)
                    return PROC_MODE.REF;
            }
            else if (mode == 1)
                return PROC_MODE.MDI;
            else if (mode == 2)
                return PROC_MODE.AUTO;

            return PROC_MODE.ERROR;
        }

        //Manage the Status
        private PROC_STATUS ConvertToSTEPStatus(uint status)
        {
            switch (status)
            {
                case 0: return PROC_STATUS.IDLE;
                case 1: return PROC_STATUS.RUN;
                case 2: return PROC_STATUS.HOLD;
            }
            return PROC_STATUS.ERROR;
        }

        //Check Bit In Range
        private CmsError CheckBitRange(int bitnum)
        {
            if (bitnum < 0 || bitnum > 7)
                return BIT_NOT_IN_RANGE_ERROR;

            return NO_ERROR;
        }

        // Check if Memory Area is corrected
        private CmsError ConvertMemToPath(MEMORY_TYPE MemoryType, int Address, int SubAddress, int SubBit, int Qty, char MemAccess, out string item)
        {
            char[] allowedAccess = { 'X', 'B', 'W', 'D' };

            //Check if is the right area and allowed type
            if (!MemoryType.ToString().StartsWith(SIEMENS_MEMTYPE) || !allowedAccess.Contains(MemAccess) || Qty < 1)
            {
                item = "";
                return INCORRECT_PARAMETERS_ERROR;
            }
            else
            {
                //If is Bit Access change access type
                if (MemAccess == 'X')
                    item = "DB" + Address + ".DB" + MemAccess + SubAddress + "." + SubBit;
                else
                    item = "DB" + Address + ".DB" + MemAccess + SubAddress + "[" + Qty + "]";

                return NO_ERROR;
            }
        }

        // Check if NC is connected
        private CmsError CheckConnection()
        {
            if (!NC_IsConnected())
                return NOT_CONNECTED_ERROR;

            return NO_ERROR;
        }

        /// <summary>
        /// Check if PLC is responding to Ping
        /// </summary>
        /// <returns></returns>
        private CmsError CheckS7Ping()
        {

            // faccio ping...
            if (testPing() != IPStatus.Success)
                return PLC_IP_NOT_FOUND_ERROR;
            return NO_ERROR;
        }


        /// <summary>
        /// Ping test to configured Ip address
        /// </summary>
        /// <returns></returns>
        private IPStatus testPing()
        {
            IPStatus answ = IPStatus.Unknown; ;
            IPAddress address;
            PingReply reply;
            Ping pingSender = new Ping();
            address = IPAddress.Loopback;
            IPAddress.TryParse(this.Ip, out address);
            reply = pingSender.Send(address, 100);
            answ = reply.Status;
            return answ;
        }

        //Manage the Exception Launch
        private CmsError ManageException(Exception ex)
        {
            // Catch the S7Net exceptions
            if (ex.Message.Contains(NcNotFound) || ex.Message.Contains(NcNotFound2) || ex.Message.Contains(NcNotFound3) || ex.Message.Contains("Read() failed:"))
            {
                Connected = false;
                return NOT_CONNECTED_ERROR;
            }
            else
            {
                return CmsError.InternalError(ex.Message, ex);
            }
        }

        // Create and return CmsError object
        private CmsError GetError(string message)
        {
            return CmsError.NcError(message);
        }

        //Read Static Data
        private CmsError ReadStaticNCData()
        {
            //Check if the NC is Connected
            CmsError cmsError = CheckConnection();
            if (cmsError.IsError())
                return cmsError;

            // Read oly one time every X seconds
            if (DateTime.Now - Last_Static_Read > new TimeSpan(NC_MIN_SEC_READ_STATIC_DATA * TimeSpan.TicksPerSecond))
            {
                //Try to get information
                try
                {
                    // completare nuove variabili (matricola macchina, seriale PLC, firmware PLC)
                    S7Language = 0;
                    ConfChannelNo = 1;
                    Last_Static_Read = DateTime.Now;
                    Cnc_name = $"{currPLC.CPU}";
                    // FIXME
                    Cms_MachNumber = "0000"; // matricola macchina, DB604.DBB6720..6723
                    Cnc_SftVersion = "SMC000"; // versione SW del firmware PLC/CNC | DB604.DBB6724..6745
                    Cnc_SeriesNum = "SMC111"; // seriale PLC/CNC | DB604.DBB6746..6763
                    PlcFirmware_SerialNum = "V.0.0.0"; // seriale PLC/CNC | DB604.DBB6764..6767
                    UnitOfMeasure = MILLIMETERS;
                }
                catch (Exception ex)
                {
                    return ManageException(ex);
                }
            }

            return NO_ERROR;
        }

        // Convert the internal Name var in Readable STEP Name
        private string GetName(uint value)
        {
            string name = "Siemens ";
            switch (value)
            {
                case 0: name += "840D pl"; break;
                case 1000: name += "FM-NC"; break;
                case 2000: name += "810D pl"; break;
                case 3000: name += "802S"; break;
                case 4000: name += "802D pl"; break;
                case 5000: name += "840Di pl"; break;
                case 6000: name += "SOLUTIONLINE"; break;
                case 10700: name += "840D sl"; break;
                case 14000: name += "802D sl T/M - N/G - C/U"; break;
                case 15000: name += "840Di sl"; break;
            }
            return name;
        }

        //Convert to Step Language
        private CultureInfo ConvertToSTEPLanguage(uint language)
        {
            switch (language)
            {
                case 1: return new CultureInfo("de");
                case 2: return new CultureInfo("fr");
                case 3: return new CultureInfo("en");
                case 4: return new CultureInfo("es");
                case 6: return new CultureInfo("it");
                case 7: return new CultureInfo("nl");
                case 8: return new CultureInfo("zh-CHS");
                case 9: return new CultureInfo("sv");
                case 18: return new CultureInfo("hu");
                case 19: return new CultureInfo("fi");
                case 26: return new CultureInfo("el");
                case 28: return new CultureInfo("cs");
                case 50: return new CultureInfo("pt-BR");
                case 53: return new CultureInfo("pl");
                case 55: return new CultureInfo("da");
                case 57: return new CultureInfo("ru");
                case 65: return new CultureInfo("hr-HR");
                case 68: return new CultureInfo("sk");
                case 69: return new CultureInfo("sl");
                case 72: return new CultureInfo("ro");
                case 75: return new CultureInfo("bg");
                case 80: return new CultureInfo("zh-CHT");
                case 85: return new CultureInfo("ko");
                case 87: return new CultureInfo("ja");
                case 89: return new CultureInfo("tr");
                case 122: return new CultureInfo("id");
                case 212: return new CultureInfo("th");
                case 213: return new CultureInfo("vi");
                case 230: return new CultureInfo("ms");
                default: return new CultureInfo("en");
            }
        }

        //Convert to Step Language
        private string ConvertToNCLanguage(CultureInfo language)
        {
            return language.ThreeLetterISOLanguageName;
        }

        private int SwapIntEndianFormat(int value)
        {
            var b1 = (value >> 0) & 0xff;
            var b2 = (value >> 8) & 0xff;
            var b3 = (value >> 16) & 0xff;
            var b4 = (value >> 24) & 0xff;

            return b1 << 24 | b2 << 16 | b3 << 8 | b4 << 0;
        }

        private short SwapShortEndianFormat(short value)
        {
            var b1 = (value >> 0) & 0xff;
            var b2 = (value >> 8) & 0xff;

            return (short)(b1 << 8 | b2 << 0);
        }

        private ushort SwapShortEndianFormat(ushort value)
        {
            var b1 = (value >> 0) & 0xff;
            var b2 = (value >> 8) & 0xff;

            return (ushort)(b1 << 8 | b2 << 0);
        }

        private List<int> ChangeIntListEndianess(List<int> bigEndianvalues)
        {
            List<int> littleEndianValues = new List<int>();
            foreach (int value in bigEndianvalues)
            {
                var a = SwapIntEndianFormat(value);
                littleEndianValues.Add(a);
            }

            return littleEndianValues;
        }

        private List<ushort> ChangeUShortListEndianess(List<ushort> bigEndianvalues)
        {
            List<ushort> littleEndianValues = new List<ushort>();
            foreach (ushort value in bigEndianvalues)
            {
                var a = SwapShortEndianFormat(value);
                littleEndianValues.Add(a);
            }

            return littleEndianValues;
        }

        private bool PositionContainsTool(MountedToolModel mounted, int toolId)
        {
            if (mounted.ToolId == toolId)
                return true;
            //else
            //{
            //    // Check if tool is a multitool child
            //    foreach (var multi in MultitoolsData)
            //    {
            //        // Check childs id
            //        int index = multi.ChildsTools.FindIndex(x => x.Id == toolId);
            //        if (index >= 0)
            //            return true;
            //    }
            //}

            return false;
        }

        //private void CheckData(object obj, List<FieldsConfiguration> config)
        //{
        //    foreach(PropertyInfo prop in obj.GetType().GetProperties())
        //    {
        //        bool val = config.Where(x => x.Name == prop.Name).Select(x => x.);
        //    }
        //}

        private string ConvertStepToSiemensScreen(SCREEN_PAGE page)
        {
            switch (page)
            {
                case SCREEN_PAGE.Siemens_Machine: return "AreaMachine";
                case SCREEN_PAGE.Siemens_Parameter: return "AreaParameter";
                case SCREEN_PAGE.Siemens_Program: return "AreaProgramEdit";
                case SCREEN_PAGE.Siemens_ProgramManager: return "AreaProgramManager";
                case SCREEN_PAGE.Siemens_Setup: return "AreaStartup";
                case SCREEN_PAGE.Siemens_Diagnostics: return "AreaDiagnosis";
                default: return "";
            }
        }

        #endregion Subordinate Private Functions


    }


    internal static class MEMORY_ADDRESS
    {
        // Tabella DB principale
        internal const int TABLE = 604;

        // aree Parametri
        internal static MEMORY_CELL PARAMETER_DATA = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, 600, 20, 8000);
        internal static MEMORY_CELL PARAMETER_RT_DATA = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, 601, 8, 3200);

        // aree Moduli
        internal static MEMORY_CELL MODULE_DATA = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, 602, 18, 2304);
        internal static MEMORY_CELL MODULE_RT_DATA = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, 603, 12, 1536);

        // riscaldi 
        internal static MEMORY_CELL RISC_OCC_DATA = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, 500, 64, 64);
        internal static MEMORY_CELL RISC_CHP_DATA = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, 500, 128, 1024);
        internal static MEMORY_CELL RISC_CFI_DATA = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, 500, 2176, 1024);
        internal static MEMORY_CELL RISC_ICH_MIN_DATA = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, 500, 3200, 4096);
        internal static MEMORY_CELL RISC_OCS_DATA = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, 500, 9472, 64);
        internal static MEMORY_CELL RISC_ESP_DATA = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, 500, 9728, 1024);
        internal static MEMORY_CELL RISC_OVP_DATA = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, 500, 10752, 1024);
        internal static MEMORY_CELL RISC_ICH_DATA = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, 500, 11776, 4096);

        // produzione
        internal static MEMORY_CELL PROCESS_STATUS = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, 605, 0, 2);

        // Machine number
        internal static MEMORY_CELL NEW_MATR_MACC = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, 604, 6720, 4);

        // generic machine gauge data
        internal static MEMORY_CELL MACHINE_GAUGE_DATA = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, 605, 6, 16);


        internal static MEMORY_CELL NC_WATCHDOG = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 0, 1);
        internal static MEMORY_CELL ACTIVE_WATCHDOG = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 2, 1);

        internal static MEMORY_CELL ACTIVE_CLIENT = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 4, 1);

        internal static MEMORY_CELL FUNCTION_ACCESS = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 6, 8);

        internal static MEMORY_CELL PRE_POST_POWER_ON = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 6542, 4);
        //internal static MEMORY_CELL PRE_POST_POWER_ON_CLICKABLE = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 2576, 2);
        internal static MEMORY_CELL PRE_POST_POWER_ON_ACK = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 2578, 2);
        internal static MEMORY_CELL PRE_POST_POWER_ON_CLICKED = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 2580, 2);

        internal static MEMORY_CELL AXIS_RESET_PROCEDURE = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 2608, 1);

        internal static MEMORY_CELL SELECTED_PROCESS = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 2582, 24);
        internal static MEMORY_CELL SELECT_PROCESS = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 2606, 1);

        internal static MEMORY_CELL COUNTERS = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 0, 40);

        internal static MEMORY_CELL SELECTED_AXIS = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 2626, 1);
        internal static MEMORY_CELL SELECT_AXIS = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 2627, 1);

        internal static MEMORY_CELL NC_SOFTKEYS_VALUE = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 2610, 4);
        internal static MEMORY_CELL NC_SOFTKEYS_CLICKABLE = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 2614, 4);
        internal static MEMORY_CELL NC_SOFT_KEYS_ACK = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 2618, 4);
        internal static MEMORY_CELL NC_SOFT_KEYS_CLICKED = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 2622, 4);

        internal static MEMORY_CELL USER_SOFTKEYS_VALUE = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 6552, 16);
        internal static MEMORY_CELL USER_SOFTKEYS_CLICKABLE = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 6568, 16);
        internal static MEMORY_CELL USER_SOFT_KEYS_ACK = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 6584, 16);
        internal static MEMORY_CELL USER_SOFT_KEYS_CLICKED = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 6616, 16);

        internal static MEMORY_CELL ALARMS_STATUS = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 14, 128);
        internal static MEMORY_CELL ALARMS_DATA = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 142, 1024);

        internal static MEMORY_CELL ALARM_ACK = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 2190, 128);
        internal static MEMORY_CELL ALARM_RESTORATION_STROBE = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 2318, 128);
        internal static MEMORY_CELL ALARM_REFRESH_STROBE = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 2446, 128);

        internal static MEMORY_CELL HEADS_DATA = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 2692, 240);

        internal static MEMORY_CELL HEADS_ACK = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 2932, 4);
        internal static MEMORY_CELL HEADS_STROBE_INCREMENT = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 2936, 4);
        internal static MEMORY_CELL HEADS_STROBE_DECREMENT = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 2940, 4);

        internal static MEMORY_CELL COUNTERS_DATA = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 2944, 64);
        internal static MEMORY_CELL COUNTER_IS_RESETTABLE = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 3008, 2);
        internal static MEMORY_CELL COUNTER_IS_RESETTABLE_ACK = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 3010, 2);
        internal static MEMORY_CELL COUNTER_IS_RESETTABLE_STROBE = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 3012, 2);

        internal static MEMORY_CELL M155_INPUT_NEEDED = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 3014, 1);
        internal static MEMORY_CELL M155_INPUT_ACK = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 3015, 1);
        internal static MEMORY_CELL M155_INPUT_STROBE = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 3016, 1);

        internal static MEMORY_CELL M156_INPUT_NEEDED = new MEMORY_CELL(MEMORY_TYPE.Osai_MW, 4333, 1);
        internal static MEMORY_CELL M156_INPUT_ACK = new MEMORY_CELL(MEMORY_TYPE.Osai_MW, 4335, 1);
        internal static MEMORY_CELL M156_INPUT_STROBE = new MEMORY_CELL(MEMORY_TYPE.Osai_MW, 4337, 1);
        internal static MEMORY_CELL M156_INPUT_ID_LIST = new MEMORY_CELL(MEMORY_TYPE.Osai_MW, 4339, 8);

        internal static MEMORY_CELL M154_ACK = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 3042, 1);
        internal static MEMORY_CELL M154_STROBE = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 3043, 1);
        internal static MEMORY_CELL M154_SWITCH_ONOFF = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 0, 2);

        internal static MEMORY_CELL AXES_BUTTON_VISIBLE = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 3044, 16);

        internal static MEMORY_CELL MAGAZINE_ACTION = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, TABLE, 4000, 16);


        //old CMS-Control variables
        internal static MEMORY_CELL HEADS_WORKED_TIMES = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, 254, 60, 4);
        internal static MEMORY_CELL HEAD_RESET_WORKED_TIME = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, 255, 92, 4);
        internal static MEMORY_CELL MACHINE_WORKED_TIME = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, 255, 94, 4);
        internal static MEMORY_CELL MACHINE_RESET_WORKED_TIME = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, 255, 98, 4);
        internal static MEMORY_CELL CANDY_MEM = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, 255, 130, 1);
        internal static MEMORY_CELL EXP_CANDY_MEM = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, 255, 92, 1);


    }
}