diff --git a/CMS_CORE_Library/Demo/Nc_Demo.cs b/CMS_CORE_Library/Demo/Nc_Demo.cs
index f4b4f0a..ed01d45 100644
--- a/CMS_CORE_Library/Demo/Nc_Demo.cs
+++ b/CMS_CORE_Library/Demo/Nc_Demo.cs
@@ -720,6 +720,56 @@ namespace CMS_CORE_Library.Demo
             return NO_ERROR;
         }
 
+
+        public override CmsError PLC_RWorkedTimeHead(int head, ref uint time)
+        {
+            int index = (head - 1) *4;
+
+            // Read Worked time
+            CmsError cmsError = MEM_RWDWord(R, 0, HEADS_WORKED_TIMES.MemType, HEADS_WORKED_TIMES.Address + index, ref time);
+            if (cmsError.IsError())
+                return cmsError;
+
+            return NO_ERROR;
+        }
+
+        public override CmsError PLC_WResetWorkedTimeHead(int head)
+        {
+            int index = (head - 1) * 4;
+            uint time = 0;
+
+            if (head <= 0 || head > MAX_HEADS_NUMBER)
+                return INCORRECT_PARAMETERS_ERROR;
+
+            // Read Worked time
+            CmsError cmsError = MEM_RWDWord(W, 0, HEADS_WORKED_TIMES.MemType, HEADS_WORKED_TIMES.Address + index, ref time);
+            if (cmsError.IsError())
+                return cmsError;
+
+            return NO_ERROR;
+        }
+
+        public override CmsError PLC_RWorkedTimeMachine(ref uint time)
+        {
+            
+            // Read Worked time -> ipotizzo sia il contatore 0
+            CmsError cmsError = MEM_RWDWord(R, 0, COUNTERS.MemType, COUNTERS.Address, ref time);
+            if (cmsError.IsError())
+                return cmsError;
+
+            return NO_ERROR;
+        }
+        
+        public override CmsError PLC_WResetWorkedTimeMachine(uint time)
+        {
+            // Write Worked time -> ipotizzo sia il contatore 0
+            CmsError cmsError = MEM_RWDWord(W, 0, COUNTERS.MemType, COUNTERS.Address, ref time);
+            if (cmsError.IsError())
+                return cmsError;
+
+            return NO_ERROR;
+        }
+        
         public override CmsError PLC_WHeadOverride(uint id, HEAD_OVERRIDE_SIGN sign)
         {
             if (id > MAX_HEADS_NUMBER)
diff --git a/CMS_CORE_Library/Fanuc/Nc_Fanuc.cs b/CMS_CORE_Library/Fanuc/Nc_Fanuc.cs
index c56fd63..743552c 100644
--- a/CMS_CORE_Library/Fanuc/Nc_Fanuc.cs
+++ b/CMS_CORE_Library/Fanuc/Nc_Fanuc.cs
@@ -832,6 +832,104 @@ namespace CMS_CORE_Library.Fanuc
 
             return NO_ERROR;
         }
