SoftSequence Struct Reference

Inheritance diagram for SoftSequence:

Collaboration diagram for SoftSequence:

Classes
struct	Config

Public Types
typedef mrf::ObjectInst< SoftSequence >	base_t
typedef std::vector< epicsUInt64 >	times_t
typedef std::vector< epicsUInt8 >	codes_t
Public Types inherited from mrf::Object
typedef m_obj_children_t::const_iterator	child_iterator
typedef std::map< std::string, std::string >	create_args_t
typedef Object *(*	create_factory_t) (const std::string &name, const std::string &klass, const create_args_t &args)

Public Member Functions
	SoftSequence (SeqManager *o, const std::string &name)
virtual	~SoftSequence ()
virtual void	lock () const
virtual void	unlock () const
std::string	getErr () const
IOSCANPVT	getErrScan () const
epicsUInt32	getTimestampResolution () const
void	setTimestampResolution (epicsUInt32 val)
void	setTimestamp (const double *arr, epicsUInt32 count)
epicsUInt32	getTimestamp (double *arr, epicsUInt32 count) const
void	setEventCode (const epicsUInt8 *arr, epicsUInt32 count)
epicsUInt32	getEventCode (epicsUInt8 *arr, epicsUInt32 count) const
void	setTrigSrc (epicsUInt32 src)
epicsUInt32	getTrigSrcCt () const
void	setRunMode (epicsUInt32 mode)
epicsUInt32	getRunModeCt () const
bool	isLoaded () const
bool	isEnabled () const
bool	isCommited () const
IOSCANPVT	stateChange () const
void	load ()
void	unload ()
void	commit ()
void	enable ()
void	disable ()
void	softTrig ()
epicsUInt32	counterStart () const
IOSCANPVT	counterStartScan () const
epicsUInt32	counterEnd () const
IOSCANPVT	counterEndScan () const
void	sync ()
Public Member Functions inherited from mrf::ObjectInst< SoftSequence >
virtual propertyBase *	getPropertyBase (const char *pname, const std::type_info &ptype)
virtual void	visitProperties (bool(*cb)(propertyBase *, void *), void *arg)
Public Member Functions inherited from mrf::Object
const std::string &	name () const
const Object *	parent () const
child_iterator	beginChild () const
child_iterator	endChild () const
template<typename P >
mrf::auto_ptr< property< P > >	getProperty (const char *pname)

Public Attributes
SeqManager *const	owner
SeqHW *	hw
epicsMutex	mutex
struct SoftSequence::Config	scratch
struct SoftSequence::Config	committed
bool	is_enabled
	Whether user has requested enable. More...
bool	is_committed
	clear when scratch and commited sequences differ More...
bool	is_insync
epicsUInt32	numStart
	Guarded by interruptLock only. More...
epicsUInt32	numEnd
epicsUInt32	timeScale
IOSCANPVT	changed
IOSCANPVT	onStart
IOSCANPVT	onEnd
IOSCANPVT	onErr
std::string	last_err

Additional Inherited Members
Static Public Member Functions inherited from mrf::ObjectInst< SoftSequence >
static int	initObject ()
Static Public Member Functions inherited from mrf::Object
static Object *	getObject (const std::string &name)
static Object *	getCreateObject (const std::string &name, const std::string &klass, const create_args_t &args=create_args_t())
static void	addFactory (const std::string &klass, create_factory_t fn)
static void	visitObjects (bool(*)(Object *, void *), void *)
Protected Member Functions inherited from mrf::ObjectInst< SoftSequence >
	ObjectInst (const std::string &n)
	ObjectInst (const std::string &n, A &a)
virtual	~ObjectInst ()
Protected Member Functions inherited from mrf::Object
	Object (const std::string &n, const Object *par=0)
virtual	~Object ()=0

Detailed Description

Definition at line 133 of file mrmSeq.cpp.

Member Typedef Documentation

base_t

typedef mrf::ObjectInst<SoftSequence> SoftSequence::base_t

Definition at line 135 of file mrmSeq.cpp.

codes_t

typedef std::vector<epicsUInt8> SoftSequence::codes_t

Definition at line 322 of file mrmSeq.cpp.

times_t

typedef std::vector<epicsUInt64> SoftSequence::times_t

Definition at line 321 of file mrmSeq.cpp.

Constructor & Destructor Documentation

SoftSequence()

SoftSequence::SoftSequence	(	SeqManager *	o,
		const std::string &	name
	)

