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
-
-        /// <summary>
-        /// Oggetto MAIN x connessione OSAI
-        /// </summary>
-        protected OSAI OSAI_ref;
-        /// <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 (OSAI_ref.Connected)
-            {
-                try
-                {
-                    answ = OSAI_ref.O_RW_Byte(bWrite, MemType, memIndex, memOrderStart, ref Value);
-                }
-                catch
-                { }
-            }
-            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)
-            {
-                try
-                {
-                    answ = OSAI_ref.O_RW_Word(bWrite, MemType, memIndex, ref Value);
-                }
-                catch
-                { }
-            }
-            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)
-            {
-                try
-                {
-                    answ = OSAI_ref.O_RW_DWord(bWrite, MemType, memIndex, ref Value);
-                }
-                catch
-                { }
-            }
-            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)
-            {
-                try
-                {
-                    answ = OSAI_ref.O_RW_Short(bWrite, MemType, memIndex, ref Value);
-                }
-                catch
-                { }
-            }
-            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 (OSAI_ref.Connected)
-            {
-                try
-                {
-                    answ = OSAI_ref.O_RW_Integer(bWrite, MemType, memIndex, ref Value);
-                }
-                catch
-                { }
-            }
-            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 (OSAI_ref.Connected)
-            {
-                try
-                {
-                    answ = OSAI_ref.O_RW_Double(bWrite, MemType, memIndex, ref Value);
-                }
-                catch
-                { }
-            }
-            return answ;
-        }
-
-        #endregion
-
-        #region CNC Siemens
-
-        /// <summary>
-        /// Oggetto MAIN x connessione SIEMENS
-        /// </summary>
-        protected SIEMENS SIEMENS_ref;
-
-        /// <summary>
-        /// Area di memoria base x MTConnect con SIEMENS (DB1499)
-        /// </summary>
-        protected int baseMemDb = 1499;
-        /// <summary>
-        /// Area di memoria base x dati UTENSILE (DB253)
-        /// </summary>
-        protected int baseMemUT = 253;
-        /// <summary>
-        /// Area di memoria base x dati TESTE (DB254)
-        /// </summary>
-        protected int baseMemUO = 254;
-
-        /// <summary>
-        /// wrapper chiamata lettura/scrittura SINGOLO BYTE...
-        /// </summary>
-        /// <param name="bWrite"></param>
-        /// <param name="MemType">main address (1499/1500)</param>
-        /// <param name="memIndex"></param>
-        /// <param name="Value"></param>
-        /// <returns></returns>
-        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;
-        }
-        /// <summary>
-        /// wrapper chiamata lettura/scrittura MULTI BYTE...
-        /// </summary>
-        /// <param name="bWrite"></param>
-        /// <param name="MemType">main address (1499/1500)</param>
-        /// <param name="memIndex"></param>
-        /// <param name="MATRICE Value"></param>
-        /// <returns></returns>
-        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;
-        }
-        /// <summary>
-        /// wrapper chiamata lettura/scrittura MULTI Word...
-        /// </summary>
-        /// <param name="bWrite"></param>
-        /// <param name="MemType">main address (1499/1500)</param>
-        /// <param name="memIndex"></param>
-        /// <param name="MATRICE Value"></param>
-        /// <returns></returns>
-        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;
-        }
-        /// <summary>
-        /// wrapper chiamata lettura/scrittura MULTI DWord...
-        /// </summary>
-        /// <param name="bWrite"></param>
-        /// <param name="MemType">main address (1499/1500)</param>
-        /// <param name="memIndex"></param>
-        /// <param name="MATRICE Value"></param>
-        /// <returns></returns>
-        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
+        
 
         /// <summary> 
         /// lettura file di persistenza 
@@ -2081,15 +1829,6 @@ namespace MTC_Adapter
             adpTryRestart = true;
             parentForm.displayTaskAndWait("Adapter Started!");
         }
