using CndexLinkDotNet;
using IOB_UT;
using System;
using System.Collections.Generic;
using System.Net;
using System.Net.NetworkInformation;
using testSam;

namespace IOB_WIN
{
  public class IobOSAI : IobGeneric
  {

    /// <summary>
    /// LookUpTable di decodifica da CNC a segnali tipo bitmap MAPO
    /// </summary>
    Dictionary<string, string> signLUT = new Dictionary<string, string>();
    /// <summary>
    /// Struttura dati principale in continuo update...
    /// </summary>
    protected Cndex.GETINFO1DATA oData;

#if false
    /// <summary>
    /// wrapper chiamata lettura/scrittura OSAI x BYTE...
    /// </summary>
    /// <param name="bWrite"></param>
    /// <param name="MemType"></param>
    /// <param name="memIndex"></param>
    /// <param name="memOrderStart">0/1 orimo o secondo byte della word...</param>
    /// <param name="MATRICE Value"></param>
    /// <returns></returns>
    public bool OsaiMemRW_Byte(bool bWrite, OSAI.MemTypeWord MemType, Int32 memIndex, Int32 memOrderStart, ref byte[] Value)
    {
      bool answ = false;
#if false
      if (OSAI_ref.Connected)
      {
        try
        {
          parentForm.commPlcActive = true;
          answ = OSAI_ref.O_RW_Byte(bWrite, MemType, memIndex, memOrderStart, ref Value);
        }
        catch (Exception exc)
        {
          lg.Error(exc, "Eccezione in OsaiMemRW_Byte");
        }
      } 
#endif
      parentForm.commPlcActive = false;
      return answ;
    }
    /// <summary>
    /// wrapper chiamata lettura/scrittura x WORD...
    /// </summary>
    /// <param name="bWrite"></param>
    /// <param name="MemType"></param>
    /// <param name="memIndex"></param>
    /// <param name="MATRICE Value"></param>
    /// <returns></returns>
    public bool OsaiMemRW_Word(bool bWrite, OSAI.MemTypeWord MemType, Int32 memIndex, ref ushort[] Value)
    {
      bool answ = false;
      if (OSAI_ref.Connected)
      {
#if false
        try
        {
          parentForm.commPlcActive = true;
          answ = OSAI_ref.O_RW_Word(bWrite, MemType, memIndex, ref Value);
        }
        catch (Exception exc)
        {
          lg.Error(exc, "Eccezione in OsaiMemRW_Word");
        } 
#endif
      }
      parentForm.commPlcActive = false;
      return answ;
    }
    /// <summary>
    /// wrapper chiamata lettura/scrittura x DOUBLE-WORD...
    /// </summary>
    /// <param name="bWrite"></param>
    /// <param name="MemType"></param>
    /// <param name="memIndex"></param>
    /// <param name="MATRICE Value"></param>
    /// <returns></returns>
    public bool OsaiMemRW_DWord(bool bWrite, OSAI.MemTypeWord MemType, Int32 memIndex, ref uint[] Value)
    {
      bool answ = false;
      if (OSAI_ref.Connected)
      {
#if false
        try
        {
          parentForm.commPlcActive = true;
          answ = OSAI_ref.O_RW_DWord(bWrite, MemType, memIndex, ref Value);
        }
        catch (Exception exc)
        {
          lg.Error(exc, "Eccezione in OsaiMemRW_DWord");
        } 
#endif
      }
      parentForm.commPlcActive = false;
      return answ;
    }
    /// <summary>
    /// wrapper chiamata lettura/scrittura x Short...
    /// </summary>
    /// <param name="bWrite"></param>
    /// <param name="MemType"></param>
    /// <param name="memIndex"></param>
    /// <param name="MATRICE Value"></param>
    /// <returns></returns>
    public bool OsaiMemRW_Short(bool bWrite, OSAI.MemTypeWord MemType, Int32 memIndex, ref short[] Value)
    {
      bool answ = false;
      if (OSAI_ref.Connected)
      {
#if false
        try
        {
          parentForm.commPlcActive = true;
          answ = OSAI_ref.O_RW_Short(bWrite, MemType, memIndex, ref Value);
        }
        catch (Exception exc)
        {
          lg.Error(exc, "Eccezione in OsaiMemRW_Short");
        } 
#endif
      }
      parentForm.commPlcActive = false;
      return answ;
    }
    /// <summary>
    /// wrapper chiamata lettura/scrittura x INT...
    /// </summary>
    /// <param name="bWrite"></param>
    /// <param name="MemType"></param>
    /// <param name="memIndex"></param>
    /// <param name="MATRICE Value"></param>
    /// <returns></returns>
    public bool OsaiMemRW_Integer(bool bWrite, OSAI.MemTypeWord MemType, Int32 memIndex, ref int[] Value)
    {
      bool answ = false;
#if false
      if (OSAI_ref.Connected)
      {
        try
        {
          parentForm.commPlcActive = true;
          answ = OSAI_ref.O_RW_Integer(bWrite, MemType, memIndex, ref Value);
        }
        catch (Exception exc)
        {
          lg.Error(exc, "Eccezione in OsaiMemRW_Integer");
        }
      } 
#endif
      parentForm.commPlcActive = false;
      return answ;
    }
    /// <summary>
    /// wrapper chiamata lettura/scrittura x Double...
    /// </summary>
    /// <param name="bWrite"></param>
    /// <param name="MemType"></param>
    /// <param name="memIndex"></param>
    /// <param name="MATRICE Value"></param>
    /// <returns></returns>
    public bool OsaiMemRW_Double(bool bWrite, OSAI.MemTypeDouble MemType, Int32 memIndex, ref double[] Value)
    {
      bool answ = false;
#if false
      if (OSAI_ref.Connected)
      {
        try
        {
          parentForm.commPlcActive = true;
          answ = OSAI_ref.O_RW_Double(bWrite, MemType, memIndex, ref Value);
        }
        catch (Exception exc)
        {
          lg.Error(exc, "Eccezione in OsaiMemRW_Double");
        }
      } 
#endif
      parentForm.commPlcActive = false;
      return answ;
    } 
#endif

