Index: Includes/eip_encap_cl1.h
===================================================================
--- Includes/eip_encap_cl1.h	(revision 124917)
+++ Includes/eip_encap_cl1.h	(working copy)
@@ -238,7 +238,7 @@
 void EipEncapCl1_StopTxTimer(struct EIP_IO_PRODUCER_TRANSPORT_Ttag* hTransport);
 void EipEncapCl1_StopRxTimer(struct EIP_IO_CONSUMER_TRANSPORT_Ttag* hTransport);
 
-void EipEncapCl1_ReloadTxTimer( struct EIP_IO_PRODUCER_TRANSPORT_Ttag* hTransport );
+//void EipEncapCl1_ReloadTxTimer( struct EIP_IO_PRODUCER_TRANSPORT_Ttag* hTransport );
 
 void EipEncapCl1_IoFrameReceiveJob( PS_JOB_T* ptMsg );
 
Index: Includes/eip_timer2.h
===================================================================
--- Includes/eip_timer2.h	(revision 124917)
+++ Includes/eip_timer2.h	(working copy)
@@ -126,6 +126,11 @@
   EipTimer_Reload( EIP_TIMER_RSC_H hEipTimer,
                    EIP_TIMER_H hTimer );
 
+   /* Same as above, but to be used when called from a timer callback recursively (one shot timers) */
+  uint32_t
+  EipTimer_Reload_Self( EIP_TIMER_RSC_H hEipTimer,
+                        EIP_TIMER_H hTimer );
+
   /*#####################################################################################*/
 
   bool EipTimer_IsRunning(EIP_TIMER_H hTimer);
Index: Sources/Objects/ConnectionManager/eip_cm.c
===================================================================
--- Sources/Objects/ConnectionManager/eip_cm.c	(revision 124917)
+++ Sources/Objects/ConnectionManager/eip_cm.c	(working copy)
@@ -1096,7 +1096,15 @@
       {
         /* Send the next TX frame to the network  */
         EipEncapCl1_Produce(ptConnection->uToHandle.hTransport);
-        EipEncapCl1_ReloadTxTimer( ptConnection->uToHandle.hTransport );
+        
+        /* Do not reload the cyclic TX timer. We never reload continuous timers.
+           NOTE: According to spec, there are three types of production events:
+              - Application production (CoS handhshake) with a 1ms rate    <- WE ARE HERE
+              - Connection object production (which is triggered by the Application production and is subject to production inhibiting (rate limiting)   <-- we have just passed the limiter this
+              - Link producer production which is independently fed by the transmission trigger timer as well as the Connection Object Production   <-- so that we have just triggered this
+                 - this will produce strange timings in wireshark, but is indeed the intended behavior! Application then often disable the tranmission trigger timer
+                   globally if they use CoS production.
+        */
       }
     }
   }
Index: Sources/eip_encap_cl1.c
===================================================================
--- Sources/eip_encap_cl1.c	(revision 124917)
+++ Sources/eip_encap_cl1.c	(working copy)
@@ -260,11 +260,19 @@
     ptProducer->tProdInhibit.bTimerState &= ~EIP_IO_TRANSPORT_PRODUCTION_INHIBIT_TIMER_NEWDATAOCCURRED_BIT;
 
     EipEncapCl1_Produce( ptProducer );
-    EipEncapCl1_ReloadTxTimer( ptProducer );
+    
+    /* Do not reload the cyclic TX timer. We never reload continuous TX timers.
+       NOTE: According to spec, there are three types of production events:
+          - Application production (CoS handhshake) with a 1ms rate
+          - Connection object production (which is triggered by the Application production and is subject to production inhibiting (rate limiting)    <- WE ARE HERE
+          - Link producer production which is independently fed by the transmission trigger timer as well as the Connection Object Production   <-- We have just triggered this
+             - this will produce strange timings in wireshark, but is indeed the intended behavior! Application then often disable the tranmission trigger timer
+               globally if they use CoS production.
+    */
 
     /* Restart prod inhibit timer also (according to figure 3-4.14 in Vol1.3.31 */
     ptProducer->tProdInhibit.bTimerState |= EIP_IO_TRANSPORT_PRODUCTION_INHIBIT_TIMER_RUNNING_BIT;
