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.
489 lines
14 KiB
489 lines
14 KiB
12 years ago
|
/*
|
||
|
* 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 <klocale.h>
|
||
|
|
||
|
#include <gpib/ib.h>
|
||
|
|
||
|
#include "gpib_functions.h"
|
||
|
#include "scope_functions.h"
|
||
|
#include "signal_functions.h"
|
||
|
#include "commanalyzer_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("remotefpga");
|
||
|
|
||
|
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(), masterUser.ascii(), masterRealm.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");
|
||
|
}
|
||
|
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) {
|
||
|
m_servClientTimeout->start(NETWORK_COMM_TIMEOUT_MS, TRUE);
|
||
|
transferred_data = true;
|
||
|
m_commandLoopState = 1;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
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;
|
||
|
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;
|
||
|
clearFrameTail();
|
||
|
|
||
|
if (m_instrumentCommand != "") {
|
||
|
m_servClientTimeout->start(NETWORK_COMM_TIMEOUT_MS, TRUE);
|
||
|
transferred_data = true;
|
||
|
m_commandLoopState = 2;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
else if (m_commandLoopState == 2) {
|
||
|
if (canReadLine()) {
|
||
|
processPendingData();
|
||
|
}
|
||
|
if (canReadFrame()) {
|
||
|
if (m_activeDeviceType == 2) {
|
||
|
// Oscilloscope
|
||
|
}
|
||
|
else if (m_activeDeviceType == 3) {
|
||
|
// Function generator
|
||
|
}
|
||
|
else if (m_activeDeviceType == 4) {
|
||
|
// Communications analyzer
|
||
|
}
|
||
|
else {
|
||
|
// Unknown
|
||
|
transferred_data = true;
|
||
|
m_commandLoopState = 0;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
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) {
|
||
|
|
||
|
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);
|
||
|
|
||
|
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);
|
||
|
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");
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return 0;
|
||
|
}
|