Mapo-IOB-WIN/IOB-WIN-NEXT/IobModbusTCPZetapack.cs

using EasyModbus;
using System;

namespace IOB_WIN_NEXT
{
    /* --------------------------------------------------------------------------------
    * Controlli ModBusTCP Zetapack
    * - protocollo ModBus TCP
    * - specifico comportamento impianti imballaggio Zetapack (Giacovelli)
    * - gestione allarmi
    *
    * STRUTTURA MEMORIA a banchi di UInt16, convertiti successivamente in int EVENTUALMENTE divisi per 10/100/1000
    * G:\Drive condivisi\30_Clienti\Giacovelli - WIL\Zetapack PLC
    *
    * -------------------------------------------------------------------------------- */

    public class IobModbusTCPZetapack : IobModbusTCP
    {
        #region Public Constructors

        /// <summary>
        /// Classe base con i metodi x ModBusTCP
        /// </summary>
        /// <param name="caller"></param>
        /// <param name="IOBConf"></param>
        public IobModbusTCPZetapack(AdapterForm caller, IobConfiguration IOBConf) : base(caller, IOBConf)
        {
            lgInfo("NEW IOB ModBus TCP Zetapack");

            // provo lettura una prima volta i dati DYN
            if (currPLC != null && currPLC.Connected)
            {
                try
                {
                    processDynData();
                }
                catch (Exception exc)
                {
                    lgError($"Eccezione in processDynData iniziale x ModBus TCP IMAS Aeromec:{Environment.NewLine}{exc}");
                }
            }
        }

        #endregion Public Constructors

        #region Protected Properties

        /// <summary>
        /// Restituisce status di AUTOmatico, hard coded
        /// </summary>
        protected bool Auto
        {
            get
            {
                return testCondition("WorkBitCond");
#if false
                bool answ = false;
                int currStatus = 0;
                // hard coded
                int statusReg = 40002;
                int[] listInt = new int[2];
                listInt = HoldingRegisterLUT[statusReg];
                currStatus = ModbusClient.ConvertRegistersToInt(listInt);
                // hard coded il 5° bit
                answ = ((currStatus & (1 << 14)) > 0);
                return answ;
#endif
            }
        }

        /// <summary>
        /// Restituisce status di ESTOP triggered (triggered = premuta, altrimenti armed)
        /// </summary>
        protected bool EStopTriggered
        {
            get
            {
                return testCondition("EStopBitCond");
            }
        }

        /// <summary>
        /// Restituisce status di LAVORA, hard coded
        /// </summary>
        protected bool Work
        {
            get
            {
                return testCondition("WorkBitCond");
#if false

                bool answ = false;
                int currStatus = 0;
                // hard coded
                int statusReg = 40002;
                int[] listInt = new int[2];
                listInt = HoldingRegisterLUT[statusReg];
                currStatus = ModbusClient.ConvertRegistersToInt(listInt);
                // hard coded il 5° bit
                answ = ((currStatus & (1 << 0)) > 0);
                return answ;
#endif
            }
        }

        #endregion Protected Properties

        #region Protected Methods

        /// <summary>
        /// Effettua decodifica aree memoria alla bitmap usata x MAPO
        /// </summary>
        protected override void decodeToBaseBitmap()
        {
            // init a zero...
            B_input = 0;

            /* -----------------------------------------------------
             * bitmap MAPO STANDARD 60
             * B0: POWER_ON
             * B1: RUN
             * B2: pzCount
             * B3: allarme
             * B4: manuale
             * B5: slowTC
             * B6: WarmUpCoolDown
             * B7: EmergArmata
             *
             ----------------------------------------------------- */

            var MemInt = new byte[2];

            int byteSignals = 0;
            // bit 0 (poweron) imposto a 1 SE connected...
            if (currPLC.Connected)
            {
                byteSignals += (1 << 0);
            }
            if (HoldingRegisterLUT != null && HoldingRegisterLUT.Count > 0)
            {
                // se emergenza NON premuta (triggered) indico OK (armata...)
                if (!EStopTriggered)
                {
                    byteSignals += (1 << 7);
                }

                // processo dagli stati + gravi...
                if (hasAlarms())
                {
                    byteSignals += (1 << 3);
                }
                if (Work)
                {
                    byteSignals += (1 << 1);
                }
                if (!Auto)
                {
                    byteSignals += (1 << 4);
                }
            }
            else
            {
                lgInfo("HoldingRegisterLUT vuoto!");
            }

            // salvo!
            B_input = byteSignals;
        }

        #endregion Protected Methods

        #region Private Methods

        private void testBlockRead(int baseAddr, int numByte)
        {
            int baseHold = 40001;
            int[] readTestFull = new int[2];
            lgTrace($"-------------------- Inizio test lettura {baseAddr} --------------------");
            try
            {
                stopwatch.Restart();
                readTestFull = currPLC.ReadHoldingRegisters(baseAddr - baseHold, numByte);
                stopwatch.Stop();
                lgTrace($"Stats lettura | {readTestFull.Length} val | {stopwatch.ElapsedMilliseconds}ms");
            }
            catch
            { }

            for (int i = 0; i < readTestFull.Length / 2; i++)
            {
                int[] thisSet = new int[2];
                Array.Copy(readTestFull, i * 2, thisSet, 0, 2);
                lgTrace($"{baseAddr + i * 2:000} | HoldingRegisters: {thisSet[0]} / {thisSet[1]} | Val Real: {ModbusClient.ConvertRegistersToFloat(thisSet):N6}");
            }
            lgTrace("-------------------- Completato test lettura {baseAddr} --------------------");
        }

        /// <summary>
        /// Testa la condition modbus da LUT + configurazione
        /// </summary>
        /// <param name="cKey"></param>
        /// <returns></returns>
        private bool testCondition(string cKey)
        {
            bool answ = false;
            if (OptCheckConditions.ContainsKey(cKey))
            {
                int currStatus = 0;
                int[] listInt = new int[2];
                listInt = HoldingRegisterLUT[OptCheckConditions[cKey].BaseAddr];
                currStatus = ModbusClient.ConvertRegistersToInt(listInt);
                // hard coded il 9° bit a zero
                answ = ((currStatus & (1 << OptCheckConditions[cKey].BitNum)) == OptCheckConditions[cKey].ValOk);
                lgTrace($"testCondition for {cKey} | BaseAddr: {OptCheckConditions[cKey].BaseAddr} | BitNum: {OptCheckConditions[cKey].BitNum} | ValOk: {OptCheckConditions[cKey].ValOk}");
            }
            else
            {
                lgTrace($"testCondition error: {cKey} not found");
            }
            return answ;
        }

        private void testRead()
        {
            foreach (var item in memSetR)
            {
                testBlockRead(item.Key, item.Value);
            }
        }

        #endregion Private Methods
    }
}