-        /// <summary>
-        /// Effettua refresh del vettore privato degli allarmi attivi
-        /// </summary>
-        /// <param name="Alarm2Refresh">flag mask degli allarmi da aggiornare</param>
-        /// <param name="giveAck">boolean: se si debba tornare ACK</param>
-        public virtual void refreshAlarmState(StFlag32 Alarm2Refresh, bool giveAck)
-        {
-            // carico lo stato di tutti gli allarmi... forzo a 1 il flag degli allarmi
-        }
 
         /// <summary>
         /// ferma l'adapter...
@@ -2361,6 +2100,8 @@ namespace MTC_Adapter
             }
         }
 
+        #region gestione allarmi
+
         /// <summary>
         /// effettua ogni log period una rilettura di TUTTI gli allarmi...
         /// </summary>
@@ -2379,6 +2120,146 @@ namespace MTC_Adapter
             if (utils.CRB("recTime")) logTimeResults();
         }
         /// <summary>
+        /// Effettua refresh del vettore privato degli allarmi attivi
+        /// </summary>
+        /// <param name="Alarm2Refresh">flag mask degli allarmi da aggiornare</param>
+        /// <param name="giveAck">boolean: se si debba tornare ACK</param>
+        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);
+                }
+            }
+        }
+        /// <summary>
+        /// Scrive vettore ACK degli allarmi
+        /// </summary>
+        /// <param name="retACK_DW0"></param>
+        /// <returns></returns>
+        public virtual bool writeAlarmAck(ref byte[] retACK_DW0)
+        {
+            return false;
+        }
+
+        /// <summary>
+        /// Legge vettore di TUTTE memorie tipo DWord dato vettore memorie (completo)
+        /// </summary>
+        /// <param name="MemBlock"></param>
+        /// <returns></returns>
+        public virtual bool readAllAlarms(ref uint[] MemBlock)
+        {
+            return false;
+        }
+        /// <summary>
+        /// Legge vettore di TUTTE memorie tipo DWord dato indice di partenza e vettore memorie
+        /// </summary>
+        /// <param name="MemBlock"></param>
+        /// <param name="blockIndex"></param>
+        /// <returns></returns>
+        public virtual bool readAlarmBlock(ref uint[] MemBlock, int blockIndex)
+        {
+            return false;
+        }
+
+        #endregion
+        /// <summary>
         /// recupero dati PATH
         /// </summary>
         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
     {
+        /// <summary>
+        /// Oggetto MAIN x connessione OSAI
+        /// </summary>
+        protected OSAI OSAI_ref;
+        /// <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 (OSAI_ref.Connected)
+            {
+                try
+                {
+                    answ = OSAI_ref.O_RW_Byte(bWrite, MemType, memIndex, memOrderStart, ref Value);
+                }
+                catch
+                { }
+            }
+            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)
+            {
+                try
+                {
+                    answ = OSAI_ref.O_RW_Word(bWrite, MemType, memIndex, ref Value);
+                }
+                catch
+                { }
+            }
+            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)
+            {
+                try
+                {
+                    answ = OSAI_ref.O_RW_DWord(bWrite, MemType, memIndex, ref Value);
+                }
+                catch
+                { }
+            }
+            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)
+            {
+                try
+                {
+                    answ = OSAI_ref.O_RW_Short(bWrite, MemType, memIndex, ref Value);
+                }
+                catch
+                { }
+            }
+            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 (OSAI_ref.Connected)
+            {
+                try
+                {
+                    answ = OSAI_ref.O_RW_Integer(bWrite, MemType, memIndex, ref Value);
+                }
+                catch
+                { }
+            }
+            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 (OSAI_ref.Connected)
+            {
+                try
+                {
+                    answ = OSAI_ref.O_RW_Double(bWrite, MemType, memIndex, ref Value);
+                }
+                catch
+                { }
+            }
+            return answ;
+        }
+
         /// <summary>
         /// struttura dati OSAI x dati NC (pag 148)
         /// </summary>
@@ -18,7 +156,7 @@ namespace MTC_Adapter
         /// Vettore degli allarmi CNC attivi
         /// </summary>
         //public CMSCncLib.OPENcontrol.MSGERROR allarmiCNC;
