uLab
/
remotelaboratory
mirror of https://mirror.git.trinitydesktop.org/gitea/uLab/remotelaboratory
0
0
Fork 0
Code Issues Releases Wiki Activity

Fix commanalyzer functionality

Browse Source
master
Timothy Pearson 13 years ago
parent 8d3c1358ee
commit 8970266265
10 changed files with 580 additions and 363 deletions
Show Stats Download Patch File Download Diff File

4
clients/tde/src/part/commanalyzer/Makefile.am
Unescape Escape View File

@ -1,10 +1,10 @@
INCLUDES = $(all_includes) -I$(top_srcdir)/src -I$(top_srcdir)/src/widgets INCLUDES = $(all_includes) -I$(top_srcdir)/src -I$(top_srcdir)/src/widgets $(KDE_INCLUDES)/tde
KDE_CXXFLAGS = $(USE_EXCEPTIONS) KDE_CXXFLAGS = $(USE_EXCEPTIONS)
METASOURCES = AUTO METASOURCES = AUTO
#Part #Part
kde_module_LTLIBRARIES = libremotelab_commanalyzer.la kde_module_LTLIBRARIES = libremotelab_commanalyzer.la
libremotelab_commanalyzer_la_LIBADD = ../../widgets/libtracewidget.la ../../widgets/libfloatspinbox.la $(LIB_KFILE) $(LIB_KPARTS) $(LIB_TDEUI) $(LIB_QT) libremotelab_commanalyzer_la_LIBADD = ../../widgets/libtracewidget.la ../../widgets/libfloatspinbox.la $(LIB_KFILE) $(LIB_KPARTS) $(LIB_TDEUI) $(LIB_QT)
libremotelab_commanalyzer_la_LDFLAGS = $(all_libraries) $(KDE_PLUGIN) -ltdecore -ltdeui -lkio -ltdefx libremotelab_commanalyzer_la_LDFLAGS = $(all_libraries) $(KDE_PLUGIN) -ltdecore -ltdeui -lkio -ltdefx -ltdekrbsocket -ltqtrla
libremotelab_commanalyzer_la_SOURCES = \ libremotelab_commanalyzer_la_SOURCES = \
part.cpp layout.ui part.cpp layout.ui

787
clients/tde/src/part/commanalyzer/part.cpp
Unescape Escape View File