Definition at line 391 of file mrmSeq.cpp.

    :base_t(name)
    ,owner(o)
    ,hw(0)
    ,is_enabled(false)
    ,is_committed(false)
    ,is_insync(false)
    ,numStart(0u)
    ,numEnd(0u)
    ,timeScale(0u) // raw/ticks
{
    scanIoInit(&changed);
    scanIoInit(&onStart);
    scanIoInit(&onEnd);
    scanIoInit(&onErr);
}

~SoftSequence()

SoftSequence::~SoftSequence ( )

virtual

Definition at line 408 of file mrmSeq.cpp.

{}

Member Function Documentation

commit()

void SoftSequence::commit

(

)

Definition at line 488 of file mrmSeq.cpp.

{
    SCOPED_LOCK(mutex);
    DEBUG(3, ("Committing %c\n", is_committed ? 'Y' : 'N') );

    if(is_committed) {DEBUG(3, ("Skip\n")); return;}

    // scratch.times already check for monotonic

    Config conf(scratch); // vector copies

    size_t buflen = std::min(conf.codes.size(),
                             conf.times.size());
    conf.codes.resize(buflen);
    conf.times.resize(buflen);

    // ensure presence of trailing end of sequence marker event 0x7f
    if(conf.codes.empty() || conf.codes.back()!=0x7f)
    {
        if(!conf.times.empty() && conf.times.back()==0xffffffff)
            throw std::runtime_error("Wow, input array is missing 0x7f and maxing out times");

        conf.codes.push_back(0x7f);

        if(conf.times.empty())
            conf.times.push_back(0);
        else
            conf.times.push_back(conf.times.back()+1);
    }

    if(conf.times.size()>2048)
        throw std::runtime_error("Sequence too long");

    assert(!hw || hw->loaded==this);

    {
        interruptLock L;
        committed.swap(conf);
        is_committed = true;
        is_insync = false;

        if(hw && !hw->disarm())
            sync();
    }

    scanIoRequest(changed);
    DEBUG(1, ("Committed\n") );
}

counterEnd()

epicsUInt32 SoftSequence::counterEnd ( ) const

inline

Definition at line 305 of file mrmSeq.cpp.

{ interruptLock L; return numEnd; }

counterEndScan()

IOSCANPVT SoftSequence::counterEndScan ( ) const

inline

Definition at line 306 of file mrmSeq.cpp.

{ return onEnd; }

counterStart()

epicsUInt32 SoftSequence::counterStart ( ) const

inline

Definition at line 303 of file mrmSeq.cpp.

{ interruptLock L; return numStart; }

counterStartScan()

IOSCANPVT SoftSequence::counterStartScan ( ) const

inline

Definition at line 304 of file mrmSeq.cpp.

{ return onStart; }

disable()

void SoftSequence::disable

(

)

Definition at line 555 of file mrmSeq.cpp.

{
    SCOPED_LOCK(mutex);
    DEBUG(3, ("Disabling %c\n", is_enabled ? 'Y' : 'N') );
    if(!is_enabled)
        {DEBUG(3, ("Skip\n")); return;}

    is_enabled = false;

    if(hw) {
        interruptLock L;
        hw->disarm();
    }

    scanIoRequest(changed);
    DEBUG(1, ("Disabled\n") );
}

enable()

void SoftSequence::enable

(

)

Definition at line 537 of file mrmSeq.cpp.

{
    SCOPED_LOCK(mutex);
    DEBUG(3, ("Enabling %c\n", is_enabled ? 'Y' : 'N') );
    if(is_enabled)
        {DEBUG(3, ("Skip\n")); return;}

    is_enabled = true;

    if(hw) {
        interruptLock I;

        hw->arm();
    }
    scanIoRequest(changed);
    DEBUG(1, ("Enabled\n") );
}

getErr()

std::string SoftSequence::getErr ( ) const

inline

Definition at line 143 of file mrmSeq.cpp.

{ SCOPED_LOCK(mutex); return last_err; }

getErrScan()

IOSCANPVT SoftSequence::getErrScan ( ) const

inline

Definition at line 144 of file mrmSeq.cpp.

{ return onErr; }

getEventCode()

epicsUInt32 SoftSequence::getEventCode ( epicsUInt8 *  arr, epicsUInt32  count  ) const

inline

Definition at line 235 of file mrmSeq.cpp.

    {
        SCOPED_LOCK(mutex);
        epicsUInt32 ret = std::min(size_t(count), committed.codes.size());
        std::copy(committed.codes.begin(),
                  committed.codes.begin()+ret,
                  arr);
        return ret;
    }