    /// <summary>
    /// Oggetto MAIN x connessione OSAI
    /// </summary>
    protected ComCNOsai OSAI_ref;

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

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

      // inizializzo correttamente aree memoria secondo CONF - iniFileName
      IniFile fIni = new IniFile(IOBConf.iniFileName);

      // inizializzo aree di memoria correnti...

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

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

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

      // Creo oggetto x gestione connessione/comunicazione NC: secondo il tipo creo CNDEX o OPEN
      parentForm.commPlcActive = true;
      if (IOBConf.tipoIob == tipoAdapter.OSAI_OPEN)
      {
        OSAI_ref = new Open_Series(IOBConf.cncIpAddr, false);
      }
      else
      {
        OSAI_ref = new ComCNOsai(IOBConf.cncIpAddr, false);
      }
      parentForm.commPlcActive = false;

      if (utils.CRB("verbose"))
      {
        lgInfo(string.Format("INIT OSAI_ref da CncLib come {0}", IOBConf.tipoIob));
      }

      // disconnetto e connetto...
      if (utils.CRB("verbose"))
      {
        lgInfo("OSAI: tryDisconnect");
      }

      tryDisconnect();
      lgInfo("OSAI: tryConnect");
      tryConnect();


      // recupero machine status e mode da cui decodificare info sul PLC...
      byte machineStatus = OSAI_ref.GetMachineStatus();
      byte modeSelected = OSAI_ref.GetModeSelected();
      lgInfo(string.Format("Lettura preliminare: machineStatus={0} | modeSelected={1}", machineStatus, modeSelected));

      // possiamo leggere tutto da qui che contiene status, mode e last_nc_error
      oData = new Cndex.GETINFO1DATA();
      var ncInfo = OSAI_ref.NcInfo1(ref oData);

      lgInfo(string.Format("Lettura START completa NCINFO1DATA{0} lastNcError={1}{0}status={2}{0}substatus={9}{0}mode_select={3}{0}main_progr_name={4}{0}speed_ov={5}{0}progr_speed={6}{0}real_speed={7}{0}real_feed={8}{0}", Environment.NewLine, oData.last_nc_error, oData.status, oData.mode_select, oData.main_progr_name, oData.speed_ov, oData.progr_speed, oData.real_speed, oData.real_feed, oData.substatus));