@ -13,7 +13,7 @@
#include <kstatusbar.h> #include <kstatusbar.h>
#include <kstdaction.h> #include <kstdaction.h>
#include <tqfile.h> //encodeName() #include <tqfile.h> //encodeName()
#include <tqtimer.h> //postInit() hack #include <tqtimer.h>
#include <tqvbox.h> #include <tqvbox.h>
#include <tqsocket.h> #include <tqsocket.h>
#include <tqmutex.h> #include <tqmutex.h>
@ -26,6 +26,8 @@
#include "floatspinbox.h" #include "floatspinbox.h"
#include "layout.h" #include "layout.h"
#define NETWORK_COMM_TIMEOUT_MS 15000
/* exception handling */ /* exception handling */
struct exit_exception { struct exit_exception {
int c; int c;
@ -35,12 +37,16 @@ struct exit_exception {
namespace RemoteLab { namespace RemoteLab {
typedef KParts::GenericFactory<RemoteLab::CommAnalyzerPart> Factory; typedef KParts::GenericFactory<RemoteLab::CommAnalyzerPart> Factory;
#define CLIENT_LIBRARY "libremotelab_commanalyzer"
K_EXPORT_COMPONENT_FACTORY( libremotelab_commanalyzer, RemoteLab::Factory ) K_EXPORT_COMPONENT_FACTORY( libremotelab_commanalyzer, RemoteLab::Factory )
CommAnalyzerPart::CommAnalyzerPart( TQWidget *parentWidget, const char *widgetName, TQObject *parent, const char *name, const TQStringList& ) CommAnalyzerPart::CommAnalyzerPart( TQWidget *parentWidget, const char *widgetName, TQObject *parent, const char *name, const TQStringList& )
: ReadOnlyPart( parent, name ), m_traceWidget(0), m_socket(0), m_base(0), stopTraceUpdate(false) : RemoteInstrumentPart( parent, name ), m_traceWidget(0), m_commHandlerState(-1), m_commHandlerMode(0), m_commHandlerCommandState(0), m_base(0), stopTraceUpdate(false)
{ {
// Initialize important base class variables
m_clientLibraryName = CLIENT_LIBRARY;
// Initialize mutex // Initialize mutex
m_instrumentMutex = new TQMutex(false); m_instrumentMutex = new TQMutex(false);
@ -48,6 +54,10 @@ CommAnalyzerPart::CommAnalyzerPart( TQWidget *parentWidget, const char *widgetNa
setInstance(Factory::instance()); setInstance(Factory::instance());
setWidget(new TQVBox(parentWidget, widgetName)); setWidget(new TQVBox(parentWidget, widgetName));
// Create timers
m_updateTimeoutTimer = new TQTimer(this);
connect(m_updateTimeoutTimer, SIGNAL(timeout()), this, SLOT(mainEventLoop()));
// Create widgets // Create widgets
m_base = new CommAnalyzerBase(widget()); m_base = new CommAnalyzerBase(widget());
m_traceWidget = m_base->traceWidget; m_traceWidget = m_base->traceWidget;
@ -61,347 +71,529 @@ CommAnalyzerPart::CommAnalyzerPart( TQWidget *parentWidget, const char *widgetNa
} }
CommAnalyzerPart::~CommAnalyzerPart() { CommAnalyzerPart::~CommAnalyzerPart() {
if (m_traceWidget) { if (m_instrumentMutex->locked()) {
delete m_traceWidget; printf("[WARNING] Exiting when data transfer still in progress!\n\r"); fflush(stdout);
}
if (m_socket) {
m_socket->close();
while (m_socket->state() == TQSocket::Closing) {
tqApp->processEvents();
}
delete m_socket;
} }
disconnectFromServer();
delete m_instrumentMutex; delete m_instrumentMutex;
} }
void CommAnalyzerPart::postInit() { void CommAnalyzerPart::postInit() {
m_updateTimer = new TQTimer(this); //
connect(m_updateTimer, SIGNAL(timeout()), this, SLOT(updateTrace()));
} }
bool CommAnalyzerPart::openURL(const KURL &url) { bool CommAnalyzerPart::openURL(const KURL &url) {
connectToServer(url.url()); int ret;
ret = connectToServer(url.url());
processLockouts();
return (ret != 0);
} }
bool CommAnalyzerPart::closeURL() { bool CommAnalyzerPart::closeURL() {
if (m_socket) { disconnectFromServer();
m_socket->close();
while (m_socket->state() != TQSocket::Idle) {
tqApp->processEvents();
}
}
m_url = KURL(); m_url = KURL();
return true;
}
if (m_instrumentMutex->locked()) { void CommAnalyzerPart::processLockouts() {
throw exit_exception(-1); }
}
return true; void CommAnalyzerPart::disconnectFromServerCallback() {
m_updateTimeoutTimer->stop();
} }
TQString CommAnalyzerPart::callServerMethod(int command) { void CommAnalyzerPart::connectionFinishedCallback() {
if (m_instrumentMutex->locked() == true) { connect(m_socket, SIGNAL(readyRead()), m_socket, SLOT(processPendingData()));
printf("[WARN] An attempt was made to access the instrument asynchronously, and was rejected to prevent a lockup\n\r"); fflush(stdout); m_socket->processPendingData();
return TQString::null; connect(m_socket, SIGNAL(newDataReceived()), this, SLOT(mainEventLoop()));
m_tickerState = 0;
m_commHandlerState = 0;
m_commHandlerMode = 0;
m_socket->setDataTimeout(NETWORK_COMM_TIMEOUT_MS);
m_updateTimeoutTimer->start(NETWORK_COMM_TIMEOUT_MS, TRUE);
processLockouts();
mainEventLoop();
return;
}
#define UPDATEDISPLAY_TIMEOUT m_connectionActiveAndValid = false; \
m_tickerState = 0; \
m_commHandlerState = 2; \
m_commHandlerMode = 0; \
m_socket->clearIncomingData(); \
setStatusMessage(i18n("Server ping timeout. Please verify the status of your network connection.")); \
m_updateTimeoutTimer->start(NETWORK_COMM_TIMEOUT_MS, TRUE); \
m_instrumentMutex->unlock(); \
return;
#define COMMUNICATIONS_FAILED m_connectionActiveAndValid = false; \
m_tickerState = 0; \
m_commHandlerState = 2; \
m_commHandlerMode = 0; \
m_socket->clearIncomingData(); \
setStatusMessage(i18n("Instrument communication failure. Please verify the status of your network connection.")); \
m_updateTimeoutTimer->start(NETWORK_COMM_TIMEOUT_MS, TRUE); \
m_instrumentMutex->unlock(); \
return;
#define SET_WATCHDOG_TIMER if (!m_updateTimeoutTimer->isActive()) m_updateTimeoutTimer->start(NETWORK_COMM_TIMEOUT_MS, TRUE);
#define PAT_WATCHDOG_TIMER m_updateTimeoutTimer->stop(); m_updateTimeoutTimer->start(NETWORK_COMM_TIMEOUT_MS, TRUE);
#define SET_NEXT_STATE(x) if (m_commHandlerMode == 0) { \
m_commHandlerState = x; \
} \
else { \
m_commHandlerState = 255; \
}
void CommAnalyzerPart::mainEventLoop() {
TQDataStream ds(m_socket);
ds.setPrintableData(true);
if (!m_instrumentMutex->tryLock()) {
TQTimer::singleShot(0, this, SLOT(mainEventLoop())); // Handle the concurrently received call immediately after current execution
return;
} }
try {
m_instrumentMutex->lock(); if (m_socket) {
if (m_socket->state() == TQSocket::Connected) { if ((m_commHandlerMode == 0) || (m_commHandlerMode == 1)) {
TQString cmd = TQChar(command); if (m_commHandlerState == 0) {
cmd.append('\r'); // Request communications analyzer access
m_socket->writeBlock(cmd.latin1(), cmd.length()); ds << TQString("COMMUNICATIONS ANALYZER");
// Read from the server m_socket->writeEndOfFrame();
TQString serverRet;
while ((!serverRet.contains('\r')) && (m_socket->state() == TQSocket::Connected)) { m_commHandlerState = 1;
char data[1]; }
if( m_socket->readBlock(data, 1) > 0) { else if (m_commHandlerState == 1) {
serverRet.append(data[0]); // Get response data
if (m_socket->canReadFrame()) {
PAT_WATCHDOG_TIMER
// Get command status
TQString result;
ds >> result;
m_socket->clearFrameTail();
if (result == "ACK") {
SET_NEXT_STATE(2)
}
else {
COMMUNICATIONS_FAILED
}
}
else {
if (!m_updateTimeoutTimer->isActive()) {
UPDATEDISPLAY_TIMEOUT
}
} }
tqApp->eventLoop()->processEvents(TQEventLoop::AllEvents);
} }
m_instrumentMutex->unlock(); else if (m_commHandlerState == 2) {
return serverRet; // Set spectrum analyzer mode
} ds << TQString("SETMODESPECTRUMANALYZER");
else { m_socket->writeEndOfFrame();
m_instrumentMutex->unlock();
return TQString::null;
}
}
catch (exit_exception& e) {
m_instrumentMutex->unlock();
return TQString::null;
}
}
int16_t CommAnalyzerPart::callServerMethodInt16(int command) { SET_NEXT_STATE(3)
if (m_instrumentMutex->locked() == true) { }
printf("[WARN] An attempt was made to access the instrument asynchronously, and was rejected to prevent a lockup\n\r"); fflush(stdout); else if (m_commHandlerState == 3) {
return 0; // Get response data
} if (m_socket->canReadFrame()) {
try { PAT_WATCHDOG_TIMER
m_instrumentMutex->lock();
if (m_socket->state() == TQSocket::Connected) { // Get command status
TQString cmd = TQChar(command); TQString result;
cmd.append('\r'); ds >> result;
m_socket->writeBlock(cmd.latin1(), cmd.length()); m_socket->clearFrameTail();
// Read from the server
int bytesread = 0; if (result == "ACK") {
int16_t data[1]; // Set spectrum analyzer mode
while ((bytesread < 2) && (m_socket->state() == TQSocket::Connected)) { ds << TQString("SETMODESPECTRUMANALYZER");
int ret = m_socket->readBlock(((char*)data)+bytesread, 1); m_socket->writeEndOfFrame();
if (ret > 0) {
bytesread += ret; SET_NEXT_STATE(4)
}
else {
COMMUNICATIONS_FAILED
}
}
else {
if (!m_updateTimeoutTimer->isActive()) {
UPDATEDISPLAY_TIMEOUT
}
} }
tqApp->eventLoop()->processEvents(TQEventLoop::AllEvents);
} }
TQString serverRet; else if (m_commHandlerState == 4) {
while ((!serverRet.contains('\r')) && (m_socket->state() == TQSocket::Connected)) { // Get response data
char data[1]; if (m_socket->canReadFrame()) {
if( m_socket->readBlock(data, 1) > 0) { PAT_WATCHDOG_TIMER
serverRet.append(data[0]);
// Get command status
TQString result;
ds >> result;
m_socket->clearFrameTail();
if (result == "ACK") {
// Get number of samples in trace, step 1
ds << TQString("GETTRACESAMPLECOUNT");
m_socket->writeEndOfFrame();
SET_NEXT_STATE(5)
}
else {
COMMUNICATIONS_FAILED
}
}
else {
if (!m_updateTimeoutTimer->isActive()) {
UPDATEDISPLAY_TIMEOUT
}
} }
tqApp->eventLoop()->processEvents(TQEventLoop::AllEvents);
} }
m_instrumentMutex->unlock(); else if (m_commHandlerState == 5) {
return data[0]; // Get response data
} if (m_socket->canReadFrame()) {
else { PAT_WATCHDOG_TIMER
m_instrumentMutex->unlock();
return 0; // Get number of samples in trace, step 2
} TQString result;
} ds >> result;
catch (exit_exception& e) { if (result == "ACK") {
m_instrumentMutex->unlock(); ds >> m_samplesInTrace;
return 0; }
} m_socket->clearFrameTail();
}
if (result == "ACK") {
double CommAnalyzerPart::callServerMethodDouble(int command) { // Get number of horizontal divisions, step 1
if (m_instrumentMutex->locked() == true) { ds << TQString("GETHORIZONTALDIVCOUNT");
printf("[WARN] An attempt was made to access the instrument asynchronously, and was rejected to prevent a lockup\n\r"); fflush(stdout); m_socket->writeEndOfFrame();
return 0;
} SET_NEXT_STATE(6)
try { }
m_instrumentMutex->lock(); else {
if (m_socket->state() == TQSocket::Connected) { COMMUNICATIONS_FAILED
TQString cmd = TQChar(command); }
cmd.append('\r'); }
m_socket->writeBlock(cmd.latin1(), cmd.length()); else {
// Read from the server if (!m_updateTimeoutTimer->isActive()) {
unsigned int bytesread = 0; UPDATEDISPLAY_TIMEOUT
double data[1]; }
while ((bytesread < sizeof(double)) && (m_socket->state() == TQSocket::Connected)) {
int ret = m_socket->readBlock(((char*)data)+bytesread, 1);
if (ret > 0) {
bytesread += ret;
} }
tqApp->eventLoop()->processEvents(TQEventLoop::AllEvents);
} }
TQString serverRet; else if (m_commHandlerState == 6) {
while ((!serverRet.contains('\r')) && (m_socket->state() == TQSocket::Connected)) { // Get response data
char data[1]; if (m_socket->canReadFrame()) {
if( m_socket->readBlock(data, 1) > 0) { PAT_WATCHDOG_TIMER
serverRet.append(data[0]);
// Get number of horizontal divisions, step 2
TQString result;
ds >> result;
if (result == "ACK") {
ds >> m_hdivs;
}
m_socket->clearFrameTail();
if (result == "ACK") {
// Get number of vertical divisions, step 1
ds << TQString("GETVERTICALDIVCOUNT");
m_socket->writeEndOfFrame();
SET_NEXT_STATE(7)
}
else {
COMMUNICATIONS_FAILED
}
}
else {
if (!m_updateTimeoutTimer->isActive()) {
UPDATEDISPLAY_TIMEOUT
}
} }
tqApp->eventLoop()->processEvents(TQEventLoop::AllEvents);
} }
m_instrumentMutex->unlock(); else if (m_commHandlerState == 7) {
return data[0]; // Get response data
} if (m_socket->canReadFrame()) {
else { PAT_WATCHDOG_TIMER
m_instrumentMutex->unlock();
return 0; // Get number of vertical divisions, step 2
} TQString result;
} ds >> result;
catch (exit_exception& e) { if (result == "ACK") {
m_instrumentMutex->unlock(); ds >> m_vdivs;
return 0; }
} m_socket->clearFrameTail();
}
if (result == "ACK") {
// Get reference power level, step 1
ds << TQString("GETREFERENCEPOWERLEVEL");
m_socket->writeEndOfFrame();
void CommAnalyzerPart::sendServerCommandWithParameter(int command, TQString param) { SET_NEXT_STATE(8)
if (m_instrumentMutex->locked() == true) { }
printf("[WARN] An attempt was made to access the instrument asynchronously, and was rejected to prevent a lockup\n\r"); fflush(stdout); else {
return; COMMUNICATIONS_FAILED
} }
try { }
m_instrumentMutex->lock(); else {
if (m_socket->state() == TQSocket::Connected) { if (!m_updateTimeoutTimer->isActive()) {
TQString cmd = TQChar(command); UPDATEDISPLAY_TIMEOUT
param = TQString("%1%2%3").arg(param).arg(TQChar('°')).arg(TQChar('\r')); }
cmd += param;
m_socket->writeBlock(cmd.ascii(), cmd.length());
// Read from the server
TQString serverRet;
while ((!serverRet.contains('\r')) && (m_socket->state() == TQSocket::Connected)) {
char data[1];
if( m_socket->readBlock(data, 1) > 0) {
serverRet.append(data[0]);
} }
tqApp->eventLoop()->processEvents(TQEventLoop::AllEvents);
} }
} else if (m_commHandlerState == 8) {
m_instrumentMutex->unlock(); // Get response data
return; if (m_socket->canReadFrame()) {
} PAT_WATCHDOG_TIMER
catch (exit_exception& e) {
m_instrumentMutex->unlock(); // Get reference power level, step 2
return; TQString result;
} ds >> result;
} if (result == "ACK") {
ds >> m_rpower;
void CommAnalyzerPart::sendServerCommand(int command) { }
if (m_instrumentMutex->locked() == true) { m_socket->clearFrameTail();
printf("[WARN] An attempt was made to access the instrument asynchronously, and was rejected to prevent a lockup\n\r"); fflush(stdout);
return; if (result == "ACK") {
} // Get vertical division scale, step 1
try { ds << TQString("GETVERTDIVSCALE");
m_instrumentMutex->lock(); m_socket->writeEndOfFrame();
if (m_socket->state() == TQSocket::Connected) {
TQString cmd = TQChar(command); SET_NEXT_STATE(9)
cmd.append('\r'); }
m_socket->writeBlock(cmd.latin1(), cmd.length()); else {
// Read from the server COMMUNICATIONS_FAILED
TQString serverRet; }
while ((!serverRet.contains('\r')) && (m_socket->state() == TQSocket::Connected)) { }
char data[1]; else {
if( m_socket->readBlock(data, 1) > 0) { if (!m_updateTimeoutTimer->isActive()) {
serverRet.append(data[0]); UPDATEDISPLAY_TIMEOUT
}
} }
tqApp->eventLoop()->processEvents(TQEventLoop::AllEvents);
} }
} else if (m_commHandlerState == 9) {
m_instrumentMutex->unlock(); // Get response data
return; if (m_socket->canReadFrame()) {
} PAT_WATCHDOG_TIMER
catch (exit_exception& e) {
m_instrumentMutex->unlock(); // Get vertical division scale, step 2
return; TQString result;
} ds >> result;
} if (result == "ACK") {
ds >> m_vscale;
void CommAnalyzerPart::callServerMethodDoubleArray(int command, double * array, int arrayLen) { }
if (m_instrumentMutex->locked() == true) { m_socket->clearFrameTail();
printf("[WARN] An attempt was made to access the instrument asynchronously, and was rejected to prevent a lockup\n\r"); fflush(stdout);
return; if (result == "ACK") {
} // Get center frequency, step 1
try { ds << TQString("GETCENTERFREQUENCY");
m_instrumentMutex->lock(); m_socket->writeEndOfFrame();
if (m_socket->state() == TQSocket::Connected) {
TQString cmd = TQChar(command); SET_NEXT_STATE(10)
cmd.append('\r'); }
m_socket->writeBlock(cmd.latin1(), cmd.length()); else {
// Read from the server COMMUNICATIONS_FAILED
TQString serverRet; }
while ((!serverRet.contains('\r')) && (m_socket->state() == TQSocket::Connected)) { }
char data[1]; else {
if( m_socket->readBlock(data, 1) > 0) { if (!m_updateTimeoutTimer->isActive()) {
serverRet.append(data[0]); UPDATEDISPLAY_TIMEOUT
}
} }
tqApp->eventLoop()->processEvents(TQEventLoop::AllEvents);
} }
unsigned int bytesread = 0; else if (m_commHandlerState == 10) {
int16_t data[1]; // Get response data
while ((bytesread < 2) && (m_socket->state() == TQSocket::Connected)) { if (m_socket->canReadFrame()) {
int ret = m_socket->readBlock(((char*)data)+bytesread, 1); PAT_WATCHDOG_TIMER
if (ret > 0) {
bytesread += ret; // Get center frequency, step 2
TQString result;
ds >> result;
if (result == "ACK") {
ds >> m_centerfreq;
}
m_socket->clearFrameTail();
if (result == "ACK") {
// Get frequency span, step 1
ds << TQString("GETFREQUENCYSPAN");
m_socket->writeEndOfFrame();
SET_NEXT_STATE(11)
}
else {
COMMUNICATIONS_FAILED
}
}
else {
if (!m_updateTimeoutTimer->isActive()) {
UPDATEDISPLAY_TIMEOUT
}
} }
tqApp->eventLoop()->processEvents(TQEventLoop::AllEvents);
} }
serverRet = ""; else if (m_commHandlerState == 11) {
while ((!serverRet.contains('\r')) && (m_socket->state() == TQSocket::Connected)) { // Get response data
char data[1]; if (m_socket->canReadFrame()) {
if( m_socket->readBlock(data, 1) > 0) { PAT_WATCHDOG_TIMER
serverRet.append(data[0]);
// Get frequency span, step 2
TQString result;
ds >> result;
if (result == "ACK") {
ds >> m_spanfreq;
}
m_socket->clearFrameTail();
if (result == "ACK") {
// Update display widget(s)
updateGraticule();
}
if (result == "ACK") {
// Get trace, step 1
ds << TQString("GETSPECTRUMTRACE");
m_socket->writeEndOfFrame();
SET_NEXT_STATE(12)
}
else {
COMMUNICATIONS_FAILED
}
}
else {
if (!m_updateTimeoutTimer->isActive()) {
UPDATEDISPLAY_TIMEOUT
}
} }
tqApp->eventLoop()->processEvents(TQEventLoop::AllEvents);
} }
bytesread = 0; else if (m_commHandlerState == 12) {
int elementsread = 0; // Get response data
for (elementsread=0;elementsread<arrayLen;elementsread++) { if (m_socket->canReadFrame()) {
bytesread = 0; PAT_WATCHDOG_TIMER
while ((bytesread < sizeof(double)) && (m_socket->state() == TQSocket::Connected)) {
if (m_socket->size() < 1) { // Get trace, step 2
tqApp->eventLoop()->processEvents(TQEventLoop::AllEvents); TQDoubleArray trace;
} TQString result;
int ret = m_socket->readBlock(((char*)array)+bytesread+(elementsread*sizeof(double)), 1); ds >> result;
if (ret > 0) { if (result == "ACK") {
bytesread += ret; ds >> trace;
}
m_socket->clearFrameTail();
if (result == "ACK") {
// Update display widget(s)
m_traceWidget->setSamples(trace);
postProcessTrace();
m_traceWidget->repaint();
}
if (result == "ACK") {
SET_NEXT_STATE(2)
}
else {
COMMUNICATIONS_FAILED
} }
} }
else {
if (!m_updateTimeoutTimer->isActive()) {
UPDATEDISPLAY_TIMEOUT
}
}
}
else if (m_commHandlerState == 255) {
// Execute pending command
m_commHandlerMode = 2;
m_socket->clearIncomingData();
} }
SET_WATCHDOG_TIMER
} }
m_instrumentMutex->unlock(); else if (m_commHandlerMode == 2) {
return; if (m_commHandlerCommandState == 0) {
} m_commHandlerMode = 0;
catch (exit_exception& e) { m_commHandlerState = 2;
m_instrumentMutex->unlock(); }
return; else if (m_commHandlerCommandState == 1) {
} // Set reference power level
} ds << TQString("SETREFERENCEPOWERLEVEL");
ds << m_rpower;
int CommAnalyzerPart::connectToServer(TQString server) { m_socket->writeEndOfFrame();
if (!m_socket) {
m_socket = new TQSocket(this);
}
m_socket->connectToHost(server, 4002);
while ((m_socket->state() != TQSocket::Connected) && (m_socket->state() != TQSocket::Idle)) {
tqApp->eventLoop()->processEvents(TQEventLoop::AllEvents);
}
if (m_socket->state() != TQSocket::Connected) {
return -1;
}
// Gather information from the server m_commHandlerCommandState = 2;
if (callServerMethod(41) == "NCK") { }
// FIXME else if (m_commHandlerCommandState == 2) {
// Display message and exit // Get response data
return -1; if (m_socket->canReadFrame()) {
} PAT_WATCHDOG_TIMER
sendServerCommand(40); // Set spectrum analyzer mode
m_samplesInTrace = callServerMethodInt16(63); // Get number of samples in trace // Set reference power level, step 2
m_traceWidget->setNumberOfSamples(m_samplesInTrace); TQString result;
m_hdivs = callServerMethodInt16(62); // Get number of horizontal divisions ds >> result;
m_traceWidget->setNumberOfHorizontalDivisions(m_hdivs); m_socket->clearFrameTail();
m_vdivs = callServerMethodInt16(64); // Get number of vertical divisions
m_traceWidget->setNumberOfVerticalDivisions(m_vdivs); if (result == "ACK") {
// Get reference power level, step 1
ds << TQString("GETREFERENCEPOWERLEVEL");
m_socket->writeEndOfFrame();
m_rpower = callServerMethodDouble(65); // Get reference power level m_commHandlerCommandState = 3;
m_vscale = callServerMethodDouble(66); // Get vertical division scale }
else {
COMMUNICATIONS_FAILED
}
}
else {
if (!m_updateTimeoutTimer->isActive()) {
UPDATEDISPLAY_TIMEOUT
}
}
}
else if (m_commHandlerCommandState == 3) {
// Get response data
if (m_socket->canReadFrame()) {
PAT_WATCHDOG_TIMER
// Get reference power level, step 2
TQString result;
ds >> result;
if (result == "ACK") {
ds >> m_rpower;
}
m_socket->clearFrameTail();
m_centerfreq = callServerMethodDouble(67); // Get center frequency // Update display as needed
m_spanfreq = callServerMethodDouble(68); // Get frequency span updateGraticule();
updateGraticule(); if (result == "ACK") {
m_commHandlerCommandState = 0;
TQTimer::singleShot(0, this, SLOT(mainEventLoop()));
}
else {
COMMUNICATIONS_FAILED
}
}
else {
if (!m_updateTimeoutTimer->isActive()) {
UPDATEDISPLAY_TIMEOUT
}
}
}
}
}
else {
m_commHandlerState = 0;
m_commHandlerCommandState = 0;
}
// Start trace update timer m_instrumentMutex->unlock();
m_updateTimer->start(10, FALSE);
} }
void CommAnalyzerPart::postProcessTrace() { void CommAnalyzerPart::postProcessTrace() {
return; return;
} }
void CommAnalyzerPart::updateTrace() {
m_updateTimer->stop();
callServerMethodDoubleArray(42, m_traceWidget->samples(), m_samplesInTrace);
postProcessTrace();
m_traceWidget->repaint();
if (m_socket->state() == TQSocket::Connected) {
if (stopTraceUpdate == true) {
stopTraceUpdate = false;
}
else {
m_updateTimer->start(10, FALSE);
}
}
}
void CommAnalyzerPart::updateGraticule() { void CommAnalyzerPart::updateGraticule() {
m_traceWidget->setNumberOfSamples(m_samplesInTrace);
m_traceWidget->setNumberOfHorizontalDivisions(m_hdivs);
m_traceWidget->setNumberOfVerticalDivisions(m_vdivs);
m_leftFrequency = m_centerfreq - (m_spanfreq/2.0); m_leftFrequency = m_centerfreq - (m_spanfreq/2.0);
m_rightFrequency = m_centerfreq + (m_spanfreq/2.0); m_rightFrequency = m_centerfreq + (m_spanfreq/2.0);
m_traceWidget->setDisplayLimits(m_leftFrequency, m_rpower, m_rightFrequency, m_rpower-(m_vscale*m_hdivs)); m_traceWidget->setDisplayLimits(m_leftFrequency, m_rpower, m_rightFrequency, m_rpower-(m_vscale*m_hdivs));
@ -413,25 +605,10 @@ void CommAnalyzerPart::updateGraticule() {
} }
void CommAnalyzerPart::saRefLevelChanged(double newval) { void CommAnalyzerPart::saRefLevelChanged(double newval) {
// We cannot directly send data to the remote instrument because the GUI event may have ocurred during a remote instrument transaction
// This "flaw" is a direct result of maximizing performance by processing GUI events during network transfers, as well as the fact that this client is a multithreaded application
m_rpower = newval; m_rpower = newval;
stopTraceUpdate = true; m_commHandlerMode = 1;
TQTimer::singleShot(0, this, SLOT(changeSaRefLevel())); m_commHandlerCommandState = 1;
} mainEventLoop();
void CommAnalyzerPart::changeSaRefLevel() {
// Keep trying to set the new power level
if (m_instrumentMutex->locked() == false) {
sendServerCommandWithParameter(61, TQString("%1").arg(m_rpower, 0, 'E')); // Set reference power level
m_rpower = callServerMethodDouble(65); // Get reference power level
updateGraticule(); // Update the display grid
m_updateTimer->start(10, FALSE); // Restart trace update timer
}
else {
tqApp->eventLoop()->processEvents(TQEventLoop::ExcludeUserInput);
TQTimer::singleShot(0, this, SLOT(changeSaRefLevel()));
}
} }
KAboutData* CommAnalyzerPart::createAboutData() { KAboutData* CommAnalyzerPart::createAboutData() {

34
clients/tde/src/part/commanalyzer/part.h
Unescape Escape View File

@ -9,6 +9,8 @@
#include <kparts/part.h> #include <kparts/part.h>
#include <kurl.h> #include <kurl.h>
#include <tqtrla.h>
class KAboutData; class KAboutData;
using KParts::StatusBarExtension; using KParts::StatusBarExtension;
class TraceWidget; class TraceWidget;
@ -19,7 +21,7 @@ class CommAnalyzerBase;
namespace RemoteLab namespace RemoteLab
{ {
class CommAnalyzerPart : public KParts::ReadOnlyPart class CommAnalyzerPart : public KParts::RemoteInstrumentPart
{ {
Q_OBJECT Q_OBJECT
@ -30,40 +32,38 @@ namespace RemoteLab
virtual bool openFile() { return false; } // pure virtual in the base class virtual bool openFile() { return false; } // pure virtual in the base class
virtual bool closeURL(); virtual bool closeURL();
static KAboutData *createAboutData(); static KAboutData *createAboutData();
int connectToServer(TQString server);
public slots: public slots:
virtual bool openURL(const KURL &url); virtual bool openURL(const KURL &url);
private slots: private slots:
void postInit(); void postInit();
void updateTrace(); void processLockouts();
void updateGraticule(); void updateGraticule();
void connectionFinishedCallback();
void disconnectFromServerCallback();
// void connectionStatusChangedCallback();
void mainEventLoop();
virtual void postProcessTrace(); virtual void postProcessTrace();
void saRefLevelChanged(double); void saRefLevelChanged(double);
void changeSaRefLevel();
private:
TQString callServerMethod(int command);
void sendServerCommand(int command);
int16_t callServerMethodInt16(int command);
double callServerMethodDouble(int command);
void callServerMethodDoubleArray(int command, double * array, int arrayLen);
void sendServerCommandWithParameter(int command, TQString param);
private: private:
TraceWidget* m_traceWidget; TraceWidget* m_traceWidget;
TQSocket* m_socket; int m_commHandlerState;
int16_t m_samplesInTrace; int m_commHandlerMode;
int m_commHandlerCommandState;
TQTimer* m_updateTimeoutTimer;
bool m_connectionActiveAndValid;
unsigned char m_tickerState;
TQ_INT16 m_samplesInTrace;
double m_leftFrequency; double m_leftFrequency;
double m_rightFrequency; double m_rightFrequency;
int16_t m_hdivs; TQ_INT16 m_hdivs;
int16_t m_vdivs; TQ_INT16 m_vdivs;
double m_centerfreq; double m_centerfreq;
double m_spanfreq; double m_spanfreq;
double m_rpower; double m_rpower;
double m_vscale; double m_vscale;
TQTimer* m_updateTimer;
CommAnalyzerBase* m_base; CommAnalyzerBase* m_base;
TQMutex* m_instrumentMutex; TQMutex* m_instrumentMutex;
bool stopTraceUpdate; bool stopTraceUpdate;

3
clients/tde/src/widgets/Makefile.am
Unescape Escape View File

@ -1,5 +1,6 @@
INCLUDES = $(all_includes) INCLUDES = $(all_includes) $(KDE_INCLUDES)/tde
METASOURCES = AUTO METASOURCES = AUTO
noinst_LTLIBRARIES = libtracewidget.la libfloatspinbox.la noinst_LTLIBRARIES = libtracewidget.la libfloatspinbox.la
libtracewidget_la_SOURCES = tracewidget.cpp libtracewidget_la_SOURCES = tracewidget.cpp
libtracewidget_la_LDFLAGS = $(all_libraries) -ltqtrla
libfloatspinbox_la_SOURCES = floatspinbox.cpp libfloatspinbox_la_SOURCES = floatspinbox.cpp

23
clients/tde/src/widgets/floatspinbox.cpp
Unescape Escape View File

@ -13,15 +13,15 @@
#define ROUND(x) ((int)(0.5 + (x))) #define ROUND(x) ((int)(0.5 + (x)))
FloatSpinBox::FloatSpinBox(double fmin, double fmax, double fvalue, TQWidget *parent) : TQSpinBox(parent) FloatSpinBox::FloatSpinBox(double fmin, double fmax, double fvalue, TQWidget *parent) : TQSpinBox(parent) {
{
init(fmin, fmax, fvalue); init(fmin, fmax, fvalue);
connect( this, SIGNAL(valueChanged(int)), SLOT(acceptValueChanged(int)) ); connect( this, SIGNAL(valueChanged(int)), SLOT(acceptValueChanged(int)) );
} }
FloatSpinBox::FloatSpinBox(TQWidget *parent , const char* name) : TQSpinBox(parent, name) FloatSpinBox::FloatSpinBox(TQWidget *parent , const char* name) : TQSpinBox(parent, name) {
{ init(0, 0, 0);
connect( this, SIGNAL(valueChanged(int)), SLOT(acceptValueChanged(int)) ); connect( this, SIGNAL(valueChanged(int)), SLOT(acceptValueChanged(int)) );
} }
@ -52,16 +52,14 @@ void FloatSpinBox::setFloatMax(double fmax) {
init(min, fmax, value); init(min, fmax, value);
} }
TQString FloatSpinBox::mapValueToText(int ival) TQString FloatSpinBox::mapValueToText(int ival) {
{
TQString str; TQString str;
value = min + (double)ival * pow(10, -dec); value = min + (double)ival * pow(10, -dec);
str.sprintf("%.*f", dec, value); str.sprintf("%.*f", dec, value); // This can hang as 'value' may (randomly) have an insanely high precision that is very difficult to convert to text
return( str ); return( str );
} }
int FloatSpinBox::mapTextToValue (bool * ok) int FloatSpinBox::mapTextToValue (bool * ok) {
{
TQString str = cleanText(); TQString str = cleanText();
double tryValue = str.toDouble( ok ); double tryValue = str.toDouble( ok );
if (*ok) { if (*ok) {
@ -70,14 +68,13 @@ int FloatSpinBox::mapTextToValue (bool * ok)
return ROUND( (value - min) * pow( 10, dec ) ); return ROUND( (value - min) * pow( 10, dec ) );
} }
void FloatSpinBox::setFloatValue(double d) void FloatSpinBox::setFloatValue(double d) {
{
value = d; value = d;
setValue( ROUND( (value - min) * pow( 10, dec )) ); setValue( ROUND( (value - min) * pow( 10, dec )) );
} }
void FloatSpinBox::acceptValueChanged(int ival) void FloatSpinBox::acceptValueChanged(int ival) {
{ Q_UNUSED(ival);
emit floatValueChanged( value ); emit floatValueChanged( value );
} }

13
clients/tde/src/widgets/tracewidget.cpp
Unescape Escape View File

@ -16,7 +16,6 @@ TraceWidget::TraceWidget(TQWidget* parent, const char* name) : TQWidget(parent,
m_rightEdge(0), m_rightEdge(0),
m_topEdge(0), m_topEdge(0),
m_bottomEdge(0), m_bottomEdge(0),
m_sampleArray(0),
m_graticulePixmap(0) { m_graticulePixmap(0) {
setBackgroundMode(NoBackground); setBackgroundMode(NoBackground);
@ -30,10 +29,7 @@ TraceWidget::~TraceWidget() {
void TraceWidget::setNumberOfSamples(unsigned int samples) { void TraceWidget::setNumberOfSamples(unsigned int samples) {
m_samples = samples; m_samples = samples;
if (m_sampleArray) { m_sampleArray.resize(m_samples);
delete [] m_sampleArray;
}
m_sampleArray = new double[m_samples];
updateGraticule(); updateGraticule();
} }
@ -55,10 +51,15 @@ void TraceWidget::setDisplayLimits(double x, double y, double w, double h) {
m_bottomEdge = h; m_bottomEdge = h;
} }
double* TraceWidget::samples() { TQDoubleArray& TraceWidget::samples() {
return m_sampleArray; return m_sampleArray;
} }
void TraceWidget::setSamples(TQDoubleArray& tqda) {
m_sampleArray = tqda;
m_samples = tqda.size();
}
void TraceWidget::updateGraticule() { void TraceWidget::updateGraticule() {
unsigned int d,s,x,y; unsigned int d,s,x,y;

7
clients/tde/src/widgets/tracewidget.h
Unescape Escape View File

@ -3,6 +3,8 @@
#include <tqwidget.h> #include <tqwidget.h>
#include <tqtrla.h>
class TQPixmap; class TQPixmap;
class TraceWidget : public TQWidget class TraceWidget : public TQWidget
@ -18,7 +20,8 @@ class TraceWidget : public TQWidget
void setNumberOfVerticalDivisions(unsigned int divisions); void setNumberOfVerticalDivisions(unsigned int divisions);
void setDisplayLimits(double x, double y, double w, double h); void setDisplayLimits(double x, double y, double w, double h);
double* samples(); TQDoubleArray& samples();
void setSamples(TQDoubleArray&);
protected: protected:
virtual void paintEvent(TQPaintEvent*); virtual void paintEvent(TQPaintEvent*);
@ -35,6 +38,6 @@ class TraceWidget : public TQWidget
double m_rightEdge; double m_rightEdge;
double m_topEdge; double m_topEdge;
double m_bottomEdge; double m_bottomEdge;
double* m_sampleArray; TQDoubleArray m_sampleArray;
TQPixmap* m_graticulePixmap; TQPixmap* m_graticulePixmap;
}; };

21
lib/libtqtrla/src/tqtrla.cpp
Unescape Escape View File

@ -295,6 +295,27 @@ TQDataStream &operator>>( TQDataStream &s, TQFloatArray &data ) {
return s; return s;
} }
TQDataStream &operator<<( TQDataStream &s, const TQDoubleArray &data ) {
TQ_UINT32 i;
TQ_UINT32 count = data.count();
s << count;
for (i=0; i<count; i++) {
s << data[i];
}
return s;
}
TQDataStream &operator>>( TQDataStream &s, TQDoubleArray &data ) {
TQ_UINT32 i;
TQ_UINT32 count;
s >> count;
data.resize(count);
for (i=0; i<count; i++) {
s >> data[i];
}
return s;
}
bool operator==( const ServiceType &s1, const ServiceType &s2 ) { bool operator==( const ServiceType &s1, const ServiceType &s2 ) {
bool identical = true; bool identical = true;

9
lib/libtqtrla/src/tqtrla.h
Unescape Escape View File

@ -102,6 +102,15 @@ Q_EXPORT TQDataStream &operator>>(TQDataStream &, TQFloatArray &);
// ============================================================================= // =============================================================================
typedef TQMemArray<double> TQDoubleArray;
#ifndef QT_NO_DATASTREAM
Q_EXPORT TQDataStream &operator<<(TQDataStream &, const TQDoubleArray &);
Q_EXPORT TQDataStream &operator>>(TQDataStream &, TQDoubleArray &);
#endif
// =============================================================================
class ServiceType class ServiceType
{ {
public: public:

42
servers/gpib_server_lin/src/gpib_conn.cpp
Unescape Escape View File

@ -209,10 +209,17 @@ void GPIBSocket::commandLoop() {
} }
if (m_activeDeviceType != 0) { if (m_activeDeviceType != 0) {
ds << TQString("ACK");
writeEndOfFrame();
m_servClientTimeout->start(NETWORK_COMM_TIMEOUT_MS, TRUE); m_servClientTimeout->start(NETWORK_COMM_TIMEOUT_MS, TRUE);
transferred_data = true; transferred_data = true;
m_commandLoopState = 1; m_commandLoopState = 1;
} }
else {
ds << TQString("NCK");
writeEndOfFrame();
}
} }
} }
else if (m_commandLoopState == 1) { else if (m_commandLoopState == 1) {
@ -226,6 +233,7 @@ void GPIBSocket::commandLoop() {
ds.setPrintableData(true); ds.setPrintableData(true);
TQByteArray recData; TQByteArray recData;
ds >> recData; ds >> recData;
clearFrameTail();
if (recData.size() > 0) { if (recData.size() > 0) {
if (write(m_serverParent->m_serialDeviceSocket, recData.data(), recData.size()) < 0) { if (write(m_serverParent->m_serialDeviceSocket, recData.data(), recData.size()) < 0) {
// ERROR // ERROR
@ -251,12 +259,12 @@ void GPIBSocket::commandLoop() {
TQDataStream ds(this); TQDataStream ds(this);
ds.setPrintableData(true); ds.setPrintableData(true);
ds >> m_instrumentCommand; ds >> m_instrumentCommand;
if (m_instrumentCommand != "") { if (m_instrumentCommand != "") {
if (m_activeDeviceType == 2) { if (m_activeDeviceType == 2) {
// Oscilloscope // Oscilloscope
if (m_instrumentCommand == "SETHORIZTIMEBASE") { // Want to change horizontal timebase if (m_instrumentCommand == "SETHORIZTIMEBASE") { // Want to change horizontal timebase
float value; double value;
ds >> value; ds >> value;
if (scope_set_timebase(value, m_serverParent->m_scopeType.ascii(), m_serverParent->m_scopeDeviceSocket) == 0) { if (scope_set_timebase(value, m_serverParent->m_scopeType.ascii(), m_serverParent->m_scopeDeviceSocket) == 0) {
ds << TQString("ACK"); ds << TQString("ACK");
@ -341,7 +349,7 @@ void GPIBSocket::commandLoop() {
} }
} }
else if (m_instrumentCommand == "SETTRIGGERLEVEL") { // Want to change trigger level else if (m_instrumentCommand == "SETTRIGGERLEVEL") { // Want to change trigger level
float value; double value;
ds >> value; ds >> value;
if (scope_set_trigger_level(value, m_serverParent->m_scopeType.ascii(), m_serverParent->m_scopeDeviceSocket) == 0) { if (scope_set_trigger_level(value, m_serverParent->m_scopeType.ascii(), m_serverParent->m_scopeDeviceSocket) == 0) {
ds << TQString("ACK"); ds << TQString("ACK");
@ -381,7 +389,7 @@ void GPIBSocket::commandLoop() {
} }
} }
else if (m_instrumentCommand == "SETFREQUENCY") { // Want to change frequency else if (m_instrumentCommand == "SETFREQUENCY") { // Want to change frequency
float value; double value;
ds >> value; ds >> value;
if (signal_set_frequency(value, m_serverParent->m_funcgenType.ascii(), m_serverParent->m_funcgenDeviceSocket, errorbuf) == 0) { if (signal_set_frequency(value, m_serverParent->m_funcgenType.ascii(), m_serverParent->m_funcgenDeviceSocket, errorbuf) == 0) {
ds << TQString("ACK"); ds << TQString("ACK");
@ -393,7 +401,7 @@ void GPIBSocket::commandLoop() {
} }
} }
else if (m_instrumentCommand == "SETDUTYCYCLE") { // Want to change duty cycle else if (m_instrumentCommand == "SETDUTYCYCLE") { // Want to change duty cycle
float value; double value;
ds >> value; ds >> value;
if (signal_set_duty_cycle(value, m_serverParent->m_funcgenType.ascii(), m_serverParent->m_funcgenDeviceSocket, errorbuf) == 0) { if (signal_set_duty_cycle(value, m_serverParent->m_funcgenType.ascii(), m_serverParent->m_funcgenDeviceSocket, errorbuf) == 0) {
ds << TQString("ACK"); ds << TQString("ACK");
@ -445,7 +453,7 @@ void GPIBSocket::commandLoop() {
} }
} }
else if (m_instrumentCommand == "SETPEAKPEAKVOLTAGE") { // Want to change P-P voltage else if (m_instrumentCommand == "SETPEAKPEAKVOLTAGE") { // Want to change P-P voltage
float value; double value;
ds >> value; ds >> value;
if (signal_set_peak_peak_voltage(value, m_serverParent->m_funcgenType.ascii(), m_serverParent->m_funcgenDeviceSocket, errorbuf) == 0) { if (signal_set_peak_peak_voltage(value, m_serverParent->m_funcgenType.ascii(), m_serverParent->m_funcgenDeviceSocket, errorbuf) == 0) {
ds << TQString("ACK"); ds << TQString("ACK");
@ -457,7 +465,7 @@ void GPIBSocket::commandLoop() {
} }
} }
else if (m_instrumentCommand == "SETOFFSETVOLTAGE") { // Want to change offset voltage else if (m_instrumentCommand == "SETOFFSETVOLTAGE") { // Want to change offset voltage
float value; double value;
ds >> value; ds >> value;
if (signal_set_offset_voltage(value, m_serverParent->m_funcgenType.ascii(), m_serverParent->m_funcgenDeviceSocket, errorbuf) == 0) { if (signal_set_offset_voltage(value, m_serverParent->m_funcgenType.ascii(), m_serverParent->m_funcgenDeviceSocket, errorbuf) == 0) {
ds << TQString("ACK"); ds << TQString("ACK");
@ -485,7 +493,7 @@ void GPIBSocket::commandLoop() {
if (commanalyzer_get_spectrum_analyzer_trace(m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) { if (commanalyzer_get_spectrum_analyzer_trace(m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
int i; int i;
int tracelen = commanalyzerTraceLength(m_serverParent->m_commanalyzerType.ascii()); int tracelen = commanalyzerTraceLength(m_serverParent->m_commanalyzerType.ascii());
TQFloatArray traceData; TQDoubleArray traceData;
traceData.resize(tracelen); traceData.resize(tracelen);
for (i=0; i<tracelen; i++) { for (i=0; i<tracelen; i++) {
traceData[i] = commanalyzer_raw_trace_data[i]; traceData[i] = commanalyzer_raw_trace_data[i];
@ -531,7 +539,7 @@ void GPIBSocket::commandLoop() {
} }
} }
else if (m_instrumentCommand == "SETCENTERFREQUENCY") { // Want to change center frequency else if (m_instrumentCommand == "SETCENTERFREQUENCY") { // Want to change center frequency
float value; double value;
ds >> value; ds >> value;
if (commanalyzer_set_spectrum_analyzer_center_frequency(value, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) { if (commanalyzer_set_spectrum_analyzer_center_frequency(value, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
ds << TQString("ACK"); ds << TQString("ACK");
@ -543,7 +551,7 @@ void GPIBSocket::commandLoop() {
} }
} }
else if (m_instrumentCommand == "SETFREQUENCYSPAN") { // Want to change frequency span else if (m_instrumentCommand == "SETFREQUENCYSPAN") { // Want to change frequency span
float value; double value;
ds >> value; ds >> value;
if (commanalyzer_set_spectrum_analyzer_frequency_span(value, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) { if (commanalyzer_set_spectrum_analyzer_frequency_span(value, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
ds << TQString("ACK"); ds << TQString("ACK");
@ -595,7 +603,7 @@ void GPIBSocket::commandLoop() {
} }
} }
else if (m_instrumentCommand == "SETINPUTATTENUATION") { // Want to change input attenuation else if (m_instrumentCommand == "SETINPUTATTENUATION") { // Want to change input attenuation
float value; double value;
ds >> value; ds >> value;
if (commanalyzer_set_spectrum_analyzer_input_attenuation(value, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) { if (commanalyzer_set_spectrum_analyzer_input_attenuation(value, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
ds << TQString("ACK"); ds << TQString("ACK");
@ -607,7 +615,7 @@ void GPIBSocket::commandLoop() {
} }
} }
else if (m_instrumentCommand == "SETVERTICALSCALE") { // Want to change scale else if (m_instrumentCommand == "SETVERTICALSCALE") { // Want to change scale
float value; double value;
ds >> value; ds >> value;
if (commanalyzer_set_spectrum_analyzer_scale(value, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) { if (commanalyzer_set_spectrum_analyzer_scale(value, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
ds << TQString("ACK"); ds << TQString("ACK");
@ -639,7 +647,7 @@ void GPIBSocket::commandLoop() {
} }
} }
else if (m_instrumentCommand == "SETGENOUTPUTPOWER") { // Want to change generator output power else if (m_instrumentCommand == "SETGENOUTPUTPOWER") { // Want to change generator output power
float value; double value;
ds >> value; ds >> value;
if (commanalyzer_set_spectrum_analyzer_generator_power(value, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) { if (commanalyzer_set_spectrum_analyzer_generator_power(value, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
ds << TQString("ACK"); ds << TQString("ACK");
@ -651,7 +659,7 @@ void GPIBSocket::commandLoop() {
} }
} }
else if (m_instrumentCommand == "SETGENOUTPUTFREQUENCY") { // Want to change generator output frequency else if (m_instrumentCommand == "SETGENOUTPUTFREQUENCY") { // Want to change generator output frequency
float value; double value;
ds >> value; ds >> value;
if (commanalyzer_set_spectrum_analyzer_generator_frequency(value, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) { if (commanalyzer_set_spectrum_analyzer_generator_frequency(value, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
ds << TQString("ACK"); ds << TQString("ACK");
@ -683,7 +691,7 @@ void GPIBSocket::commandLoop() {
} }
} }
else if (m_instrumentCommand == "SETTRACEAVERAGING") { // Want to set trace averaging else if (m_instrumentCommand == "SETTRACEAVERAGING") { // Want to set trace averaging
float value; double value;
ds >> value; ds >> value;
if (commanalyzer_set_spectrum_analyzer_trace_averaging(value, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) { if (commanalyzer_set_spectrum_analyzer_trace_averaging(value, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
ds << TQString("ACK"); ds << TQString("ACK");
@ -695,7 +703,7 @@ void GPIBSocket::commandLoop() {
} }
} }
else if (m_instrumentCommand == "SETREFERENCEPOWERLEVEL") { // Want to set reference power level else if (m_instrumentCommand == "SETREFERENCEPOWERLEVEL") { // Want to set reference power level
float value; double value;
ds >> value; ds >> value;
if (commanalyzer_set_spectrum_analyzer_reference_power_level(value, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) { if (commanalyzer_set_spectrum_analyzer_reference_power_level(value, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
ds << TQString("ACK"); ds << TQString("ACK");
@ -766,7 +774,7 @@ void GPIBSocket::commandLoop() {
writeEndOfFrame(); writeEndOfFrame();
} }
} }
else if (m_instrumentCommand == "SETCENTERFREQUENCY") { // Want to get the center frequency else if (m_instrumentCommand == "GETCENTERFREQUENCY") { // Want to get the center frequency
double freq; double freq;
if (commanalyzer_get_spectrum_analyzer_center_frequency(&freq, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) { if (commanalyzer_get_spectrum_analyzer_center_frequency(&freq, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
ds << TQString("ACK"); ds << TQString("ACK");

Write Preview
Loading…
Cancel
Save