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); }
Monitor::shared_pointer CAChannelMonitor::create( CAChannel::shared_pointer const & channel, epics::pvData::MonitorRequester::shared_pointer const & monitorRequester, epics::pvData::PVStructure::shared_pointer const & pvRequest) { // TODO use std::make_shared std::tr1::shared_ptr<CAChannelMonitor> tp( new CAChannelMonitor(channel, monitorRequester, pvRequest) ); Monitor::shared_pointer thisPtr = tp; static_cast<CAChannelMonitor*>(thisPtr.get())->activate(); return thisPtr; }
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); } }
void MonitorRequesterImpl::monitorConnect(const epics::pvData::Status& status, Monitor::shared_pointer const & monitor, StructureConstPtr const & /*structure*/) { qDebug() << "monitorConnect"; if (status.isSuccess()) { Status startStatus = monitor->start(); // show error if (!startStatus.isSuccess()) { std::cerr << "[" << m_channelName << "] channel monitor start: " << startStatus.toString() << std::endl; } } else { std::cerr << "monitorConnect(" << status.toString() << ")" << std::endl; } }
virtual void monitorConnect(const epics::pvData::Status& status, Monitor::shared_pointer const & monitor, StructureConstPtr const & /*structure*/) { if (status.isSuccess()) { /* string str; structure->toString(&str); std::cout << str << std::endl; */ Status startStatus = monitor->start(); // show error // TODO and exit if (!startStatus.isSuccess()) { std::cerr << "[" << m_channelName << "] channel monitor start: " << startStatus << std::endl; } } else { std::cerr << "monitorConnect(" << status << ")" << std::endl; } }
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); } }
int main() { for (int i = 0; i < 10; i++) { { /* ClientContextImpl::shared_pointer context = createClientContextImpl(); context->printInfo(); context->initialize(); context->printInfo(); epicsThreadSleep ( SLEEP_TIME ); ChannelProvider::shared_pointer provider = context->getProvider(); */ ClientFactory::start(); ChannelProvider::shared_pointer provider = getChannelProviderRegistry()->getProvider("pva"); ChannelFindRequester::shared_pointer findRequester(new ChannelFindRequesterImpl()); ChannelFind::shared_pointer channelFind = provider->channelFind("testSomething", findRequester); epicsThreadSleep ( SLEEP_TIME ); //channelFind->destroy(); ChannelRequester::shared_pointer channelRequester(new ChannelRequesterImpl()); Channel::shared_pointer channel = provider->createChannel("testStructureArrayTest", channelRequester); epicsThreadSleep ( SLEEP_TIME ); channel->printInfo(); { GetFieldRequester::shared_pointer getFieldRequesterImpl(new GetFieldRequesterImpl()); channel->getField(getFieldRequesterImpl, ""); epicsThreadSleep ( SLEEP_TIME ); } { ChannelProcessRequester::shared_pointer channelProcessRequester(new ChannelProcessRequesterImpl()); PVStructure::shared_pointer pvRequest; ChannelProcess::shared_pointer channelProcess = channel->createChannelProcess(channelProcessRequester, pvRequest); epicsThreadSleep ( SLEEP_TIME ); channelProcess->process(); epicsThreadSleep ( SLEEP_TIME ); channelProcess->destroy(); epicsThreadSleep ( SLEEP_TIME ); } { ChannelGetRequester::shared_pointer channelGetRequesterImpl(new ChannelGetRequesterImpl()); PVStructure::shared_pointer pvRequest = CreateRequest::create()->createRequest("field()"); ChannelGet::shared_pointer channelGet = channel->createChannelGet(channelGetRequesterImpl, pvRequest); epicsThreadSleep ( 3.0 ); channelGet->get(); epicsThreadSleep ( 3.0 ); channelGet->destroy(); } { ChannelPutRequester::shared_pointer channelPutRequesterImpl(new ChannelPutRequesterImpl()); PVStructure::shared_pointer pvRequest = CreateRequest::create()->createRequest("field(value,timeStamp)"); ChannelPut::shared_pointer channelPut = channel->createChannelPut(channelPutRequesterImpl, pvRequest); epicsThreadSleep ( SLEEP_TIME ); channelPut->get(); epicsThreadSleep ( SLEEP_TIME ); // TODO !!! //channelPut->put(); //epicsThreadSleep ( SLEEP_TIME ); channelPut->destroy(); } { ChannelPutGetRequester::shared_pointer channelPutGetRequesterImpl(new ChannelPutGetRequesterImpl()); PVStructure::shared_pointer pvRequest = CreateRequest::create()->createRequest("putField(value,timeStamp)getField(timeStamp)"); ChannelPutGet::shared_pointer channelPutGet = channel->createChannelPutGet(channelPutGetRequesterImpl, pvRequest); epicsThreadSleep ( SLEEP_TIME ); channelPutGet->getGet(); epicsThreadSleep ( SLEEP_TIME ); channelPutGet->getPut(); epicsThreadSleep ( SLEEP_TIME ); // TODO !!! //channelPutGet->putGet(); //epicsThreadSleep ( SLEEP_TIME ); channelPutGet->destroy(); } { ChannelRPCRequester::shared_pointer channelRPCRequesterImpl(new ChannelRPCRequesterImpl()); PVStructure::shared_pointer pvRequest = CreateRequest::create()->createRequest("record[]field(arguments)"); ChannelRPC::shared_pointer channelRPC = channel->createChannelRPC(channelRPCRequesterImpl, pvRequest); epicsThreadSleep ( SLEEP_TIME ); // for test simply use pvRequest as arguments channelRPC->request(pvRequest); epicsThreadSleep ( SLEEP_TIME ); channelRPC->destroy(); } { ChannelArrayRequester::shared_pointer channelArrayRequesterImpl(new ChannelArrayRequesterImpl()); StringArray fieldNames; fieldNames.push_back("field"); FieldConstPtrArray fields; fields.push_back(getFieldCreate()->createScalar(pvString)); PVStructure::shared_pointer pvRequest(getPVDataCreate()->createPVStructure(getFieldCreate()->createStructure(fieldNames, fields))); ChannelArray::shared_pointer channelArray = channel->createChannelArray(channelArrayRequesterImpl, pvRequest); epicsThreadSleep ( SLEEP_TIME ); channelArray->getArray(0,0,1); epicsThreadSleep ( SLEEP_TIME ); // TODO !!! //channelArray->putArray(0,0,1); //epicsThreadSleep ( SLEEP_TIME ); channelArray->setLength(3); epicsThreadSleep ( SLEEP_TIME ); channelArray->getLength(); epicsThreadSleep ( SLEEP_TIME ); channelArray->destroy(); } { MonitorRequester::shared_pointer monitorRequesterImpl(new MonitorRequesterImpl()); PVStructure::shared_pointer pvRequest = CreateRequest::create()->createRequest("field()"); Monitor::shared_pointer monitor = channel->createMonitor(monitorRequesterImpl, pvRequest); epicsThreadSleep( SLEEP_TIME ); Status status = monitor->start(); std::cout << "monitor->start() = " << status << std::endl; epicsThreadSleep( 3*SLEEP_TIME ); status = monitor->stop(); std::cout << "monitor->stop() = " << status << std::endl; monitor->destroy(); } epicsThreadSleep ( 3*SLEEP_TIME ); printf("Destroying channel... \n"); channel->destroy(); printf("done.\n"); epicsThreadSleep ( 3*SLEEP_TIME ); } ClientFactory::stop(); /* printf("Destroying context... \n"); context->destroy(); printf("done.\n"); */ epicsThreadSleep ( SLEEP_TIME ); } //std::cout << "-----------------------------------------------------------------------" << std::endl; //epicsExitCallAtExits(); return(0); }