      // inizio il calcolo dello status semaforico
      short bitStatus = 0;
      if (OSAI_ref.Connected)
      {
        bitStatus += 1;
      }

      // lettura variabili (es contapezzi)
      ComCNOsai.stVAR temp;
      temp.nAddress = 29; // impostare da conf
      temp.nBit = 0;
      temp.nNumCn = 1;
      temp.szVarName = "";

      short risultato;
      risultato = OSAI_ref.ReadShortVar(temp);


      // area vb di riferimento x decodifica...
#if false
    ' valore bitmap dello statup IOB
    Dim status As Short = 0

    ' power on
    If CnOsai.Connected Then
      status += 1
    End If

    ' RUN mode
    If (machineStatus = ComCNOsai.CYCLE_ And modeSelected = ComCNOsai.AUTO) Then
      status += 2
    End If

    ' Allarme
    If (machineStatus = ComCNOsai.ERRO_) Then
      status += 8
    End If

    ' Manuale
    If (modeSelected <> ComCNOsai.AUTO) Then
      status += 16
    End If

    ' Allarme
    If (machineStatus = ComCNOsai.EMERG_) Then
      status += 32
    End If


    ' compongo i bit di status...
    Dim IobBitmap As String
    IobBitmap = "--------------" + vbCrLf
    IobBitmap += "Bitmap IOB:" + vbCrLf
    IobBitmap += status.ToString() + vbCrLf
    IobBitmap += "--------------" + vbCrLf + vbCrLf

    ' per leggere variabili dichiaro la struttura
    Dim temp As ComCNOsai.stVAR
    temp.nAddress = nVar_NC_state ' da conf che vale 352 da 
    temp.nBit = 0
    temp.nNumCn = 1
    temp.szVarName = ""

    Dim risultato As Short
    risultato = CnOsai.ReadShortVar(temp)

    IobBitmap += vbCrLf
    IobBitmap += "Variabile " + nVar_NC_state.ToString() + ": " + risultato.ToString()
#endif



      if (utils.CRB("enableContapezzi"))
      {
        lgInfo("OSAI: inizio gestione contapezzi");
        try
        {
#if false
          // verifico quale modalità sia richiesta: STD (6711) oppure BIT (Custom, con indicazione area)
          if (currIobConf.optPar.Count > 0 && currIobConf.optPar["PZCOUNT_MODE"] != "")
          {
            if (currIobConf.optPar["PZCOUNT_MODE"].StartsWith("STD"))
            {
              pzCntReload();
              // refresh associazione Macchina - IOB
              sendM2IOB();
              // per adesso imposto lettura dal CNC == contapezzi (poi farà vera lettura...)
              lastCountCNC = contapezzi;
            }
            else
            {
              contapezzi = 0;
              lgInfo("Contapezzi STD disabilitato: modalità {0}", currIobConf.optPar["PZCOUNT_MODE"]);
            }
          }
          else
          {
            contapezzi = 0;
            lgInfo("Parametro mancante PZCOUNT_MODE");
          } 
#endif
        }
        catch (Exception exc)
        {
          lgError(exc, "Errore in contapezzi OSAI");
        }
      }
      // finisco INIT ADAPTER
      lgInfo("End init Adapter OSAI");
    }