getRunModeCt()

epicsUInt32 SoftSequence::getRunModeCt ( ) const

inline

Definition at line 282 of file mrmSeq.cpp.

    {
        SCOPED_LOCK(mutex);
        return committed.mode;
    }

getTimestamp()

epicsUInt32 SoftSequence::getTimestamp ( double *  arr, epicsUInt32  count  ) const

inline

Definition at line 209 of file mrmSeq.cpp.

    {
        SCOPED_LOCK(mutex);
        const double tmult = getTimeScale();
        epicsUInt32 ret = std::min(size_t(count), committed.times.size());
        for(epicsUInt32 i=0; i<ret; i++) {
            arr[i] = committed.times[i]/tmult;
        }
        return ret;
    }

getTimestampResolution()

epicsUInt32 SoftSequence::getTimestampResolution ( ) const

inline

Definition at line 146 of file mrmSeq.cpp.

    {
        SCOPED_LOCK(mutex);
        return timeScale;
    }

getTrigSrcCt()

epicsUInt32 SoftSequence::getTrigSrcCt ( ) const

inline

Definition at line 257 of file mrmSeq.cpp.

    {
        SCOPED_LOCK(mutex);
        return committed.src;
    }

isCommited()

bool SoftSequence::isCommited ( ) const

inline

Definition at line 293 of file mrmSeq.cpp.

{ SCOPED_LOCK(mutex); return is_committed; }

isEnabled()

bool SoftSequence::isEnabled ( ) const

inline

Definition at line 292 of file mrmSeq.cpp.

{ SCOPED_LOCK(mutex); return is_enabled; }

isLoaded()

bool SoftSequence::isLoaded ( ) const

inline

Definition at line 291 of file mrmSeq.cpp.

{ SCOPED_LOCK(mutex); return hw; }

load()

void SoftSequence::load

(

)

Definition at line 423 of file mrmSeq.cpp.

{
    SCOPED_LOCK(mutex);
    DEBUG(3, ("Loading %c\n", hw ? 'L' : 'U') );
    if(hw) {DEBUG(3, ("Skip\n")); return;}

    // find unused SeqHW
    {
        interruptLock L;

        is_insync = false; // paranoia

        for(size_t i=0, N=owner->hw.size(); i<N; i++) {
            SeqHW *temp = owner->hw[i];
            if(temp && !temp->loaded) {
                temp->loaded = this;
                hw = temp;
                break;
            }
        }

        if(hw) {
            // paranoia: disable any external trigger mappings
            owner->mapTriggerSrc(hw->idx, 0x02000000);

            if(!hw->disarm())
                sync();
        }
    }

    if(!hw) {
        last_err = "All HW Seq. in use";
        scanIoRequest(onErr);
        throw alarm_exception(MAJOR_ALARM, WRITE_ALARM);
    }

    scanIoRequest(changed);
    DEBUG(1, ("Loaded\n") );
}

lock()

virtual void SoftSequence::lock ( ) const

inlinevirtual

Implements mrf::Object.

Definition at line 140 of file mrmSeq.cpp.

{ mutex.lock(); }

setEventCode()

void SoftSequence::setEventCode ( const epicsUInt8 *  arr, epicsUInt32  count  )

inline

Definition at line 220 of file mrmSeq.cpp.

    {
        codes_t codes(count);
        std::copy(arr,
                  arr+count,
                  codes.begin());
        {
            SCOPED_LOCK(mutex);
            scratch.codes.swap(codes);
            is_committed = false;
        }
        DEBUG(4, ("Set events\n"));
        scanIoRequest(changed);
    }

setRunMode()

void SoftSequence::setRunMode ( epicsUInt32  mode )

inline

Definition at line 263 of file mrmSeq.cpp.

    {
        switch(mode) {
        case Single:
        case Normal:
            break;
        default:
            throw std::runtime_error("Unknown sequencer run mode");
        }

        {
            SCOPED_LOCK(mutex);
            scratch.mode = (RunMode)mode;
            is_committed = false;
        }
        DEBUG(4, ("Set run mode %u\n", (unsigned)mode));
        scanIoRequest(changed);
    }

setTimestamp()

void SoftSequence::setTimestamp ( const double *  arr, epicsUInt32  count  )

inline

