Changeset 1727 for trunk/MagicSoft/Cosy/candrv/nodedrv.cc

Timestamp:

01/23/03 13:32:58 (22 years ago)

Author:

tbretz

Message:

*** empty log message ***

File:

• trunk/MagicSoft/Cosy/candrv/nodedrv.cc (modified) (9 diffs)

trunk/MagicSoft/Cosy/candrv/nodedrv.cc

@@ -33 +33 @@
 //  virtual void StopDevice()
 //  virtual void HandleSDO(WORD_t idx, BYTE_t subidx, LWORD_t val, timeval_t *tv)
-//  virtual void HandleSDOOK(WORD_t idx, BYTE_t subidx)
+//  virtual void HandleSDOOK(WORD_t idx, BYTE_t subidx, timeval_t *tv)
 //  virtual void HandleSDOError(LWORD_t data)
 //  virtual void HandlePDO1(BYTE_t *data, timeval_t *tv)
@@ -48 +48 @@
 #include <iostream.h>
 
+#include <TTimer.h>
+
+#include "base/timer.h"
 #include "network.h"
 #include "MLogManip.h"
@@ -76 +79 @@
     }
 
+    fTimerOn = kFALSE;
+    fTimeout = new TTimer(this, 100, kFALSE); // 100ms, asynchronous
+
     lout << "- Node #" << (int)nodeid << " (" << name << ") initialized." << endl;
-}
-
-// --------------------------------------------------------------------------
-//
-// Empty destructor
+
+}
+
+// --------------------------------------------------------------------------
+//
+// destructor
 //
 NodeDrv::~NodeDrv()
 {
+    fTimerOn = kFALSE;
+    delete fTimeout;
 }
 
@@ -122 +131 @@
     EnableCanMsg(kSDO_RX);
     EnableCanMsg(kSDO_TX);
+    EnableCanMsg(kNodeguard);
+    EnableCanMsg(kEMERGENCY);
 
     fIsZombie = kFALSE;
@@ -135 +146 @@
 // This output is never redirected to the GUI
 //
-void NodeDrv::HandleSDOOK(WORD_t idx, BYTE_t subidx)
+void NodeDrv::HandleSDOOK(WORD_t idx, BYTE_t subidx, timeval_t *tv)
 {
     const Bool_t gui = lout.IsOutputDeviceEnabled(MLog::eGui);
@@ -367 +378 @@
 // --------------------------------------------------------------------------
 //
-// Send an NMT message (command) to this device
+// Send a NMT message (command) to this device
 //
 // The message is not send if the node has the status Zombie.
@@ -377 +388 @@
         fNetwork->SendNMT(fId, cmd);
     return !fIsZombie;
+}
+
+// --------------------------------------------------------------------------
+//
+// Send a Nodeguard message (command) to this device
+//
+void NodeDrv::SendNodeguard()
+{
+    fNetwork->SendNodeguard(fId);
 }
 
@@ -404 +424 @@
 
     if (!rc)
+    {
+        lout << "NodeDrv::WaitForSdo: 0x" << hex << idx << "/" << dec << (int)subidx << " " << GetNodeName() << " --> ZOMBIE!" << endl;
+        SetZombie();
+    }
+/*
+    if (HasError())
+    {
+        lout << "NodeDrv::WaitForSdo: HasError 0x" << hex << idx << "/" << dec << (int)subidx << " " << GetNodeName() << " --> ZOMBIE!" << endl;
         fIsZombie = kTRUE;
-
+    }
+*/
     return fIsZombie ? false : rc;
 }
@@ -453 +482 @@
 }
 