    /// <summary>
    /// Override disconnessione
    /// </summary>
    public override void tryDisconnect()
    {
      if (connectionOk)
      {
        string szStatusConnection = "";
        try
        {
          OSAI_ref.CloseSession();
          connectionOk = false;
          // resetto timing!
          TimingData.resetData();
          lgInfo(szStatusConnection);
          lgInfo("Effettuata disconnessione adapter OSAI!");
        }
        catch (Exception exc)
        {
          lgFatal(exc, "Errore nella disconnessione dall'adapter OSAI");
        }
      }
      else
      {
        lgError("IMPOSSIBILE effettuare disconnessione: Connessione non disponibile...");
      }
    }
    /// <summary>
    /// Override connessione
    /// </summary>
    public override void tryConnect()
    {
      if (!connectionOk)
      {
        // controllo che il ping sia stato tentato almeno pingTestSec fa...
        if (DateTime.Now.Subtract(lastPING).TotalSeconds > utils.CRI("pingTestSec"))
        {
          if (verboseLog || periodicLog)
          {
            lgInfo("ConnKO - tryConnect");
          }
          // in primis salvo data ping...
          lastPING = DateTime.Now;
          // ora PING!!!
          Ping pingSender = new Ping();
          IPAddress address = IPAddress.Loopback;
          IPAddress.TryParse(currIobConf.cncIpAddr, out address);
          PingReply reply = pingSender.Send(address, 100);
          // se passa il ping faccio il resto...
          if (reply.Status == IPStatus.Success)
          {
            string szStatusConnection = "";
            try
            {
              // ora provo connessione...
              parentForm.commPlcActive = true;
              OSAI_ref.OpenSession();

              parentForm.commPlcActive = false;
              lgInfo("szStatusConnection: " + szStatusConnection);
              connectionOk = true;
              // refresh stato allarmi!!!
              if (connectionOk)
              {
                dtAvvioAdp = DateTime.Now;
                if (adpRunning)
                {
                  // carico status allarmi (completo)
                  lgInfo("Inizio refresh completo stato allarmi...");
                  forceAlarmCheck();
                  lgInfo("Completato refresh completo stato allarmi!");
                }
                else
                {
                  lgInfo("Connessione OK");
                }
              }
              else
              {
                lgError("Impossibile procedere, connessione mancante...");
              }
            }
            catch (Exception exc)
            {
              lgFatal(string.Format("Errore nella connessione all'adapter OSAI: {0}{1}{2}", szStatusConnection, Environment.NewLine, exc));
              connectionOk = false;
              lgInfo(string.Format("Eccezione in TryConnect, Adapter NON running, pausa di {0} msec prima di ulteriori tentativi di riconnessione", utils.CRI("waitRecMSec")));
            }
          }
          else
          {
            // loggo no risposta ping ...
            connectionOk = false;
            if (verboseLog || periodicLog)
            {
              lgInfo(string.Format("Attenzione: controllo PING fallito per IP {0} - {1}", currIobConf.cncIpAddr, reply.Status));
            }
          }
        }
      }
      // se non è ancora connesso faccio procesisng memoria caso disconnesso...
      if (!connectionOk)
      {
        // processo semafori ed invio...
        processMemoryDiscon();
      }
    }

