Exemplo n.º 1
0
void  MonitorRequesterImpl::monitorEvent(Monitor::shared_pointer const & monitor)
{
    qDebug() << "monitorEvent " << m_channelIndex;
    MonitorElement::shared_pointer element;

    knobData *kPtr = m_mutexData->GetMutexKnobDataPtr(m_channelIndex);  // use pointer
    if(kPtr->index == -1) return;
    qDebug() << "connection state" << kPtr->edata.connected;

    while (element = monitor->poll()) {

        PVField::shared_pointer value = element->pvStructurePtr->getSubField("value");
        if (value.get() == 0) {
             std::cout <<  "no 'value' field" << m_channelName  << std::endl;
             std::cout << *(element->pvStructurePtr.get())  << std::endl;
        } else {
            Type valueType = value->getField()->getType();

            // we have a structure
            if (valueType != scalar && valueType != scalarArray) {
                 std::cout << "structure " <<  m_channelName << std::endl;
                 std::cout << *(element->pvStructurePtr.get()) << std::endl;

                // we have a scalar value or scalar array
            } else {
                if (value->getField()->getType() == scalar) {
                     std::cout << "scalar "<<  m_channelName << std::endl;

                    ParseScalar("", static_pointer_cast<PVScalar>(value), kPtr);

                    PVField::shared_pointer alarm = element->pvStructurePtr->getSubField("alarm");
                    if (alarm.get() != 0) ParsePVStructure(static_pointer_cast<PVStructure>(alarm), kPtr, false);

                    PVField::shared_pointer display = element->pvStructurePtr->getSubField("display");
                    if (display.get() != 0) ParsePVStructure(static_pointer_cast<PVStructure>(display), kPtr, false);

                    PVField::shared_pointer control = element->pvStructurePtr->getSubField("control");
                    if (control.get() != 0) ParsePVStructure(static_pointer_cast<PVStructure>(control), kPtr, false);

                    PVField::shared_pointer valueAlarm = element->pvStructurePtr->getSubField("valueAlarm");
                    if (valueAlarm.get() != 0) ParsePVStructure(static_pointer_cast<PVStructure>(valueAlarm), kPtr, false);

                } else {
                     std::cout <<  "scalar array " << m_channelName << " values: "  << std::endl;
                    ParseScalarArray(static_pointer_cast<PVScalarArray>(value), kPtr);
                }
            }
        }
    }

    kPtr->edata.accessW = true;
    kPtr->edata.accessR = true;
    kPtr->edata.monitorCount++;
    strcpy(kPtr->edata.fec, "EPICS4");
    m_mutexData->SetMutexKnobDataReceived(kPtr);

    monitor->release(element);
}
    virtual void monitorEvent(Monitor::shared_pointer const & monitor)
    {
        std::cout << "monitorEvent" << std::endl;

        MonitorElement::shared_pointer element = monitor->poll();

        std::cout << "changed/overrun " << *element->changedBitSet << '/' <<
                     *element->overrunBitSet << std::endl << *element->pvStructurePtr << std::endl;

        monitor->release(element);
    }
    virtual void monitorEvent(Monitor::shared_pointer const & monitor)
    {

        MonitorElement::shared_pointer element;
        while ((element = monitor->poll()))
        {
            channelCount++;
            if (channelCount == channels)
            {
                iterationCount++;
                channelCount = 0;
            }

            if (iterationCount == iterations)
            {
                epicsTimeStamp endTime;
                epicsTimeGetCurrent(&endTime);

                double duration = epicsTime(endTime) - epicsTime(startTime);
                double getPerSec = iterations*channels/duration;
                double gbit = getPerSec*arraySize*sizeof(double)*8/(1000*1000*1000); // * bits / giga; NO, it's really 1000 and not 1024
                if (verbose)
                    printf("%5.6f seconds, %.3f (x %d = %.3f) monitors/s, data throughput %5.3f Gbits/s\n",
                           duration, iterations/duration, channels, getPerSec, gbit);
                sum += getPerSec;

                iterationCount = 0;
                epicsTimeGetCurrent(&startTime);

                runCount++;
                if (runs == 0 || runCount < runs)
                {
                    // noop
                }
                else
                {
                    printf("%d %d %d %d %.3f\n", channels, arraySize, iterations, runs, sum/runs);

                    Lock guard(waitLoopPtrMutex);
                    waitLoopEvent->signal();	// all done
                }
            }
            else if (channelCount == 0)
            {
                // noop
            }

            monitor->release(element);
        }

    }
Exemplo n.º 4
0
    virtual void monitorEvent(Monitor::shared_pointer const & monitor)
    {

        MonitorElement::shared_pointer element;
        while ((element = monitor->poll()))
        {
            if (mode == ValueOnlyMode)
            {
                PVField::shared_pointer value = element->pvStructurePtr->getSubField("value");
                if (value.get() == 0)
                {
                    std::cerr << "no 'value' field" << std::endl;
                    std::cout << m_channelName << std::endl;
                    //std::cout << *(element->pvStructurePtr.get()) << std::endl << std::endl;
                    pvutil_ostream myos(std::cout.rdbuf());
                    myos << *(element->pvStructurePtr.get()) << std::endl << std::endl;
                }
                else
                {
                    Type valueType = value->getField()->getType();
                    if (valueType != scalar && valueType != scalarArray)
                    {
                        // switch to structure mode, unless it's T-type
                        if (valueType == structure && isTType(static_pointer_cast<PVStructure>(value)))
                        {
                            std::cout << std::setw(30) << std::left << m_channelName;
                            std::cout << fieldSeparator;
                            formatTType(std::cout, static_pointer_cast<PVStructure>(value));
                            std::cout << std::endl;
                        }
                        else
                        {
                            std::cout << m_channelName << std::endl;
                            //std::cout << *(element->pvStructurePtr.get()) << std::endl << std::endl;
                            pvutil_ostream myos(std::cout.rdbuf());
                            myos << *(element->pvStructurePtr.get()) << std::endl << std::endl;
                        }
                    }
                    else
                    {
                        if (fieldSeparator == ' ' && value->getField()->getType() == scalar)
                            std::cout << std::setw(30) << std::left << m_channelName;
                        else
                            std::cout << m_channelName;

                        std::cout << fieldSeparator;

                        terse(std::cout, value) << std::endl;
                    }
                }
            }
            else if (mode == TerseMode)
            {
                if (fieldSeparator == ' ')
                    std::cout << std::setw(30) << std::left << m_channelName;
                else
                    std::cout << m_channelName;

                std::cout << fieldSeparator;

                terseStructure(std::cout, element->pvStructurePtr) << std::endl;
            }
            else
            {
                std::cout << m_channelName << std::endl;
                //std::cout << *(element->pvStructurePtr.get()) << std::endl << std::endl;
                pvutil_ostream myos(std::cout.rdbuf());
                myos << *(element->pvStructurePtr.get()) << std::endl << std::endl;
            }

            monitor->release(element);
        }

    }