Mapo-IOB-WIN/IOB-WIN-NEXT/IobOpc/OpcUaEwonAdige.cs

using MapoSDK;
using Opc.Ua;
using System.Collections.Generic;
using System.Linq;

namespace IOB_WIN_NEXT.IobOpc
{
    public class OpcUaEwonAdige : OpcUaEwon
    {
        #region Public Constructors

        /// <summary>
        /// Estende l'init della classe base, impiegando il pacchetto Nuget OPC-UA foundation con la
        /// gestione specifica per EWON (es Adige/BLM, Stel) 
        /// https://github.com/OPCFoundation/UA-.NETStandard
        /// </summary>
        /// <param name="caller"></param>
        /// <param name="IOBConf"></param>
        public OpcUaEwonAdige(AdapterForm caller, IobConfiguration IOBConf) : base(caller, IOBConf)
        {
            lgInfo("Init Ewon versione Adige/BLM");

            // inizializzo classe base...
            if (!string.IsNullOrEmpty(getOptPar("CHANGE_ODL_MODE")))
            {
                CHANGE_ODL_MODE = getOptPar("CHANGE_ODL_MODE");
            }
            sendKeyRichiesta = true;
        }

        #endregion Public Constructors

        #region Protected Methods

        /// <summary>
        /// Effettua vera scrittura parametri
        /// </summary>
        /// <param name="updatedPar"></param>
        protected override void plcWriteParams(ref List<objItem> updatedPar)
        {
            base.plcWriteParams(ref updatedPar);

            // se DEVO gestire setup Mecolpress...
            if (opcUaParams.SetupConf.SetupMode == IOB_UT_NEXT.MachineSetupMode.MECOLPRESS)
            {
                List<WriteValue> nodes2Write = new List<WriteValue>();
                // faccio un check tra i valori in memoria che devono corrispondere e se NON
                // corrispondono --> metto valore in scrittura...
                int numDiff = 0;
                foreach (var item in opcUaParams.SetupConf.checkParList)
                {
                    // cerco la memoria corrispondente...
                    var memorieMes = dataItemMem.Where(x => x.Key.Contains(item.Key)).ToList();
                    var memorieMac = dataItemMem.Where(x => x.Key.Contains(item.Value)).ToList();
                    // se ho trovato qualcosa verifico se corrispondono...
                    if (memorieMes.Count > 0 && memorieMes.Count > 0)
                    {
                        // controllo primo record con primo record
                        if (memorieMes.FirstOrDefault().Value.value != memorieMac.FirstOrDefault().Value.value)
                        {
                            numDiff++;
                        }
                    }
                }

                // ciclo le condizioni di uscita
                foreach (var item in opcUaParams.SetupConf.writeParAction)
                {
                    WriteValue commWriteVal = new WriteValue();
                    commWriteVal.NodeId = new NodeId(item.TargetParam);
                    commWriteVal.AttributeId = Attributes.Value;
                    commWriteVal.Value = new DataValue();
                    // se ho differenze --> scrivo richiesta attrezzaggio...
                    if (numDiff > 0)
                    {
                        commWriteVal.Value.Value = item.TargetValNotEqual;
                    }
                    else
                    {
                        commWriteVal.Value.Value = item.TargetValEqual;
                    }

                    // accodo x scrittura
                    nodes2Write.Add(commWriteVal);
                    lgInfo($"richiesta scrittura valore | nodeId: {commWriteVal.NodeId} | targetPar: {item.TargetParam} | val {commWriteVal.Value.Value}");

                }

                // x ora NON eseguo
                if (opcUaParams.SetupConf.EnableAdvSetup)
                {
                    // ora scrivo!
                    if (nodes2Write.Count > 0)
                    {
                        UA_ref.WriteNodes(nodes2Write);
                    }
                }
            }
        }

        #endregion Protected Methods

        /// <summary>
        /// Verifica presenza eventuali allarmi in modalità BLM/Adige
        /// </summary>
        /// <returns></returns>
        protected override bool hasAlarms()
        {
            /*----------------------------------------------
             * verifica lo stato allarmi da
             * - condizione allarme (key)
             * - numero allarmi presenti
             * - lettura relative chiavi OPC-UA dei codici
             * - lettura relative chiavi OPC-UA del testo allarme
             * - verifica variazione dell'insieme dei codici attivi (INT)
             * - costruzione della stringa finale allarmi attivi (unico banco)
            ----------------------------------------------*/
            bool answ = false;
            int numErrors = 0;
            int currStatus = 0;
            ushort full16 = 65535;
            int[] listInt = new int[2];
            if (alarmMaps != null)
            {
                // leggo a ciclo le aree degli allarmi CONFIGURATI, se ne trovo --> segnalo allarme...
                foreach (var item in alarmMaps)
                {
                    // banchi in array Int16 --> scompongo
                    for (int i = 0; i < item.size / 2; i++)
                    {
                        currStatus = getAlarmStatus(item);
                        // ora filtro x l'i-esimo banco a 16 bit...
                        if (i == 0)
                        {
                            currStatus = (ushort)(currStatus & full16);
                        }
                        else
                        {
                            var temp = currStatus >> 16;
                            currStatus = (ushort)temp;
                        }

                        // aggiornamento blink counters dato nuovo valore
                        item.checkBlinkCounter(i, (uint)currStatus);

                        // calcolo indice errori
                        if ((uint)(item.alarmsMask[i] & currStatus) > 0)
                        {
                            numErrors++;
                        }
                        // verifico SE sia variato... confronto allarmi filtrato stile blink per bit status:
                        // - allarmi che iniziano per # IGNORATI
                        // - altri allarmi con un countdown da MAX_COUNTER_BLINK a 0 per il fronte
                        // di discesa
                        if (item.isChanged(i, (uint)currStatus))
                        {
                            // registro gli allarmi attivi e trasmetto...
                            if (sendAlarmVariations(item.memAddr, i, item.alarmsState[i], (uint)(item.alarmsMask[i] & currStatus), item.messages))
                            {
                                // se inviato --> salvo stato da current...
                                item.updStatusVal(i, (uint)(item.alarmsMask[i] & currStatus));
                            }
                        }
                    }
                }
            }
            answ = numErrors > 0;
            return answ;
        }
    }
}