    /// <summary>
    /// lettura principale (bit semafori)
    /// </summary>
    public override void readSemafori()
    {
      base.readSemafori();
      try
      {
        if (verboseLog)
        {
          lgInfo("inizio read semafori");
        }

        parentForm.sIN = Semaforo.SV;

        stopwatch.Restart();
        // possiamo leggere tutto da qui che contiene status, mode e last_nc_error
        //oData = new Cndex.GETINFO1DATA();
        var ncInfo = OSAI_ref.NcInfo1(ref oData);
        // time rec
        if (utils.CRB("recTime"))
        {
          TimingData.addResult(currIobConf.codIOB, "GETINFO1DATA", stopwatch.ElapsedTicks);
        }
        stopwatch.Stop();

        // salvo il solo BYTE dell'input decifrando il semaforo... 
        decodeToBitmap();
      }
      catch (Exception exc)
      {
        lgError(string.Format("Eccezione in readSemafori:{0}{1}", Environment.NewLine, exc));
        connectionOk = false;
      }
    }
    /// <summary>
    /// Effettua decodifica aree memoria alla bitmap usata x MAPO
    /// </summary>
    private void decodeToBitmap()
    {
      // init a zero...
      B_input = 0;
      // SE SI E' CONNESSO al CNC allora è 1=powerON...
      if (OSAI_ref.Connected)
      {
        B_input += 1 << 0;
      }

      // decodifico impiegando dictionary... cercando il TIPO di memoria & co...
      string bKey = "";
      string bVal = "";
      char area;
      // valore INVERTED (default è false)
      bool invSignal = false;
      string memArea = "";
      string[] memIdx;
      int bitNum = 0;
      int byteNum = 0;
      int byte2check = 0;
      for (int i = 0; i < 8; i++)
      {
        bKey = string.Format("BIT{0}", i);
        // cerco se ci sia in LUT
        if (signLUT.ContainsKey(bKey))
        {
          // recupero nome variabile...
          bVal = signLUT[bKey];
          // se l'area è PZCOUNT... processo PUNTUALMENTE il CONTAPEZZI...
          if (bVal.StartsWith("PZCOUNT"))
          {
            string currODL = "";
            try
            {
              currODL = utils.callUrl(urlGetCurrODL);
              lgInfo(string.Format("Lettura ODL, {0} --> {1}", currIdxODL, currODL));
              // provo a salvare nuovo ODL
              int.TryParse(currODL, out currIdxODL);
            }
            catch (Exception exc)
            {
              if (DateTime.Now.Subtract(lastWarnODL).TotalSeconds > 15)
              {
                lgError(exc, "Errore in fase di chiamata URL x ODL corrente | URL chiamato: {0}", urlGetCurrODL);
                lastWarnODL = DateTime.Now;
              }
            }
            if (currODL != null && currODL != "" && currODL != "0")
            {
              // controllo se è passato intervallo minimo tra 2 controlli/elaborazioni x distanziare invio e ridurre letture
              if (DateTime.Now >= lastPzCountSend.AddMilliseconds(pzCountDelay))
              {
                // verifico se variato contapezzi in area STD PAR6711... e se passato ritardo minimo...
                if (lastCountCNC > contapezzi)
                {
                  // salvo nuovo contapezzi (incremento di 1...)
                  contapezzi++;
                  // salvo in semaforo!
                  B_input += 1 << 2;
                }
                // registro contapezzi
                lgInfo(string.Format("Contapezzi OSAI: {0} | Contapezzi interno {1}", lastCountCNC, contapezzi));

                // invio a server contapezzi (aggiornato)
                string retVal = utils.callUrl(urlSetPzCount + contapezzi.ToString());
                // verifica se tutto OK 
                if (retVal != "OK")
                {
                  // errore salvataggio contapezzi    
                  lgInfo(string.Format("Errore salvataggio Contapezzi OSAI: {0} | Contapezzi interno {1} | Errore salvataggio: {2}", lastCountCNC, contapezzi, retVal));
                }
                // resetto timer...
                lastPzCountSend = DateTime.Now;
              }
            }
            else
            {
              if (DateTime.Now >= lastPzCountSend.AddMilliseconds(pzCountDelay))
              {
                lgInfo(string.Format("Attenzione: mancanza ODL non procedo con gestione contapezzi. Contapezzi OSAI: {0} | Contapezzi interno {1}", lastCountCNC, contapezzi));
                // resetto timer...
                lastPzCountSend = DateTime.Now;
              }
            }
          }
          else // area "normale" byte.bit
          {
            // di norma è segnale normale => 1, altrimenti inverse => 0...
            invSignal = false;
            // cerco se sia inverse (ultimo char "!") --> registro e elimino char...
            invSignal = bVal.StartsWith("!");
            // tolgo comunque inversione...
            bVal = bVal.Replace("!", "");
            // recupero area...
            area = bVal[0];
            // altrimenti decodifico area...
            memArea = bVal.Substring(1, bVal.Length - 1);
            memIdx = memArea.Split('.');
            // calcolo bit e byte number...
            int.TryParse(memIdx[0], out byteNum);
            if (memIdx.Length > 1)
            {
              int.TryParse(memIdx[1], out bitNum);
            }
            // in base al nome cerco in una delle aree.. e prendo solo solo quel bit di quel byte...
#if false
            switch (area)
            {
              case 'G':
                byte2check = MemBlockG[byteNum];
                break;
              case 'R':
                byte2check = MemBlockR[byteNum];
                break;
              case 'X':
                byte2check = MemBlockX[byteNum];
                break;
              case 'Y':
                byte2check = MemBlockY[byteNum];
                break;
              default:
                break;
            } 
#endif
            // a secondo che sia segnale normale o inverso...
            if (invSignal)
            {
              // controllo se il bit sia NON attivo (basso)... == 0...
              if ((byte2check & (1 << bitNum)) == 0)
              {
                B_input += 1 << i;
              }
            }
            else
            {
              // controllo se il bit sia attivo (alto)... != 0
              if ((byte2check & (1 << bitNum)) != 0)
              {
                B_input += 1 << i;
              }
            }
          }
        }
      }
      // log opzionale!
      if (verboseLog)
      {
        lgInfo(string.Format("Trasformazione B_input: {0}", B_input));
      }
    }
    /// <summary>
    /// Recupero programma in lavorazione
    /// </summary>
    /// <returns></returns>
    public override string getPrgName()
    {
      string prgName = "";
      // recupero NUOVO prgName...
      try
      {                                                                    
        // recupero nome programma MAIN
        prgName = System.Text.Encoding.Default.GetString(oData.main_progr_name);                                                                          
        // trimmo path del programma, ovvero "CNCMEMUSERPATH1"
        prgName = prgName.Replace(utils.CRS("basePrgMemPath"), "");
        lgInfo("Current PROG: {0}", prgName);
      }
      catch (Exception exc)
      {
        lgError(string.Format("Eccezione in recupero PRG NAME MAIN:{0}{1}", Environment.NewLine, exc));
        connectionOk = false;
      }
      return prgName;
    }
    /// <summary>
    /// Recupero programma in lavorazione come Dictionary CNC...
    /// - SYSINFO: (prima KEY globale) TUTTI i valori separati da # (x fare check modifica)
    /// - altre stringhe: ogni singolo parametro / valore
    /// </summary>
    /// <returns></returns>
    public override Dictionary<string, string> getSysInfo()
    {
      Dictionary<string, string> outVal = new Dictionary<string, string>();
      stopwatch.Restart();
#if false
      CncLib.Focas1.ODBSYS answ = OSAI_ref.getSysInfo();
      if (utils.CRB("recTime"))
      {
        TimingData.addResult(currIobConf.codIOB, string.Format("SYS-INFO"), stopwatch.ElapsedTicks);
      }

      try
      {
        string cnc_type = new string(answ.cnc_type);
        string mt_type = new string(answ.mt_type);
        string series = new string(answ.series);
        string version = new string(answ.version);
        string axes = new string(answ.axes);
        //short addInfo = answ.addinfo;
        short max_axis = answ.max_axis;
        // preparo i singoli valori dell'array...
        outVal.Add("SYSINFO", string.Format("{0}#{1}#{2}#{3}#{4}#{5}", cnc_type, mt_type, series, version, axes, max_axis));
        outVal.Add("CNC", cnc_type);
        outVal.Add("MTT", mt_type);
        outVal.Add("SER", series);
        outVal.Add("VER", version);
        outVal.Add("AXS", string.Format("{0}|{1}", axes, max_axis));
      }
      catch (Exception exc)
      {
        lgError(exc, "Errore in getSysInfo");
        connectionOk = false;
      } 
#endif
      return outVal;
    }
    /// <summary>
    /// Effettua vero processing contapezzi:
    /// 6711: pezzi lavorati
    /// 6712: pezzi lavorati totali
    /// 6713: pezzi richiesti
    /// </summary>
    public override void processContapezzi()
    {
      if (utils.CRB("enableContapezzi"))
      {
        try
        {
          // verifico quale modalità sia richiesta: STD (6711) oppure BIT (Custom, con indicazione area)
          if (currIobConf.optPar.Count > 0 && currIobConf.optPar["PZCOUNT_MODE"] != "")
          {
            string memAddr = currIobConf.optPar["PZCOUNT_MODE"];
            if (memAddr.StartsWith("STD"))
            {
              // inizio verifica area memoria/parametro levando prima parte codice
              memAddr = memAddr.Replace("STD.", "");
              // var di appoggio
              int cntAddr = 0;
              object outputVal = new object();
              // verifico se si tratta di lettura parametro... formato tipo STD.PAR.6711
              if (memAddr.StartsWith("PAR."))
              {
                // recupero parametro...
                int.TryParse(memAddr.Replace("PAR.", ""), out cntAddr);
                if (cntAddr == 0)
                {
                  cntAddr = 6711;
                }

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

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

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

                // leggo!
                stopwatch.Restart();
                // switch x tipo dati --> tipo lettura... e salvo ultimo conteggio rilevato
                switch (areaCounter.vType)
                {
#if false
                  case "B":
                    byte valB = 0;
                    OSAI_ref.F_RW_Byte(false, areaCounter.mType, areaCounter.mPos, ref valB);
                    outputVal = valB;
                    break;
                  case "D":
                    ushort valW = 0;
                    OSAI_ref.F_RW_Word(false, areaCounter.mType, areaCounter.mPos, ref valW);
                    outputVal = valW;
                    break;
                  case "DW":
                    uint valDW = 0;
                    OSAI_ref.F_RW_DWord(false, areaCounter.mType, areaCounter.mPos, ref valDW);
                    if (utils.CRB("verbose"))
                    {
                      lgInfo("[1] valDW contapezzi: {0}", valDW);
                    }

                    outputVal = valDW;
                    if (utils.CRB("verbose"))
                    {
                      lgInfo("[2] outputVal contapezzi: {0}", outputVal);
                    }

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

                // salvo...
                Int32.TryParse(outputVal.ToString(), out lastCountCNC);
                if (utils.CRB("verbose"))
                {
                  lgInfo("[3] lastCountCNC contapezzi: {0}", lastCountCNC);
                }
              }
              stopwatch.Stop();
            }
          }
        }
        catch (Exception exc)
        {
          lgError(exc, "Errore in contapezzi CNC");
          connectionOk = false;
        }
      }
    }
    /// <summary>
    /// Esegue processing MODE (e nel contempo recupera altri dati dell'area G)
    /// </summary>
    public override void processMode()
    {
      if (utils.CRB("enableMode"))
      {
        try
        {
          // verifico modo con valore corrente, se cambia aggiorno...
          CNC_MODE newMode = decodeModeOsai(oData.mode_select);
          if (newMode != currMode)
          {
            // aggiorno!
            currMode = newMode;
            // conversione NUM MODE in descrizione da ENUM
            string descrMode = Enum.GetName(typeof(CNC_MODE), currMode);
            // accodo x invio
            string sVal = string.Format("[CNC_MODE]{0}", descrMode);
            // chiamo accodamento...
            accodaFLog(sVal, qEncodeFLog("CNC_MODE", descrMode));
          }
        }
        catch (Exception exc)
        {
          lgError(exc, string.Format("Errore in process Mode G43: {0}{1}", Environment.NewLine, exc));
          connectionOk = false;
          stopwatch.Stop();
        }
      }
    }
    /// <summary>
    /// Decodifica del MODE selezionato
    /// </summary>
    /// <param name="mode"></param>
    /// <returns></returns>
    protected CNC_MODE decodeModeOsai(int mode)
    {
      CNC_MODE answ = CNC_MODE.ND;
      switch (mode)
      {
        case 1:
          answ = CNC_MODE.MDI;
          break;
        case 2:
          answ = CNC_MODE.AUTO;
          break;
        case 3:
          answ = CNC_MODE.SEMI;
          break;
        case 4:
          answ = CNC_MODE.JOG_MAN;
          break;
        case 5:
          answ = CNC_MODE.JOG_INC;
          break;
        case 6:
          answ = CNC_MODE.PROFILE;
          break;
        case 7:
          answ = CNC_MODE.HOME;
          break;
        case 8:
          answ = CNC_MODE.HANDLE_INC;
          break;
        default:
          break;
      }
      return answ;
    }
    /// <summary>
    /// Recupero dati dinamici...
    /// </summary>
    public override Dictionary<string, string> getDynData()
    {
      Dictionary<string, string> outVal = new Dictionary<string, string>();
      stopwatch.Restart();
      try
      {
        string actf = oData.real_feed.ToString();
        string acts = oData.real_speed.ToString();
        outVal.Add("DYNDATA", string.Format("FEED {0}#SPEED_RPM {1}", actf, acts));

        if (utils.CRB("SendFeedSpeed"))
        {
          outVal.Add("FEED", actf);
          outVal.Add("SPEED_RPM", acts);
          //outVal.Add("NUM_ALARM", numAlarm);                   
          outVal.Add("ACT_TOOL", oData.actual_tool.ToString());
        }
        if (utils.CRB("SendAxPos"))
        {
          // salvo info assi...                           
          outVal.Add("AX_SEL", oData.ax_sel.ToString());
          outVal.Add("NUM_AX_SEL", oData.num_ax_sel.ToString());
        }
      }
      catch (Exception exc)
      {
        lgError(exc, "Errore in getDynData");
      }
      stopwatch.Stop();
      return outVal;
    }
    /// <summary>
    /// Recupero dati override (da area G che è già stata letta...)
    /// </summary>
    /// <returns></returns>
    public override Dictionary<string, string> getOverrides()
    {
      Dictionary<string, string> outVal = new Dictionary<string, string>();
      outVal.Add("FEED_OVER", (oData.feed_ov).ToString());
      outVal.Add("RAPID_OVER", (oData.rapid_override).ToString());
      return outVal;
    }

#if false

    /// <summary>
    /// Override salvataggio valori in memoria...
    /// </summary>
    /// <param name="tipo">tipo di DUMP</param>
    public override void saveMemDump(dumpType tipo)
    {
#if false
      // se l'area ha una size > 0...
      if (areaD.arraySize > 0)
      {
        dump_MemArea(tipo, FANUC.MemType.D, areaD.startIdx, areaD.arraySize);
      }
      // se l'area ha una size > 0...
      if (areaR.arraySize > 0)
      {
        dump_MemArea(tipo, FANUC.MemType.R, areaR.startIdx, areaR.arraySize);
      }
      // se l'area ha una size > 0...
      if (areaX.arraySize > 0)
      {
        dump_MemArea(tipo, FANUC.MemType.X, areaX.startIdx, areaX.arraySize);
      }
      // se l'area ha una size > 0...
      if (areaY.arraySize > 0)
      {
        dump_MemArea(tipo, FANUC.MemType.Y, areaY.startIdx, areaY.arraySize);
      }
      // se l'area ha una size > 0...
      if (areaPAR.arraySize > 0)
      {
        dump_ParArea(tipo, areaPAR.startIdx, areaPAR.arraySize);
      } 
#endif
    }
    /// <summary>
    /// Dump area D della memoria 
    /// </summary>
    /// <param name="tipo">tipo di DUMP: START (sovrascrivendo) / SAMPLE (salva tanti campionamenti)</param>
    /// <param name="tipoMem">tipo memoria</param>
    /// <param name="memIndex">area memoria di partenza</param>
    /// <param name="memSizeByte">dimensione memoria</param>
    private void dump_MemArea(dumpType tipo, FANUC.MemType tipoMem, int memIndex, int memSizeByte)
    {
      DateTime adesso = DateTime.Now;
      string nomeFileB = "";
      string nomeFileW = "";
      string nomeFileDW = "";
      Dictionary<string, string> mappaValori = new Dictionary<string, string>();
      // per sicurezza verifico < 9999 byte
      if (memSizeByte > 9999)
      {
        memSizeByte = 9999;
      }
      // leggo TUTTI i (MAX 9999) byte della memoria D...
      byte[] MemBlockCurr = new byte[memSizeByte];
      if (verboseLog)
      {
        lgInfo("START MemDump", tipoMem);
      }

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

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

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

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

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

      // salvo in file i dati letti come DWord (4byte)
      mappaValori = new Dictionary<string, string>();
      for (int i = 0; i < MemBlockCurr.Length / 4; i++)
      {
        mappaValori.Add(i.ToString("0000"), BitConverter.ToUInt32(MemBlockCurr, i * 4).ToString());
      }
      utils.WritePlain(mappaValori, nomeFileDW);
    }
    /// <summary>
    /// Dump area PARAMETRI
    /// </summary>
    /// <param name="tipo">tipo di DUMP: START (sovrascrivendo) / SAMPLE (salva tanti campionamenti)</param>
    /// <param name="memIndex">Parametro di partenza</param>
    /// <param name="numPar">Numero parametri da esportare... memoria</param>
    private void dump_ParArea(dumpType tipo, int memIndex, int numPar)
    {
      DateTime adesso = DateTime.Now;
      string nomeFile = "";
      Dictionary<string, string> mappaValori = new Dictionary<string, string>();
      // per sicurezza verifico < 9999 parametri
      if (numPar > 9999)
      {
        numPar = 9999;
      }

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

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

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

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

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

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