+        
+
+        public override CmsError PLC_RWorkedTimeHead(int head, ref uint time)
+        {
+            int index = (head - 1) * 4;
+
+            // Read Worked time
+            CmsError cmsError = MEM_RWDWord(R, 0, HEADS_WORKED_TIMES.MemType, HEADS_WORKED_TIMES.Address + index, ref time);
+            if (cmsError.IsError())
+                return cmsError;
+
+            return NO_ERROR;
+        }
+
+        public override CmsError PLC_WResetWorkedTimeHead(int head)
+        {
+            byte usControlWord = 0;
+
+            if (head <= 0 || head > MAX_HEADS_NUMBER)
+                return INCORRECT_PARAMETERS_ERROR;
+
+            // Read status
+            CmsError cmsError = MEM_RWByte(R, 0, HEAD_RESET_WORKED_TIME.MemType, HEAD_RESET_WORKED_TIME.Address, 0, ref usControlWord);
+            if (cmsError.IsError())
+                return cmsError;
+
+            // Re-Write it status
+            usControlWord = Convert.ToByte((usControlWord & 0xE0) | (head & 0X1F));
+            cmsError = MEM_RWByte(W, 0, HEAD_RESET_WORKED_TIME.MemType, HEAD_RESET_WORKED_TIME.Address, 0, ref usControlWord);
+            if (cmsError.IsError())
+                return cmsError;
+
+            return NO_ERROR;
+        }
+
+        public override CmsError PLC_RWorkedTimeMachine(ref uint time)
+        {
+            // Read Worked time 
+            CmsError cmsError = MEM_RWDWord(R, 0, MACHINE_WORKED_TIME.MemType, MACHINE_WORKED_TIME.Address, ref time);
+            if (cmsError.IsError())
+                return cmsError;
+
+            return NO_ERROR;
+        }
+
+        public override CmsError PLC_WResetWorkedTimeMachine(uint time)
+        {
+            uint actTime = 0;
+
+            // Read actual Value
+            CmsError cmsError = MEM_RWDWord(R, 0, MACHINE_WORKED_TIME.MemType, MACHINE_WORKED_TIME.Address, ref actTime);
+            if (cmsError.IsError())
+                return cmsError;
+
+            // Per richiedere l'azzeramento del timer invio 4 volte il segnale velocemente al PLC
+            // Il PLC resetta il bit e aspetta quello successivo entro 500ms, se no abortisce
+            // Sfrutto così la velocità dei sw, cosa che un "nemico" a mano se provasse a forzare il bit non avrebbe
+            bool bitValue = true;
+            int nTry = 0;
+
+            for (int i = 0; i < 4; i++)
+            {
+                //Scrivo il bit
+                cmsError = MEM_RWBoolean(W, 0, MACHINE_RESET_WORKED_TIME.MemType, MACHINE_RESET_WORKED_TIME.Address, 0, ref bitValue);
+                if (cmsError.IsError())
+                    return cmsError;
+
+                //Aspetto che venga abbassato
+                do
+                {
+                    Thread.Sleep(50);
+                    nTry += 1;
+                    cmsError = MEM_RWBoolean(R, 0, MACHINE_RESET_WORKED_TIME.MemType, MACHINE_RESET_WORKED_TIME.Address, 0, ref bitValue);
+                    if (cmsError.IsError())
+                        return cmsError;
+
+                } while (!bitValue || nTry > 10);
+
+                //se il valore è rimasto a 1 il plc non l'ha preso in carico, e abortisco
+                if (bitValue)
+                {
+                    bitValue = true;
+                    cmsError = MEM_RWBoolean(W, 0, MACHINE_RESET_WORKED_TIME.MemType, MACHINE_RESET_WORKED_TIME.Address, 0, ref bitValue);
+                    if (cmsError.IsError())
+                        return cmsError;
+
+                    return PLC_NOT_RUNNING_ERROR;
+                }
+                else
+                {
+                    //Se l'ha abbassato scrivo il nuovo dato
+                    cmsError = MEM_RWDWord(W, 0, MACHINE_WORKED_TIME.MemType, MACHINE_WORKED_TIME.Address, ref time);
+                }
+
+            }
+
+            return NO_ERROR;
+        }
 
         public override CmsError PLC_WHeadOverride(uint id, HEAD_OVERRIDE_SIGN sign)
         {
@@ -4628,5 +4726,8 @@ namespace CMS_CORE_Library.Fanuc
 
         //old CMS-Control variables
         internal static MEMORY_CELL HEADS_WORKED_TIMES = new MEMORY_CELL(MEMORY_TYPE.Fanuc_D, 3060, 4);
+        internal static MEMORY_CELL HEAD_RESET_WORKED_TIME = new MEMORY_CELL(MEMORY_TYPE.Fanuc_D, 7217, 4);
+        internal static MEMORY_CELL MACHINE_WORKED_TIME = new MEMORY_CELL(MEMORY_TYPE.Fanuc_D, 7213, 4);
+        internal static MEMORY_CELL MACHINE_RESET_WORKED_TIME = new MEMORY_CELL(MEMORY_TYPE.Fanuc_D, 7212, 4);
     }
 }
\ No newline at end of file
diff --git a/CMS_CORE_Library/Nc.cs b/CMS_CORE_Library/Nc.cs
index fdf9823..773dec3 100644
--- a/CMS_CORE_Library/Nc.cs
+++ b/CMS_CORE_Library/Nc.cs
@@ -566,6 +566,12 @@ namespace CMS_CORE_Library
 
         public abstract CmsError PLC_WScadaValue(string memIndex, SCADA_MEM_TYPE memType, object value);
 