-    EipTimer_Reload( ptProducer->tCommon.hEip->hEipTimer1msRsc, ptProducer->tProdInhibit.hTimer);
+    EipTimer_Reload_Self( ptProducer->tCommon.hEip->hEipTimer1msRsc, ptProducer->tProdInhibit.hTimer);
   }
   else
   {
@@ -1324,6 +1332,7 @@
 
 /*#####################################################################################*/
 
+#if 0
 void
 EipEncapCl1_ReloadTxTimer( struct EIP_IO_PRODUCER_TRANSPORT_Ttag* hProducer )
 {
@@ -1337,3 +1346,4 @@
     }
   }
 }
+#endif
Index: Sources/eip_timer2.c
===================================================================
--- Sources/eip_timer2.c	(revision 124917)
+++ Sources/eip_timer2.c	(working copy)
@@ -69,6 +69,8 @@
   struct EIP_TIMER_LIST_HEADtag tSlowTimers;                               /* All timers slower than 19mS are contained here. List is in ascending order
                                                                               with respect to ulDelayTime, so that the first one is always the next to expire. */
 
+  struct EIP_TIMER_LIST_HEADtag tTimersToBeReInserted;                     /* timers stashed for reinsertion */
+
 } EIP_TIMER_RSC_T;
 
 /*  Notes:
@@ -415,8 +417,48 @@
   return ulRet;
 }
 
-static inline void EipTimer_CleanupTimer(EIP_TIMER_RSC_T* ptRsc, EIP_TIMER_T *ptTimer, struct EIP_TIMER_LIST_HEADtag *ptTimersToBeReInserted)
+uint32_t
+EipTimer_Reload_Self( EIP_TIMER_RSC_T* ptRsc,
+                      EIP_TIMER_H      hTimer )
 {
+  EIP_TIMER_T* ptTimer = hTimer;
+  uint32_t ulRet = SUCCESS_HIL_OK;
+
+  assert(ptRsc != NULL);
+
+  if (ptTimer == NULL)
+  {
+    ulRet = ERR_EIP_TIMER_INVALID_HANDLE;
+  }
+  else if ((ptTimer->tTicks.ulReload & EIP_TIMER_MODE_MASK) == EIP_TIMER_CONTINUOUS)
+  {
+    ulRet = ERR_EIP_TIMER_INVALID_HANDLE; /* allow no reloads on continous timers, use the start & stop functions. Do not self-stop any timers. */
+  }
+  else
+  {
+    /* put the timer into the reinsertion list */
+    (void) OSAL_MutexLock(ptRsc->hLock);
+    /* Remove the timer from its list, if applicable */
+    if ((ptTimer->tList.le_next != NULL) || (ptTimer->tList.le_prev != NULL))
+    {
+      LIST_REMOVE(ptTimer, tList);
+      memset(&ptTimer->tList, 0, sizeof(ptTimer->tList));
+    }
+
+    /* Reload it */
+    ptTimer->tTicks.ulDelayTime = ptTimer->tTicks.ulReload & ~(EIP_TIMER_MODE_MASK | EIP_TIMER_RUNNING);
+
+    /** add it into the reinsertion list */
+    LIST_INSERT_HEAD(&ptRsc->tTimersToBeReInserted, ptTimer, tList);
+
+    (void) OSAL_MutexUnlock(ptRsc->hLock);
+  }
+  return ulRet;
+}
+
+
+static inline void EipTimer_CleanupTimer(EIP_TIMER_RSC_T* ptRsc, EIP_TIMER_T *ptTimer)
+{
   /* Handle timer reload or auto-cleanup */
   switch( ptTimer->tTicks.ulReload & EIP_TIMER_MODE_MASK )
   {
@@ -432,7 +474,7 @@
       else
       {
         /* the timer is a slow timer now due to the reload: remember for reinsertion */
-        LIST_INSERT_HEAD(ptTimersToBeReInserted, ptTimer, tList);
+        LIST_INSERT_HEAD(&ptRsc->tTimersToBeReInserted, ptTimer, tList);
       }
       break;
 
@@ -451,9 +493,9 @@
 {
   /* Process all timers in the current millisecond's list */
   EIP_TIMER_T *ptIt;
-  struct EIP_TIMER_LIST_HEADtag tTimersToBeReInserted;
+  //struct EIP_TIMER_LIST_HEADtag tTimersToBeReInserted;
 
-  LIST_INIT(&tTimersToBeReInserted);
+  //LIST_INIT(&tTimersToBeReInserted);
 
   /* TODO: It would be nice to call the expiry callbacks with interrupts enabled, but we protect the timers and their lists globally with a
            fast interrupt lock, so that timer operations within the callback may corrupt our data structures.
@@ -474,11 +516,11 @@
     ptThisTimer->tExpiryCallback.fnExp( ptThisTimer->tExpiryCallback.pvParam );
 
     /* reload continuous timers and collect them in the reinsert list */
-    EipTimer_CleanupTimer(ptRsc, ptThisTimer, &tTimersToBeReInserted);
+    EipTimer_CleanupTimer(ptRsc, ptThisTimer);
   }
 
   /* Reinsert timers (they may have been fast timers and are now continous slow timers). */
-  ptIt = LIST_FIRST(&tTimersToBeReInserted);
+  ptIt = LIST_FIRST(&ptRsc->tTimersToBeReInserted);
   while (ptIt != NULL)
   {
     EIP_TIMER_T *ptThisTimer = ptIt;
@@ -496,9 +538,9 @@
   EIP_TIMER_T *ptIt = LIST_FIRST(&ptRsc->tSlowTimers);
   uint32_t ulNewTimerCtr = 0;
   uint32_t ulRemainingTimersBias = ptRsc->ulTimerRef;
-  struct EIP_TIMER_LIST_HEADtag tTimersToBeReInserted;
+  //struct EIP_TIMER_LIST_HEADtag tTimersToBeReInserted;
 
-  LIST_INIT(&tTimersToBeReInserted);
+  //LIST_INIT(&tTimersToBeReInserted);
 
   /* TODO: It would be nice to call the expiry callbacks with interrupts enabled, but we protect the timers and their lists globally with a
            fast interrupt lock, so that timer operations within the callback may corrupt our data structures.
@@ -523,11 +565,11 @@
       LIST_REMOVE(ptThisTimer, tList);
       memset(&ptThisTimer->tList, 0, sizeof(ptThisTimer->tList));
 
-      /* call the timer expiry callback, note that some timers (one shots) may start/reload themselves. */
+      /* call the timer expiry callback, note that some timers (one shots) may put themselves in the reinsert list */
       ptThisTimer->tExpiryCallback.fnExp( ptThisTimer->tExpiryCallback.pvParam );
 
       /* reload continuous timers and collect them in the reinsert list */
-      EipTimer_CleanupTimer(ptRsc, ptThisTimer, &tTimersToBeReInserted);
+      EipTimer_CleanupTimer(ptRsc, ptThisTimer);
     }
     else
     {
@@ -586,7 +628,7 @@
            in the EIP stack and so we don't care. We just keep these as slow timers, which is functional. */
   {
     EIP_TIMER_T *ptPrevInsertedTimer = NULL;
-    ptIt = LIST_FIRST(&tTimersToBeReInserted);
+    ptIt = LIST_FIRST(&ptRsc->tTimersToBeReInserted);
     while (ptIt != NULL)
     {
       EIP_TIMER_T *ptThisTimer = ptIt;
@@ -707,6 +749,7 @@
 
     LIST_INIT(&ptRsc->tFreeTimers);
     LIST_INIT(&ptRsc->tSlowTimers);
+    LIST_INIT(&ptRsc->tTimersToBeReInserted);
 
     for( ulCnt = 0; ulCnt < EIP_TIMER_NUM_FAST_TIMERS; ulCnt++ )
     {