You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1339 lines
47 KiB
1339 lines
47 KiB
/*
|
|
* Remote Laboratory GPIB Server
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* (c) 2012 Timothy Pearson
|
|
* Raptor Engineering
|
|
* http://www.raptorengineeringinc.com
|
|
*/
|
|
|
|
#include <stdio.h> /* perror() */
|
|
#include <stdlib.h> /* atoi() */
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <unistd.h> /* read() */
|
|
#include <errno.h>
|
|
#include <netinet/in.h>
|
|
#include <arpa/inet.h>
|
|
#include <netdb.h>
|
|
#include <fcntl.h>
|
|
#include <termios.h>
|
|
#include <unistd.h>
|
|
#include <sys/signal.h>
|
|
#include <sys/types.h>
|
|
|
|
#include <tqtimer.h>
|
|
#include <tqfile.h>
|
|
|
|
#include <tdelocale.h>
|
|
|
|
#include <gpib/ib.h>
|
|
|
|
#include "gpib_functions.h"
|
|
#include "scope_functions.h"
|
|
#include "signal_functions.h"
|
|
#include "commanalyzer_functions.h"
|
|
#include "companalyzer_functions.h"
|
|
|
|
#include "gpib_conn.h"
|
|
|
|
#define ABORT_SOCKET(s) s->close(); \
|
|
s->disconnect(); \
|
|
delete s; \
|
|
s = NULL;
|
|
|
|
#define NETWORK_COMM_TIMEOUT_MS 5000
|
|
|
|
/* exception handling */
|
|
struct exit_exception {
|
|
int c;
|
|
exit_exception(int c):c(c) { }
|
|
};
|
|
|
|
/*
|
|
The GPIBSocket class provides a socket that is connected with a client.
|
|
For every client that connects to the server, the server creates a new
|
|
instance of this class.
|
|
*/
|
|
GPIBSocket::GPIBSocket(int sock, TQObject *parent, const char *name) :
|
|
TDEKerberosServerSocket(parent, name), m_criticalSection(0), m_loopTimer(NULL), m_config(static_cast<GPIBServer*>(parent)->m_config),
|
|
m_serverParent(static_cast<GPIBServer*>(parent)), m_commandLoopState(0)
|
|
{
|
|
|
|
// Initialize timers
|
|
m_kerberosInitTimer = new TQTimer();
|
|
connect(m_kerberosInitTimer, SIGNAL(timeout()), this, SLOT(finishKerberosHandshake()));
|
|
m_servClientTimeout = new TQTimer();
|
|
|
|
setServiceName("ulab");
|
|
|
|
line = 0;
|
|
connect(this, SIGNAL(connectionClosed()), SLOT(connectionClosedHandler()));
|
|
connect(this, SIGNAL(connectionClosed()), parent, SLOT(remoteConnectionClosed()));
|
|
setSocket(sock);
|
|
}
|
|
|
|
GPIBSocket::~GPIBSocket() {
|
|
if (m_servClientTimeout) {
|
|
m_servClientTimeout->stop();
|
|
delete m_servClientTimeout;
|
|
m_servClientTimeout = NULL;
|
|
}
|
|
if (m_kerberosInitTimer) {
|
|
m_kerberosInitTimer->stop();
|
|
delete m_kerberosInitTimer;
|
|
m_kerberosInitTimer = NULL;
|
|
}
|
|
if (m_loopTimer) {
|
|
m_loopTimer->stop();
|
|
delete m_loopTimer;
|
|
m_loopTimer = NULL;
|
|
}
|
|
}
|
|
|
|
void GPIBSocket::close() {
|
|
if (state() == TQSocket::Connected) {
|
|
TDEKerberosServerSocket::close();
|
|
connectionClosedHandler();
|
|
TQTimer::singleShot(0, parent(), SLOT(remoteConnectionClosed()));
|
|
}
|
|
}
|
|
|
|
void GPIBSocket::connectionClosedHandler() {
|
|
printf("[DEBUG] Connection from %s closed\n\r", m_remoteHost.ascii());
|
|
|
|
if (m_criticalSection > 0) {
|
|
throw exit_exception(-1);
|
|
}
|
|
}
|
|
|
|
void GPIBSocket::initiateKerberosHandshake() {
|
|
setUsingKerberos(true);
|
|
m_kerberosInitTimer->start(100, TRUE);
|
|
}
|
|
|
|
void GPIBSocket::finishKerberosHandshake() {
|
|
if (kerberosStatus() == TDEKerberosServerSocket::KerberosInitializing) {
|
|
m_kerberosInitTimer->start(100, TRUE);
|
|
return;
|
|
}
|
|
if (kerberosStatus() == TDEKerberosServerSocket::KerberosInUse) {
|
|
m_config->setGroup("Security");
|
|
TQString masterUser = m_config->readEntry("masteruser");
|
|
TQString masterRealm = m_config->readEntry("masterrealm");
|
|
if (masterRealm == "") {
|
|
masterRealm = "(NULL)";
|
|
}
|
|
if ((m_authenticatedUserName != masterUser) || (m_authenticatedRealmName != masterRealm)) {
|
|
printf("[DEBUG] Connection from %s closed due to authentication failure (attempted connection as user %s@%s)\n\r", m_remoteHost.ascii(), m_authenticatedUserName.ascii(), m_authenticatedRealmName.ascii());
|
|
close();
|
|
return;
|
|
}
|
|
|
|
setDataTimeout(NETWORK_COMM_TIMEOUT_MS);
|
|
|
|
TQDataStream ds(this);
|
|
ds.setPrintableData(true);
|
|
ds << TQString("OK");
|
|
writeEndOfFrame();
|
|
|
|
enterCommandLoop();
|
|
return;
|
|
}
|
|
else {
|
|
printf("[DEBUG] Connection from %s closed due to Kerberos failure\n\r", m_remoteHost.ascii()); fflush(stdout);
|
|
close();
|
|
return;
|
|
}
|
|
}
|
|
|
|
void GPIBSocket::commandLoop() {
|
|
bool transferred_data;
|
|
|
|
m_criticalSection++;
|
|
try {
|
|
transferred_data = false;
|
|
if (state() == TQSocket::Connected) {
|
|
if (m_commandLoopState == 0) {
|
|
if (canReadLine()) {
|
|
processPendingData();
|
|
}
|
|
if (canReadFrame()) {
|
|
TQDataStream ds(this);
|
|
ds.setPrintableData(true);
|
|
TQString instrumentRequest;
|
|
ds >> instrumentRequest;
|
|
clearFrameTail();
|
|
|
|
m_activeDeviceType = 0;
|
|
if (instrumentRequest == "LIST") {
|
|
TQStringList deviceList;
|
|
if (m_serverParent->m_serialDevice != "") {
|
|
deviceList.append("SERIAL PORT");
|
|
}
|
|
if (m_serverParent->m_scopeType != "") {
|
|
deviceList.append("OSCILLOSCOPE");
|
|
}
|
|
if (m_serverParent->m_funcgenType != "") {
|
|
deviceList.append("FUNCTION GENERATOR");
|
|
}
|
|
if (m_serverParent->m_commanalyzerType != "") {
|
|
deviceList.append("COMMUNICATIONS ANALYZER");
|
|
}
|
|
if (m_serverParent->m_companalyzerType != "") {
|
|
deviceList.append("COMPONENT ANALYZER");
|
|
}
|
|
ds << deviceList;
|
|
writeEndOfFrame();
|
|
}
|
|
else if (instrumentRequest == "SERIAL PORT") {
|
|
m_activeDeviceType = 1;
|
|
}
|
|
else if (instrumentRequest == "OSCILLOSCOPE") {
|
|
m_activeDeviceType = 2;
|
|
}
|
|
else if (instrumentRequest == "FUNCTION GENERATOR") {
|
|
m_activeDeviceType = 3;
|
|
}
|
|
else if (instrumentRequest == "COMMUNICATIONS ANALYZER") {
|
|
m_activeDeviceType = 4;
|
|
}
|
|
|
|
if (m_activeDeviceType != 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
|
|
m_servClientTimeout->start(NETWORK_COMM_TIMEOUT_MS, TRUE);
|
|
transferred_data = true;
|
|
m_commandLoopState = 1;
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
}
|
|
else if (m_commandLoopState == 1) {
|
|
if (canReadLine()) {
|
|
processPendingData();
|
|
}
|
|
if (m_activeDeviceType == 1) {
|
|
// Serial port
|
|
if (canReadFrame()) {
|
|
TQDataStream ds(this);
|
|
ds.setPrintableData(true);
|
|
TQByteArray recData;
|
|
ds >> recData;
|
|
clearFrameTail();
|
|
if (recData.size() > 0) {
|
|
if (write(m_serverParent->m_serialDeviceSocket, recData.data(), recData.size()) < 0) {
|
|
// ERROR
|
|
}
|
|
transferred_data = true;
|
|
printf("[DEBUG] Got %d bytes from the network interface\n\r", recData.size()); fflush(stdout);
|
|
}
|
|
}
|
|
TQByteArray txData;
|
|
txData.resize(10000);
|
|
int cc = read(m_serverParent->m_serialDeviceSocket, txData.data(), txData.size());
|
|
if (cc > 0) {
|
|
TQDataStream ds(this);
|
|
ds.setPrintableData(true);
|
|
ds << txData;
|
|
writeEndOfFrame();
|
|
transferred_data = true;
|
|
printf("[DEBUG] Got %d bytes from the serial port\n\r", cc); fflush(stdout);
|
|
}
|
|
}
|
|
else {
|
|
if (canReadFrame()) {
|
|
TQDataStream ds(this);
|
|
ds.setPrintableData(true);
|
|
ds >> m_instrumentCommand;
|
|
|
|
if (m_instrumentCommand != "") {
|
|
if (m_activeDeviceType == 2) {
|
|
// Oscilloscope
|
|
if (m_instrumentCommand == "RESET") { // Want to reset scope
|
|
if (scope_reset(m_serverParent->m_funcgenType.ascii(), m_serverParent->m_funcgenDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");;
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETHORIZTIMEBASE") { // Want to change horizontal timebase
|
|
double value;
|
|
ds >> value;
|
|
if (scope_set_timebase(value, m_serverParent->m_scopeType.ascii(), m_serverParent->m_scopeDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "GETHORIZTIMEBASE") { // Want horizontal timebase
|
|
double timebase;
|
|
if (scope_get_timebase(&timebase, m_serverParent->m_scopeType.ascii(), m_serverParent->m_scopeDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
ds << timebase;
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if ((m_instrumentCommand == "GETCHANNELTRACE")) { // Want channel trace
|
|
TQ_INT32 value;
|
|
ds >> value;
|
|
TQ_INT32 traceLength;
|
|
traceLength = scope_get_channel_trace(value, m_serverParent->m_scopeType.ascii(), m_serverParent->m_scopeDeviceSocket);
|
|
if (traceLength > 0) {
|
|
long i;
|
|
TQDoubleArray traceData;
|
|
TQDoubleArray positionData;
|
|
traceData.resize(traceLength);
|
|
positionData.resize(traceLength);
|
|
for (i=0; i<traceLength; i++) {
|
|
traceData[i] = scope_raw_trace_data[i];
|
|
positionData[i] = scope_raw_position_data[i];
|
|
}
|
|
ds << TQString("ACK");
|
|
ds << traceData;
|
|
ds << positionData;
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETVOLTSDIV") { // Want to change volts per division
|
|
TQ_INT32 value1;
|
|
ds >> value1;
|
|
double value2;
|
|
ds >> value2;
|
|
if (scope_set_volts_div(value1, value2, m_serverParent->m_scopeType.ascii(), m_serverParent->m_scopeDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "GETVOLTSDIV") { // Want to get volts per division
|
|
double voltsdiv;
|
|
TQ_INT32 value;
|
|
ds >> value;
|
|
if (scope_get_channel_volts_div(&voltsdiv, value, m_serverParent->m_scopeType.ascii(), m_serverParent->m_scopeDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
ds << voltsdiv;
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "GETSECONDSSDIV") { // Want to get seconds per division
|
|
double secondsdiv;
|
|
TQ_INT32 value;
|
|
ds >> value;
|
|
if (scope_get_channel_seconds_div(&secondsdiv, value, m_serverParent->m_scopeType.ascii(), m_serverParent->m_scopeDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
ds << secondsdiv;
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "GETTRACESAMPLECOUNT") { // Want to get number of samples in the trace
|
|
unsigned long samples;
|
|
TQ_INT32 value;
|
|
ds >> value;
|
|
if (scope_get_channel_sample_count(&samples, value, m_serverParent->m_scopeType.ascii(), m_serverParent->m_scopeDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
TQ_INT32 safeSamples = samples;
|
|
ds << safeSamples;
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETRUNNING") { // Want to change run status
|
|
TQ_INT16 value;
|
|
ds >> value;
|
|
if (scope_set_acquisition(value, m_serverParent->m_scopeType.ascii(), m_serverParent->m_scopeDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "GETRUNNING") { // Want to get run status
|
|
int running;
|
|
if (scope_get_acquisition(&running, m_serverParent->m_scopeType.ascii(), m_serverParent->m_scopeDeviceSocket) == 0) {
|
|
TQ_INT16 safeRunning;
|
|
safeRunning = running;
|
|
ds << TQString("ACK");
|
|
ds << safeRunning;
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETCHANNELACTIVE") { // Want to change channel enable
|
|
TQ_INT32 value1;
|
|
ds >> value1;
|
|
TQ_INT16 value2;
|
|
ds >> value2;
|
|
if (scope_set_channel_state(value1, value2, m_serverParent->m_scopeType.ascii(), m_serverParent->m_scopeDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETTRIGGERCHANNEL") { // Want to change trigger channel
|
|
TQ_INT16 value;
|
|
ds >> value;
|
|
if (scope_set_trigger_channel(value, m_serverParent->m_scopeType.ascii(), m_serverParent->m_scopeDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "GETTRIGGERCHANNEL") { // Want to get trigger channel
|
|
int channel;
|
|
if (scope_get_trigger_channel(&channel, m_serverParent->m_scopeType.ascii(), m_serverParent->m_scopeDeviceSocket) == 0) {
|
|
TQ_INT16 safeChannel = channel;
|
|
ds << TQString("ACK");
|
|
ds << safeChannel;
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETTRIGGERLEVEL") { // Want to change trigger level
|
|
double value;
|
|
ds >> value;
|
|
if (scope_set_trigger_level(value, m_serverParent->m_scopeType.ascii(), m_serverParent->m_scopeDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "GETTRIGGERLEVEL") { // Want to get trigger level
|
|
double triggerlevel;
|
|
if (scope_get_trigger_level(&triggerlevel, m_serverParent->m_scopeType.ascii(), m_serverParent->m_scopeDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
ds << triggerlevel;
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETCHANVERTPOS") { // Want to change channel vertical position
|
|
TQ_INT32 value1;
|
|
ds >> value1;
|
|
float value2;
|
|
ds >> value2;
|
|
if (scope_set_channel_position(value1, value2, m_serverParent->m_scopeType.ascii(), m_serverParent->m_scopeDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "GETHORIZONTALDIVCOUNT") { // Want the number of horizontal divisions available
|
|
TQ_INT16 divisions = scope_get_number_of_vertical_divisions(m_serverParent->m_scopeType.ascii(), m_serverParent->m_scopeDeviceSocket);
|
|
if (divisions >= 0) {
|
|
ds << TQString("ACK");
|
|
ds << divisions;
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "GETVERTICALDIVCOUNT") { // Want the number of vertical divisions available
|
|
TQ_INT16 divisions = scope_get_number_of_horizontal_divisions(m_serverParent->m_scopeType.ascii(), m_serverParent->m_scopeDeviceSocket);
|
|
if (divisions >= 0) {
|
|
ds << TQString("ACK");
|
|
ds << divisions;
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "GETNUMBEROFCHANNELS") { // Want the number of channels available
|
|
TQ_INT16 divisions = scope_get_number_of_channels(m_serverParent->m_scopeType.ascii(), m_serverParent->m_scopeDeviceSocket);
|
|
if (divisions >= 0) {
|
|
ds << TQString("ACK");
|
|
ds << divisions;
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "GETCHANNELACTIVE") { // Want to get channel activity
|
|
int state;
|
|
TQ_INT32 value;
|
|
ds >> value;
|
|
if (scope_get_channel_state(&state, value, m_serverParent->m_scopeType.ascii(), m_serverParent->m_scopeDeviceSocket) == 0) {
|
|
TQ_INT16 safeState = state;
|
|
ds << TQString("ACK");
|
|
ds << safeState;
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "GETPERMITTEDVDIVS") { // Want to get permitted volts/div settings
|
|
double attenuation_mult;
|
|
double* permitted_array;
|
|
int permitted_count;
|
|
TQ_INT32 value;
|
|
ds >> value;
|
|
if (scope_get_probe_attenuation_multiplier(&attenuation_mult, value, m_serverParent->m_scopeType.ascii(), m_serverParent->m_scopeDeviceSocket) == 0) {
|
|
if (scope_get_permitted_volts_div_settings_at_1x(&permitted_count, &permitted_array, m_serverParent->m_scopeType.ascii(), m_serverParent->m_scopeDeviceSocket) == 0) {
|
|
long i;
|
|
TQDoubleList permittedValues;
|
|
for (i=0; i<permitted_count; i++) {
|
|
permittedValues.append(permitted_array[i]/attenuation_mult);
|
|
}
|
|
free(permitted_array);
|
|
ds << TQString("ACK");
|
|
ds << permittedValues;
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "GETPERMITTEDSDIVS") { // Want to get permitted seconds/div settings
|
|
double* permitted_array;
|
|
int permitted_count;
|
|
if (scope_get_permitted_seconds_div_settings(&permitted_count, &permitted_array, m_serverParent->m_scopeType.ascii(), m_serverParent->m_scopeDeviceSocket) == 0) {
|
|
long i;
|
|
TQDoubleList permittedValues;
|
|
for (i=0; i<permitted_count; i++) {
|
|
permittedValues.append(permitted_array[i]);
|
|
}
|
|
free(permitted_array);
|
|
ds << TQString("ACK");
|
|
ds << permittedValues;
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else {
|
|
printf("[WARNING] Received unknown command %s from host %s\n\r", m_instrumentCommand.ascii(), m_remoteHost.ascii()); fflush(stdout);
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_activeDeviceType == 3) {
|
|
// Function generator
|
|
char errorbuf[1000];
|
|
if (m_instrumentCommand == "RESET") { // Want to reset function generator
|
|
if (signal_reset(m_serverParent->m_funcgenType.ascii(), m_serverParent->m_funcgenDeviceSocket, errorbuf) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString(errorbuf);
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETFREQUENCY") { // Want to change frequency
|
|
double value;
|
|
ds >> value;
|
|
if (signal_set_frequency(value, m_serverParent->m_funcgenType.ascii(), m_serverParent->m_funcgenDeviceSocket, errorbuf) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString(errorbuf);
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETDUTYCYCLE") { // Want to change duty cycle
|
|
double value;
|
|
ds >> value;
|
|
if (signal_set_duty_cycle(value, m_serverParent->m_funcgenType.ascii(), m_serverParent->m_funcgenDeviceSocket, errorbuf) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString(errorbuf);
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETSHAPESQUARE") { // Want to set square wave
|
|
if (signal_set_waveform("SQUARE", m_serverParent->m_funcgenType.ascii(), m_serverParent->m_funcgenDeviceSocket, errorbuf) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString(errorbuf);
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETSHAPESINE") { // Want to set sine wave
|
|
if (signal_set_waveform("SINUSOID", m_serverParent->m_funcgenType.ascii(), m_serverParent->m_funcgenDeviceSocket, errorbuf) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString(errorbuf);
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETSHAPETRIANGLE") { // Want to set triangle wave
|
|
if (signal_set_waveform("RAMP", m_serverParent->m_funcgenType.ascii(), m_serverParent->m_funcgenDeviceSocket, errorbuf) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString(errorbuf);
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETSHAPENOISE") { // Want to set noise wave
|
|
if (signal_set_waveform("NOISE", m_serverParent->m_funcgenType.ascii(), m_serverParent->m_funcgenDeviceSocket, errorbuf) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString(errorbuf);
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETPEAKPEAKVOLTAGE") { // Want to change P-P voltage
|
|
double value;
|
|
ds >> value;
|
|
if (signal_set_peak_peak_voltage(value, m_serverParent->m_funcgenType.ascii(), m_serverParent->m_funcgenDeviceSocket, errorbuf) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString(errorbuf);
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETOFFSETVOLTAGE") { // Want to change offset voltage
|
|
double value;
|
|
ds >> value;
|
|
if (signal_set_offset_voltage(value, m_serverParent->m_funcgenType.ascii(), m_serverParent->m_funcgenDeviceSocket, errorbuf) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString(errorbuf);
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else {
|
|
printf("[WARNING] Received unknown command %s from host %s\n\r", m_instrumentCommand.ascii(), m_remoteHost.ascii()); fflush(stdout);
|
|
}
|
|
}
|
|
else if (m_activeDeviceType == 4) {
|
|
// Communications analyzer
|
|
if (m_instrumentCommand == "SETMODESPECTRUMANALYZER") { // Want to set SA mode
|
|
if (commanalyzer_switch_to_spectrum_analyzer_mode(m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if ((m_instrumentCommand == "GETSPECTRUMTRACE")) { // Want SA trace
|
|
if (commanalyzer_get_spectrum_analyzer_trace(m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
|
|
int i;
|
|
int tracelen = commanalyzerTraceLength(m_serverParent->m_commanalyzerType.ascii());
|
|
TQDoubleArray traceData;
|
|
traceData.resize(tracelen);
|
|
for (i=0; i<tracelen; i++) {
|
|
traceData[i] = commanalyzer_raw_trace_data[i];
|
|
}
|
|
ds << TQString("ACK");
|
|
ds << traceData;
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "LOCKSCREEN") { // Want to lock screen
|
|
if (commanalyzer_lock_screen(m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
|
|
commanalyzer_set_display_brightness(0, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket); // Don't burn in the screen
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETGENMODETRACKING") { // Want to set generator to tracking mode
|
|
if (commanalyzer_spectrum_analyzer_set_generator_mode_tracking(m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETGENMODEFIXED") { // Want to set generator to fixed mode
|
|
if (commanalyzer_spectrum_analyzer_set_generator_mode_fixed(m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETCENTERFREQUENCY") { // Want to change center frequency
|
|
double value;
|
|
ds >> value;
|
|
if (commanalyzer_set_spectrum_analyzer_center_frequency(value, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETFREQUENCYSPAN") { // Want to change frequency span
|
|
double value;
|
|
ds >> value;
|
|
if (commanalyzer_set_spectrum_analyzer_frequency_span(value, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETRFINPUTDEDICATED") { // Want to set RF input to dedicated connector
|
|
if (commanalyzer_spectrum_analyzer_set_rf_input_dedicated(m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETRFINPUTMULTIPLEXED") { // Want to set RF input to multiplexed connector
|
|
if (commanalyzer_spectrum_analyzer_set_rf_input_muxed(m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETGENOUTPUTDEDICATED") { // Want to set generator output to dedicated connector
|
|
if (commanalyzer_spectrum_analyzer_set_generator_output_dedicated(m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETGENOUTPUTMULTIPLEXED") { // Want to set generator output to multiplexed connector
|
|
if (commanalyzer_spectrum_analyzer_set_generator_output_muxed(m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETINPUTATTENUATION") { // Want to change input attenuation
|
|
double value;
|
|
ds >> value;
|
|
if (commanalyzer_set_spectrum_analyzer_input_attenuation(value, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETVERTICALSCALE") { // Want to change scale
|
|
double value;
|
|
ds >> value;
|
|
if (commanalyzer_set_spectrum_analyzer_scale(value, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETINPUTATTENMODEAUTO") { // Want to set RF input attenuator mode to automatic
|
|
if (commanalyzer_set_spectrum_analyzer_input_attenuator_mode_auto(m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETINPUTATTENMODEFIXED") { // Want to set RF input attenuator mode to fixed
|
|
if (commanalyzer_set_spectrum_analyzer_input_attenuator_mode_fixed(m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETGENOUTPUTPOWER") { // Want to change generator output power
|
|
double value;
|
|
ds >> value;
|
|
if (commanalyzer_set_spectrum_analyzer_generator_power(value, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETGENOUTPUTFREQUENCY") { // Want to change generator output frequency
|
|
double value;
|
|
ds >> value;
|
|
if (commanalyzer_set_spectrum_analyzer_generator_frequency(value, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETGENSWEEPASCENDING") { // Want to set generator sweep to ascending
|
|
if (commanalyzer_spectrum_analyzer_set_generator_sweep_ascending(m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETGENSWEEPDESCENDING") { // Want to set generator sweep to descending
|
|
if (commanalyzer_spectrum_analyzer_set_generator_sweep_descending(m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETTRACEAVERAGING") { // Want to set trace averaging
|
|
double value;
|
|
ds >> value;
|
|
if (commanalyzer_set_spectrum_analyzer_trace_averaging(value, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETREFERENCEPOWERLEVEL") { // Want to set reference power level
|
|
double value;
|
|
ds >> value;
|
|
if (commanalyzer_set_spectrum_analyzer_reference_power_level(value, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "GETHORIZONTALDIVCOUNT") { // Want the number of horizontal divisions available
|
|
TQ_INT16 divisions = commanalyzer_get_spectrum_analyzer_number_of_horizontal_divisions(m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket);
|
|
if (divisions >= 0) {
|
|
ds << TQString("ACK");
|
|
ds << divisions;
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "GETVERTICALDIVCOUNT") { // Want the number of vertical divisions available
|
|
TQ_INT16 divisions = commanalyzer_get_spectrum_analyzer_number_of_vertical_divisions(m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket);
|
|
if (divisions >= 0) {
|
|
ds << TQString("ACK");
|
|
ds << divisions;
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "GETTRACESAMPLECOUNT") { // Want the number of samples in a trace
|
|
TQ_INT16 divisions = commanalyzerTraceLength(m_serverParent->m_commanalyzerType.ascii());
|
|
if (divisions >= 0) {
|
|
ds << TQString("ACK");
|
|
ds << divisions;
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "GETREFERENCEPOWERLEVEL") { // Want the reference power level
|
|
double rpower;
|
|
if (commanalyzer_get_spectrum_analyzer_reference_power_level(&rpower, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
ds << rpower;
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "GETVERTDIVSCALE") { // Want the vertical division scale
|
|
double scale;
|
|
if (commanalyzer_get_spectrum_analyzer_scale(&scale, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
ds << scale;
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "GETCENTERFREQUENCY") { // Want to get the center frequency
|
|
double freq;
|
|
if (commanalyzer_get_spectrum_analyzer_center_frequency(&freq, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
ds << freq;
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "GETFREQUENCYSPAN") { // Want to get the frequency span
|
|
double freq;
|
|
if (commanalyzer_get_spectrum_analyzer_span(&freq, m_serverParent->m_commanalyzerType.ascii(), m_serverParent->m_commanalyzerDeviceSocket) == 0) {
|
|
ds << TQString("ACK");
|
|
ds << freq;
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else {
|
|
printf("[WARNING] Received unknown command %s from host %s\n\r", m_instrumentCommand.ascii(), m_remoteHost.ascii()); fflush(stdout);
|
|
}
|
|
}
|
|
else if (m_activeDeviceType == 5) {
|
|
// Component analyzer
|
|
char errorbuf[1000];
|
|
if (m_instrumentCommand == "GETMEASUREMENT") { // Want a new component measurement with the configured parameters
|
|
TQ_UINT8 number_of_parameters = 2;
|
|
companalyzer_measurements_t measurement;
|
|
int retcode = companalyzer_get_parameter_measurement(&measurement, m_serverParent->m_companalyzerType.ascii(), m_serverParent->m_companalyzerDeviceSocket);
|
|
if (retcode == 0) {
|
|
ds << TQString("ACK");
|
|
ds << number_of_parameters;
|
|
ds << (TQ_UINT32&)measurement.parameter_a_status;
|
|
ds << (TQ_UINT32&)measurement.parameter_a;
|
|
ds << (TQ_UINT32&)measurement.parameter_a_type;
|
|
ds << measurement.parameter_a_value;
|
|
ds << (TQ_UINT32&)measurement.parameter_b_status;
|
|
ds << (TQ_UINT32&)measurement.parameter_b;
|
|
ds << (TQ_UINT32&)measurement.parameter_b_type;
|
|
ds << measurement.parameter_b_value;
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString("NCK");
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETMEASUREDPARAMETERS") { // Want to set the measured parameters
|
|
uint8_t all_ok = 1;
|
|
uint8_t number_of_parameters;
|
|
companalyzer_measurement::companalyzer_measurement_t parameter_a;
|
|
companalyzer_measurement::companalyzer_measurement_t parameter_b;
|
|
ds >> number_of_parameters;
|
|
if (number_of_parameters == 2) {
|
|
ds >> (TQ_UINT32&)parameter_a;
|
|
ds >> (TQ_UINT32&)parameter_b;
|
|
if (companalyzer_set_measurement_parameters(parameter_a, parameter_b, m_serverParent->m_companalyzerType.ascii(), m_serverParent->m_companalyzerDeviceSocket, errorbuf) != 0) {
|
|
all_ok = false;
|
|
}
|
|
}
|
|
else {
|
|
sprintf(errorbuf, "EXTInvalid number of parameters provided°");
|
|
all_ok = false;
|
|
}
|
|
if (all_ok) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString(errorbuf);
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else if (m_instrumentCommand == "SETMEASUREMENTFREQUENCY") { // Want to set the measurement frequency
|
|
double frequency;
|
|
ds >> frequency;
|
|
if (companalyzer_set_measurement_frequency(frequency, m_serverParent->m_companalyzerType.ascii(), m_serverParent->m_companalyzerDeviceSocket, errorbuf) == 0) {
|
|
ds << TQString("ACK");
|
|
writeEndOfFrame();
|
|
}
|
|
else {
|
|
ds << TQString(errorbuf);
|
|
writeEndOfFrame();
|
|
}
|
|
}
|
|
else {
|
|
printf("[WARNING] Received unknown command %s from host %s\n\r", m_instrumentCommand.ascii(), m_remoteHost.ascii()); fflush(stdout);
|
|
}
|
|
}
|
|
else {
|
|
// Unknown
|
|
transferred_data = true;
|
|
m_commandLoopState = 0;
|
|
}
|
|
|
|
m_servClientTimeout->start(NETWORK_COMM_TIMEOUT_MS, TRUE);
|
|
transferred_data = true;
|
|
m_commandLoopState = 1;
|
|
}
|
|
|
|
clearFrameTail();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
m_criticalSection--;
|
|
if (transferred_data) {
|
|
if (m_loopTimer) m_loopTimer->start(0, TRUE);
|
|
}
|
|
else {
|
|
if (m_loopTimer) m_loopTimer->start(100, TRUE);
|
|
}
|
|
return;
|
|
}
|
|
catch (...) {
|
|
m_criticalSection--;
|
|
return;
|
|
}
|
|
}
|
|
|
|
int GPIBSocket::enterCommandLoop() {
|
|
m_commandLoopState = 0;
|
|
if (!m_loopTimer) {
|
|
m_loopTimer = new TQTimer();
|
|
connect(m_loopTimer, SIGNAL(timeout()), this, SLOT(commandLoop()));
|
|
}
|
|
if (m_loopTimer) m_loopTimer->start(0, TRUE);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
The GPIBServer class handles new connections to the server. For every
|
|
client that connects, it creates a new GPIBSocket -- that instance is now
|
|
responsible for the communication with that client.
|
|
*/
|
|
GPIBServer::GPIBServer(TQObject* parent, int port, KSimpleConfig* config) :
|
|
TQServerSocket( port, 1, parent ), m_config(config), m_numberOfConnections(0),
|
|
m_scopeDeviceSocket(-1), m_funcgenDeviceSocket(-1), m_commanalyzerDeviceSocket(-1), m_companalyzerDeviceSocket(-1) {
|
|
|
|
if ( !ok() ) {
|
|
printf("[ERROR] Failed to bind to port %d\n\r", port);
|
|
exit(1);
|
|
}
|
|
|
|
if (readConfig() != 0) {
|
|
exit(-1);
|
|
}
|
|
|
|
printf("[INFO] Server started on port %d\n\r", port); fflush(stdout);
|
|
}
|
|
|
|
GPIBServer::~GPIBServer() {
|
|
//
|
|
}
|
|
|
|
void GPIBServer::newConnection(int socket) {
|
|
GPIBSocket *s = new GPIBSocket(socket, this);
|
|
s->m_remoteHost = s->peerAddress().toString();
|
|
printf("[DEBUG] New connection from %s\n\r", s->m_remoteHost.ascii());
|
|
connect(s, SIGNAL(connectionClosed()), s, SLOT(deleteLater()));
|
|
s->initiateKerberosHandshake();
|
|
emit newConnect(s);
|
|
}
|
|
|
|
void GPIBServer::remoteConnectionClosed() {
|
|
m_numberOfConnections--;
|
|
}
|
|
|
|
int GPIBServer::readConfig() {
|
|
// Serial port
|
|
m_config->setGroup("Serial Port");
|
|
m_serialDevice = m_config->readEntry("device", "");
|
|
TQString desiredBaudRate = m_config->readEntry("baudrate", "9600");
|
|
if (desiredBaudRate == "1200") {
|
|
m_serialBaud = B1200;
|
|
}
|
|
else if (desiredBaudRate == "9600") {
|
|
m_serialBaud = B9600;
|
|
}
|
|
else if (desiredBaudRate == "19200") {
|
|
m_serialBaud = B19200;
|
|
}
|
|
else if (desiredBaudRate == "115200") {
|
|
m_serialBaud = B115200;
|
|
}
|
|
else {
|
|
printf("[WARNING] Invalid baudrate %s specified, selecting 9600 instead\n\r", desiredBaudRate.ascii()); fflush(stdout);
|
|
desiredBaudRate = "9600";
|
|
m_serialBaud = B9600;
|
|
}
|
|
|
|
// Oscilloscope
|
|
m_config->setGroup("Oscilloscope");
|
|
m_scopeType = m_config->readEntry("type", "");
|
|
m_scopeConnection = m_config->readEntry("connection", "gpib");
|
|
m_scopeBoard = m_config->readNumEntry("board", 0);
|
|
m_scopeDevice = m_config->readNumEntry("device", 0);
|
|
|
|
// Function generator
|
|
m_config->setGroup("Function Generator");
|
|
m_funcgenType = m_config->readEntry("type", "");
|
|
m_funcgenConnection = m_config->readEntry("connection", "gpib");
|
|
m_funcgenBoard = m_config->readNumEntry("board", 0);
|
|
m_funcgenDevice = m_config->readNumEntry("device", 0);
|
|
|
|
// Communications analyzer
|
|
m_config->setGroup("Communications Analyzer");
|
|
m_commanalyzerType = m_config->readEntry("type", "");
|
|
m_commanalyzerConnection = m_config->readEntry("connection", "gpib");
|
|
m_commanalyzerBoard = m_config->readNumEntry("board", 0);
|
|
m_commanalyzerDevice = m_config->readNumEntry("device", 0);
|
|
|
|
// Component analyzer
|
|
m_config->setGroup("Component Analyzer");
|
|
m_companalyzerType = m_config->readEntry("type", "");
|
|
m_companalyzerConnection = m_config->readEntry("connection", "gpib");
|
|
m_companalyzerBoard = m_config->readNumEntry("board", 0);
|
|
m_companalyzerDevice = m_config->readNumEntry("device", 0);
|
|
|
|
if (m_serialDevice != "") {
|
|
struct termios oldtio, newtio;
|
|
|
|
m_serialDeviceSocket = ::open(m_serialDevice.ascii(), O_RDWR | O_NOCTTY | O_NONBLOCK | O_APPEND);
|
|
if (m_serialDeviceSocket < 0) {
|
|
printf("[FAIL] Unable to open serial device %s\n\r", m_serialDevice.ascii()); fflush(stdout);
|
|
return 1;
|
|
}
|
|
|
|
tcgetattr(m_serialDeviceSocket, &oldtio); // Save current port settings
|
|
|
|
bzero(&newtio, sizeof(newtio));
|
|
newtio.c_cflag = m_serialBaud | CS8 | CLOCAL | CREAD;
|
|
newtio.c_iflag = IGNPAR;
|
|
newtio.c_oflag = 0;
|
|
|
|
// Set input mode (non-canonical, no echo,...)
|
|
newtio.c_lflag = 0;
|
|
|
|
newtio.c_cc[VTIME] = 0; // Inter-character timer unused
|
|
newtio.c_cc[VMIN] = 0; // Blocking read unused
|
|
|
|
tcflush(m_serialDeviceSocket, TCIFLUSH);
|
|
tcsetattr(m_serialDeviceSocket, TCSANOW, &newtio);
|
|
|
|
printf("[INFO] Serial port on node %s activated at %s baud\n\r", m_serialDevice.ascii(), desiredBaudRate.ascii());
|
|
}
|
|
|
|
if (m_scopeType != "") {
|
|
printf("[INFO] Oscilloscope conjectured to be on GPIB address %d:%d\n\r", m_scopeBoard, m_scopeDevice);
|
|
m_scopeDeviceSocket = open_gpib_device(m_scopeBoard, m_scopeDevice);
|
|
if (m_scopeDeviceSocket < 0) {
|
|
// return -1;
|
|
}
|
|
else {
|
|
time_t rawtime;
|
|
struct tm * timeinfo;
|
|
char datebuffer [80];
|
|
char timebuffer [80];
|
|
time ( &rawtime );
|
|
timeinfo = localtime ( &rawtime );
|
|
strftime(timebuffer,80,"TIME \"%H:%M:%S\"",timeinfo);
|
|
strftime(datebuffer,80,"DATE \"%Y-%m-%d\"",timeinfo);
|
|
printf("[INFO] Configuring %s oscilloscope\n\r", scopeLongDescription(m_scopeType.ascii()));
|
|
printf("[INFO] %s\n\r", datebuffer);
|
|
printf("[INFO] %s\n\r", timebuffer);
|
|
if (gpib_write(m_scopeDeviceSocket, timebuffer) == 0) {
|
|
gpib_write(m_scopeDeviceSocket, datebuffer);
|
|
scope_perform_initial_setup(m_scopeType.ascii(), m_scopeDeviceSocket);
|
|
printf("[INFO] Communication verified\n\r");
|
|
}
|
|
else {
|
|
printf("[WARN] Communication failed!\n\r");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (m_funcgenType != "") {
|
|
printf("[INFO] Function generator conjectured to be on GPIB address %d:%d\n\r", m_funcgenBoard, m_funcgenDevice);
|
|
m_funcgenDeviceSocket = open_gpib_device(m_funcgenBoard, m_funcgenDevice);
|
|
if (m_funcgenDeviceSocket < 0) {
|
|
//return 1;
|
|
}
|
|
else {
|
|
printf("[INFO] Configuring %s function generator\n\r", funcgenLongDescription(m_funcgenType.ascii()));
|
|
if (gpib_write(m_funcgenDeviceSocket, "RESET") == 0) {
|
|
printf("[INFO] Communication verified\n\r");
|
|
}
|
|
else {
|
|
printf("[WARN] Communication failed!\n\r");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (m_commanalyzerType != "") {
|
|
printf("[INFO] Communications analyzer conjectured to be on GPIB address %d:%d\n\r", m_commanalyzerBoard, m_commanalyzerDevice);
|
|
m_commanalyzerDeviceSocket = open_gpib_device(m_commanalyzerBoard, m_commanalyzerDevice);
|
|
if (m_commanalyzerDeviceSocket < 0) {
|
|
//return 1;
|
|
}
|
|
else {
|
|
time_t rawtime;
|
|
struct tm * timeinfo;
|
|
time ( &rawtime );
|
|
timeinfo = localtime ( &rawtime );
|
|
printf("[INFO] Configuring %s communications analyzer\n\r", commanalyzerLongDescription(m_commanalyzerType.ascii()));
|
|
if (commanalyzer_set_time(timeinfo, m_commanalyzerType.ascii(), m_commanalyzerDeviceSocket) == 0) {
|
|
commanalyzer_set_date(timeinfo, m_commanalyzerType.ascii(), m_commanalyzerDeviceSocket);
|
|
printf("[INFO] Communication verified\n\r");
|
|
}
|
|
else {
|
|
printf("[WARN] Communication failed!\n\r");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (m_companalyzerType != "") {
|
|
printf("[INFO] Component analyzer conjectured to be on GPIB address %d:%d\n\r", m_companalyzerBoard, m_companalyzerDevice);
|
|
m_companalyzerDeviceSocket = open_gpib_device(m_companalyzerBoard, m_companalyzerDevice);
|
|
if (m_companalyzerDeviceSocket < 0) {
|
|
//return 1;
|
|
}
|
|
else {
|
|
time_t rawtime;
|
|
struct tm * timeinfo;
|
|
time ( &rawtime );
|
|
timeinfo = localtime ( &rawtime );
|
|
printf("[INFO] Configuring %s component analyzer\n\r", companalyzerLongDescription(m_companalyzerType.ascii()));
|
|
if (companalyzer_set_time(timeinfo, m_companalyzerType.ascii(), m_companalyzerDeviceSocket) == 0) {
|
|
companalyzer_set_date(timeinfo, m_companalyzerType.ascii(), m_companalyzerDeviceSocket);
|
|
printf("[INFO] Communication verified\n\r");
|
|
}
|
|
else {
|
|
printf("[WARN] Communication failed!\n\r");
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
} |