-        public Dictionary<string, string> allarmiCNC =new Dictionary<string, string>();
+        public Dictionary<string, string> allarmiCNC = new Dictionary<string, string>();
         /// <summary>
         /// estende l'init della classe base...
         /// </summary>
@@ -421,6 +559,7 @@ namespace MTC_Adapter
 
             return answ;
         }
+#if false
         /// <summary>
         /// recupera allarmi ed aggiorna strobe (privato) degli allarmi
         /// </summary>
@@ -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
+        /// <summary>
+        /// Scrive vettore ACK degli allarmi
+        /// </summary>
+        /// <param name="retACK_DW0"></param>
+        /// <returns></returns>
+        public override bool writeAlarmAck(ref byte[] retACK_DW0)
+        {
+            int memIndexAck = 19018;
+            return OsaiMemRW_Byte(W, OSAI.MemTypeWord.MW_CODE, memIndexAck, 0, ref retACK_DW0);
+        }
+
+        /// <summary>
+        /// Legge vettore di TUTTE memorie tipo DWord dato vettore memorie (completo)
+        /// </summary>
+        /// <param name="MemBlock"></param>
+        /// <returns></returns>
+        public override bool readAllAlarms(ref uint[] MemBlock)
+        {
+            int memIndex = 19036;
+            return OsaiMemRW_DWord(R, OSAI.MemTypeWord.MW_CODE, memIndex, ref MemBlock);
+        }
+        /// <summary>
+        /// Legge vettore di TUTTE memorie tipo DWord dato indice di partenza e vettore memorie
+        /// </summary>
+        /// <param name="MemBlock"></param>
+        /// <param name="blockIndex"></param>
+        /// <returns></returns>
+        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);
+        }
+
         /// <summary>
         /// processing!
         /// </summary>
@@ -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
     {
+        /// <summary>
+        /// Oggetto MAIN x connessione SIEMENS
+        /// </summary>
+        protected SIEMENS SIEMENS_ref;
+
+        /// <summary>
+        /// Area di memoria base x MTConnect con SIEMENS (DB1499)
+        /// </summary>
+        protected int baseMemDb = 1499;
+        /// <summary>
+        /// Area di memoria base x dati UTENSILE (DB253)
+        /// </summary>
+        protected int baseMemUT = 253;
+        /// <summary>
+        /// Area di memoria base x dati TESTE (DB254)
+        /// </summary>
+        protected int baseMemUO = 254;
+
+        /// <summary>
+        /// wrapper chiamata lettura/scrittura SINGOLO BYTE...
+        /// </summary>
+        /// <param name="bWrite"></param>
+        /// <param name="MemType">main address (1499/1500)</param>
+        /// <param name="memIndex"></param>
+        /// <param name="Value"></param>
+        /// <returns></returns>
+        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;
+        }
+        /// <summary>
+        /// wrapper chiamata lettura/scrittura MULTI BYTE...
+        /// </summary>
+        /// <param name="bWrite"></param>
+        /// <param name="MemType">main address (1499/1500)</param>
+        /// <param name="memIndex"></param>
+        /// <param name="MATRICE Value"></param>
+        /// <returns></returns>
+        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;
+        }
+        /// <summary>
+        /// wrapper chiamata lettura/scrittura MULTI Word...
+        /// </summary>
+        /// <param name="bWrite"></param>
+        /// <param name="MemType">main address (1499/1500)</param>
+        /// <param name="memIndex"></param>
+        /// <param name="MATRICE Value"></param>
+        /// <returns></returns>
+        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;
+        }
+        /// <summary>
+        /// wrapper chiamata lettura/scrittura MULTI DWord...
+        /// </summary>
+        /// <param name="bWrite"></param>
+        /// <param name="MemType">main address (1499/1500)</param>
+        /// <param name="memIndex"></param>
+        /// <param name="MATRICE Value"></param>
+        /// <returns></returns>
+        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;
+        }
+
         /// <summary>
         /// struttura dati SIEMENS x ALL DYN DATA
         /// C:\Users\samuele\Documents\FOCAS A02B-0207-K737_04.20\Document\SpecE\Position\cnc_rddynamic2.htm