+// --------------------------------------------------------------------------
+//
+// Start the standard CANopen guarding of the device.
+// While ms is the guard time in millisec. This is the time between
+// two requests for a Nodeguard message.
+// ltf is the LifeTimeFactor. This means how often it is checked, that at
+// least one Nodeguard message was answered.
+//
+void NodeDrv::StartGuarding()
+{
+    if (fTimerOn)
+        return;
+
+    SendNodeguard();
+
+    fTimerOn = kTRUE;
+    fTimeout->SetTime(fGuardTime);
+    fTimeout->Reset();
+    fTimeout->TurnOn();
+    //fTimeout->Start(fGuardTime, kTRUE);
+
+    lout << "- " << GetNodeName() << ": Guarding (" << dec;
+    lout << fLifeTimeFactor << "*" << fGuardTime << "ms) started." << endl;
+}
+
+void NodeDrv::StartGuarding(Int_t ms, Int_t ltf)
+{
+    if (fTimerOn)
+    {
+        lout << "- " << GetNodeName() << ": ERROR - Guarding already started." << endl;
+        return;
+    }
+    fGuardTime      = ms;
+    fLifeTimeFactor = ltf;
+
+    StartGuarding();
+}
+
+void NodeDrv::StopGuarding()
+{
+    fTimeout->TurnOff();
+    fTimerOn = kFALSE;
+
+    lout << "- " << GetNodeName() << ": Guarding stopped." << endl;
+}
+
+// --------------------------------------------------------------------------
+//
+// Handle the Nodeguard-Timer Event.
+// It checks whether the node timed out. If it timed out it is set to
+// the Zombie state.
+// A new Nodeguard request is send and a new timer event is triggered.
+//
+Bool_t NodeDrv::HandleTimer(TTimer *t)
+{
+    //
+    // WARNING:
+    //           It seems, that you should never access ANY output from
+    //           here. Neither the GUI, nor COUT. This can result in
+    //           'unexpected async reply'
+    //
+
+   /*
+     Fons:
+     -----
+
+     timers never trigger at the same time or when in a TTimer::Notify.
+     Little explanation:
+
+     - there are two types of timers synchronous and a-synchronous.
+     - synchronous timers are only handled via the ROOT eventloop
+       (see TUnixSystem::DispatchOneEvent()). If there are no mouse/keyboard
+       events then the synchronous timer queue is checked. So if the processing
+       of a mouse/keyboard event takes a long time synchronous timers are not
+       called for a while. To prevent this from happening one can call in long
+       procedures gSystem->ProcessEvents(). The system schedules only the
+       next timer in the queue when the current one's Notify() has finished.
+     - a-synchronous timers are triggered via SIGALARM, i.e. the program is
+       interupted and execution jumps to the Notify() function. When the
+       notify is finished the next a-sync timer is scheduled and the system
+       resumes from the place where it was initially interrupted. One of the
+       things to remember when using a-sync timers is don't make any graphics
+       calls in them. X11 is not re-entrant and it might be that the SIGALARM
+       signal interrupted the system while being in X11. A-sync timers are best
+       used to set flags that you can test at a convenient and controlled
+       time.
+       */
+    if (fIsZombie)
+        return kTRUE;
+
+    Timer time;
+    Double_t now = time.Now();
+    if (now > fTimeoutTime)
+    {
+        //cout << "ERROR - " << GetNodeName() << " didn't respond in timeout window." << endl;
+        //lout << "ERROR - " << GetNodeName() << " didn't respond in timeout window." << endl;
+        //cout << dec << "+" << (int)GetId() << ": Handle: " << fmod(now, 500) << endl;
+        //cout << dec << "+" << (int)GetId() << ": Handle: " << fmod(fTimeoutTime, 500) << endl;
+        //cout << fGuardTime << endl;
+        fIsZombie = true;
+        //SetZombie();
+
+        return kTRUE;
+    }
+
+    SendNodeguard();
+
+    return kTRUE;
+}
+
+// --------------------------------------------------------------------------
+//
+// Set the timeout timer to the time the event was received plus the
+// guard time times lifetimefactor.
+//
+void NodeDrv::HandleNodeguard(timeval_t *tv)
+{
+    Timer t(tv);
+    fTimeoutTime = t + (fGuardTime*fLifeTimeFactor/1000.);
+}
+
+void NodeDrv::SetZombie()
+{
+    fIsZombie = true;
+    StopGuarding();
+}