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

using IOB_UT_NEXT;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using static IOB_UT_NEXT.CustomObj;

namespace IOB_WIN_NEXT
{
    /* --------------------------------------------------------------------------------
    * Controlli ModBusTCP FIMAT
    * - protocollo ModBus TCP
    * - gestione stato via Modbus
    * - resto gestioen via file
    *
    * G:\Drive condivisi\30_Clienti\Tenditalia\Macchina Fimat
    *
    * -------------------------------------------------------------------------------- */

    public class IobModbusTCPFimat : IobModbusTCP
    {
        #region Public Constructors

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

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

        #endregion Public Constructors

        #region Protected Fields

        /// <summary>
        /// Quantità massima PODL prima di fare split ordine (default 999'999)
        /// </summary>
        protected int maxPodlQty = 999999;

        #endregion Protected Fields

        #region Protected Properties

        /// <summary>
        /// Restituisce controllo IN ALLARME
        /// </summary>
        protected bool AlarmState
        {
            get
            {
                return testIntCondition("AlarmIntCond");
            }
        }

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

        /// <summary>
        /// Restituisce status di Manuale, hard coded
        /// </summary>
        protected bool ManualState
        {
            get
            {
                return testBitCondition("ManualBitCond");
            }
        }

        /// <summary>
        /// Restituisce status di WORK (auto + lavora), hard coded
        /// </summary>
        protected bool WorkState
        {
            get
            {
                return testIntCondition("WorkIntCond");
            }
        }

        #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);
            }
            // se ho qualcosa nella holding register...
            if (HoldingRegisterLUT != null && HoldingRegisterLUT.Count > 0)
            {
                // se emergenza NON premuta (triggered) indico OK (armata...) FARE !!! togliere true
                if (!EStopTriggered)
                {
                    byteSignals += (1 << 7);
                }

                // impiego controlli da setup IntConditions... processo dagli stati + gravi...
                if (AlarmState || hasAlarms())
                {
                    byteSignals += (1 << 3);
                }
                else if (ManualState)
                {
                    byteSignals += (1 << 4);
                }
                else if (WorkState)
                {
                    byteSignals += (1 << 1);
                }

                checkTranslateBit();
                checkTranslateInt();
            }
            else
            {
                lgInfo("HoldingRegisterLUT vuoto!");
            }

            // salvo!
            B_input = byteSignals;
        }


        /// <summary>
        /// Effettua sync dati x PODL attivi
        /// </summary>
        protected override void processDataSync()
        {
            DateTime adesso = DateTime.Now;
            string tempPath = Path.Combine(pathList["path-locBase"], pathList["path-01-Temp"]);
            string archPath = Path.Combine(pathList["path-locBase"], pathList["path-02-Sent"], $"{adesso:yyyy}", $"{adesso:MM}");
            string remoPath = Path.Combine(pathList["path-locBase"], pathList["path-04-remW"]);
            baseUtils.checkDir(tempPath);
            baseUtils.checkDir(archPath);
            // recupero elenco PODL da processare, check PODL già inviati, save locale
            bool create = RecipeReqWriteLocal(tempPath, useLocalRecipe);
            // invio ricette a impianto
            bool trasmitted = RecipeSend(tempPath, archPath, remoPath);
        }

        /// <summary>
        /// Cerca di recuperare i file generati dall'impianto in merito al processing degli ordini
        /// </summary>
        /// <returns></returns>
        protected override bool processFileImport()
        {
            bool fatto = false;
            // cerca e sposta i NUOVI file

            // per ogni file ricevuto controlla se sia corrispondente ad un file inviato (cerca PODL)

            // se trova PODL prova ad avviare/chiudere PODL relativo (eventualmente duplicandolo)

            return fatto;
        }


        /// <summary>
        /// Verifica l'elenco dei PODL (Attivi) per la macchina e verifica se vadano inviati
        /// (controllando archivio PODL inviati)
        /// </summary>
        /// <param name="actPOdlList"></param>
        /// <returns></returns>
        protected bool trySendPOdl(List<PODLModel> actPOdlList)
        {
            bool answ = false;
            foreach (var item in actPOdlList)
            {
                // verifico se sia nella folder di quelli inviati

                // se non presente preparo, leggendo conf del NUMERO ricetta (e configurandola come 10'000+num???)

                // infine invio
            }
            return answ;
        }

        #endregion Protected Methods
    }
}