+        public abstract CmsError PLC_RWorkedTimeHead(int head, ref uint time);
+
+        public abstract CmsError PLC_WResetWorkedTimeHead(int head);
+        public abstract CmsError PLC_RWorkedTimeMachine(ref uint time);
+        public abstract CmsError PLC_WResetWorkedTimeMachine(uint time);
+
         public abstract CmsError PLC_RCandy(ref int value);
         public abstract CmsError PLC_WCandy(int value);
         public abstract CmsError PLC_RExpiredCandy(ref bool value);
diff --git a/CMS_CORE_Library/Osai/Nc_Osai.cs b/CMS_CORE_Library/Osai/Nc_Osai.cs
index 213c19d..83748e3 100644
--- a/CMS_CORE_Library/Osai/Nc_Osai.cs
+++ b/CMS_CORE_Library/Osai/Nc_Osai.cs
@@ -802,6 +802,103 @@ namespace CMS_CORE_Library.Osai
 
             return NO_ERROR;
         }
+               
+        public override CmsError PLC_RWorkedTimeHead(int head, ref uint time)
+        {
+            int index = (head - 1) * 2;
+
+            // Read Worked time
+            CmsError cmsError = MEM_RWDWord(R, 0, HEADS_WORKED_TIMES.MemType, HEADS_WORKED_TIMES.Address + index, ref time);
+            if (cmsError.IsError())
+                return cmsError;
+
+            return NO_ERROR;
+        }
+        
+        public override CmsError PLC_WResetWorkedTimeHead(int head)
+        {
+            ushort usControlWord = 0;
+
+            if(head <= 0 || head > MAX_HEADS_NUMBER)
+                return INCORRECT_PARAMETERS_ERROR;
+
+            // Read status
+            CmsError cmsError = MEM_RWWord(R, 0, HEAD_RESET_WORKED_TIME.MemType, HEAD_RESET_WORKED_TIME.Address, ref usControlWord);
+            if (cmsError.IsError())
+                return cmsError;
+
+            // Re-Write it status
+            usControlWord = Convert.ToUInt16((usControlWord & 0xFFE0) | (head & 0X1F));
+            cmsError = MEM_RWWord(W, 0, HEAD_RESET_WORKED_TIME.MemType, HEAD_RESET_WORKED_TIME.Address, ref usControlWord);
+            if (cmsError.IsError())
+                return cmsError;
+
+            return NO_ERROR;
+        }
+
+        public override CmsError PLC_RWorkedTimeMachine(ref uint time)
+        {
+            // Read Worked time 
+            CmsError cmsError = MEM_RWDWord(R, 0, MACHINE_WORKED_TIME.MemType, MACHINE_WORKED_TIME.Address, ref time);
+            if (cmsError.IsError())
+                return cmsError;
+
+            return NO_ERROR;
+        }
+
+        public override CmsError PLC_WResetWorkedTimeMachine(uint time)
+        {
+            uint actTime = 0;
+
+            // Read actual Value
+            CmsError cmsError = MEM_RWDWord(R, 0, MACHINE_WORKED_TIME.MemType, MACHINE_WORKED_TIME.Address, ref actTime);
+            if (cmsError.IsError())
+                return cmsError;
+
+            // Per richiedere l'azzeramento del timer invio 4 volte il segnale velocemente al PLC
+            // Il PLC resetta il bit e aspetta quello successivo entro 500ms, se no abortisce
+            // Sfrutto così la velocità dei sw, cosa che un "nemico" a mano se provasse a forzare il bit non avrebbe
+            bool bitValue = true;
+            int nTry = 0;
+
+            for (int i = 0; i<4; i++)
+            {
+                //Scrivo il bit
+                cmsError = MEM_RWBoolean(W, 0, MACHINE_RESET_WORKED_TIME.MemType, MACHINE_RESET_WORKED_TIME.Address,0, ref bitValue);
+                if (cmsError.IsError())
+                    return cmsError;
+
+                //Aspetto che venga abbassato
+                do
+                {
+                    Thread.Sleep(50);
+                    nTry += 1;
+                    cmsError = MEM_RWBoolean(R, 0, MACHINE_RESET_WORKED_TIME.MemType, MACHINE_RESET_WORKED_TIME.Address, 0, ref bitValue);
+                    if (cmsError.IsError())
+                        return cmsError;
+
+                } while (!bitValue || nTry > 10);
+
+                //se il valore è rimasto a 1 il plc non l'ha preso in carico, e abortisco
+                if (bitValue)
+                {
+                    bitValue = true;
+                    cmsError = MEM_RWBoolean(W, 0, MACHINE_RESET_WORKED_TIME.MemType, MACHINE_RESET_WORKED_TIME.Address, 0, ref bitValue);
+                    if (cmsError.IsError())
+                        return cmsError;
+
+                    return PLC_NOT_RUNNING_ERROR;
+                }
+                else
+                {
+                    //Se l'ha abbassato scrivo il nuovo dato
+                    cmsError = MEM_RWDWord(W, 0, MACHINE_WORKED_TIME.MemType, MACHINE_WORKED_TIME.Address, ref time);
+                }
+
+            }
+
+            return NO_ERROR;
+        }
 
         public override CmsError PLC_WHeadOverride(uint id, HEAD_OVERRIDE_SIGN sign)
         {
@@ -4407,6 +4504,11 @@ namespace CMS_CORE_Library.Osai
 
         //old CMS-Control variables
         internal static MEMORY_CELL HEADS_WORKED_TIMES = new MEMORY_CELL(MEMORY_TYPE.Osai_MW, 2910, 4);
+        internal static MEMORY_CELL HEAD_RESET_WORKED_TIME = new MEMORY_CELL(MEMORY_TYPE.Osai_MW, 3458, 4);
+        internal static MEMORY_CELL MACHINE_WORKED_TIME = new MEMORY_CELL(MEMORY_TYPE.Osai_MW, 3455, 4);
+        internal static MEMORY_CELL MACHINE_RESET_WORKED_TIME = new MEMORY_CELL(MEMORY_TYPE.Osai_MW, 3454, 4);
+
+
     }
 
     #endregion Memory addresses
