diff --git a/MTC_Adapter/MTC_Adapter/AdapterSiemens.cs b/MTC_Adapter/MTC_Adapter/AdapterSiemens.cs
index 8d6ca5d..76518dd 100644
--- a/MTC_Adapter/MTC_Adapter/AdapterSiemens.cs
+++ b/MTC_Adapter/MTC_Adapter/AdapterSiemens.cs
@@ -510,116 +510,44 @@ namespace MTC_Adapter
 
             return answ;
         }
+
+
         /// <summary>
-        /// recupera allarmi ed aggiorna strobe (privato) degli allarmi
+        /// Scrive vettore ACK degli allarmi
         /// </summary>
-        /// <param name="Alarm2Refresh">32bit mask degli allarmi da aggiornare</param>
-        /// <param name="giveAck">boolean: se si debba tornare ACK</param>
-        public override void refreshAlarmState(StFlag32 Alarm2Refresh, bool giveAck)
+        /// <param name="retACK_DW0"></param>
+        /// <returns></returns>
+        public override bool writeAlarmAck(ref byte[] retACK_DW0)
         {
-            // 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;
-            byte[] MemBlock;
-            // primo blocco memoria allarmi
-            int memIndex = 10532;
-            // 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 byte[128];
-                // recupero tutti i 32 bit del blocco
-                inizio = DateTime.Now;
-                SIEMENSMemRW_Byte(R, baseMemDb, memIndex, ref MemBlock);
-                if (utils.CRB("recTime")) TimingData.addResult(string.Format("R{0}-STRB_DW0", MemBlock.Length), 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 byte[4];
-                    // 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;
-                            SIEMENSMemRW_Byte(R, baseMemDb, memIndex + i * 4, ref MemBlock);
-                            if (utils.CRB("recTime")) TimingData.addResult(string.Format("R{0}-STRB_DW0", MemBlock.Length), DateTime.Now.Subtract(inizio).Ticks);
-
-                            // da testare metodo copia alternativo, condizionato a web.config
-                            if (!utils.CRB("fastCopy"))
-                            {
-                                // aggiorno nel vettore allarmi i byte interessati
-                                for (int j = 0; j < 4; j++)
-                                {
-                                    // copy array a blocchi
-                                    AlarmFlags[i * 4 + j] = MemBlock[j];
-                                }
-                            }
-                            else
-                            {
-                                Buffer.BlockCopy(MemBlock, 0, AlarmFlags, i, MemBlock.Length);
-                            }
-
-                            // segnalo allarme letto! memorizzo allarme nel vettore ack....
-                            retACK_DW0 = utils.setBitOnStFlag(retACK_DW0, true, i);
-                        }
-                    }
-                    // scrivo ack se richiesto!!!
-                    if (giveAck)
-                    {
-                        // mi preparo a scrivere ACK
-                        memIndex = 10500;
-                        // scrivo update ad ack!!!
-                        inizio = DateTime.Now;
-                        SIEMENSMemRW_Byte(W, baseMemDb, memIndex, 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))
-                {
-                    memIndex = 10500;
-                    // invio INTERO set ACK_DW0 con bit abbassati...
-                    retACK_DW0 = BitConverter.GetBytes(Convert.ToUInt32(STRB_DW0 & ACK_DW0));
-                    inizio = DateTime.Now;
-                    SIEMENSMemRW_Byte(W, baseMemDb, memIndex, ref retACK_DW0);
-                    if (utils.CRB("recTime")) TimingData.addResult(string.Format("W{0}-ACK_DW0", retACK_DW0.Length), DateTime.Now.Subtract(inizio).Ticks);
-                }
-            }
+            // DB1499.DBX0.0
+            int memIndexAck = 0;
+            return SIEMENSMemRW_Byte(W, baseMemDb, memIndexAck, 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)
+        {
+            // DB1499.DBW118
+            int memIndex = 118;
+            return SIEMENSMemRW_DWord(R, baseMemDb, 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)
+        {
+            // DB1499.DBW118
+            int memIndex = 118;
+            return SIEMENSMemRW_DWord(R, baseMemDb, memIndex + blockIndex * 2, ref MemBlock);
+        }
+        
         /// <summary>
         /// processing!
         /// </summary>