TimingContext.cpp

Go to the documentation of this file.

//Copyright GSI 2012
#include <climits>
#include <fesa-core-gsi/Synchronization/TimingContext.h>
#include <fesa-core/Synchronization/Timing.h>
#include <fesa-core-gsi/Exception/GSIException.h>
#include <fesa-core-gsi/Synchronization/GSICycleDescriptor.h>
#include <fesa-core/Synchronization/SynchronizationLabObjectFactory.h>

namespace fesaGSI
{

        // This constructor is only used by the on-subscription event-source
    TimingContext::TimingContext(long long cycleStamp, const std::string& cycleName) :
        fesa::TimingContext()
    {
        type_ = fesa::MultiplexingContext::CycleOccurrenceCtxt;
        forewarning_ = false;
        fesa::CycleSelector cycleSelector;
        fesa::parseCycleSelector(cycleName, cycleSelector);
        fesa::SynchronizationLabObjectFactory* syncFactory = fesa::SynchronizationLabObjectFactory::getInstance();
        fesaGSI::GSICycleDescriptor *ptd = dynamic_cast<fesaGSI::GSICycleDescriptor*> (syncFactory->getCycleDescriptor(cycleSelector.domain_, cycleSelector.criterion_));
        cycleStamp_ = cycleStamp;
        cycleName_ = cycleName;
        cycleId_ = ptd->getCycleSelectorId(cycleName);
        timingDomainId_ = ptd->getTgmMachineId();
        timingDomainName_ = cycleSelector.domain_;
        cycleTimeStamp_.Second = cycleStamp / 1000000000;
        cycleTimeStamp_.Nano = cycleStamp % 1000000000;
        cycleTimeStamp_.CTrain = 0;
        cycleTimeStamp_.Machine = ptd->getTgmMachineId();
    }

    //This constructor is the important one. It is used to create TimingContexts from within the TimingEventSource
    TimingContext::TimingContext(TimLibTime& interruptTimeStamp, unsigned long payload, bool forewarning) :
        fesa::TimingContext(), interruptTimeStamp_(interruptTimeStamp)
    {
        type_ = fesa::MultiplexingContext::CycleOccurrenceCtxt;
        forewarning_ = forewarning;
        init(payload);
    }

    void TimingContext::init(unsigned long payload)
        {
        // timingDomainName_
        timingDomainName_ = TgmGetMachineName(interruptTimeStamp_.Machine);

        // TimingDomainID_
        timingDomainId_ = interruptTimeStamp_.Machine;

        //Getting CycleStamp
        TimLibError err = TimLibGetTgmInfo(interruptTimeStamp_, &cycleTimeStamp_, NULL, NULL);
        if (err != TimLibErrorSUCCESS)
        {
            throw GSIException(__FILE__, __LINE__, FesaGSIErrorAccessingTimLib.c_str());
        }

        // long long cycleStamp_
        cycleStamp_ = cycleTimeStamp_.Second * (long long) 1000000000 + cycleTimeStamp_.Nano;

        // Getting cycleID
        unsigned long userGroupNb = TgmGetGroupNumber((TgmMachine) interruptTimeStamp_.Machine, "USER");
        err = TimLibGetGroupValueFromStamp(cycleTimeStamp_, userGroupNb, 0, (long unsigned int*)&cycleId_);
        if (err != TimLibErrorSUCCESS)
        {
            throw GSIException(__FILE__, __LINE__, FesaGSIErrorAccessingTimLib.c_str());
        }

        // forewarning_ //TODO Think of usage @ GSI
//        if ((interruptTimeStamp_.Machine == TgmSPS) && (forewarning_ == false) && (payload < SCHAR_MAX))
//        {
//            forewarning_ = ((long int)payload != cycleId_) ? true : false;
//            if (forewarning_ == true)
//            {
//                cycleId_ = payload;
//            }
//        }

        fesa::SynchronizationLabObjectFactory* syncFactory = fesa::SynchronizationLabObjectFactory::getInstance();
        fesa::CycleDescriptor *td = syncFactory->createOrGetEventCycleDescriptor(timingDomainName_, "USER");
        cycleName_ = td->getCycleSelectorName(cycleId_);
    }

    int64_t TimingContext::getInterruptTimeStamp()
    {
        return interruptTimeStamp_.Second * (int64_t) 1000000000 + interruptTimeStamp_.Nano;
    }

    uint32_t TimingContext::getCycleTime()
    {
        return interruptTimeStamp_.CTrain;
    }

}//end namespace