Definition at line 182 of file mrmSeq.cpp.

    {
        const double tmult = getTimeScale();
        times_t times(count);
        // check for monotonic
        // TODO: not handling overflow (HW supports controlled rollover w/ special 0xffffffff times)
        for(epicsUInt32 i=0; i<count; i++)
        {
            if(!finite(arr[i]) || arr[i]<0.0)
                throw std::runtime_error("times must be finite >=0");

            times[i] = (arr[i]*tmult)+0.5;

            if(i>0 && times[i]<=times[i-1])
                throw std::runtime_error("Non-monotonic timestamp array");
            else if(times[i]==0xffffffff)
                throw std::runtime_error("Time overflow, rollover not supported");
        }
        {
            SCOPED_LOCK(mutex);
            scratch.times.swap(times);
            is_committed = false;
        }
        DEBUG(4, ("Set times\n"));
        scanIoRequest(changed);
    }

setTimestampResolution()

void SoftSequence::setTimestampResolution ( epicsUInt32  val )

inline

Definition at line 151 of file mrmSeq.cpp.

    {
        {
            SCOPED_LOCK(mutex);
            timeScale = val;
        }
        DEBUG(4, ("Set time scale\n"));
        scanIoRequest(changed);
    }

setTrigSrc()

void SoftSequence::setTrigSrc ( epicsUInt32  src )

inline

Definition at line 245 of file mrmSeq.cpp.

    {
        DEBUG(4, ("Setting trig src %x\n", (unsigned)src));
        {
            SCOPED_LOCK(mutex);
            scratch.src = src;
            is_committed = false;
        }
        DEBUG(4, ("Set trig src %x\n", (unsigned)src));
        scanIoRequest(changed);
    }

softTrig()

void SoftSequence::softTrig

(

)

Definition at line 410 of file mrmSeq.cpp.

{
    DEBUG(3, ("SW Triggering\n") );
    SCOPED_LOCK(mutex);
    if(!hw || !is_enabled) {DEBUG(3, ("Skip\n")); return;}

    {
        interruptLock L;
        nat_iowrite32(hw->ctrlreg, hw->ctrlreg_hw | EVG_SEQ_RAM_SW_TRIG);
    }
    DEBUG(2, ("SW Triggered\n") );
}

stateChange()

IOSCANPVT SoftSequence::stateChange ( ) const

inline

Definition at line 294 of file mrmSeq.cpp.

{ return changed; }

sync()

void SoftSequence::sync

(

)

Definition at line 574 of file mrmSeq.cpp.

{
    DEBUG(3, ("Syncing %c\n", is_insync ? 'Y' : 'N') );
    if(is_insync)
        {DEBUG(3, ("Skip\n")); return;}

    assert(hw);

    if(nat_ioread32(hw->ctrlreg)&EVG_SEQ_RAM_RUNNING) {
        // we may still be _ENABLED at this point, but the trigger source is set to
        // Disabled, so this makes no difference.
        epicsInterruptContextMessage("SoftSequence::sync() while running\n");
        return;
    }

    // At this point the sequencer is not running and effectively disabled.
    // From paranoia, reset it anyway
    nat_iowrite32(hw->ctrlreg, hw->ctrlreg_hw | EVG_SEQ_RAM_RESET);

    hw->ctrlreg_user &= ~(EVG_SEQ_RAM_REPEAT_MASK|EVG_SEQ_RAM_SRC_MASK);

    switch(committed.mode) {
    case Single:
        hw->ctrlreg_user |= EVG_SEQ_RAM_SINGLE;
        break;
    case Normal:
        hw->ctrlreg_user |= EVG_SEQ_RAM_NORMAL;
        break;
    }

    epicsUInt8 src;

    // default to disabled
    switch(owner->type) {
    case SeqManager::TypeEVG:
        src = 31;
        break;
    case SeqManager::TypeEVR:
        src = 63;
        break;
    default:
        return;
    }

    // paranoia: disable any external trigger mappings
    owner->mapTriggerSrc(hw->idx, 0x02000000);

    // map trigger source codes
    // MSB governs the type of mapping
    switch(committed.src&0xff000000) {
    case 0x00000000: // raw mapping
        DEBUG(5, ("  Raw mapping %x\n", committed.src));
        // LSB is code
        src = committed.src&0xff;
        break;
    case 0x01000000: // software trigger mapping
        DEBUG(5, ("  SW mapping %x\n", committed.src));
        // ignore 0x00ffffff
        switch(owner->type) {
        case SeqManager::TypeEVG:
            src = 17+hw->idx;
            break;
        case SeqManager::TypeEVR:
            src = 61;
            break;
        }
        break;
    case 0x02000000: // external trigger
        DEBUG(5, ("  EXT mapping %x\n", committed.src));
        if(owner->type==SeqManager::TypeEVG) {
            // pass through to sub-class
            owner->mapTriggerSrc(hw->idx, committed.src);
            src = 24+hw->idx;
        }
        break;
    case 0x03000000: // disable trigger
        DEBUG(5, ("  NO mapping %x\n", committed.src));
        // use default
        break;
    default:
        DEBUG(0, ("unknown sequencer trigger code %08x\n", (unsigned)committed.src));
        break;
    }
    DEBUG(5, ("  Trig Src %x\n", src));

    hw->ctrlreg_user |= src;

    // write out the RAM
    volatile epicsUInt32 *ram = static_cast<volatile epicsUInt32 *>(hw->rambase);
    for(size_t i=0, N=committed.codes.size(); i<N; i++)
    {
        nat_iowrite32(ram++, committed.times[i]);
        nat_iowrite32(ram++, committed.codes[i]);
        if(committed.codes[i]==0x7f)
            break;
    }

    {
        epicsUInt32 ctrl = hw->ctrlreg_hw = hw->ctrlreg_user;
        if(is_enabled)
            ctrl |= EVG_SEQ_RAM_ARM;
        else
            ctrl |= EVG_SEQ_RAM_DISABLE; // paranoia

        DEBUG(3, ("  SeqCtrl %x\n", ctrl));
        nat_iowrite32(hw->ctrlreg, ctrl);
    }

    is_insync = true;
    DEBUG(3, ("In Sync\n") );
}