diff --git a/CMS_CORE_Library/Siemens/Nc_Siemens.cs b/CMS_CORE_Library/Siemens/Nc_Siemens.cs
index 1ac96aa..d49ee1d 100644
--- a/CMS_CORE_Library/Siemens/Nc_Siemens.cs
+++ b/CMS_CORE_Library/Siemens/Nc_Siemens.cs
@@ -999,7 +999,7 @@ namespace CMS_CORE_Library.Siemens
             readValues = readInts.SelectMany(BitConverter.GetBytes).ToList();
 
             // Read Worked time heads
-            cmsError = MEM_RWDWordList(R, 0, HEADS_WORKED_TIMES.MemType, HEADS_WORKED_TIMES.Address, number, ref readHours);
+            cmsError = MEM_RWDWordList(R, 0, HEADS_WORKED_TIMES.MemType, HEADS_WORKED_TIMES.Address, HEADS_WORKED_TIMES.SubAddress, number, ref readHours);
             if (cmsError.IsError())
                 return cmsError;
 
@@ -1036,6 +1036,103 @@ namespace CMS_CORE_Library.Siemens
             return NO_ERROR;
         }
 
+        public override CmsError PLC_RWorkedTimeHead(int head, ref uint time)
+        {
+            int index = (head - 1) * 4;
+
+            // Read Worked time
+            CmsError cmsError = MEM_RWDWord(R, 0, HEADS_WORKED_TIMES.MemType, HEADS_WORKED_TIMES.Address, HEADS_WORKED_TIMES.SubAddress + index, ref time);
+            if (cmsError.IsError())
+                return cmsError;
+
+            return NO_ERROR;
+        }
+
+        public override CmsError PLC_WResetWorkedTimeHead(int head)
+        {
+            byte usControlWord = 0;
+
+            if (head <= 0 || head > MAX_HEADS_NUMBER)
+                return INCORRECT_PARAMETERS_ERROR;
+
+            // Read status
+            CmsError cmsError = MEM_RWByte(R, 0, HEAD_RESET_WORKED_TIME.MemType, HEAD_RESET_WORKED_TIME.Address, HEADS_WORKED_TIMES.SubAddress, 0, ref usControlWord);
+            if (cmsError.IsError())
+                return cmsError;
+
+            // Re-Write it status
+            usControlWord = Convert.ToByte((usControlWord & 0xE0) | (head & 0X1F));
+            cmsError = MEM_RWByte(W, 0, HEAD_RESET_WORKED_TIME.MemType, HEAD_RESET_WORKED_TIME.Address, HEADS_WORKED_TIMES.SubAddress, 0, ref usControlWord);
+            if (cmsError.IsError())
+                return cmsError;
+
+            return NO_ERROR;
+        }
+
+        public override CmsError PLC_RWorkedTimeMachine(ref uint time)
+        {
+            // Read Worked time 
+            CmsError cmsError = MEM_RWDWord(R, 0, MACHINE_WORKED_TIME.MemType, MACHINE_WORKED_TIME.Address, MACHINE_WORKED_TIME.SubAddress, ref time);
+            if (cmsError.IsError())
+                return cmsError;
+
+            return NO_ERROR;
+        }
+
+        public override CmsError PLC_WResetWorkedTimeMachine(uint time)
+        {
+            uint actTime = 0;
+
+            // Read actual Value
+            CmsError cmsError = MEM_RWDWord(R, 0, MACHINE_WORKED_TIME.MemType, MACHINE_WORKED_TIME.Address, MACHINE_WORKED_TIME.SubAddress, ref actTime);
+            if (cmsError.IsError())
+                return cmsError;
+
+            // Per richiedere l'azzeramento del timer invio 4 volte il segnale velocemente al PLC
+            // Il PLC resetta il bit e aspetta quello successivo entro 500ms, se no abortisce
+            // Sfrutto così la velocità dei sw, cosa che un "nemico" a mano se provasse a forzare il bit non avrebbe
+            bool bitValue = true;
+            int nTry = 0;
+
+            for (int i = 0; i < 4; i++)
+            {
+                //Scrivo il bit
+                cmsError = MEM_RWBoolean(W, 0, MACHINE_RESET_WORKED_TIME.MemType, MACHINE_RESET_WORKED_TIME.Address, MACHINE_RESET_WORKED_TIME.SubAddress, 0, ref bitValue);
+                if (cmsError.IsError())
+                    return cmsError;
+
+                //Aspetto che venga abbassato
+                do
+                {
+                    Thread.Sleep(50);
+                    nTry += 1;
+                    cmsError = MEM_RWBoolean(R, 0, MACHINE_RESET_WORKED_TIME.MemType, MACHINE_RESET_WORKED_TIME.Address, MACHINE_RESET_WORKED_TIME.SubAddress, 0, ref bitValue);
+                    if (cmsError.IsError())
+                        return cmsError;
+
+                } while (!bitValue || nTry > 10);
+
+                //se il valore è rimasto a 1 il plc non l'ha preso in carico, e abortisco
+                if (bitValue)
+                {
+                    bitValue = true;
+                    cmsError = MEM_RWBoolean(W, 0, MACHINE_RESET_WORKED_TIME.MemType, MACHINE_RESET_WORKED_TIME.Address, MACHINE_RESET_WORKED_TIME.SubAddress, 0, ref bitValue);
+                    if (cmsError.IsError())
+                        return cmsError;
+
+                    return PLC_NOT_RUNNING_ERROR;
+                }
+                else
+                {
+                    //Se l'ha abbassato scrivo il nuovo dato
+                    cmsError = MEM_RWDWord(W, 0, MACHINE_WORKED_TIME.MemType, MACHINE_WORKED_TIME.Address, MACHINE_WORKED_TIME.SubAddress, ref time);
+                }
+
+            }
+
+            return NO_ERROR;
+        }
+
         public override CmsError PLC_WHeadOverride(uint id, HEAD_OVERRIDE_SIGN sign)
         {
             if (id > MAX_HEADS_NUMBER)
@@ -6001,5 +6098,8 @@ namespace CMS_CORE_Library.Siemens
 
         //old CMS-Control variables
         internal static MEMORY_CELL HEADS_WORKED_TIMES = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, 254, 60, 4);
+        internal static MEMORY_CELL HEAD_RESET_WORKED_TIME = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, 255, 92, 4);
+        internal static MEMORY_CELL MACHINE_WORKED_TIME = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, 255, 94, 4);
+        internal static MEMORY_CELL MACHINE_RESET_WORKED_TIME = new MEMORY_CELL(MEMORY_TYPE.Siemens_DB, 98, 92, 4);
     }
 }
\ No newline at end of file