From bf4262e2dd54523a0c1ce46afe51c0d3d2acd1bb Mon Sep 17 00:00:00 2001 From: "Samuele E. Locatelli" Date: Fri, 12 May 2017 16:57:53 +0200 Subject: [PATCH] spostato check allarmi osai FUORI dalla classe OSAI in generic, ora procedo x SIEMENS poi testo... --- MTC_Adapter/MTC_Adapter/AdapterGeneric.cs | 405 ++++++++-------------- MTC_Adapter/MTC_Adapter/AdapterOsai.cs | 199 ++++++++++- MTC_Adapter/MTC_Adapter/AdapterSiemens.cs | 102 ++++++ 3 files changed, 431 insertions(+), 275 deletions(-) diff --git a/MTC_Adapter/MTC_Adapter/AdapterGeneric.cs b/MTC_Adapter/MTC_Adapter/AdapterGeneric.cs index 4e17cd9..2c13520 100644 --- a/MTC_Adapter/MTC_Adapter/AdapterGeneric.cs +++ b/MTC_Adapter/MTC_Adapter/AdapterGeneric.cs @@ -1612,260 +1612,8 @@ namespace MTC_Adapter return new otherData(valori[0], memAddr, valori[1].Trim(), valori[2].Trim()); } - #region oggetti specifici per CNC OSAI/FANUC/SIEMENS... - - #region CNC OSAI - - /// - /// Oggetto MAIN x connessione OSAI - /// - protected OSAI OSAI_ref; - /// - /// wrapper chiamata lettura/scrittura OSAI x BYTE... - /// - /// - /// - /// - /// 0/1 orimo o secondo byte della word... - /// - /// - public bool OsaiMemRW_Byte(bool bWrite, OSAI.MemTypeWord MemType, Int32 memIndex, Int32 memOrderStart, ref byte[] Value) - { - bool answ = false; - if (OSAI_ref.Connected) - { - try - { - answ = OSAI_ref.O_RW_Byte(bWrite, MemType, memIndex, memOrderStart, ref Value); - } - catch - { } - } - return answ; - } - /// - /// wrapper chiamata lettura/scrittura x WORD... - /// - /// - /// - /// - /// - /// - public bool OsaiMemRW_Word(bool bWrite, OSAI.MemTypeWord MemType, Int32 memIndex, ref ushort[] Value) - { - bool answ = false; - if (OSAI_ref.Connected) - { - try - { - answ = OSAI_ref.O_RW_Word(bWrite, MemType, memIndex, ref Value); - } - catch - { } - } - return answ; - } - /// - /// wrapper chiamata lettura/scrittura x DOUBLE-WORD... - /// - /// - /// - /// - /// - /// - public bool OsaiMemRW_DWord(bool bWrite, OSAI.MemTypeWord MemType, Int32 memIndex, ref uint[] Value) - { - bool answ = false; - if (OSAI_ref.Connected) - { - try - { - answ = OSAI_ref.O_RW_DWord(bWrite, MemType, memIndex, ref Value); - } - catch - { } - } - return answ; - } - /// - /// wrapper chiamata lettura/scrittura x Short... - /// - /// - /// - /// - /// - /// - public bool OsaiMemRW_Short(bool bWrite, OSAI.MemTypeWord MemType, Int32 memIndex, ref short[] Value) - { - bool answ = false; - if (OSAI_ref.Connected) - { - try - { - answ = OSAI_ref.O_RW_Short(bWrite, MemType, memIndex, ref Value); - } - catch - { } - } - return answ; - } - /// - /// wrapper chiamata lettura/scrittura x INT... - /// - /// - /// - /// - /// - /// - public bool OsaiMemRW_Integer(bool bWrite, OSAI.MemTypeWord MemType, Int32 memIndex, ref int[] Value) - { - bool answ = false; - if (OSAI_ref.Connected) - { - try - { - answ = OSAI_ref.O_RW_Integer(bWrite, MemType, memIndex, ref Value); - } - catch - { } - } - return answ; - } - /// - /// wrapper chiamata lettura/scrittura x Double... - /// - /// - /// - /// - /// - /// - public bool OsaiMemRW_Double(bool bWrite, OSAI.MemTypeDouble MemType, Int32 memIndex, ref double[] Value) - { - bool answ = false; - if (OSAI_ref.Connected) - { - try - { - answ = OSAI_ref.O_RW_Double(bWrite, MemType, memIndex, ref Value); - } - catch - { } - } - return answ; - } - - #endregion - - #region CNC Siemens - - /// - /// Oggetto MAIN x connessione SIEMENS - /// - protected SIEMENS SIEMENS_ref; - - /// - /// Area di memoria base x MTConnect con SIEMENS (DB1499) - /// - protected int baseMemDb = 1499; - /// - /// Area di memoria base x dati UTENSILE (DB253) - /// - protected int baseMemUT = 253; - /// - /// Area di memoria base x dati TESTE (DB254) - /// - protected int baseMemUO = 254; - - /// - /// wrapper chiamata lettura/scrittura SINGOLO BYTE... - /// - /// - /// main address (1499/1500) - /// - /// - /// - public bool SIEMENSMemRW_Byte(bool bWrite, int MemType, Int32 memIndex, ref byte Value) - { - bool answ = false; - // chiamo la versione multibyte... - byte[] ValArray = new byte[1]; - SIEMENSMemRW_Byte(bWrite, MemType, memIndex, ref ValArray); - Value = ValArray[0]; - return answ; - } - /// - /// wrapper chiamata lettura/scrittura MULTI BYTE... - /// - /// - /// main address (1499/1500) - /// - /// - /// - public bool SIEMENSMemRW_Byte(bool bWrite, int MemType, Int32 memIndex, ref byte[] Value) - { - bool answ = false; - if (SIEMENS_ref.Connected) - { - try - { - answ = SIEMENS_ref.S_RW_Byte(bWrite, MemType, memIndex, ref Value); - } - catch - { } - } - return answ; - } - /// - /// wrapper chiamata lettura/scrittura MULTI Word... - /// - /// - /// main address (1499/1500) - /// - /// - /// - public bool SIEMENSMemRW_Word(bool bWrite, int MemType, Int32 memIndex, ref ushort[] Value) - { - bool answ = false; - if (SIEMENS_ref.Connected) - { - try - { - answ = SIEMENS_ref.S_RW_Word(bWrite, MemType, memIndex, ref Value); - } - catch - { } - } - return answ; - } - /// - /// wrapper chiamata lettura/scrittura MULTI DWord... - /// - /// - /// main address (1499/1500) - /// - /// - /// - public bool SIEMENSMemRW_DWord(bool bWrite, int MemType, Int32 memIndex, ref uint[] Value) - { - bool answ = false; - if (SIEMENS_ref.Connected) - { - try - { - answ = SIEMENS_ref.S_RW_DWord(bWrite, MemType, memIndex, ref Value); - } - catch - { } - } - return answ; - } - - #endregion - - - #endregion - #region metodi adapter + /// /// lettura file di persistenza @@ -2081,15 +1829,6 @@ namespace MTC_Adapter adpTryRestart = true; parentForm.displayTaskAndWait("Adapter Started!"); } - /// - /// Effettua refresh del vettore privato degli allarmi attivi - /// - /// flag mask degli allarmi da aggiornare - /// boolean: se si debba tornare ACK - public virtual void refreshAlarmState(StFlag32 Alarm2Refresh, bool giveAck) - { - // carico lo stato di tutti gli allarmi... forzo a 1 il flag degli allarmi - } /// /// ferma l'adapter... @@ -2361,6 +2100,8 @@ namespace MTC_Adapter } } + #region gestione allarmi + /// /// effettua ogni log period una rilettura di TUTTI gli allarmi... /// @@ -2379,6 +2120,146 @@ namespace MTC_Adapter if (utils.CRB("recTime")) logTimeResults(); } /// + /// Effettua refresh del vettore privato degli allarmi attivi + /// + /// flag mask degli allarmi da aggiornare + /// boolean: se si debba tornare ACK + public virtual void refreshAlarmState(StFlag32 Alarm2Refresh, bool giveAck) + { + // indici memorie allarmi: strobe ed ACK + //int memIndex = 19036; + //int memIndexAck = 19018; + + // log bitmap se verboso attivo + ho allarmi da refreshare + if ((Alarm2Refresh != StFlag32.NONE) && utils.CRB("verbose")) + { + lg.Info("Richiesto refresh allarmi x bitmask: {0}", utils.binaryForm((int)Alarm2Refresh)); + } + + bool ackReturned = false; + // byte di acknowledge... + byte[] retACK_DW0 = new byte[4]; + // inizio impostando una bitmap x ACK che abbia i bit abbassati se lo strobe è disattivo: AND logico tra STR e ACK + retACK_DW0 = BitConverter.GetBytes(Convert.ToUInt32(STRB_DW0 & ACK_DW0)); + + inizio = DateTime.Now; + uint[] MemBlock; + // controllo, SE devo leggere tutto uso un unico accesso ai 128byte, altrimenti leggo a blocchi di 32bit... + if (Alarm2Refresh == (StFlag32)unchecked((int)UInt32.MaxValue)) + { + // blocco memoria x lettura dati COMPLETO (4Byte*32 = 128Byte) + MemBlock = new uint[32]; + // recupero tutti i 32 bit del blocco + inizio = DateTime.Now; + //OsaiMemRW_DWord(R, OSAI.MemTypeWord.MW_CODE, memIndex, ref MemBlock); + readAllAlarms(ref MemBlock); + if (utils.CRB("recTime")) TimingData.addResult(string.Format("R{0}-STRB_DW0", MemBlock.Length * 4), DateTime.Now.Subtract(inizio).Ticks); + if (AlarmFlags != null) + { + try + { + // aggiorno vettore allarmi x intero! size del vettore di destinazione (in byte!!!!) + Buffer.BlockCopy(MemBlock, 0, AlarmFlags, 0, AlarmFlags.Length); + } + catch (Exception exc) + { + lg.Error(string.Format("Errore in BLOCKCOPY{0}{1}", Environment.NewLine, exc)); + } + } + } + else + { + if (Alarm2Refresh != StFlag32.NONE) + { + // blocco memoria x lettura dati + MemBlock = new uint[1]; + // verifico gli allarmi di tutti i bit alzati... + for (int i = 0; i < 32; i++) + { + if (Alarm2Refresh.HasFlag((StFlag32)Math.Pow(2, i))) + { + // recupero tutti i 32 bit del blocco + inizio = DateTime.Now; + //OsaiMemRW_DWord(R, OSAI.MemTypeWord.MW_CODE, memIndex + i * 2, ref MemBlock); + readAlarmBlock(ref MemBlock, i); + if (utils.CRB("recTime")) TimingData.addResult(string.Format("R{0}-STRB_DW0", MemBlock.Length * 4), DateTime.Now.Subtract(inizio).Ticks); + try + { + // aggiorno vettore allarmi x intero! + Buffer.BlockCopy(MemBlock, 0, AlarmFlags, i * 4, 4); + } + catch (Exception exc) + { + lg.Error(string.Format("Errore in BLOCKCOPY per indice i = {2},{0}{1}", Environment.NewLine, exc, i)); + } + if (utils.CRI("loglevel") > 5) + { + lg.Info("Bit {0}, MemBlock: {1}", i, MemBlock[0]); + } + // segnalo allarme letto! memorizzo allarme nel vettore ack.... + retACK_DW0 = utils.setBitOnStFlag(retACK_DW0, true, i); + } + } + // scrivo ack se richiesto!!! + if (giveAck) + { + // scrivo update ad ack!!! + inizio = DateTime.Now; + //OsaiMemRW_Byte(W, OSAI.MemTypeWord.MW_CODE, memIndexAck, 0, ref retACK_DW0); + writeAlarmAck(ref retACK_DW0); + if (utils.CRB("recTime")) TimingData.addResult(string.Format("W{0}-ACK_DW0", retACK_DW0.Length), DateTime.Now.Subtract(inizio).Ticks); + ackReturned = true; + } + } + } + + // SE non ho già tornato un ACK... + if (!ackReturned) + { + // se è diverso il vettori degli ACK in memoria da quello PLC... + if (ACK_DW0 != (StFlag32)BitConverter.ToUInt32(retACK_DW0, 0)) + { + // invio INTERO set ACK_DW0 con bit abbassati... + retACK_DW0 = BitConverter.GetBytes(Convert.ToUInt32(STRB_DW0 & ACK_DW0)); + inizio = DateTime.Now; + //OsaiMemRW_Byte(W, OSAI.MemTypeWord.MW_CODE, memIndexAck, 0, ref retACK_DW0); + writeAlarmAck(ref retACK_DW0); + if (utils.CRB("recTime")) TimingData.addResult(string.Format("W{0}-ACK_DW0", retACK_DW0.Length), DateTime.Now.Subtract(inizio).Ticks); + } + } + } + /// + /// Scrive vettore ACK degli allarmi + /// + /// + /// + public virtual bool writeAlarmAck(ref byte[] retACK_DW0) + { + return false; + } + + /// + /// Legge vettore di TUTTE memorie tipo DWord dato vettore memorie (completo) + /// + /// + /// + public virtual bool readAllAlarms(ref uint[] MemBlock) + { + return false; + } + /// + /// Legge vettore di TUTTE memorie tipo DWord dato indice di partenza e vettore memorie + /// + /// + /// + /// + public virtual bool readAlarmBlock(ref uint[] MemBlock, int blockIndex) + { + return false; + } + + #endregion + /// /// recupero dati PATH /// public virtual void getPath() diff --git a/MTC_Adapter/MTC_Adapter/AdapterOsai.cs b/MTC_Adapter/MTC_Adapter/AdapterOsai.cs index b09a67f..b192086 100644 --- a/MTC_Adapter/MTC_Adapter/AdapterOsai.cs +++ b/MTC_Adapter/MTC_Adapter/AdapterOsai.cs @@ -10,6 +10,144 @@ namespace MTC_Adapter { public class AdapterOsai : AdapterGeneric { + /// + /// Oggetto MAIN x connessione OSAI + /// + protected OSAI OSAI_ref; + /// + /// wrapper chiamata lettura/scrittura OSAI x BYTE... + /// + /// + /// + /// + /// 0/1 orimo o secondo byte della word... + /// + /// + public bool OsaiMemRW_Byte(bool bWrite, OSAI.MemTypeWord MemType, Int32 memIndex, Int32 memOrderStart, ref byte[] Value) + { + bool answ = false; + if (OSAI_ref.Connected) + { + try + { + answ = OSAI_ref.O_RW_Byte(bWrite, MemType, memIndex, memOrderStart, ref Value); + } + catch + { } + } + return answ; + } + /// + /// wrapper chiamata lettura/scrittura x WORD... + /// + /// + /// + /// + /// + /// + public bool OsaiMemRW_Word(bool bWrite, OSAI.MemTypeWord MemType, Int32 memIndex, ref ushort[] Value) + { + bool answ = false; + if (OSAI_ref.Connected) + { + try + { + answ = OSAI_ref.O_RW_Word(bWrite, MemType, memIndex, ref Value); + } + catch + { } + } + return answ; + } + /// + /// wrapper chiamata lettura/scrittura x DOUBLE-WORD... + /// + /// + /// + /// + /// + /// + public bool OsaiMemRW_DWord(bool bWrite, OSAI.MemTypeWord MemType, Int32 memIndex, ref uint[] Value) + { + bool answ = false; + if (OSAI_ref.Connected) + { + try + { + answ = OSAI_ref.O_RW_DWord(bWrite, MemType, memIndex, ref Value); + } + catch + { } + } + return answ; + } + /// + /// wrapper chiamata lettura/scrittura x Short... + /// + /// + /// + /// + /// + /// + public bool OsaiMemRW_Short(bool bWrite, OSAI.MemTypeWord MemType, Int32 memIndex, ref short[] Value) + { + bool answ = false; + if (OSAI_ref.Connected) + { + try + { + answ = OSAI_ref.O_RW_Short(bWrite, MemType, memIndex, ref Value); + } + catch + { } + } + return answ; + } + /// + /// wrapper chiamata lettura/scrittura x INT... + /// + /// + /// + /// + /// + /// + public bool OsaiMemRW_Integer(bool bWrite, OSAI.MemTypeWord MemType, Int32 memIndex, ref int[] Value) + { + bool answ = false; + if (OSAI_ref.Connected) + { + try + { + answ = OSAI_ref.O_RW_Integer(bWrite, MemType, memIndex, ref Value); + } + catch + { } + } + return answ; + } + /// + /// wrapper chiamata lettura/scrittura x Double... + /// + /// + /// + /// + /// + /// + public bool OsaiMemRW_Double(bool bWrite, OSAI.MemTypeDouble MemType, Int32 memIndex, ref double[] Value) + { + bool answ = false; + if (OSAI_ref.Connected) + { + try + { + answ = OSAI_ref.O_RW_Double(bWrite, MemType, memIndex, ref Value); + } + catch + { } + } + return answ; + } + /// /// struttura dati OSAI x dati NC (pag 148) /// @@ -18,7 +156,7 @@ namespace MTC_Adapter /// Vettore degli allarmi CNC attivi /// //public CMSCncLib.OPENcontrol.MSGERROR allarmiCNC; - public Dictionary allarmiCNC =new Dictionary(); + public Dictionary allarmiCNC = new Dictionary(); /// /// estende l'init della classe base... /// @@ -421,6 +559,7 @@ namespace MTC_Adapter return answ; } +#if false /// /// recupera allarmi ed aggiorna strobe (privato) degli allarmi /// @@ -429,12 +568,9 @@ namespace MTC_Adapter public override void refreshAlarmState(StFlag32 Alarm2Refresh, bool giveAck) { // indici memorie allarmi: strobe ed ACK - int memIndex = 19036; - int memIndexAck = 19018; + //int memIndex = 19036; + //int memIndexAck = 19018; - - - // log bitmap se verboso attivo + ho allarmi da refreshare if ((Alarm2Refresh != StFlag32.NONE) && utils.CRB("verbose")) { @@ -456,7 +592,8 @@ namespace MTC_Adapter MemBlock = new uint[32]; // recupero tutti i 32 bit del blocco inizio = DateTime.Now; - OsaiMemRW_DWord(R, OSAI.MemTypeWord.MW_CODE, memIndex, ref MemBlock); + //OsaiMemRW_DWord(R, OSAI.MemTypeWord.MW_CODE, memIndex, ref MemBlock); + readAllAlarms(ref MemBlock); if (utils.CRB("recTime")) TimingData.addResult(string.Format("R{0}-STRB_DW0", MemBlock.Length * 4), DateTime.Now.Subtract(inizio).Ticks); if (AlarmFlags != null) { @@ -484,7 +621,8 @@ namespace MTC_Adapter { // recupero tutti i 32 bit del blocco inizio = DateTime.Now; - OsaiMemRW_DWord(R, OSAI.MemTypeWord.MW_CODE, memIndex + i * 2, ref MemBlock); + //OsaiMemRW_DWord(R, OSAI.MemTypeWord.MW_CODE, memIndex + i * 2, ref MemBlock); + readAlarmBlock(ref MemBlock, i); if (utils.CRB("recTime")) TimingData.addResult(string.Format("R{0}-STRB_DW0", MemBlock.Length * 4), DateTime.Now.Subtract(inizio).Ticks); try { @@ -508,7 +646,8 @@ namespace MTC_Adapter { // scrivo update ad ack!!! inizio = DateTime.Now; - OsaiMemRW_Byte(W, OSAI.MemTypeWord.MW_CODE, memIndexAck, 0, ref retACK_DW0); + //OsaiMemRW_Byte(W, OSAI.MemTypeWord.MW_CODE, memIndexAck, 0, ref retACK_DW0); + writeAlarmAck(ref retACK_DW0); if (utils.CRB("recTime")) TimingData.addResult(string.Format("W{0}-ACK_DW0", retACK_DW0.Length), DateTime.Now.Subtract(inizio).Ticks); ackReturned = true; } @@ -521,15 +660,49 @@ namespace MTC_Adapter // se è diverso il vettori degli ACK in memoria da quello PLC... if (ACK_DW0 != (StFlag32)BitConverter.ToUInt32(retACK_DW0, 0)) { - memIndex = 19018; // invio INTERO set ACK_DW0 con bit abbassati... retACK_DW0 = BitConverter.GetBytes(Convert.ToUInt32(STRB_DW0 & ACK_DW0)); inizio = DateTime.Now; - OsaiMemRW_Byte(W, OSAI.MemTypeWord.MW_CODE, memIndex, 0, ref retACK_DW0); + //OsaiMemRW_Byte(W, OSAI.MemTypeWord.MW_CODE, memIndexAck, 0, ref retACK_DW0); + writeAlarmAck(ref retACK_DW0); if (utils.CRB("recTime")) TimingData.addResult(string.Format("W{0}-ACK_DW0", retACK_DW0.Length), DateTime.Now.Subtract(inizio).Ticks); } - } + } } +#endif + /// + /// Scrive vettore ACK degli allarmi + /// + /// + /// + public override bool writeAlarmAck(ref byte[] retACK_DW0) + { + int memIndexAck = 19018; + return OsaiMemRW_Byte(W, OSAI.MemTypeWord.MW_CODE, memIndexAck, 0, ref retACK_DW0); + } + + /// + /// Legge vettore di TUTTE memorie tipo DWord dato vettore memorie (completo) + /// + /// + /// + public override bool readAllAlarms(ref uint[] MemBlock) + { + int memIndex = 19036; + return OsaiMemRW_DWord(R, OSAI.MemTypeWord.MW_CODE, memIndex, ref MemBlock); + } + /// + /// Legge vettore di TUTTE memorie tipo DWord dato indice di partenza e vettore memorie + /// + /// + /// + /// + public override bool readAlarmBlock(ref uint[] MemBlock, int blockIndex) + { + int memIndex = 19036; + return OsaiMemRW_DWord(R, OSAI.MemTypeWord.MW_CODE, memIndex + blockIndex * 2, ref MemBlock); + } + /// /// processing! /// @@ -1332,7 +1505,7 @@ namespace MTC_Adapter // salvo valori vettore prec... prevPosAxis[i] = newPos; prevDirAxis[i] = newDir; - + vettAxis[i].mAxFeedOver.Value = FeedRateOver; } catch diff --git a/MTC_Adapter/MTC_Adapter/AdapterSiemens.cs b/MTC_Adapter/MTC_Adapter/AdapterSiemens.cs index 710a47d..8d6ca5d 100644 --- a/MTC_Adapter/MTC_Adapter/AdapterSiemens.cs +++ b/MTC_Adapter/MTC_Adapter/AdapterSiemens.cs @@ -10,6 +10,108 @@ namespace MTC_Adapter { public class AdapterSiemens : AdapterGeneric { + /// + /// Oggetto MAIN x connessione SIEMENS + /// + protected SIEMENS SIEMENS_ref; + + /// + /// Area di memoria base x MTConnect con SIEMENS (DB1499) + /// + protected int baseMemDb = 1499; + /// + /// Area di memoria base x dati UTENSILE (DB253) + /// + protected int baseMemUT = 253; + /// + /// Area di memoria base x dati TESTE (DB254) + /// + protected int baseMemUO = 254; + + /// + /// wrapper chiamata lettura/scrittura SINGOLO BYTE... + /// + /// + /// main address (1499/1500) + /// + /// + /// + public bool SIEMENSMemRW_Byte(bool bWrite, int MemType, Int32 memIndex, ref byte Value) + { + bool answ = false; + // chiamo la versione multibyte... + byte[] ValArray = new byte[1]; + SIEMENSMemRW_Byte(bWrite, MemType, memIndex, ref ValArray); + Value = ValArray[0]; + return answ; + } + /// + /// wrapper chiamata lettura/scrittura MULTI BYTE... + /// + /// + /// main address (1499/1500) + /// + /// + /// + public bool SIEMENSMemRW_Byte(bool bWrite, int MemType, Int32 memIndex, ref byte[] Value) + { + bool answ = false; + if (SIEMENS_ref.Connected) + { + try + { + answ = SIEMENS_ref.S_RW_Byte(bWrite, MemType, memIndex, ref Value); + } + catch + { } + } + return answ; + } + /// + /// wrapper chiamata lettura/scrittura MULTI Word... + /// + /// + /// main address (1499/1500) + /// + /// + /// + public bool SIEMENSMemRW_Word(bool bWrite, int MemType, Int32 memIndex, ref ushort[] Value) + { + bool answ = false; + if (SIEMENS_ref.Connected) + { + try + { + answ = SIEMENS_ref.S_RW_Word(bWrite, MemType, memIndex, ref Value); + } + catch + { } + } + return answ; + } + /// + /// wrapper chiamata lettura/scrittura MULTI DWord... + /// + /// + /// main address (1499/1500) + /// + /// + /// + public bool SIEMENSMemRW_DWord(bool bWrite, int MemType, Int32 memIndex, ref uint[] Value) + { + bool answ = false; + if (SIEMENS_ref.Connected) + { + try + { + answ = SIEMENS_ref.S_RW_DWord(bWrite, MemType, memIndex, ref Value); + } + catch + { } + } + return answ; + } + /// /// struttura dati SIEMENS x ALL DYN DATA /// C:\Users\samuele\Documents\FOCAS A02B-0207-K737_04.20\Document\SpecE\Position\cnc_rddynamic2.htm