unload()

void SoftSequence::unload

(

)

Definition at line 463 of file mrmSeq.cpp.

{
    SCOPED_LOCK(mutex);
    DEBUG(3, ("Unloading %c\n", hw ? 'L' : 'U') );

    if(!hw) {DEBUG(3, ("Skip\n")); return;}

    assert(hw->loaded=this);

    {
        interruptLock L;

        hw->disarm();

        hw->loaded = NULL;
        hw = NULL;

        is_insync = false;
    }

    scanIoRequest(changed);
    DEBUG(1, ("Unloaded\n") );

}

unlock()

virtual void SoftSequence::unlock ( ) const

inlinevirtual

Implements mrf::Object.

Definition at line 141 of file mrmSeq.cpp.

{ mutex.unlock(); }

Member Data Documentation

changed

IOSCANPVT SoftSequence::changed

Definition at line 356 of file mrmSeq.cpp.

committed

struct SoftSequence::Config SoftSequence::committed

hw

SeqHW* SoftSequence::hw

guarded by our mutex and interruptLock only write when both held read when either held

Definition at line 317 of file mrmSeq.cpp.

is_committed

bool SoftSequence::is_committed

clear when scratch and commited sequences differ

Definition at line 346 of file mrmSeq.cpp.

is_enabled

bool SoftSequence::is_enabled

Whether user has requested enable.

Definition at line 344 of file mrmSeq.cpp.

is_insync

bool SoftSequence::is_insync

clear when the commited sequence differs from the HW sequence (eg. commit while running) Guarded by interruptLock only

Definition at line 349 of file mrmSeq.cpp.

last_err

std::string SoftSequence::last_err

Definition at line 358 of file mrmSeq.cpp.

mutex

epicsMutex SoftSequence::mutex

mutable

Definition at line 319 of file mrmSeq.cpp.

numEnd

epicsUInt32 SoftSequence::numEnd

Definition at line 352 of file mrmSeq.cpp.

numStart

epicsUInt32 SoftSequence::numStart

Guarded by interruptLock only.

Definition at line 352 of file mrmSeq.cpp.

onEnd

IOSCANPVT SoftSequence::onEnd

Definition at line 356 of file mrmSeq.cpp.

onErr

IOSCANPVT SoftSequence::onErr

Definition at line 356 of file mrmSeq.cpp.

onStart

IOSCANPVT SoftSequence::onStart

Definition at line 356 of file mrmSeq.cpp.

owner

SeqManager* const SoftSequence::owner

Definition at line 312 of file mrmSeq.cpp.

scratch

struct SoftSequence::Config SoftSequence::scratch

timeScale

epicsUInt32 SoftSequence::timeScale

Definition at line 354 of file mrmSeq.cpp.

---

The documentation for this struct was generated from the following file:

• mrmSeq.cpp